diff --git a/src/libraries/System.Linq.Queryable/ref/System.Linq.Queryable.cs b/src/libraries/System.Linq.Queryable/ref/System.Linq.Queryable.cs
index f8282977280bf0..1f99c525352dc6 100644
--- a/src/libraries/System.Linq.Queryable/ref/System.Linq.Queryable.cs
+++ b/src/libraries/System.Linq.Queryable/ref/System.Linq.Queryable.cs
@@ -18,11 +18,11 @@ public abstract partial class EnumerableQuery
     {
         internal EnumerableQuery() { }
     }
+    [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Enumerating in-memory collections as IQueryable can require unreferenced code because expressions referencing IQueryable extension methods can get rebound to IEnumerable extension methods. The IEnumerable extension methods could be trimmed causing the application to fail at runtime.")]
+    [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
     public partial class EnumerableQuery<T> : System.Linq.EnumerableQuery, System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable, System.Linq.IOrderedQueryable, System.Linq.IOrderedQueryable<T>, System.Linq.IQueryable, System.Linq.IQueryable<T>, System.Linq.IQueryProvider
     {
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Enumerating in-memory collections as IQueryable can require unreferenced code because expressions referencing IQueryable extension methods can get rebound to IEnumerable extension methods. The IEnumerable extension methods could be trimmed causing the application to fail at runtime.")]
         public EnumerableQuery(System.Collections.Generic.IEnumerable<T> enumerable) { }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Enumerating in-memory collections as IQueryable can require unreferenced code because expressions referencing IQueryable extension methods can get rebound to IEnumerable extension methods. The IEnumerable extension methods could be trimmed causing the application to fail at runtime.")]
         public EnumerableQuery(System.Linq.Expressions.Expression expression) { }
         System.Type System.Linq.IQueryable.ElementType { get { throw null; } }
         System.Linq.Expressions.Expression System.Linq.IQueryable.Expression { get { throw null; } }
@@ -37,16 +37,25 @@ public EnumerableQuery(System.Linq.Expressions.Expression expression) { }
     }
     public static partial class Queryable
     {
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource Aggregate<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TSource, TSource>> func) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TAccumulate Aggregate<TSource, TAccumulate>(this System.Linq.IQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, TAccumulate>> func) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TResult Aggregate<TSource, TAccumulate, TResult>(this System.Linq.IQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, TAccumulate>> func, System.Linq.Expressions.Expression<System.Func<TAccumulate, TResult>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static bool All<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static bool Any<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static bool Any<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Append<TSource>(this System.Linq.IQueryable<TSource> source, TSource element) { throw null; }
         [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Enumerating in-memory collections as IQueryable can require unreferenced code because expressions referencing IQueryable extension methods can get rebound to IEnumerable extension methods. The IEnumerable extension methods could be trimmed causing the application to fail at runtime.")]
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable AsQueryable(this System.Collections.IEnumerable source) { throw null; }
         [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Enumerating in-memory collections as IQueryable can require unreferenced code because expressions referencing IQueryable extension methods can get rebound to IEnumerable extension methods. The IEnumerable extension methods could be trimmed causing the application to fail at runtime.")]
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TElement> AsQueryable<TElement>(this System.Collections.Generic.IEnumerable<TElement> source) { throw null; }
         public static decimal Average(this System.Linq.IQueryable<decimal> source) { throw null; }
         public static double Average(this System.Linq.IQueryable<double> source) { throw null; }
@@ -58,105 +67,205 @@ public static partial class Queryable
         public static double? Average(this System.Linq.IQueryable<long?> source) { throw null; }
         public static float? Average(this System.Linq.IQueryable<float?> source) { throw null; }
         public static float Average(this System.Linq.IQueryable<float> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static decimal Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static double Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static double Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static double Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static decimal? Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal?>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static double? Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double?>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static double? Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int?>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static double? Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long?>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static float? Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float?>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static float Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> Cast<TResult>(this System.Linq.IQueryable source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource[]> Chunk<TSource>(this System.Linq.IQueryable<TSource> source, int size) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Concat<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static bool Contains<TSource>(this System.Linq.IQueryable<TSource> source, TSource item) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static bool Contains<TSource>(this System.Linq.IQueryable<TSource> source, TSource item, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static int Count<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static int Count<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource?> DefaultIfEmpty<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> DefaultIfEmpty<TSource>(this System.Linq.IQueryable<TSource> source, TSource defaultValue) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> DistinctBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> DistinctBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Distinct<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Distinct<TSource>(this System.Linq.IQueryable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? ElementAtOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, System.Index index) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? ElementAtOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, int index) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource ElementAt<TSource>(this System.Linq.IQueryable<TSource> source, System.Index index) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource ElementAt<TSource>(this System.Linq.IQueryable<TSource> source, int index) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> ExceptBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TKey> source2, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> ExceptBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TKey> source2, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Except<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Except<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? FirstOrDefault<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? FirstOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource FirstOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, TSource defaultValue) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource FirstOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, TSource defaultValue) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource First<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource First<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<System.Linq.IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<System.Linq.IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<System.Linq.IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<System.Linq.IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> GroupBy<TSource, TKey, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>, TResult>> resultSelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> GroupBy<TSource, TKey, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IEnumerable<TElement>, TResult>> resultSelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IEnumerable<TElement>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Linq.IQueryable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IEnumerable<TInner>, TResult>> resultSelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Linq.IQueryable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IEnumerable<TInner>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> IntersectBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TKey> source2, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> IntersectBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TKey> source2, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Intersect<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Intersect<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Linq.IQueryable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, TResult>> resultSelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Linq.IQueryable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? LastOrDefault<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? LastOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource LastOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, TSource defaultValue) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource LastOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, TSource defaultValue) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource Last<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource Last<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static long LongCount<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static long LongCount<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? MaxBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? MaxBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TSource>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? Max<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? Max<TSource>(this System.Linq.IQueryable<TSource> source, System.Collections.Generic.IComparer<TSource>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TResult? Max<TSource, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TResult>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? MinBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? MinBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TSource>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? Min<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? Min<TSource>(this System.Linq.IQueryable<TSource> source, System.Collections.Generic.IComparer<TSource>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TResult? Min<TSource, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TResult>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> OfType<TResult>(this System.Linq.IQueryable source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IOrderedQueryable<T> OrderDescending<T>(this System.Linq.IQueryable<T> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IOrderedQueryable<T> OrderDescending<T>(this System.Linq.IQueryable<T> source, System.Collections.Generic.IComparer<T> comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IOrderedQueryable<T> Order<T>(this System.Linq.IQueryable<T> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IOrderedQueryable<T> Order<T>(this System.Linq.IQueryable<T> source, System.Collections.Generic.IComparer<T> comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Prepend<TSource>(this System.Linq.IQueryable<TSource> source, TSource element) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Reverse<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> SelectMany<TSource, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Collections.Generic.IEnumerable<TResult>>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> SelectMany<TSource, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Collections.Generic.IEnumerable<TResult>>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Collections.Generic.IEnumerable<TCollection>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, TResult>> resultSelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Collections.Generic.IEnumerable<TCollection>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, TResult>> resultSelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> Select<TSource, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, TResult>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> Select<TSource, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TResult>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static bool SequenceEqual<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static bool SequenceEqual<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? SingleOrDefault<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource? SingleOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource SingleOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, TSource defaultValue) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource SingleOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, TSource defaultValue) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource Single<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static TSource Single<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> SkipLast<TSource>(this System.Linq.IQueryable<TSource> source, int count) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> SkipWhile<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> SkipWhile<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Skip<TSource>(this System.Linq.IQueryable<TSource> source, int count) { throw null; }
         public static decimal Sum(this System.Linq.IQueryable<decimal> source) { throw null; }
         public static double Sum(this System.Linq.IQueryable<double> source) { throw null; }
@@ -168,33 +277,61 @@ public static partial class Queryable
         public static long? Sum(this System.Linq.IQueryable<long?> source) { throw null; }
         public static float? Sum(this System.Linq.IQueryable<float?> source) { throw null; }
         public static float Sum(this System.Linq.IQueryable<float> source) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static decimal Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static double Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static int Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static long Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static decimal? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal?>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static double? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double?>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static int? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int?>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static long? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long?>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static float? Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float?>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static float Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float>> selector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> TakeLast<TSource>(this System.Linq.IQueryable<TSource> source, int count) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> TakeWhile<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> TakeWhile<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Take<TSource>(this System.Linq.IQueryable<TSource> source, int count) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Take<TSource>(this System.Linq.IQueryable<TSource> source, System.Range range) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IOrderedQueryable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IOrderedQueryable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IOrderedQueryable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IOrderedQueryable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> UnionBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> UnionBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Union<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Union<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Where<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TSource> Where<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, bool>> predicate) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<(TFirst First, TSecond Second)> Zip<TFirst, TSecond>(this System.Linq.IQueryable<TFirst> source1, System.Collections.Generic.IEnumerable<TSecond> source2) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this System.Linq.IQueryable<TFirst> source1, System.Collections.Generic.IEnumerable<TSecond> source2, System.Collections.Generic.IEnumerable<TThird> source3) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
         public static System.Linq.IQueryable<TResult> Zip<TFirst, TSecond, TResult>(this System.Linq.IQueryable<TFirst> source1, System.Collections.Generic.IEnumerable<TSecond> source2, System.Linq.Expressions.Expression<System.Func<TFirst, TSecond, TResult>> resultSelector) { throw null; }
     }
 }
diff --git a/src/libraries/System.Linq.Queryable/src/System.Linq.Queryable.csproj b/src/libraries/System.Linq.Queryable/src/System.Linq.Queryable.csproj
index 4d7656af1da60a..75fb21c085ac1c 100644
--- a/src/libraries/System.Linq.Queryable/src/System.Linq.Queryable.csproj
+++ b/src/libraries/System.Linq.Queryable/src/System.Linq.Queryable.csproj
@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>$(NetCoreAppCurrent)</TargetFramework>
+    <EnableAotAnalyzer>true</EnableAotAnalyzer>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System\Linq\CachedReflection.cs" />
diff --git a/src/libraries/System.Linq.Queryable/src/System/Linq/CachedReflection.cs b/src/libraries/System.Linq.Queryable/src/System/Linq/CachedReflection.cs
index 99c98faf7ecbe3..514580fb334c0e 100644
--- a/src/libraries/System.Linq.Queryable/src/System/Linq/CachedReflection.cs
+++ b/src/libraries/System.Linq.Queryable/src/System/Linq/CachedReflection.cs
@@ -14,36 +14,42 @@ internal static class CachedReflectionInfo
     {
         private static MethodInfo? s_Aggregate_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Aggregate_TSource_2(Type TSource) =>
              (s_Aggregate_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, object, object>>, object>(Queryable.Aggregate).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Aggregate_TSource_TAccumulate_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Aggregate_TSource_TAccumulate_3(Type TSource, Type TAccumulate) =>
              (s_Aggregate_TSource_TAccumulate_3 ??= new Func<IQueryable<object>, object, Expression<Func<object, object, object>>, object>(Queryable.Aggregate).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TAccumulate);
 
         private static MethodInfo? s_Aggregate_TSource_TAccumulate_TResult_4;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Aggregate_TSource_TAccumulate_TResult_4(Type TSource, Type TAccumulate, Type TResult) =>
              (s_Aggregate_TSource_TAccumulate_TResult_4 ??= new Func<IQueryable<object>, object, Expression<Func<object, object, object>>, Expression<Func<object, object>>, object>(Queryable.Aggregate).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TAccumulate, TResult);
 
         private static MethodInfo? s_All_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo All_TSource_2(Type TSource) =>
              (s_All_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, bool>(Queryable.All).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Any_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Any_TSource_1(Type TSource) =>
              (s_Any_TSource_1 ??= new Func<IQueryable<object>, bool>(Queryable.Any).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Any_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Any_TSource_2(Type TSource) =>
              (s_Any_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, bool>(Queryable.Any).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
@@ -100,588 +106,686 @@ public static MethodInfo Any_TSource_2(Type TSource) =>
 
         private static MethodInfo? s_Average_Int32_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Average_Int32_TSource_2(Type TSource) =>
              (s_Average_Int32_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, int>>, double>(Queryable.Average).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Average_NullableInt32_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Average_NullableInt32_TSource_2(Type TSource) =>
              (s_Average_NullableInt32_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, int?>>, double?>(Queryable.Average).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Average_Single_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Average_Single_TSource_2(Type TSource) =>
              (s_Average_Single_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, float>>, float>(Queryable.Average).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Average_NullableSingle_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Average_NullableSingle_TSource_2(Type TSource) =>
              (s_Average_NullableSingle_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, float?>>, float?>(Queryable.Average).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Average_Int64_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Average_Int64_TSource_2(Type TSource) =>
              (s_Average_Int64_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, long>>, double>(Queryable.Average).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Average_NullableInt64_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Average_NullableInt64_TSource_2(Type TSource) =>
              (s_Average_NullableInt64_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, long?>>, double?>(Queryable.Average).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Average_Double_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Average_Double_TSource_2(Type TSource) =>
              (s_Average_Double_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, double>>, double>(Queryable.Average).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Average_NullableDouble_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Average_NullableDouble_TSource_2(Type TSource) =>
              (s_Average_NullableDouble_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, double?>>, double?>(Queryable.Average).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Average_Decimal_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Average_Decimal_TSource_2(Type TSource) =>
              (s_Average_Decimal_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, decimal>>, decimal>(Queryable.Average).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Average_NullableDecimal_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Average_NullableDecimal_TSource_2(Type TSource) =>
              (s_Average_NullableDecimal_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, decimal?>>, decimal?>(Queryable.Average).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Cast_TResult_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Cast_TResult_1(Type TResult) =>
              (s_Cast_TResult_1 ??= new Func<IQueryable, IQueryable<object>>(Queryable.Cast<object>).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TResult);
 
         private static MethodInfo? s_Chunk_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Chunk_TSource_1(Type TSource) =>
              (s_Chunk_TSource_1 ??= new Func<IQueryable<object>, int, IQueryable<object>>(Queryable.Chunk).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Concat_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Concat_TSource_2(Type TSource) =>
              (s_Concat_TSource_2 ??= new Func<IQueryable<object>, IEnumerable<object>, IQueryable<object>>(Queryable.Concat).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Contains_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Contains_TSource_2(Type TSource) =>
              (s_Contains_TSource_2 ??= new Func<IQueryable<object>, object, bool>(Queryable.Contains).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Contains_TSource_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Contains_TSource_3(Type TSource) =>
              (s_Contains_TSource_3 ??= new Func<IQueryable<object>, object, IEqualityComparer<object>, bool>(Queryable.Contains).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Count_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Count_TSource_1(Type TSource) =>
              (s_Count_TSource_1 ??= new Func<IQueryable<object>, int>(Queryable.Count).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Count_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Count_TSource_2(Type TSource) =>
              (s_Count_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, int>(Queryable.Count).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_DefaultIfEmpty_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo DefaultIfEmpty_TSource_1(Type TSource) =>
              (s_DefaultIfEmpty_TSource_1 ??= new Func<IQueryable<object>, IQueryable<object?>>(Queryable.DefaultIfEmpty).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_DefaultIfEmpty_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo DefaultIfEmpty_TSource_2(Type TSource) =>
              (s_DefaultIfEmpty_TSource_2 ??= new Func<IQueryable<object>, object, IQueryable<object?>>(Queryable.DefaultIfEmpty).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Distinct_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Distinct_TSource_1(Type TSource) =>
              (s_Distinct_TSource_1 ??= new Func<IQueryable<object>, IQueryable<object>>(Queryable.Distinct).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Distinct_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Distinct_TSource_2(Type TSource) =>
              (s_Distinct_TSource_2 ??= new Func<IQueryable<object>, IEqualityComparer<object>, IQueryable<object>>(Queryable.Distinct).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_DistinctBy_TSource_TKey_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo DistinctBy_TSource_TKey_2(Type TSource, Type TKey) =>
              (s_DistinctBy_TSource_TKey_2 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, IQueryable<object>>(Queryable.DistinctBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_DistinctBy_TSource_TKey_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo DistinctBy_TSource_TKey_3(Type TSource, Type TKey) =>
              (s_DistinctBy_TSource_TKey_3 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, IEqualityComparer<object>, IQueryable<object>>(Queryable.DistinctBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_ElementAt_Int32_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo ElementAt_Int32_TSource_2(Type TSource) =>
              (s_ElementAt_Int32_TSource_2 ??= new Func<IQueryable<object>, int, object>(Queryable.ElementAt).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_ElementAt_Index_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo ElementAt_Index_TSource_2(Type TSource) =>
              (s_ElementAt_Index_TSource_2 ??= new Func<IQueryable<object>, Index, object>(Queryable.ElementAt).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_ElementAtOrDefault_Int32_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo ElementAtOrDefault_Int32_TSource_2(Type TSource) =>
              (s_ElementAtOrDefault_Int32_TSource_2 ??= new Func<IQueryable<object>, int, object?>(Queryable.ElementAtOrDefault).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_ElementAtOrDefault_Index_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo ElementAtOrDefault_Index_TSource_2(Type TSource) =>
              (s_ElementAtOrDefault_Index_TSource_2 ??= new Func<IQueryable<object>, Index, object?>(Queryable.ElementAtOrDefault).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Except_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Except_TSource_2(Type TSource) =>
              (s_Except_TSource_2 ??= new Func<IQueryable<object>, IEnumerable<object>, IQueryable<object>>(Queryable.Except).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Except_TSource_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Except_TSource_3(Type TSource) =>
              (s_Except_TSource_3 ??= new Func<IQueryable<object>, IEnumerable<object>, IEqualityComparer<object>, IQueryable<object>>(Queryable.Except).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_ExceptBy_TSource_TKey_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo ExceptBy_TSource_TKey_3(Type TSource, Type TKey) =>
              (s_ExceptBy_TSource_TKey_3 ??= new Func<IQueryable<object>, IEnumerable<object>, Expression<Func<object, object>>, IQueryable<object>>(Queryable.ExceptBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_ExceptBy_TSource_TKey_4;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo ExceptBy_TSource_TKey_4(Type TSource, Type TKey) =>
              (s_ExceptBy_TSource_TKey_4 ??= new Func<IQueryable<object>, IEnumerable<object>, Expression<Func<object, object>>, IEqualityComparer<object>, IQueryable<object>>(Queryable.ExceptBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_First_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo First_TSource_1(Type TSource) =>
              (s_First_TSource_1 ??= new Func<IQueryable<object>, object>(Queryable.First).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_First_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo First_TSource_2(Type TSource) =>
              (s_First_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, object>(Queryable.First).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_FirstOrDefault_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo FirstOrDefault_TSource_1(Type TSource) =>
              (s_FirstOrDefault_TSource_1 ??= new Func<IQueryable<object>, object?>(Queryable.FirstOrDefault).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_FirstOrDefault_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo FirstOrDefault_TSource_2(Type TSource) =>
              (s_FirstOrDefault_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, object?>(Queryable.FirstOrDefault).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_FirstOrDefault_TSource_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo FirstOrDefault_TSource_3(Type TSource) =>
             (s_FirstOrDefault_TSource_3 ??= new Func<IQueryable<object>, object, object>(Queryable.FirstOrDefault).GetMethodInfo().GetGenericMethodDefinition())
             .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_FirstOrDefault_TSource_4;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo FirstOrDefault_TSource_4(Type TSource) =>
             (s_FirstOrDefault_TSource_4 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, object, object>(Queryable.FirstOrDefault).GetMethodInfo().GetGenericMethodDefinition())
             .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_GroupBy_TSource_TKey_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo GroupBy_TSource_TKey_2(Type TSource, Type TKey) =>
              (s_GroupBy_TSource_TKey_2 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, IQueryable<IGrouping<object, object>>>(Queryable.GroupBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_GroupBy_TSource_TKey_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo GroupBy_TSource_TKey_3(Type TSource, Type TKey) =>
              (s_GroupBy_TSource_TKey_3 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, IEqualityComparer<object>, IQueryable<IGrouping<object, object>>>(Queryable.GroupBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_GroupBy_TSource_TKey_TElement_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo GroupBy_TSource_TKey_TElement_3(Type TSource, Type TKey, Type TElement) =>
              (s_GroupBy_TSource_TKey_TElement_3 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, Expression<Func<object, object>>, IQueryable<IGrouping<object, object>>>(Queryable.GroupBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey, TElement);
 
         private static MethodInfo? s_GroupBy_TSource_TKey_TElement_4;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo GroupBy_TSource_TKey_TElement_4(Type TSource, Type TKey, Type TElement) =>
              (s_GroupBy_TSource_TKey_TElement_4 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, Expression<Func<object, object>>, IEqualityComparer<object>, IQueryable<IGrouping<object, object>>>(Queryable.GroupBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey, TElement);
 
         private static MethodInfo? s_GroupBy_TSource_TKey_TResult_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo GroupBy_TSource_TKey_TResult_3(Type TSource, Type TKey, Type TResult) =>
              (s_GroupBy_TSource_TKey_TResult_3 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, Expression<Func<object, IEnumerable<object>, object>>, IQueryable<object>>(Queryable.GroupBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey, TResult);
 
         private static MethodInfo? s_GroupBy_TSource_TKey_TResult_4;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo GroupBy_TSource_TKey_TResult_4(Type TSource, Type TKey, Type TResult) =>
              (s_GroupBy_TSource_TKey_TResult_4 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, Expression<Func<object, IEnumerable<object>, object>>, IEqualityComparer<object>, IQueryable<object>>(Queryable.GroupBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey, TResult);
 
         private static MethodInfo? s_GroupBy_TSource_TKey_TElement_TResult_4;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo GroupBy_TSource_TKey_TElement_TResult_4(Type TSource, Type TKey, Type TElement, Type TResult) =>
              (s_GroupBy_TSource_TKey_TElement_TResult_4 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, Expression<Func<object, object>>, Expression<Func<object, IEnumerable<object>, object>>, IQueryable<object>>(Queryable.GroupBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey, TElement, TResult);
 
         private static MethodInfo? s_GroupBy_TSource_TKey_TElement_TResult_5;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo GroupBy_TSource_TKey_TElement_TResult_5(Type TSource, Type TKey, Type TElement, Type TResult) =>
              (s_GroupBy_TSource_TKey_TElement_TResult_5 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, Expression<Func<object, object>>, Expression<Func<object, IEnumerable<object>, object>>, IEqualityComparer<object>, IQueryable<object>>(Queryable.GroupBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey, TElement, TResult);
 
         private static MethodInfo? s_GroupJoin_TOuter_TInner_TKey_TResult_5;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo GroupJoin_TOuter_TInner_TKey_TResult_5(Type TOuter, Type TInner, Type TKey, Type TResult) =>
              (s_GroupJoin_TOuter_TInner_TKey_TResult_5 ??= new Func<IQueryable<object>, IEnumerable<object>, Expression<Func<object, object>>, Expression<Func<object, object>>, Expression<Func<object, IEnumerable<object>, object>>, IQueryable<object>>(Queryable.GroupJoin).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TOuter, TInner, TKey, TResult);
 
         private static MethodInfo? s_GroupJoin_TOuter_TInner_TKey_TResult_6;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo GroupJoin_TOuter_TInner_TKey_TResult_6(Type TOuter, Type TInner, Type TKey, Type TResult) =>
              (s_GroupJoin_TOuter_TInner_TKey_TResult_6 ??= new Func<IQueryable<object>, IEnumerable<object>, Expression<Func<object, object>>, Expression<Func<object, object>>, Expression<Func<object, IEnumerable<object>, object>>, IEqualityComparer<object>, IQueryable<object>>(Queryable.GroupJoin).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TOuter, TInner, TKey, TResult);
 
         private static MethodInfo? s_Intersect_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Intersect_TSource_2(Type TSource) =>
              (s_Intersect_TSource_2 ??= new Func<IQueryable<object>, IEnumerable<object>, IQueryable<object>>(Queryable.Intersect).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Intersect_TSource_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Intersect_TSource_3(Type TSource) =>
              (s_Intersect_TSource_3 ??= new Func<IQueryable<object>, IEnumerable<object>, IEqualityComparer<object>, IQueryable<object>>(Queryable.Intersect).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_IntersectBy_TSource_TKey_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo IntersectBy_TSource_TKey_3(Type TSource, Type TKey) =>
              (s_IntersectBy_TSource_TKey_3 ??= new Func<IQueryable<object>, IEnumerable<object>, Expression<Func<object, object>>, IQueryable<object>>(Queryable.IntersectBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_IntersectBy_TSource_TKey_4;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo IntersectBy_TSource_TKey_4(Type TSource, Type TKey) =>
              (s_IntersectBy_TSource_TKey_4 ??= new Func<IQueryable<object>, IEnumerable<object>, Expression<Func<object, object>>, IEqualityComparer<object>, IQueryable<object>>(Queryable.IntersectBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_Join_TOuter_TInner_TKey_TResult_5;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Join_TOuter_TInner_TKey_TResult_5(Type TOuter, Type TInner, Type TKey, Type TResult) =>
              (s_Join_TOuter_TInner_TKey_TResult_5 ??= new Func<IQueryable<object>, IEnumerable<object>, Expression<Func<object, object>>, Expression<Func<object, object>>, Expression<Func<object, object, object>>, IQueryable<object>>(Queryable.Join).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TOuter, TInner, TKey, TResult);
 
         private static MethodInfo? s_Join_TOuter_TInner_TKey_TResult_6;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Join_TOuter_TInner_TKey_TResult_6(Type TOuter, Type TInner, Type TKey, Type TResult) =>
              (s_Join_TOuter_TInner_TKey_TResult_6 ??= new Func<IQueryable<object>, IEnumerable<object>, Expression<Func<object, object>>, Expression<Func<object, object>>, Expression<Func<object, object, object>>, IEqualityComparer<object>, IQueryable<object>>(Queryable.Join).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TOuter, TInner, TKey, TResult);
 
         private static MethodInfo? s_Last_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Last_TSource_1(Type TSource) =>
              (s_Last_TSource_1 ??= new Func<IQueryable<object>, object>(Queryable.Last).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Last_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Last_TSource_2(Type TSource) =>
              (s_Last_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, object>(Queryable.Last).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_LastOrDefault_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo LastOrDefault_TSource_1(Type TSource) =>
              (s_LastOrDefault_TSource_1 ??= new Func<IQueryable<object>, object?>(Queryable.LastOrDefault).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_LastOrDefault_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo LastOrDefault_TSource_2(Type TSource) =>
              (s_LastOrDefault_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, object?>(Queryable.LastOrDefault).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_LastOrDefault_TSource_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo LastOrDefault_TSource_3(Type TSource) =>
             (s_LastOrDefault_TSource_3 ??= new Func<IQueryable<object>, object, object>(Queryable.LastOrDefault).GetMethodInfo().GetGenericMethodDefinition())
             .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_LastOrDefault_TSource_4;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo LastOrDefault_TSource_4(Type TSource) =>
             (s_LastOrDefault_TSource_4 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, object, object>(Queryable.LastOrDefault).GetMethodInfo().GetGenericMethodDefinition())
             .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_LongCount_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo LongCount_TSource_1(Type TSource) =>
              (s_LongCount_TSource_1 ??= new Func<IQueryable<object>, long>(Queryable.LongCount).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_LongCount_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo LongCount_TSource_2(Type TSource) =>
              (s_LongCount_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, long>(Queryable.LongCount).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Max_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Max_TSource_1(Type TSource) =>
              (s_Max_TSource_1 ??= new Func<IQueryable<object>, object?>(Queryable.Max).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Max_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Max_TSource_2(Type TSource) =>
              (s_Max_TSource_2 ??= new Func<IQueryable<object>, IComparer<object>, object?>(Queryable.Max).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Max_TSource_TResult_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Max_TSource_TResult_2(Type TSource, Type TResult) =>
              (s_Max_TSource_TResult_2 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, object?>(Queryable.Max).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TResult);
 
         private static MethodInfo? s_MaxBy_TSource_TKey_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo MaxBy_TSource_TKey_2(Type TSource, Type TKey) =>
              (s_MaxBy_TSource_TKey_2 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, object?>(Queryable.MaxBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_MaxBy_TSource_TKey_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo MaxBy_TSource_TKey_3(Type TSource, Type TKey) =>
              (s_MaxBy_TSource_TKey_3 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, IComparer<object>, object?>(Queryable.MaxBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_Min_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Min_TSource_1(Type TSource) =>
              (s_Min_TSource_1 ??= new Func<IQueryable<object>, object?>(Queryable.Min).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Min_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Min_TSource_2(Type TSource) =>
              (s_Min_TSource_2 ??= new Func<IQueryable<object>, IComparer<object>, object?>(Queryable.Min).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Min_TSource_TResult_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Min_TSource_TResult_2(Type TSource, Type TResult) =>
              (s_Min_TSource_TResult_2 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, object?>(Queryable.Min).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TResult);
 
         private static MethodInfo? s_MinBy_TSource_TKey_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo MinBy_TSource_TKey_2(Type TSource, Type TKey) =>
              (s_MinBy_TSource_TKey_2 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, object?>(Queryable.MinBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_MinBy_TSource_TKey_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo MinBy_TSource_TKey_3(Type TSource, Type TKey) =>
              (s_MinBy_TSource_TKey_3 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, IComparer<object>, object?>(Queryable.MinBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_OfType_TResult_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo OfType_TResult_1(Type TResult) =>
              (s_OfType_TResult_1 ??= new Func<IQueryable, IQueryable<object>>(Queryable.OfType<object>).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TResult);
 
         private static MethodInfo? s_Order_T_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Order_T_1(Type T) =>
              (s_Order_T_1 ??= new Func<IQueryable<object>, IOrderedQueryable<object>>(Queryable.Order).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(T);
 
         private static MethodInfo? s_Order_T_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Order_T_2(Type T) =>
              (s_Order_T_2 ??= new Func<IQueryable<object>, IComparer<object>, IOrderedQueryable<object>>(Queryable.Order).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(T);
 
         private static MethodInfo? s_OrderBy_TSource_TKey_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo OrderBy_TSource_TKey_2(Type TSource, Type TKey) =>
              (s_OrderBy_TSource_TKey_2 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, IOrderedQueryable<object>>(Queryable.OrderBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_OrderDescending_T_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo OrderDescending_T_1(Type T) =>
              (s_OrderDescending_T_1 ??= new Func<IQueryable<object>, IOrderedQueryable<object>>(Queryable.OrderDescending).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(T);
 
         private static MethodInfo? s_OrderDescending_T_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo OrderDescending_T_2(Type T) =>
              (s_OrderDescending_T_2 ??= new Func<IQueryable<object>, IComparer<object>, IOrderedQueryable<object>>(Queryable.OrderDescending).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(T);
 
         private static MethodInfo? s_OrderBy_TSource_TKey_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo OrderBy_TSource_TKey_3(Type TSource, Type TKey) =>
              (s_OrderBy_TSource_TKey_3 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, IComparer<object>, IOrderedQueryable<object>>(Queryable.OrderBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_OrderByDescending_TSource_TKey_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo OrderByDescending_TSource_TKey_2(Type TSource, Type TKey) =>
              (s_OrderByDescending_TSource_TKey_2 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, IOrderedQueryable<object>>(Queryable.OrderByDescending).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_OrderByDescending_TSource_TKey_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo OrderByDescending_TSource_TKey_3(Type TSource, Type TKey) =>
              (s_OrderByDescending_TSource_TKey_3 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, IComparer<object>, IOrderedQueryable<object>>(Queryable.OrderByDescending).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_Reverse_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Reverse_TSource_1(Type TSource) =>
              (s_Reverse_TSource_1 ??= new Func<IQueryable<object>, IQueryable<object>>(Queryable.Reverse).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Select_TSource_TResult_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Select_TSource_TResult_2(Type TSource, Type TResult) =>
              (s_Select_TSource_TResult_2 ??= new Func<IQueryable<object>, Expression<Func<object, object>>, IQueryable<object>>(Queryable.Select).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TResult);
 
         private static MethodInfo? s_Select_Index_TSource_TResult_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Select_Index_TSource_TResult_2(Type TSource, Type TResult) =>
              (s_Select_Index_TSource_TResult_2 ??= new Func<IQueryable<object>, Expression<Func<object, int, object>>, IQueryable<object>>(Queryable.Select).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TResult);
 
         private static MethodInfo? s_SelectMany_TSource_TResult_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo SelectMany_TSource_TResult_2(Type TSource, Type TResult) =>
              (s_SelectMany_TSource_TResult_2 ??= new Func<IQueryable<object>, Expression<Func<object, IEnumerable<object>>>, IQueryable<object>>(Queryable.SelectMany).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TResult);
 
         private static MethodInfo? s_SelectMany_Index_TSource_TResult_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo SelectMany_Index_TSource_TResult_2(Type TSource, Type TResult) =>
              (s_SelectMany_Index_TSource_TResult_2 ??= new Func<IQueryable<object>, Expression<Func<object, int, IEnumerable<object>>>, IQueryable<object>>(Queryable.SelectMany).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TResult);
 
         private static MethodInfo? s_SelectMany_Index_TSource_TCollection_TResult_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo SelectMany_Index_TSource_TCollection_TResult_3(Type TSource, Type TCollection, Type TResult) =>
              (s_SelectMany_Index_TSource_TCollection_TResult_3 ??= new Func<IQueryable<object>, Expression<Func<object, int, IEnumerable<object>>>, Expression<Func<object, object, object>>, IQueryable<object>>(Queryable.SelectMany).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TCollection, TResult);
 
         private static MethodInfo? s_SelectMany_TSource_TCollection_TResult_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo SelectMany_TSource_TCollection_TResult_3(Type TSource, Type TCollection, Type TResult) =>
              (s_SelectMany_TSource_TCollection_TResult_3 ??= new Func<IQueryable<object>, Expression<Func<object, IEnumerable<object>>>, Expression<Func<object, object, object>>, IQueryable<object>>(Queryable.SelectMany).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TCollection, TResult);
 
         private static MethodInfo? s_SequenceEqual_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo SequenceEqual_TSource_2(Type TSource) =>
              (s_SequenceEqual_TSource_2 ??= new Func<IQueryable<object>, IEnumerable<object>, bool>(Queryable.SequenceEqual).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_SequenceEqual_TSource_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo SequenceEqual_TSource_3(Type TSource) =>
              (s_SequenceEqual_TSource_3 ??= new Func<IQueryable<object>, IEnumerable<object>, IEqualityComparer<object>, bool>(Queryable.SequenceEqual).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Single_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Single_TSource_1(Type TSource) =>
              (s_Single_TSource_1 ??= new Func<IQueryable<object>, object>(Queryable.Single).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Single_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Single_TSource_2(Type TSource) =>
              (s_Single_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, object>(Queryable.Single).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_SingleOrDefault_TSource_1;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo SingleOrDefault_TSource_1(Type TSource) =>
              (s_SingleOrDefault_TSource_1 ??= new Func<IQueryable<object>, object?>(Queryable.SingleOrDefault).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_SingleOrDefault_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo SingleOrDefault_TSource_2(Type TSource) =>
              (s_SingleOrDefault_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, object?>(Queryable.SingleOrDefault).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_SingleOrDefault_TSource_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo SingleOrDefault_TSource_3(Type TSource) =>
             (s_SingleOrDefault_TSource_3 ??= new Func<IQueryable<object>, object, object>(Queryable.SingleOrDefault).GetMethodInfo().GetGenericMethodDefinition())
              .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_SingleOrDefault_TSource_4;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo SingleOrDefault_TSource_4(Type TSource) =>
             (s_SingleOrDefault_TSource_4 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, object, object>(Queryable.SingleOrDefault).GetMethodInfo().GetGenericMethodDefinition())
              .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Skip_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Skip_TSource_2(Type TSource) =>
              (s_Skip_TSource_2 ??= new Func<IQueryable<object>, int, IQueryable<object>>(Queryable.Skip).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_SkipWhile_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo SkipWhile_TSource_2(Type TSource) =>
              (s_SkipWhile_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, IQueryable<object>>(Queryable.SkipWhile).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_SkipWhile_Index_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo SkipWhile_Index_TSource_2(Type TSource) =>
              (s_SkipWhile_Index_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, int, bool>>, IQueryable<object>>(Queryable.SkipWhile).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
@@ -738,162 +842,189 @@ public static MethodInfo SkipWhile_Index_TSource_2(Type TSource) =>
 
         private static MethodInfo? s_Sum_NullableDecimal_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Sum_NullableDecimal_TSource_2(Type TSource) =>
              (s_Sum_NullableDecimal_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, decimal?>>, decimal?>(Queryable.Sum).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Sum_Int32_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Sum_Int32_TSource_2(Type TSource) =>
              (s_Sum_Int32_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, int>>, int>(Queryable.Sum).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Sum_NullableInt32_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Sum_NullableInt32_TSource_2(Type TSource) =>
              (s_Sum_NullableInt32_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, int?>>, int?>(Queryable.Sum).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Sum_Int64_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Sum_Int64_TSource_2(Type TSource) =>
              (s_Sum_Int64_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, long>>, long>(Queryable.Sum).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Sum_NullableInt64_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Sum_NullableInt64_TSource_2(Type TSource) =>
              (s_Sum_NullableInt64_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, long?>>, long?>(Queryable.Sum).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Sum_Single_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Sum_Single_TSource_2(Type TSource) =>
              (s_Sum_Single_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, float>>, float>(Queryable.Sum).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Sum_NullableSingle_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Sum_NullableSingle_TSource_2(Type TSource) =>
              (s_Sum_NullableSingle_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, float?>>, float?>(Queryable.Sum).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Sum_Double_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Sum_Double_TSource_2(Type TSource) =>
              (s_Sum_Double_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, double>>, double>(Queryable.Sum).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Sum_NullableDouble_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Sum_NullableDouble_TSource_2(Type TSource) =>
              (s_Sum_NullableDouble_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, double?>>, double?>(Queryable.Sum).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Sum_Decimal_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Sum_Decimal_TSource_2(Type TSource) =>
              (s_Sum_Decimal_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, decimal>>, decimal>(Queryable.Sum).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Take_Int32_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Take_Int32_TSource_2(Type TSource) =>
              (s_Take_Int32_TSource_2 ??= new Func<IQueryable<object>, int, IQueryable<object>>(Queryable.Take).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Take_Range_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Take_Range_TSource_2(Type TSource) =>
              (s_Take_Range_TSource_2 ??= new Func<IQueryable<object>, Range, IQueryable<object>>(Queryable.Take).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_TakeWhile_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo TakeWhile_TSource_2(Type TSource) =>
              (s_TakeWhile_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, IQueryable<object>>(Queryable.TakeWhile).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_TakeWhile_Index_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo TakeWhile_Index_TSource_2(Type TSource) =>
              (s_TakeWhile_Index_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, int, bool>>, IQueryable<object>>(Queryable.TakeWhile).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_ThenBy_TSource_TKey_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo ThenBy_TSource_TKey_2(Type TSource, Type TKey) =>
              (s_ThenBy_TSource_TKey_2 ??= new Func<IOrderedQueryable<object>, Expression<Func<object, object>>, IOrderedQueryable<object>>(Queryable.ThenBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_ThenBy_TSource_TKey_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo ThenBy_TSource_TKey_3(Type TSource, Type TKey) =>
              (s_ThenBy_TSource_TKey_3 ??= new Func<IOrderedQueryable<object>, Expression<Func<object, object>>, IComparer<object>, IOrderedQueryable<object>>(Queryable.ThenBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_ThenByDescending_TSource_TKey_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo ThenByDescending_TSource_TKey_2(Type TSource, Type TKey) =>
              (s_ThenByDescending_TSource_TKey_2 ??= new Func<IOrderedQueryable<object>, Expression<Func<object, object>>, IOrderedQueryable<object>>(Queryable.ThenByDescending).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_ThenByDescending_TSource_TKey_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo ThenByDescending_TSource_TKey_3(Type TSource, Type TKey) =>
              (s_ThenByDescending_TSource_TKey_3 ??= new Func<IOrderedQueryable<object>, Expression<Func<object, object>>, IComparer<object>, IOrderedQueryable<object>>(Queryable.ThenByDescending).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_Union_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Union_TSource_2(Type TSource) =>
              (s_Union_TSource_2 ??= new Func<IQueryable<object>, IEnumerable<object>, IQueryable<object>>(Queryable.Union).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Union_TSource_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Union_TSource_3(Type TSource) =>
              (s_Union_TSource_3 ??= new Func<IQueryable<object>, IEnumerable<object>, IEqualityComparer<object>, IQueryable<object>>(Queryable.Union).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_UnionBy_TSource_TKey_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo UnionBy_TSource_TKey_3(Type TSource, Type TKey) =>
              (s_UnionBy_TSource_TKey_3 ??= new Func<IQueryable<object>, IEnumerable<object>, Expression<Func<object, object>>, IQueryable<object>>(Queryable.UnionBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_UnionBy_TSource_TKey_4;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo UnionBy_TSource_TKey_4(Type TSource, Type TKey) =>
              (s_UnionBy_TSource_TKey_4 ??= new Func<IQueryable<object>, IEnumerable<object>, Expression<Func<object, object>>, IEqualityComparer<object>, IQueryable<object>>(Queryable.UnionBy).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource, TKey);
 
         private static MethodInfo? s_Where_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Where_TSource_2(Type TSource) =>
              (s_Where_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, bool>>, IQueryable<object>>(Queryable.Where).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Where_Index_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Where_Index_TSource_2(Type TSource) =>
              (s_Where_Index_TSource_2 ??= new Func<IQueryable<object>, Expression<Func<object, int, bool>>, IQueryable<object>>(Queryable.Where).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Zip_TFirst_TSecond_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Zip_TFirst_TSecond_2(Type TFirst, Type TSecond) =>
             (s_Zip_TFirst_TSecond_2 ??= new Func<IQueryable<object>, IEnumerable<object>, IQueryable<(object, object)>>(Queryable.Zip).GetMethodInfo().GetGenericMethodDefinition())
             .MakeGenericMethod(TFirst, TSecond);
 
         private static MethodInfo? s_Zip_TFirst_TSecond_TResult_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Zip_TFirst_TSecond_TResult_3(Type TFirst, Type TSecond, Type TResult) =>
              (s_Zip_TFirst_TSecond_TResult_3 ??= new Func<IQueryable<object>, IEnumerable<object>, Expression<Func<object, object, object>>, IQueryable<object>>(Queryable.Zip).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TFirst, TSecond, TResult);
 
         private static MethodInfo? s_Zip_TFirst_TSecond_TThird_3;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Zip_TFirst_TSecond_TThird_3(Type TFirst, Type TSecond, Type TThird) =>
              (s_Zip_TFirst_TSecond_TThird_3 ??= new Func<IQueryable<object>, IEnumerable<object>, IEnumerable<object>, IQueryable<(object, object, object)>>(Queryable.Zip).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TFirst, TSecond, TThird);
@@ -901,24 +1032,28 @@ public static MethodInfo Zip_TFirst_TSecond_TThird_3(Type TFirst, Type TSecond,
 
         private static MethodInfo? s_SkipLast_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo SkipLast_TSource_2(Type TSource) =>
              (s_SkipLast_TSource_2 ??= new Func<IQueryable<object>, int, IQueryable<object>>(Queryable.SkipLast).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_TakeLast_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo TakeLast_TSource_2(Type TSource) =>
              (s_TakeLast_TSource_2 ??= new Func<IQueryable<object>, int, IQueryable<object>>(Queryable.TakeLast).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Append_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Append_TSource_2(Type TSource) =>
              (s_Append_TSource_2 ??= new Func<IQueryable<object>, object, IQueryable<object>>(Queryable.Append).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
 
         private static MethodInfo? s_Prepend_TSource_2;
 
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         public static MethodInfo Prepend_TSource_2(Type TSource) =>
              (s_Prepend_TSource_2 ??= new Func<IQueryable<object>, object, IQueryable<object>>(Queryable.Prepend).GetMethodInfo().GetGenericMethodDefinition())
               .MakeGenericMethod(TSource);
diff --git a/src/libraries/System.Linq.Queryable/src/System/Linq/EnumerableExecutor.cs b/src/libraries/System.Linq.Queryable/src/System/Linq/EnumerableExecutor.cs
index 5ff04c6fdcc167..14a4935864c784 100644
--- a/src/libraries/System.Linq.Queryable/src/System/Linq/EnumerableExecutor.cs
+++ b/src/libraries/System.Linq.Queryable/src/System/Linq/EnumerableExecutor.cs
@@ -10,10 +10,12 @@ namespace System.Linq
     public abstract class EnumerableExecutor
     {
         [RequiresUnreferencedCode(Queryable.InMemoryQueryableExtensionMethodsRequiresUnreferencedCode)]
+        [RequiresDynamicCode(Queryable.InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         internal abstract object? ExecuteBoxed();
 
         internal EnumerableExecutor() { }
 
+        [RequiresDynamicCode(Queryable.InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         internal static EnumerableExecutor Create(Expression expression)
         {
             Type execType = typeof(EnumerableExecutor<>).MakeGenericType(expression.Type);
@@ -31,9 +33,11 @@ public EnumerableExecutor(Expression expression)
         }
 
         [RequiresUnreferencedCode(Queryable.InMemoryQueryableExtensionMethodsRequiresUnreferencedCode)]
+        [RequiresDynamicCode(Queryable.InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         internal override object? ExecuteBoxed() => Execute();
 
         [RequiresUnreferencedCode(Queryable.InMemoryQueryableExtensionMethodsRequiresUnreferencedCode)]
+        [RequiresDynamicCode(Queryable.InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         internal T Execute()
         {
             EnumerableRewriter rewriter = new EnumerableRewriter();
diff --git a/src/libraries/System.Linq.Queryable/src/System/Linq/EnumerableQuery.cs b/src/libraries/System.Linq.Queryable/src/System/Linq/EnumerableQuery.cs
index 97c4b0daeb75c3..222f030bb8f4d6 100644
--- a/src/libraries/System.Linq.Queryable/src/System/Linq/EnumerableQuery.cs
+++ b/src/libraries/System.Linq.Queryable/src/System/Linq/EnumerableQuery.cs
@@ -16,6 +16,7 @@ public abstract class EnumerableQuery
         internal EnumerableQuery() { }
 
         [RequiresUnreferencedCode(Queryable.InMemoryQueryableExtensionMethodsRequiresUnreferencedCode)]
+        [RequiresDynamicCode(Queryable.InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         internal static IQueryable Create(Type elementType, IEnumerable sequence)
         {
             Type seqType = typeof(EnumerableQuery<>).MakeGenericType(elementType);
@@ -23,6 +24,7 @@ internal static IQueryable Create(Type elementType, IEnumerable sequence)
         }
 
         [RequiresUnreferencedCode(Queryable.InMemoryQueryableExtensionMethodsRequiresUnreferencedCode)]
+        [RequiresDynamicCode(Queryable.InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         internal static IQueryable Create(Type elementType, Expression expression)
         {
             Type seqType = typeof(EnumerableQuery<>).MakeGenericType(elementType);
@@ -30,6 +32,8 @@ internal static IQueryable Create(Type elementType, Expression expression)
         }
     }
 
+    [RequiresDynamicCode(Queryable.InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
+    [RequiresUnreferencedCode(Queryable.InMemoryQueryableExtensionMethodsRequiresUnreferencedCode)]
     public class EnumerableQuery<T> : EnumerableQuery, IOrderedQueryable<T>, IQueryProvider
     {
         private readonly Expression _expression;
@@ -37,14 +41,12 @@ public class EnumerableQuery<T> : EnumerableQuery, IOrderedQueryable<T>, IQueryP
 
         IQueryProvider IQueryable.Provider => this;
 
-        [RequiresUnreferencedCode(Queryable.InMemoryQueryableExtensionMethodsRequiresUnreferencedCode)]
         public EnumerableQuery(IEnumerable<T> enumerable)
         {
             _enumerable = enumerable;
             _expression = Expression.Constant(this);
         }
 
-        [RequiresUnreferencedCode(Queryable.InMemoryQueryableExtensionMethodsRequiresUnreferencedCode)]
         public EnumerableQuery(Expression expression)
         {
             _expression = expression;
@@ -58,8 +60,6 @@ public EnumerableQuery(Expression expression)
 
         Type IQueryable.ElementType => typeof(T);
 
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
-            Justification = "This class's ctor is annotated as RequiresUnreferencedCode.")]
         IQueryable IQueryProvider.CreateQuery(Expression expression)
         {
             ArgumentNullException.ThrowIfNull(expression);
@@ -70,8 +70,6 @@ IQueryable IQueryProvider.CreateQuery(Expression expression)
             return Create(iqType.GetGenericArguments()[0], expression);
         }
 
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
-            Justification = "This class's ctor is annotated as RequiresUnreferencedCode.")]
         IQueryable<TElement> IQueryProvider.CreateQuery<TElement>(Expression expression)
         {
             ArgumentNullException.ThrowIfNull(expression);
@@ -83,8 +81,6 @@ IQueryable<TElement> IQueryProvider.CreateQuery<TElement>(Expression expression)
             return new EnumerableQuery<TElement>(expression);
         }
 
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
-            Justification = "This class's ctor is annotated as RequiresUnreferencedCode.")]
         object? IQueryProvider.Execute(Expression expression)
         {
             ArgumentNullException.ThrowIfNull(expression);
@@ -92,8 +88,6 @@ IQueryable<TElement> IQueryProvider.CreateQuery<TElement>(Expression expression)
             return EnumerableExecutor.Create(expression).ExecuteBoxed();
         }
 
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
-            Justification = "This class's ctor is annotated as RequiresUnreferencedCode.")]
         TElement IQueryProvider.Execute<TElement>(Expression expression)
         {
             ArgumentNullException.ThrowIfNull(expression);
@@ -107,8 +101,6 @@ TElement IQueryProvider.Execute<TElement>(Expression expression)
 
         IEnumerator<T> IEnumerable<T>.GetEnumerator() => GetEnumerator();
 
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
-            Justification = "This class's ctor is annotated as RequiresUnreferencedCode.")]
         private IEnumerator<T> GetEnumerator()
         {
             if (_enumerable == null)
diff --git a/src/libraries/System.Linq.Queryable/src/System/Linq/EnumerableRewriter.cs b/src/libraries/System.Linq.Queryable/src/System/Linq/EnumerableRewriter.cs
index 17cedfed6291f6..2490a787a90367 100644
--- a/src/libraries/System.Linq.Queryable/src/System/Linq/EnumerableRewriter.cs
+++ b/src/libraries/System.Linq.Queryable/src/System/Linq/EnumerableRewriter.cs
@@ -11,6 +11,8 @@
 
 namespace System.Linq
 {
+    [RequiresUnreferencedCode(Queryable.InMemoryQueryableExtensionMethodsRequiresUnreferencedCode)]
+    [RequiresDynamicCode("Requires MakeGenericType")]
     internal sealed class EnumerableRewriter : ExpressionVisitor
     {
         // We must ensure that if a LabelTarget is rewritten that it is always rewritten to the same new target
@@ -19,13 +21,10 @@ internal sealed class EnumerableRewriter : ExpressionVisitor
         // Finding equivalent types can be relatively expensive, and hitting with the same types repeatedly is quite likely.
         private Dictionary<Type, Type>? _equivalentTypeCache;
 
-        [RequiresUnreferencedCode(Queryable.InMemoryQueryableExtensionMethodsRequiresUnreferencedCode)]
         public EnumerableRewriter()
         {
         }
 
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
-            Justification = "This class's ctor is annotated as RequiresUnreferencedCode.")]
         protected override Expression VisitMethodCall(MethodCallExpression m)
         {
             Expression? obj = Visit(m.Object);
@@ -196,38 +195,26 @@ private Type GetEquivalentType(Type type)
                 }
                 if (equiv == null)
                 {
-                    equiv = GetEquivalentTypeToEnumerables(pubType);
-
-                    [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
-                        Justification = "The enumerable interface type (IOrderedQueryable<>, IOrderedEnumerable<>, IQueryable<> and IEnumerable<>) " +
-                            "is kept since it's directly referenced here" +
-                            "and so it will also be preserved in all places where it's implemented." +
-                            "The GetInterfaces may return less after trimming but it will include" +
-                            "the enumerable interface type if it was there before trimming, which is enough for this" +
-                            "method to work.")]
-                    static Type GetEquivalentTypeToEnumerables(Type sourceType)
+                    var interfacesWithInfo = pubType.GetInterfaces();
+                    var singleTypeGenInterfacesWithGetType = interfacesWithInfo
+                        .Where(i => i.IsGenericType && i.GenericTypeArguments.Length == 1)
+                        .Select(i => new { Info = i, GenType = i.GetGenericTypeDefinition() })
+                        .ToArray();
+                    Type? typeArg = singleTypeGenInterfacesWithGetType
+                        .Where(i => i.GenType == typeof(IOrderedQueryable<>) || i.GenType == typeof(IOrderedEnumerable<>))
+                        .Select(i => i.Info.GenericTypeArguments[0])
+                        .Distinct()
+                        .SingleOrDefault();
+                    if (typeArg != null)
+                        equiv = typeof(IOrderedEnumerable<>).MakeGenericType(typeArg);
+                    else
                     {
-                        var interfacesWithInfo = sourceType.GetInterfaces();
-                        var singleTypeGenInterfacesWithGetType = interfacesWithInfo
-                            .Where(i => i.IsGenericType && i.GenericTypeArguments.Length == 1)
-                            .Select(i => new { Info = i, GenType = i.GetGenericTypeDefinition() })
-                            .ToArray();
-                        Type? typeArg = singleTypeGenInterfacesWithGetType
-                            .Where(i => i.GenType == typeof(IOrderedQueryable<>) || i.GenType == typeof(IOrderedEnumerable<>))
+                        typeArg = singleTypeGenInterfacesWithGetType
+                            .Where(i => i.GenType == typeof(IQueryable<>) || i.GenType == typeof(IEnumerable<>))
                             .Select(i => i.Info.GenericTypeArguments[0])
                             .Distinct()
-                            .SingleOrDefault();
-                        if (typeArg != null)
-                            return typeof(IOrderedEnumerable<>).MakeGenericType(typeArg);
-                        else
-                        {
-                            typeArg = singleTypeGenInterfacesWithGetType
-                                .Where(i => i.GenType == typeof(IQueryable<>) || i.GenType == typeof(IEnumerable<>))
-                                .Select(i => i.Info.GenericTypeArguments[0])
-                                .Distinct()
-                                .Single();
-                            return typeof(IEnumerable<>).MakeGenericType(typeArg);
-                        }
+                            .Single();
+                        equiv = typeof(IEnumerable<>).MakeGenericType(typeArg);
                     }
                 }
                 _equivalentTypeCache.Add(type, equiv);
@@ -275,9 +262,7 @@ private static MethodInfo FindEnumerableMethodForQueryable(string name, ReadOnly
                 "This is safe because all Queryable methods have a DynamicDependency to the corresponding Enumerable method.")]
             static MethodInfo[] GetEnumerableStaticMethods(Type type) =>
                 type.GetMethods(BindingFlags.Public | BindingFlags.Static);
-
-            [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2060:MakeGenericMethod",
-                Justification = "Enumerable methods don't have trim annotations.")]
+            [RequiresDynamicCodeAttribute("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
             MethodInfo ApplyTypeArgs(MethodInfo methodInfo) => typeArgs == null ? methodInfo : methodInfo.MakeGenericMethod(typeArgs);
 
             // In certain cases, there might be ambiguities when resolving matching overloads, for example between
@@ -335,6 +320,7 @@ static bool AreAssignableFromStrict(ParameterInfo[] left, ParameterInfo[] right)
         }
 
         [RequiresUnreferencedCode(Queryable.InMemoryQueryableExtensionMethodsRequiresUnreferencedCode)]
+        [RequiresDynamicCode("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
         private static MethodInfo FindMethod(Type type, string name, ReadOnlyCollection<Expression> args, Type[]? typeArgs)
         {
             using (IEnumerator<MethodInfo> en = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static).Where(m => m.Name == name).GetEnumerator())
@@ -372,9 +358,7 @@ private static bool ArgsMatch(MethodInfo m, ReadOnlyCollection<Expression> args,
                     return false;
 
                 mParams = GetConstrutedGenericParameters(m, typeArgs);
-
-                [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2060:MakeGenericMethod",
-                    Justification = "MakeGenericMethod is only called to get the parameter types, which are only used to make a 'match' decision. The generic method is not invoked.")]
+                [RequiresDynamicCodeAttribute("Calls System.Reflection.MethodInfo.MakeGenericMethod(params Type[])")]
                 static ParameterInfo[] GetConstrutedGenericParameters(MethodInfo method, Type[] genericTypes) =>
                     method.MakeGenericMethod(genericTypes).GetParameters();
             }
@@ -402,6 +386,7 @@ static ParameterInfo[] GetConstrutedGenericParameters(MethodInfo method, Type[]
             return true;
         }
 
+        [RequiresDynamicCode("Calls System.Type.MakeArrayType()")]
         private static Type StripExpression(Type type)
         {
             bool isArray = type.IsArray;
diff --git a/src/libraries/System.Linq.Queryable/src/System/Linq/Queryable.cs b/src/libraries/System.Linq.Queryable/src/System/Linq/Queryable.cs
index 48551411c89987..343899581156b8 100644
--- a/src/libraries/System.Linq.Queryable/src/System/Linq/Queryable.cs
+++ b/src/libraries/System.Linq.Queryable/src/System/Linq/Queryable.cs
@@ -11,8 +11,10 @@ namespace System.Linq
     public static class Queryable
     {
         internal const string InMemoryQueryableExtensionMethodsRequiresUnreferencedCode = "Enumerating in-memory collections as IQueryable can require unreferenced code because expressions referencing IQueryable extension methods can get rebound to IEnumerable extension methods. The IEnumerable extension methods could be trimmed causing the application to fail at runtime.";
+        internal const string InMemoryQueryableExtensionMethodsRequiresDynamicCode = "Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.";
 
         [RequiresUnreferencedCode(InMemoryQueryableExtensionMethodsRequiresUnreferencedCode)]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TElement> AsQueryable<TElement>(this IEnumerable<TElement> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -21,6 +23,7 @@ public static IQueryable<TElement> AsQueryable<TElement>(this IEnumerable<TEleme
         }
 
         [RequiresUnreferencedCode(InMemoryQueryableExtensionMethodsRequiresUnreferencedCode)]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable AsQueryable(this IEnumerable source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -40,6 +43,7 @@ public static IQueryable AsQueryable(this IEnumerable source)
         }
 
         [DynamicDependency("Where`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Where<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -54,6 +58,7 @@ public static IQueryable<TSource> Where<TSource>(this IQueryable<TSource> source
         }
 
         [DynamicDependency("Where`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Where<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -68,6 +73,7 @@ public static IQueryable<TSource> Where<TSource>(this IQueryable<TSource> source
         }
 
         [DynamicDependency("OfType`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> OfType<TResult>(this IQueryable source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -79,6 +85,7 @@ public static IQueryable<TResult> OfType<TResult>(this IQueryable source)
         }
 
         [DynamicDependency("Cast`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> Cast<TResult>(this IQueryable source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -90,6 +97,7 @@ public static IQueryable<TResult> Cast<TResult>(this IQueryable source)
         }
 
         [DynamicDependency("Select`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> Select<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -104,6 +112,7 @@ public static IQueryable<TResult> Select<TSource, TResult>(this IQueryable<TSour
         }
 
         [DynamicDependency("Select`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> Select<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, int, TResult>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -118,6 +127,7 @@ public static IQueryable<TResult> Select<TSource, TResult>(this IQueryable<TSour
         }
 
         [DynamicDependency("SelectMany`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> SelectMany<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, IEnumerable<TResult>>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -132,6 +142,7 @@ public static IQueryable<TResult> SelectMany<TSource, TResult>(this IQueryable<T
         }
 
         [DynamicDependency("SelectMany`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> SelectMany<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, int, IEnumerable<TResult>>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -146,6 +157,7 @@ public static IQueryable<TResult> SelectMany<TSource, TResult>(this IQueryable<T
         }
 
         [DynamicDependency("SelectMany`3", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, int, IEnumerable<TCollection>>> collectionSelector, Expression<Func<TSource, TCollection, TResult>> resultSelector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -161,6 +173,7 @@ public static IQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this
         }
 
         [DynamicDependency("SelectMany`3", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, IEnumerable<TCollection>>> collectionSelector, Expression<Func<TSource, TCollection, TResult>> resultSelector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -182,6 +195,7 @@ private static Expression GetSourceExpression<TSource>(IEnumerable<TSource> sour
         }
 
         [DynamicDependency("Join`4", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, TInner, TResult>> resultSelector)
         {
             ArgumentNullException.ThrowIfNull(outer);
@@ -197,6 +211,7 @@ public static IQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this IQuer
         }
 
         [DynamicDependency("Join`4", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, TInner, TResult>> resultSelector, IEqualityComparer<TKey>? comparer)
         {
             ArgumentNullException.ThrowIfNull(outer);
@@ -212,6 +227,7 @@ public static IQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this IQuer
         }
 
         [DynamicDependency("GroupJoin`4", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, IEnumerable<TInner>, TResult>> resultSelector)
         {
             ArgumentNullException.ThrowIfNull(outer);
@@ -227,6 +243,7 @@ public static IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this
         }
 
         [DynamicDependency("GroupJoin`4", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, IEnumerable<TInner>, TResult>> resultSelector, IEqualityComparer<TKey>? comparer)
         {
             ArgumentNullException.ThrowIfNull(outer);
@@ -266,6 +283,7 @@ public static IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this
         /// The expected behavior is that it sorts the elements of <paramref name="source"/> by itself.
         /// </remarks>
         [DynamicDependency("Order`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IOrderedQueryable<T> Order<T>(this IQueryable<T> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -304,6 +322,7 @@ public static IOrderedQueryable<T> Order<T>(this IQueryable<T> source)
         /// The expected behavior is that it sorts the elements of <paramref name="source"/> by itself.
         /// </remarks>
         [DynamicDependency("Order`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IOrderedQueryable<T> Order<T>(this IQueryable<T> source, IComparer<T> comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -317,6 +336,7 @@ public static IOrderedQueryable<T> Order<T>(this IQueryable<T> source, IComparer
         }
 
         [DynamicDependency("OrderBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -331,6 +351,7 @@ public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this IQueryable<
         }
 
         [DynamicDependency("OrderBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -369,6 +390,7 @@ public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this IQueryable<
         /// The expected behavior is that it sorts the elements of <paramref name="source"/> by itself.
         /// </remarks>
         [DynamicDependency("OrderDescending`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IOrderedQueryable<T> OrderDescending<T>(this IQueryable<T> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -407,6 +429,7 @@ public static IOrderedQueryable<T> OrderDescending<T>(this IQueryable<T> source)
         /// The expected behavior is that it sorts the elements of <paramref name="source"/> by itself.
         /// </remarks>
         [DynamicDependency("OrderDescending`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IOrderedQueryable<T> OrderDescending<T>(this IQueryable<T> source, IComparer<T> comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -420,6 +443,7 @@ public static IOrderedQueryable<T> OrderDescending<T>(this IQueryable<T> source,
         }
 
         [DynamicDependency("OrderByDescending`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -434,6 +458,7 @@ public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(this I
         }
 
         [DynamicDependency("OrderByDescending`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -448,6 +473,7 @@ public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(this I
         }
 
         [DynamicDependency("ThenBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IOrderedQueryable<TSource> ThenBy<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -462,6 +488,7 @@ public static IOrderedQueryable<TSource> ThenBy<TSource, TKey>(this IOrderedQuer
         }
 
         [DynamicDependency("ThenBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IOrderedQueryable<TSource> ThenBy<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -476,6 +503,7 @@ public static IOrderedQueryable<TSource> ThenBy<TSource, TKey>(this IOrderedQuer
         }
 
         [DynamicDependency("ThenByDescending`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IOrderedQueryable<TSource> ThenByDescending<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -490,6 +518,7 @@ public static IOrderedQueryable<TSource> ThenByDescending<TSource, TKey>(this IO
         }
 
         [DynamicDependency("ThenByDescending`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IOrderedQueryable<TSource> ThenByDescending<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -504,6 +533,7 @@ public static IOrderedQueryable<TSource> ThenByDescending<TSource, TKey>(this IO
         }
 
         [DynamicDependency("Take`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Take<TSource>(this IQueryable<TSource> source, int count)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -523,6 +553,7 @@ public static IQueryable<TSource> Take<TSource>(this IQueryable<TSource> source,
         /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
         /// <returns>An <see cref="IQueryable{T}" /> that contains the specified <paramref name="range" /> of elements from the <paramref name="source" /> sequence.</returns>
         [DynamicDependency("Take`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Take<TSource>(this IQueryable<TSource> source, Range range)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -536,6 +567,7 @@ public static IQueryable<TSource> Take<TSource>(this IQueryable<TSource> source,
         }
 
         [DynamicDependency("TakeWhile`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> TakeWhile<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -550,6 +582,7 @@ public static IQueryable<TSource> TakeWhile<TSource>(this IQueryable<TSource> so
         }
 
         [DynamicDependency("TakeWhile`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> TakeWhile<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -564,6 +597,7 @@ public static IQueryable<TSource> TakeWhile<TSource>(this IQueryable<TSource> so
         }
 
         [DynamicDependency("Skip`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Skip<TSource>(this IQueryable<TSource> source, int count)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -577,6 +611,7 @@ public static IQueryable<TSource> Skip<TSource>(this IQueryable<TSource> source,
         }
 
         [DynamicDependency("SkipWhile`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> SkipWhile<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -591,6 +626,7 @@ public static IQueryable<TSource> SkipWhile<TSource>(this IQueryable<TSource> so
         }
 
         [DynamicDependency("SkipWhile`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> SkipWhile<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -605,6 +641,7 @@ public static IQueryable<TSource> SkipWhile<TSource>(this IQueryable<TSource> so
         }
 
         [DynamicDependency("GroupBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -619,6 +656,7 @@ public static IQueryable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this I
         }
 
         [DynamicDependency("GroupBy`3", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -634,6 +672,7 @@ public static IQueryable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElem
         }
 
         [DynamicDependency("GroupBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -648,6 +687,7 @@ public static IQueryable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this I
         }
 
         [DynamicDependency("GroupBy`3", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector, IEqualityComparer<TKey>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -661,6 +701,7 @@ public static IQueryable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElem
         }
 
         [DynamicDependency("GroupBy`4", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector, Expression<Func<TKey, IEnumerable<TElement>, TResult>> resultSelector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -675,6 +716,7 @@ public static IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this
         }
 
         [DynamicDependency("GroupBy`3", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> GroupBy<TSource, TKey, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TKey, IEnumerable<TSource>, TResult>> resultSelector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -690,6 +732,7 @@ public static IQueryable<TResult> GroupBy<TSource, TKey, TResult>(this IQueryabl
         }
 
         [DynamicDependency("GroupBy`3", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> GroupBy<TSource, TKey, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TKey, IEnumerable<TSource>, TResult>> resultSelector, IEqualityComparer<TKey>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -703,6 +746,7 @@ public static IQueryable<TResult> GroupBy<TSource, TKey, TResult>(this IQueryabl
         }
 
         [DynamicDependency("GroupBy`4", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector, Expression<Func<TKey, IEnumerable<TElement>, TResult>> resultSelector, IEqualityComparer<TKey>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -717,6 +761,7 @@ public static IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this
         }
 
         [DynamicDependency("Distinct`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Distinct<TSource>(this IQueryable<TSource> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -728,6 +773,7 @@ public static IQueryable<TSource> Distinct<TSource>(this IQueryable<TSource> sou
         }
 
         [DynamicDependency("Distinct`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Distinct<TSource>(this IQueryable<TSource> source, IEqualityComparer<TSource>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -748,6 +794,7 @@ public static IQueryable<TSource> Distinct<TSource>(this IQueryable<TSource> sou
         /// <returns>An <see cref="IQueryable{T}" /> that contains distinct elements from the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
         [DynamicDependency("DistinctBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> DistinctBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -770,6 +817,7 @@ public static IQueryable<TSource> DistinctBy<TSource, TKey>(this IQueryable<TSou
         /// <returns>An <see cref="IQueryable{T}" /> that contains distinct elements from the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
         [DynamicDependency("DistinctBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> DistinctBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -795,6 +843,7 @@ public static IQueryable<TSource> DistinctBy<TSource, TKey>(this IQueryable<TSou
         /// <para>The last chunk will contain the remaining elements and may be of a smaller size.</para>
         /// </remarks>
         [DynamicDependency("Chunk`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource[]> Chunk<TSource>(this IQueryable<TSource> source, int size)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -808,6 +857,7 @@ public static IQueryable<TSource[]> Chunk<TSource>(this IQueryable<TSource> sour
         }
 
         [DynamicDependency("Concat`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Concat<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -822,6 +872,7 @@ public static IQueryable<TSource> Concat<TSource>(this IQueryable<TSource> sourc
         }
 
         [DynamicDependency("Zip`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<(TFirst First, TSecond Second)> Zip<TFirst, TSecond>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -835,6 +886,7 @@ public static IQueryable<TSource> Concat<TSource>(this IQueryable<TSource> sourc
         }
 
         [DynamicDependency("Zip`3", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TResult> Zip<TFirst, TSecond, TResult>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2, Expression<Func<TFirst, TSecond, TResult>> resultSelector)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -860,6 +912,7 @@ public static IQueryable<TResult> Zip<TFirst, TSecond, TResult>(this IQueryable<
         /// <param name="source3">The third sequence to merge.</param>
         /// <returns>A sequence of tuples with elements taken from the first, second and third sequences, in that order.</returns>
         [DynamicDependency("Zip`3", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2, IEnumerable<TThird> source3)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -875,6 +928,7 @@ public static IQueryable<TResult> Zip<TFirst, TSecond, TResult>(this IQueryable<
         }
 
         [DynamicDependency("Union`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Union<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -889,6 +943,7 @@ public static IQueryable<TSource> Union<TSource>(this IQueryable<TSource> source
         }
 
         [DynamicDependency("Union`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Union<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -913,6 +968,7 @@ public static IQueryable<TSource> Union<TSource>(this IQueryable<TSource> source
         /// <returns>An <see cref="IQueryable{T}" /> that contains the elements from both input sequences, excluding duplicates.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source1" /> or <paramref name="source2" /> is <see langword="null" />.</exception>
         [DynamicDependency("UnionBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> UnionBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, Expression<Func<TSource, TKey>> keySelector)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -937,6 +993,7 @@ public static IQueryable<TSource> UnionBy<TSource, TKey>(this IQueryable<TSource
         /// <returns>An <see cref="IQueryable{T}" /> that contains the elements from both input sequences, excluding duplicates.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source1" /> or <paramref name="source2" /> is <see langword="null" />.</exception>
         [DynamicDependency("UnionBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> UnionBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -955,6 +1012,7 @@ public static IQueryable<TSource> UnionBy<TSource, TKey>(this IQueryable<TSource
         }
 
         [DynamicDependency("Intersect`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Intersect<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -969,6 +1027,7 @@ public static IQueryable<TSource> Intersect<TSource>(this IQueryable<TSource> so
         }
 
         [DynamicDependency("Intersect`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Intersect<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -993,6 +1052,7 @@ public static IQueryable<TSource> Intersect<TSource>(this IQueryable<TSource> so
         /// <returns>A sequence that contains the elements that form the set intersection of two sequences.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source1" /> or <paramref name="source2" /> is <see langword="null" />.</exception>
         [DynamicDependency("IntersectBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> IntersectBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -1019,6 +1079,7 @@ public static IQueryable<TSource> IntersectBy<TSource, TKey>(this IQueryable<TSo
         /// <returns>A sequence that contains the elements that form the set intersection of two sequences.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source1" /> or <paramref name="source2" /> is <see langword="null" />.</exception>
         [DynamicDependency("IntersectBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> IntersectBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -1037,6 +1098,7 @@ public static IQueryable<TSource> IntersectBy<TSource, TKey>(this IQueryable<TSo
         }
 
         [DynamicDependency("Except`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Except<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -1051,6 +1113,7 @@ public static IQueryable<TSource> Except<TSource>(this IQueryable<TSource> sourc
         }
 
         [DynamicDependency("Except`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Except<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -1076,6 +1139,7 @@ public static IQueryable<TSource> Except<TSource>(this IQueryable<TSource> sourc
         /// <param name="keySelector">A function to extract the key for each element.</param>
         /// <returns>A <see cref="IQueryable{TSource}" /> that contains the set difference of the elements of two sequences.</returns>
         [DynamicDependency("ExceptBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> ExceptBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -1103,6 +1167,7 @@ public static IQueryable<TSource> ExceptBy<TSource, TKey>(this IQueryable<TSourc
         /// <param name="comparer">An <see cref="IEqualityComparer{TKey}" /> to compare keys.</param>
         /// <returns>A <see cref="IQueryable{TSource}" /> that contains the set difference of the elements of two sequences.</returns>
         [DynamicDependency("ExceptBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> ExceptBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -1121,6 +1186,7 @@ public static IQueryable<TSource> ExceptBy<TSource, TKey>(this IQueryable<TSourc
         }
 
         [DynamicDependency("First`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource First<TSource>(this IQueryable<TSource> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1132,6 +1198,7 @@ public static TSource First<TSource>(this IQueryable<TSource> source)
         }
 
         [DynamicDependency("First`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource First<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1146,6 +1213,7 @@ public static TSource First<TSource>(this IQueryable<TSource> source, Expression
         }
 
         [DynamicDependency("FirstOrDefault`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? FirstOrDefault<TSource>(this IQueryable<TSource> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1163,6 +1231,7 @@ public static TSource First<TSource>(this IQueryable<TSource> source, Expression
         /// <returns><paramref name="defaultValue" /> if <paramref name="source" /> is empty; otherwise, the first element in <paramref name="source" />.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
         [DynamicDependency("FirstOrDefault`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource FirstOrDefault<TSource>(this IQueryable<TSource> source, TSource defaultValue)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1175,6 +1244,7 @@ public static TSource FirstOrDefault<TSource>(this IQueryable<TSource> source, T
         }
 
         [DynamicDependency("FirstOrDefault`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? FirstOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1196,6 +1266,7 @@ public static TSource FirstOrDefault<TSource>(this IQueryable<TSource> source, T
         /// <returns><paramref name="defaultValue" /> if <paramref name="source" /> is empty or if no element passes the test specified by <paramref name="predicate" />; otherwise, the first element in <paramref name="source" /> that passes the test specified by <paramref name="predicate" />.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source" /> or <paramref name="predicate" /> is <see langword="null" />.</exception>
         [DynamicDependency("FirstOrDefault`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource FirstOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate, TSource defaultValue)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1210,6 +1281,7 @@ public static TSource FirstOrDefault<TSource>(this IQueryable<TSource> source, E
         }
 
         [DynamicDependency("Last`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource Last<TSource>(this IQueryable<TSource> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1221,6 +1293,7 @@ public static TSource Last<TSource>(this IQueryable<TSource> source)
         }
 
         [DynamicDependency("Last`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource Last<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1235,6 +1308,7 @@ public static TSource Last<TSource>(this IQueryable<TSource> source, Expression<
         }
 
         [DynamicDependency("LastOrDefault`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? LastOrDefault<TSource>(this IQueryable<TSource> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1252,6 +1326,7 @@ public static TSource Last<TSource>(this IQueryable<TSource> source, Expression<
         /// <returns><paramref name="defaultValue" /> if the source sequence is empty; otherwise, the last element in the <see cref="IEnumerable{T}" />.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
         [DynamicDependency("LastOrDefault`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource LastOrDefault<TSource>(this IQueryable<TSource> source, TSource defaultValue)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1264,6 +1339,7 @@ public static TSource LastOrDefault<TSource>(this IQueryable<TSource> source, TS
         }
 
         [DynamicDependency("LastOrDefault`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? LastOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1285,6 +1361,7 @@ public static TSource LastOrDefault<TSource>(this IQueryable<TSource> source, TS
         /// <returns><paramref name="defaultValue" /> if the sequence is empty or if no elements pass the test in the predicate function; otherwise, the last element that passes the test in the predicate function.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source" /> or <paramref name="predicate" /> is <see langword="null" />.</exception>
         [DynamicDependency("LastOrDefault`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource LastOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate, TSource defaultValue)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1299,6 +1376,7 @@ public static TSource LastOrDefault<TSource>(this IQueryable<TSource> source, Ex
         }
 
         [DynamicDependency("Single`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource Single<TSource>(this IQueryable<TSource> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1310,6 +1388,7 @@ public static TSource Single<TSource>(this IQueryable<TSource> source)
         }
 
         [DynamicDependency("Single`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource Single<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1324,6 +1403,7 @@ public static TSource Single<TSource>(this IQueryable<TSource> source, Expressio
         }
 
         [DynamicDependency("SingleOrDefault`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? SingleOrDefault<TSource>(this IQueryable<TSource> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1342,6 +1422,7 @@ public static TSource Single<TSource>(this IQueryable<TSource> source, Expressio
         /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
         /// <exception cref="InvalidOperationException">The input sequence contains more than one element.</exception>
         [DynamicDependency("SingleOrDefault`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource SingleOrDefault<TSource>(this IQueryable<TSource> source, TSource defaultValue)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1354,6 +1435,7 @@ public static TSource SingleOrDefault<TSource>(this IQueryable<TSource> source,
         }
 
         [DynamicDependency("SingleOrDefault`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? SingleOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1376,6 +1458,7 @@ public static TSource SingleOrDefault<TSource>(this IQueryable<TSource> source,
         /// <exception cref="ArgumentNullException"><paramref name="source" /> or <paramref name="predicate" /> is <see langword="null" />.</exception>
         /// <exception cref="InvalidOperationException">More than one element satisfies the condition in <paramref name="predicate" />.</exception>
         [DynamicDependency("SingleOrDefault`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource SingleOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate, TSource defaultValue)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1390,6 +1473,7 @@ public static TSource SingleOrDefault<TSource>(this IQueryable<TSource> source,
         }
 
         [DynamicDependency("ElementAt`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource ElementAt<TSource>(this IQueryable<TSource> source, int index)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1413,6 +1497,7 @@ public static TSource ElementAt<TSource>(this IQueryable<TSource> source, int in
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="index" /> is outside the bounds of the <paramref name="source" /> sequence.</exception>
         /// <returns>The element at the specified position in the <paramref name="source" /> sequence.</returns>
         [DynamicDependency("ElementAt`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource ElementAt<TSource>(this IQueryable<TSource> source, Index index)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1429,6 +1514,7 @@ public static TSource ElementAt<TSource>(this IQueryable<TSource> source, Index
         }
 
         [DynamicDependency("ElementAtOrDefault`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? ElementAtOrDefault<TSource>(this IQueryable<TSource> source, int index)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1448,6 +1534,7 @@ public static TSource ElementAt<TSource>(this IQueryable<TSource> source, Index
         /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
         /// <returns><see langword="default" /> if <paramref name="index" /> is outside the bounds of the <paramref name="source" /> sequence; otherwise, the element at the specified position in the <paramref name="source" /> sequence.</returns>
         [DynamicDependency("ElementAtOrDefault`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? ElementAtOrDefault<TSource>(this IQueryable<TSource> source, Index index)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1461,6 +1548,7 @@ public static TSource ElementAt<TSource>(this IQueryable<TSource> source, Index
         }
 
         [DynamicDependency("DefaultIfEmpty`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource?> DefaultIfEmpty<TSource>(this IQueryable<TSource> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1472,6 +1560,7 @@ public static TSource ElementAt<TSource>(this IQueryable<TSource> source, Index
         }
 
         [DynamicDependency("DefaultIfEmpty`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> DefaultIfEmpty<TSource>(this IQueryable<TSource> source, TSource defaultValue)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1485,6 +1574,7 @@ public static IQueryable<TSource> DefaultIfEmpty<TSource>(this IQueryable<TSourc
         }
 
         [DynamicDependency("Contains`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static bool Contains<TSource>(this IQueryable<TSource> source, TSource item)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1498,6 +1588,7 @@ public static bool Contains<TSource>(this IQueryable<TSource> source, TSource it
         }
 
         [DynamicDependency("Contains`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static bool Contains<TSource>(this IQueryable<TSource> source, TSource item, IEqualityComparer<TSource>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1511,6 +1602,7 @@ public static bool Contains<TSource>(this IQueryable<TSource> source, TSource it
         }
 
         [DynamicDependency("Reverse`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Reverse<TSource>(this IQueryable<TSource> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1522,6 +1614,7 @@ public static IQueryable<TSource> Reverse<TSource>(this IQueryable<TSource> sour
         }
 
         [DynamicDependency("SequenceEqual`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static bool SequenceEqual<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -1536,6 +1629,7 @@ public static bool SequenceEqual<TSource>(this IQueryable<TSource> source1, IEnu
         }
 
         [DynamicDependency("SequenceEqual`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static bool SequenceEqual<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source1);
@@ -1552,6 +1646,7 @@ public static bool SequenceEqual<TSource>(this IQueryable<TSource> source1, IEnu
         }
 
         [DynamicDependency("Any`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static bool Any<TSource>(this IQueryable<TSource> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1563,6 +1658,7 @@ public static bool Any<TSource>(this IQueryable<TSource> source)
         }
 
         [DynamicDependency("Any`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static bool Any<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1577,6 +1673,7 @@ public static bool Any<TSource>(this IQueryable<TSource> source, Expression<Func
         }
 
         [DynamicDependency("All`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static bool All<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1591,6 +1688,7 @@ public static bool All<TSource>(this IQueryable<TSource> source, Expression<Func
         }
 
         [DynamicDependency("Count`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static int Count<TSource>(this IQueryable<TSource> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1602,6 +1700,7 @@ public static int Count<TSource>(this IQueryable<TSource> source)
         }
 
         [DynamicDependency("Count`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static int Count<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1616,6 +1715,7 @@ public static int Count<TSource>(this IQueryable<TSource> source, Expression<Fun
         }
 
         [DynamicDependency("LongCount`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static long LongCount<TSource>(this IQueryable<TSource> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1627,6 +1727,7 @@ public static long LongCount<TSource>(this IQueryable<TSource> source)
         }
 
         [DynamicDependency("LongCount`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static long LongCount<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1641,6 +1742,7 @@ public static long LongCount<TSource>(this IQueryable<TSource> source, Expressio
         }
 
         [DynamicDependency("Min`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? Min<TSource>(this IQueryable<TSource> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1659,6 +1761,7 @@ public static long LongCount<TSource>(this IQueryable<TSource> source, Expressio
         /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
         /// <exception cref="ArgumentException">No object in <paramref name="source" /> implements the <see cref="System.IComparable" /> or <see cref="System.IComparable{T}" /> interface.</exception>
         [DynamicDependency("Min`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? Min<TSource>(this IQueryable<TSource> source, IComparer<TSource>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1673,6 +1776,7 @@ public static long LongCount<TSource>(this IQueryable<TSource> source, Expressio
         }
 
         [DynamicDependency("Min`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TResult? Min<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1695,6 +1799,7 @@ public static long LongCount<TSource>(this IQueryable<TSource> source, Expressio
         /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
         /// <exception cref="ArgumentException">No key extracted from <paramref name="source" /> implements the <see cref="IComparable" /> or <see cref="IComparable{TKey}" /> interface.</exception>
         [DynamicDependency("MinBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? MinBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1719,6 +1824,7 @@ public static long LongCount<TSource>(this IQueryable<TSource> source, Expressio
         /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
         /// <exception cref="ArgumentException">No key extracted from <paramref name="source" /> implements the <see cref="IComparable" /> or <see cref="IComparable{TKey}" /> interface.</exception>
         [DynamicDependency("MinBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? MinBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TSource>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1735,6 +1841,7 @@ public static long LongCount<TSource>(this IQueryable<TSource> source, Expressio
         }
 
         [DynamicDependency("Max`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? Max<TSource>(this IQueryable<TSource> source)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1752,6 +1859,7 @@ public static long LongCount<TSource>(this IQueryable<TSource> source, Expressio
         /// <returns>The maximum value in the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
         [DynamicDependency("Max`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? Max<TSource>(this IQueryable<TSource> source, IComparer<TSource>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1766,6 +1874,7 @@ public static long LongCount<TSource>(this IQueryable<TSource> source, Expressio
         }
 
         [DynamicDependency("Max`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TResult? Max<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1788,6 +1897,7 @@ public static long LongCount<TSource>(this IQueryable<TSource> source, Expressio
         /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
         /// <exception cref="ArgumentException">No key extracted from <paramref name="source" /> implements the <see cref="IComparable" /> or <see cref="IComparable{TKey}" /> interface.</exception>
         [DynamicDependency("MaxBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? MaxBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1812,6 +1922,7 @@ public static long LongCount<TSource>(this IQueryable<TSource> source, Expressio
         /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
         /// <exception cref="ArgumentException">No key extracted from <paramref name="source" /> implements the <see cref="IComparable" /> or <see cref="IComparable{TKey}" /> interface.</exception>
         [DynamicDependency("MaxBy`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource? MaxBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TSource>? comparer)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1938,6 +2049,7 @@ public static decimal Sum(this IQueryable<decimal> source)
         }
 
         [DynamicDependency("Sum`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static int Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1952,6 +2064,7 @@ public static int Sum<TSource>(this IQueryable<TSource> source, Expression<Func<
         }
 
         [DynamicDependency("Sum`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static int? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int?>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1966,6 +2079,7 @@ public static int Sum<TSource>(this IQueryable<TSource> source, Expression<Func<
         }
 
         [DynamicDependency("Sum`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static long Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1980,6 +2094,7 @@ public static long Sum<TSource>(this IQueryable<TSource> source, Expression<Func
         }
 
         [DynamicDependency("Sum`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static long? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long?>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -1994,6 +2109,7 @@ public static long Sum<TSource>(this IQueryable<TSource> source, Expression<Func
         }
 
         [DynamicDependency("Sum`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static float Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2008,6 +2124,7 @@ public static float Sum<TSource>(this IQueryable<TSource> source, Expression<Fun
         }
 
         [DynamicDependency("Sum`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static float? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float?>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2022,6 +2139,7 @@ public static float Sum<TSource>(this IQueryable<TSource> source, Expression<Fun
         }
 
         [DynamicDependency("Sum`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static double Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2036,6 +2154,7 @@ public static double Sum<TSource>(this IQueryable<TSource> source, Expression<Fu
         }
 
         [DynamicDependency("Sum`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static double? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double?>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2050,6 +2169,7 @@ public static double Sum<TSource>(this IQueryable<TSource> source, Expression<Fu
         }
 
         [DynamicDependency("Sum`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static decimal Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2064,6 +2184,7 @@ public static decimal Sum<TSource>(this IQueryable<TSource> source, Expression<F
         }
 
         [DynamicDependency("Sum`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static decimal? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal?>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2188,6 +2309,7 @@ public static decimal Average(this IQueryable<decimal> source)
         }
 
         [DynamicDependency("Average`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static double Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2202,6 +2324,7 @@ public static double Average<TSource>(this IQueryable<TSource> source, Expressio
         }
 
         [DynamicDependency("Average`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static double? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int?>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2216,6 +2339,7 @@ public static double Average<TSource>(this IQueryable<TSource> source, Expressio
         }
 
         [DynamicDependency("Average`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static float Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2230,6 +2354,7 @@ public static float Average<TSource>(this IQueryable<TSource> source, Expression
         }
 
         [DynamicDependency("Average`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static float? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float?>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2244,6 +2369,7 @@ public static float Average<TSource>(this IQueryable<TSource> source, Expression
         }
 
         [DynamicDependency("Average`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static double Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2258,6 +2384,7 @@ public static double Average<TSource>(this IQueryable<TSource> source, Expressio
         }
 
         [DynamicDependency("Average`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static double? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long?>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2272,6 +2399,7 @@ public static double Average<TSource>(this IQueryable<TSource> source, Expressio
         }
 
         [DynamicDependency("Average`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static double Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2286,6 +2414,7 @@ public static double Average<TSource>(this IQueryable<TSource> source, Expressio
         }
 
         [DynamicDependency("Average`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static double? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double?>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2300,6 +2429,7 @@ public static double Average<TSource>(this IQueryable<TSource> source, Expressio
         }
 
         [DynamicDependency("Average`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static decimal Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2314,6 +2444,7 @@ public static decimal Average<TSource>(this IQueryable<TSource> source, Expressi
         }
 
         [DynamicDependency("Average`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static decimal? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal?>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2328,6 +2459,7 @@ public static decimal Average<TSource>(this IQueryable<TSource> source, Expressi
         }
 
         [DynamicDependency("Aggregate`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TSource Aggregate<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, TSource, TSource>> func)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2342,6 +2474,7 @@ public static TSource Aggregate<TSource>(this IQueryable<TSource> source, Expres
         }
 
         [DynamicDependency("Aggregate`2", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TAccumulate Aggregate<TSource, TAccumulate>(this IQueryable<TSource> source, TAccumulate seed, Expression<Func<TAccumulate, TSource, TAccumulate>> func)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2356,6 +2489,7 @@ public static TAccumulate Aggregate<TSource, TAccumulate>(this IQueryable<TSourc
         }
 
         [DynamicDependency("Aggregate`3", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static TResult Aggregate<TSource, TAccumulate, TResult>(this IQueryable<TSource> source, TAccumulate seed, Expression<Func<TAccumulate, TSource, TAccumulate>> func, Expression<Func<TAccumulate, TResult>> selector)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2369,6 +2503,7 @@ public static TResult Aggregate<TSource, TAccumulate, TResult>(this IQueryable<T
         }
 
         [DynamicDependency("SkipLast`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> SkipLast<TSource>(this IQueryable<TSource> source, int count)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2382,6 +2517,7 @@ public static IQueryable<TSource> SkipLast<TSource>(this IQueryable<TSource> sou
         }
 
         [DynamicDependency("TakeLast`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> TakeLast<TSource>(this IQueryable<TSource> source, int count)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2395,6 +2531,7 @@ public static IQueryable<TSource> TakeLast<TSource>(this IQueryable<TSource> sou
         }
 
         [DynamicDependency("Append`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Append<TSource>(this IQueryable<TSource> source, TSource element)
         {
             ArgumentNullException.ThrowIfNull(source);
@@ -2408,6 +2545,7 @@ public static IQueryable<TSource> Append<TSource>(this IQueryable<TSource> sourc
         }
 
         [DynamicDependency("Prepend`1", typeof(Enumerable))]
+        [RequiresDynamicCode(InMemoryQueryableExtensionMethodsRequiresDynamicCode)]
         public static IQueryable<TSource> Prepend<TSource>(this IQueryable<TSource> source, TSource element)
         {
             ArgumentNullException.ThrowIfNull(source);
diff --git a/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.txt b/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.txt
index 2d77a903d9f54e..93dd3423e9b827 100644
--- a/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.txt
+++ b/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.txt
@@ -43,6 +43,8 @@ CannotChangeAttribute : Attribute 'System.Runtime.Versioning.SupportedOSPlatform
 CannotChangeAttribute : Attribute 'System.Runtime.Versioning.SupportedOSPlatformAttribute' on 'System.Diagnostics.Process.MinWorkingSet.set(System.IntPtr)' changed from '[SupportedOSPlatformAttribute("freebsd")]' in the contract to '[SupportedOSPlatformAttribute("freebsd")]' in the implementation.
 CannotChangeAttribute : Attribute 'System.Runtime.Versioning.UnsupportedOSPlatformAttribute' on 'System.IO.FileStream.Lock(System.Int64, System.Int64)' changed from '[UnsupportedOSPlatformAttribute("ios")]' in the contract to '[UnsupportedOSPlatformAttribute("freebsd")]' in the implementation.
 CannotChangeAttribute : Attribute 'System.Runtime.Versioning.UnsupportedOSPlatformAttribute' on 'System.IO.FileStream.Unlock(System.Int64, System.Int64)' changed from '[UnsupportedOSPlatformAttribute("ios")]' in the contract to '[UnsupportedOSPlatformAttribute("freebsd")]' in the implementation.
+CannotRemoveAttribute : Attribute 'System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute' exists on 'System.Linq.EnumerableQuery<T>..ctor(System.Collections.Generic.IEnumerable<T>)' in the contract but not the implementation.
+CannotRemoveAttribute : Attribute 'System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute' exists on 'System.Linq.EnumerableQuery<T>..ctor(System.Linq.Expressions.Expression)' in the contract but not the implementation.
 CannotChangeAttribute : Attribute 'System.Runtime.Versioning.UnsupportedOSPlatformAttribute' on 'System.Net.Http.HttpClientHandler.Proxy' changed from '[UnsupportedOSPlatformAttribute("browser")]' in the contract to '[UnsupportedOSPlatformAttribute("browser")]' in the implementation.
 CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Numerics.Vector<T>.CopyTo(System.Span<System.Byte>)' in the contract but not the implementation.
 CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Numerics.Vector<T>.CopyTo(System.Span<T>)' in the contract but not the implementation.
@@ -107,6 +109,8 @@ CannotChangeAttribute : Attribute 'System.Runtime.Versioning.SupportedOSPlatform
 CannotChangeAttribute : Attribute 'System.Runtime.Versioning.SupportedOSPlatformAttribute' on 'System.Diagnostics.Process.MinWorkingSet.set(System.IntPtr)' changed from '[SupportedOSPlatformAttribute("freebsd")]' in the contract to '[SupportedOSPlatformAttribute("freebsd")]' in the implementation.
 CannotChangeAttribute : Attribute 'System.Runtime.Versioning.UnsupportedOSPlatformAttribute' on 'System.Security.Cryptography.X509Certificates.PublicKey.GetDSAPublicKey()' changed from '[UnsupportedOSPlatformAttribute("ios")]' in the contract to '[UnsupportedOSPlatformAttribute("browser")]' in the implementation.
 Compat issues with assembly System.Core:
+CannotRemoveAttribute : Attribute 'System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute' exists on 'System.Linq.EnumerableQuery<T>..ctor(System.Collections.Generic.IEnumerable<T>)' in the contract but not the implementation.
+CannotRemoveAttribute : Attribute 'System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute' exists on 'System.Linq.EnumerableQuery<T>..ctor(System.Linq.Expressions.Expression)' in the contract but not the implementation.
 CannotRemoveAttribute : Attribute 'System.Runtime.Versioning.UnsupportedOSPlatformAttribute' exists on 'System.Security.Cryptography.Aes' in the contract but not the implementation.
 CannotRemoveAttribute : Attribute 'System.Runtime.Versioning.UnsupportedOSPlatformAttribute' exists on 'System.Security.Cryptography.AesManaged' in the contract but not the implementation.
 CannotRemoveAttribute : Attribute 'System.Runtime.Versioning.UnsupportedOSPlatformAttribute' exists on 'System.Security.Cryptography.ECCurve' in the contract but not the implementation.
@@ -121,6 +125,9 @@ CannotChangeAttribute : Attribute 'System.Runtime.Versioning.SupportedOSPlatform
 Compat issues with assembly System.IO.FileSystem:
 CannotChangeAttribute : Attribute 'System.Runtime.Versioning.UnsupportedOSPlatformAttribute' on 'System.IO.FileStream.Lock(System.Int64, System.Int64)' changed from '[UnsupportedOSPlatformAttribute("ios")]' in the contract to '[UnsupportedOSPlatformAttribute("freebsd")]' in the implementation.
 CannotChangeAttribute : Attribute 'System.Runtime.Versioning.UnsupportedOSPlatformAttribute' on 'System.IO.FileStream.Unlock(System.Int64, System.Int64)' changed from '[UnsupportedOSPlatformAttribute("ios")]' in the contract to '[UnsupportedOSPlatformAttribute("freebsd")]' in the implementation.
+Compat issues with assembly System.Linq.Queryable:
+CannotRemoveAttribute : Attribute 'System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute' exists on 'System.Linq.EnumerableQuery<T>..ctor(System.Collections.Generic.IEnumerable<T>)' in the contract but not the implementation.
+CannotRemoveAttribute : Attribute 'System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute' exists on 'System.Linq.EnumerableQuery<T>..ctor(System.Linq.Expressions.Expression)' in the contract but not the implementation.
 Compat issues with assembly System.Net.Http:
 CannotChangeAttribute : Attribute 'System.Runtime.Versioning.UnsupportedOSPlatformAttribute' on 'System.Net.Http.HttpClientHandler.Proxy' changed from '[UnsupportedOSPlatformAttribute("browser")]' in the contract to '[UnsupportedOSPlatformAttribute("browser")]' in the implementation.
 Compat issues with assembly System.Net.Security:
@@ -196,4 +203,4 @@ Compat issues with assembly System.Security.Cryptography.X509Certificates:
 CannotChangeAttribute : Attribute 'System.Runtime.Versioning.UnsupportedOSPlatformAttribute' on 'System.Security.Cryptography.X509Certificates.PublicKey.GetDSAPublicKey()' changed from '[UnsupportedOSPlatformAttribute("ios")]' in the contract to '[UnsupportedOSPlatformAttribute("browser")]' in the implementation.
 Compat issues with assembly System.Text.Json:
 CannotMakeTypeAbstract : Type 'System.Text.Json.Serialization.Metadata.JsonTypeInfo' is abstract in the implementation but is not abstract in the contract.
-Total Issues: 184
+Total Issues: 190