diff --git a/src/libraries/Common/tests/TestUtilities/System/AssertExtensions.cs b/src/libraries/Common/tests/TestUtilities/System/AssertExtensions.cs
index bf676b7b6f26be..230e4cb4276a42 100644
--- a/src/libraries/Common/tests/TestUtilities/System/AssertExtensions.cs
+++ b/src/libraries/Common/tests/TestUtilities/System/AssertExtensions.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
@@ -15,6 +16,26 @@ public static class AssertExtensions
     {
         private static bool IsNetFramework => RuntimeInformation.FrameworkDescription.StartsWith(".NET Framework");
 
+
+        /// <summary>
+        /// Helper for AOT tests that verifies that the compile succeeds, or throws PlatformNotSupported
+        /// when AOT is enabled.
+        /// </summary>
+        public static void ThrowsOnAot<T>(Action action)
+            where T : Exception
+        {
+#if NETCOREAPP // Dynamic code is always supported on .NET Framework
+            if (!RuntimeFeature.IsDynamicCodeSupported)
+            {
+                Assert.Throws<T>(action);
+            }
+            else
+#endif
+            {
+                action();
+            }
+        }
+
         public static void Throws<T>(Action action, string expectedMessage)
             where T : Exception
         {
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/Expressions/ExpressionResolverBuilder.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/Expressions/ExpressionResolverBuilder.cs
index c28b9f00bb4e7d..670c62ee2f69a8 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/Expressions/ExpressionResolverBuilder.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/Expressions/ExpressionResolverBuilder.cs
@@ -123,6 +123,15 @@ static MethodInfo GetArrayEmptyMethodInfo(Type elementType)
                 return ServiceLookupHelpers.GetArrayEmptyMethodInfo(elementType);
             }
 
+            [UnconditionalSuppressMessage("AotAnalysis", "IL3050:RequiresDynamicCode",
+                Justification = "VerifyAotCompatibility ensures elementType is not a ValueType")]
+            static NewArrayExpression NewArrayInit(Type elementType, IEnumerable<Expression> expr)
+            {
+                Debug.Assert(!ServiceProvider.VerifyAotCompatibility || !elementType.IsValueType, "VerifyAotCompatibility=true will throw during building the IEnumerableCallSite if elementType is a ValueType.");
+
+                return Expression.NewArrayInit(elementType, expr);
+            }
+
             if (callSite.ServiceCallSites.Length == 0)
             {
                 return Expression.Constant(
@@ -130,7 +139,7 @@ static MethodInfo GetArrayEmptyMethodInfo(Type elementType)
                     .Invoke(obj: null, parameters: Array.Empty<object>()));
             }
 
-            return Expression.NewArrayInit(
+            return NewArrayInit(
                 callSite.ItemType,
                 callSite.ServiceCallSites.Select(cs =>
                     Convert(
diff --git a/src/libraries/System.Linq.Expressions/ref/System.Linq.Expressions.cs b/src/libraries/System.Linq.Expressions/ref/System.Linq.Expressions.cs
index 98bfd460ddb960..015cfb079d360a 100644
--- a/src/libraries/System.Linq.Expressions/ref/System.Linq.Expressions.cs
+++ b/src/libraries/System.Linq.Expressions/ref/System.Linq.Expressions.cs
@@ -607,9 +607,13 @@ protected Expression(System.Linq.Expressions.ExpressionType nodeType, System.Typ
         public static System.Linq.Expressions.NewExpression New(System.Reflection.ConstructorInfo constructor, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression>? arguments, params System.Reflection.MemberInfo[]? members) { throw null; }
         public static System.Linq.Expressions.NewExpression New(System.Reflection.ConstructorInfo constructor, params System.Linq.Expressions.Expression[]? arguments) { throw null; }
         public static System.Linq.Expressions.NewExpression New([System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors)] System.Type type) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating arrays at runtime requires dynamic code generation.")]
         public static System.Linq.Expressions.NewArrayExpression NewArrayBounds(System.Type type, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression> bounds) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating arrays at runtime requires dynamic code generation.")]
         public static System.Linq.Expressions.NewArrayExpression NewArrayBounds(System.Type type, params System.Linq.Expressions.Expression[] bounds) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating arrays at runtime requires dynamic code generation.")]
         public static System.Linq.Expressions.NewArrayExpression NewArrayInit(System.Type type, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression> initializers) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating arrays at runtime requires dynamic code generation.")]
         public static System.Linq.Expressions.NewArrayExpression NewArrayInit(System.Type type, params System.Linq.Expressions.Expression[] initializers) { throw null; }
         public static System.Linq.Expressions.UnaryExpression Not(System.Linq.Expressions.Expression expression) { throw null; }
         public static System.Linq.Expressions.UnaryExpression Not(System.Linq.Expressions.Expression expression, System.Reflection.MethodInfo? method) { throw null; }
@@ -1028,6 +1032,7 @@ internal MethodCallExpression() { }
         System.Linq.Expressions.Expression System.Linq.Expressions.IArgumentProvider.GetArgument(int index) { throw null; }
         public System.Linq.Expressions.MethodCallExpression Update(System.Linq.Expressions.Expression? @object, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression>? arguments) { throw null; }
     }
+    [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating arrays at runtime requires dynamic code generation.")]
     public partial class NewArrayExpression : System.Linq.Expressions.Expression
     {
         internal NewArrayExpression() { }
diff --git a/src/libraries/System.Linq.Expressions/src/CompatibilitySuppressions.xml b/src/libraries/System.Linq.Expressions/src/CompatibilitySuppressions.xml
index 8185aa8209fa11..bf51da8ccbe294 100644
--- a/src/libraries/System.Linq.Expressions/src/CompatibilitySuppressions.xml
+++ b/src/libraries/System.Linq.Expressions/src/CompatibilitySuppressions.xml
@@ -97,6 +97,48 @@
     <Left>ref/net8.0/System.Linq.Expressions.dll</Left>
     <Right>lib/net8.0/System.Linq.Expressions.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0016</DiagnosticId>
+    <Target>M:System.Linq.Expressions.Expression.Call(System.Linq.Expressions.Expression,System.String,System.Type[],System.Linq.Expressions.Expression[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute]</Target>
+    <Left>ref/net8.0/System.Linq.Expressions.dll</Left>
+    <Right>lib/net8.0/System.Linq.Expressions.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0016</DiagnosticId>
+    <Target>M:System.Linq.Expressions.Expression.Call(System.Type,System.String,System.Type[],System.Linq.Expressions.Expression[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute]</Target>
+    <Left>ref/net8.0/System.Linq.Expressions.dll</Left>
+    <Right>lib/net8.0/System.Linq.Expressions.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0016</DiagnosticId>
+    <Target>M:System.Linq.Expressions.Expression.ListInit(System.Linq.Expressions.NewExpression,System.Collections.Generic.IEnumerable{System.Linq.Expressions.Expression}):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute]</Target>
+    <Left>ref/net8.0/System.Linq.Expressions.dll</Left>
+    <Right>lib/net8.0/System.Linq.Expressions.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0016</DiagnosticId>
+    <Target>M:System.Linq.Expressions.Expression.ListInit(System.Linq.Expressions.NewExpression,System.Linq.Expressions.Expression[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute]</Target>
+    <Left>ref/net8.0/System.Linq.Expressions.dll</Left>
+    <Right>lib/net8.0/System.Linq.Expressions.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0016</DiagnosticId>
+    <Target>M:System.Linq.Expressions.Expression.ListInit(System.Linq.Expressions.NewExpression,System.Reflection.MethodInfo,System.Collections.Generic.IEnumerable{System.Linq.Expressions.Expression}):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute]</Target>
+    <Left>ref/net8.0/System.Linq.Expressions.dll</Left>
+    <Right>lib/net8.0/System.Linq.Expressions.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0016</DiagnosticId>
+    <Target>M:System.Linq.Expressions.Expression.ListInit(System.Linq.Expressions.NewExpression,System.Reflection.MethodInfo,System.Linq.Expressions.Expression[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute]</Target>
+    <Left>ref/net8.0/System.Linq.Expressions.dll</Left>
+    <Right>lib/net8.0/System.Linq.Expressions.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0016</DiagnosticId>
+    <Target>M:System.Runtime.CompilerServices.CallSite`1.Create(System.Runtime.CompilerServices.CallSiteBinder):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute]</Target>
+    <Left>ref/net8.0/System.Linq.Expressions.dll</Left>
+    <Right>lib/net8.0/System.Linq.Expressions.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0020</DiagnosticId>
     <Target>M:System.Linq.Expressions.DynamicExpressionVisitor.#ctor</Target>
diff --git a/src/libraries/System.Linq.Expressions/src/Resources/Strings.resx b/src/libraries/System.Linq.Expressions/src/Resources/Strings.resx
index 01f6ec7be8ddc5..cfbf09d82e02e9 100644
--- a/src/libraries/System.Linq.Expressions/src/Resources/Strings.resx
+++ b/src/libraries/System.Linq.Expressions/src/Resources/Strings.resx
@@ -564,4 +564,7 @@
   <data name="Arg_KeyNotFoundWithKey" xml:space="preserve">
     <value>The given key '{0}' was not present in the dictionary.</value>
   </data>
+  <data name="LiftingInExpressionRequiresDynamicCode" xml:space="preserve">
+    <value>Nullable lifting on non-primitive type '{0}' is only supported in expression trees when dynamic code generation is available.</value>
+  </data>
 </root>
diff --git a/src/libraries/System.Linq.Expressions/src/System.Linq.Expressions.csproj b/src/libraries/System.Linq.Expressions/src/System.Linq.Expressions.csproj
index 47375e1d827797..08f93036a937da 100644
--- a/src/libraries/System.Linq.Expressions/src/System.Linq.Expressions.csproj
+++ b/src/libraries/System.Linq.Expressions/src/System.Linq.Expressions.csproj
@@ -3,7 +3,6 @@
     <TargetFramework>$(NetCoreAppCurrent)</TargetFramework>
     <DefineConstants> $(DefineConstants);FEATURE_FAST_CREATE</DefineConstants>
     <NoWarn>$(NoWarn);CA1859</NoWarn>
-    <EnableAOTAnalyzer>false</EnableAOTAnalyzer>
     <!--
       Disable constant propagation so that methods referenced from ILLink.Substitutions.xml don't get inlined
       with a wrong value at library build time and the substitution can still be selected at publish time.
@@ -91,6 +90,7 @@
     <Compile Include="System\Runtime\CompilerServices\CallSite.cs" />
     <Compile Include="System\Runtime\CompilerServices\CallSiteBinder.cs" />
     <Compile Include="System\Runtime\CompilerServices\CallSiteOps.cs" />
+    <Compile Include="System\Runtime\CompilerServices\CallSiteOpsReflectionCache.cs" />
     <Compile Include="System\Runtime\CompilerServices\CallSiteHelpers.cs" />
     <Compile Include="System\Runtime\CompilerServices\DynamicAttribute.cs" />
     <Compile Include="System\Runtime\CompilerServices\DebugInfoGenerator.cs" />
diff --git a/src/libraries/System.Linq.Expressions/src/System/Dynamic/DynamicObject.cs b/src/libraries/System.Linq.Expressions/src/System/Dynamic/DynamicObject.cs
index 351e63d8854069..19910ca7cf67c4 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Dynamic/DynamicObject.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Dynamic/DynamicObject.cs
@@ -611,8 +611,7 @@ private DynamicMetaObject BuildCallMethodWithResult<TBinder>(MethodInfo method,
                                     Expression.Call(
                                         String_Format_String_ObjectArray,
                                         Expression.Constant(convertFailed),
-                                        Expression.NewArrayInit(
-                                            typeof(object),
+                                        Expression.NewObjectArrayInit(
                                             new TrueReadOnlyCollection<Expression>(
                                                 Expression.Condition(
                                                     Expression.Equal(resultMO.Expression, AstUtils.Null),
@@ -645,7 +644,7 @@ private DynamicMetaObject BuildCallMethodWithResult<TBinder>(MethodInfo method,
                     Expression.Block(
                         new TrueReadOnlyCollection<ParameterExpression>(result, callArgs),
                         new TrueReadOnlyCollection<Expression>(
-                            method != DynamicObject_TryBinaryOperation ? Expression.Assign(callArgs, Expression.NewArrayInit(typeof(object), callArgsValue)) : Expression.Assign(callArgs, callArgsValue[0]),
+                            method != DynamicObject_TryBinaryOperation ? Expression.Assign(callArgs, Expression.NewObjectArrayInit(callArgsValue)) : Expression.Assign(callArgs, callArgsValue[0]),
                             Expression.Condition(
                                 Expression.Call(
                                     GetLimitedSelf(),
@@ -705,7 +704,7 @@ private DynamicMetaObject CallMethodReturnLast<TBinder>(MethodInfo method, TBind
                     Expression.Block(
                         new TrueReadOnlyCollection<ParameterExpression>(result, callArgs),
                         new TrueReadOnlyCollection<Expression>(
-                            Expression.Assign(callArgs, Expression.NewArrayInit(typeof(object), callArgsValue)),
+                            Expression.Assign(callArgs, Expression.NewObjectArrayInit(callArgsValue)),
                             Expression.Condition(
                                 Expression.Call(
                                     GetLimitedSelf(),
@@ -768,7 +767,7 @@ private DynamicMetaObject CallMethodNoResult<TBinder>(MethodInfo method, TBinder
                     Expression.Block(
                         new TrueReadOnlyCollection<ParameterExpression>(callArgs),
                         new TrueReadOnlyCollection<Expression>(
-                            Expression.Assign(callArgs, Expression.NewArrayInit(typeof(object), callArgsValue)),
+                            Expression.Assign(callArgs, Expression.NewObjectArrayInit(callArgsValue)),
                             Expression.Condition(
                                 Expression.Call(
                                     GetLimitedSelf(),
diff --git a/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/CachedReflectionInfo.cs b/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/CachedReflectionInfo.cs
index fd426b339bafd6..7052b27852b412 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/CachedReflectionInfo.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/CachedReflectionInfo.cs
@@ -21,10 +21,6 @@ internal static partial class CachedReflectionInfo
         public static MethodInfo CallSiteOps_SetNotMatched =>
             s_CallSiteOps_SetNotMatched ??= typeof(CallSiteOps).GetMethod(nameof(CallSiteOps.SetNotMatched))!;
 
-        private static MethodInfo? s_CallSiteOps_CreateMatchmaker;
-        public static MethodInfo CallSiteOps_CreateMatchmaker =>
-            s_CallSiteOps_CreateMatchmaker ??= typeof(CallSiteOps).GetMethod(nameof(CallSiteOps.CreateMatchmaker))!;
-
         private static MethodInfo? s_CallSiteOps_GetMatch;
         public static MethodInfo CallSiteOps_GetMatch =>
             s_CallSiteOps_GetMatch ??= typeof(CallSiteOps).GetMethod(nameof(CallSiteOps.GetMatch))!;
@@ -33,34 +29,6 @@ internal static partial class CachedReflectionInfo
         public static MethodInfo CallSiteOps_ClearMatch =>
             s_CallSiteOps_ClearMatch ??= typeof(CallSiteOps).GetMethod(nameof(CallSiteOps.ClearMatch))!;
 
-        private static MethodInfo? s_CallSiteOps_UpdateRules;
-        public static MethodInfo CallSiteOps_UpdateRules =>
-            s_CallSiteOps_UpdateRules ??= typeof(CallSiteOps).GetMethod(nameof(CallSiteOps.UpdateRules))!;
-
-        private static MethodInfo? s_CallSiteOps_GetRules;
-        public static MethodInfo CallSiteOps_GetRules =>
-            s_CallSiteOps_GetRules ??= typeof(CallSiteOps).GetMethod(nameof(CallSiteOps.GetRules))!;
-
-        private static MethodInfo? s_CallSiteOps_GetRuleCache;
-        public static MethodInfo CallSiteOps_GetRuleCache =>
-            s_CallSiteOps_GetRuleCache ??= typeof(CallSiteOps).GetMethod(nameof(CallSiteOps.GetRuleCache))!;
-
-        private static MethodInfo? s_CallSiteOps_GetCachedRules;
-        public static MethodInfo CallSiteOps_GetCachedRules =>
-            s_CallSiteOps_GetCachedRules ??= typeof(CallSiteOps).GetMethod(nameof(CallSiteOps.GetCachedRules))!;
-
-        private static MethodInfo? s_CallSiteOps_AddRule;
-        public static MethodInfo CallSiteOps_AddRule =>
-            s_CallSiteOps_AddRule ??= typeof(CallSiteOps).GetMethod(nameof(CallSiteOps.AddRule))!;
-
-        private static MethodInfo? s_CallSiteOps_MoveRule;
-        public static MethodInfo CallSiteOps_MoveRule =>
-            s_CallSiteOps_MoveRule ??= typeof(CallSiteOps).GetMethod(nameof(CallSiteOps.MoveRule))!;
-
-        private static MethodInfo? s_CallSiteOps_Bind;
-        public static MethodInfo CallSiteOps_Bind =>
-            s_CallSiteOps_Bind ??= typeof(CallSiteOps).GetMethod(nameof(CallSiteOps.Bind))!;
-
         private static MethodInfo? s_DynamicObject_TryGetMember;
         public static MethodInfo DynamicObject_TryGetMember =>
             s_DynamicObject_TryGetMember ??= typeof(DynamicObject).GetMethod(nameof(DynamicObject.TryGetMember))!;
diff --git a/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/DelegateHelpers.cs b/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/DelegateHelpers.cs
index 011322a2454ad2..f49cba9afdd2b7 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/DelegateHelpers.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/DelegateHelpers.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
 using System.Reflection;
 using System.Reflection.Emit;
 using System.Runtime.CompilerServices;
@@ -55,7 +56,10 @@ internal static Delegate CreateObjectArrayDelegate(Type delegateType, Func<objec
         {
             if (CanEmitObjectArrayDelegate)
             {
+#pragma warning disable IL3050
+                // Suppress analyzer warnings since they don't currently support feature flags
                 return CreateObjectArrayDelegateRefEmit(delegateType, handler);
+#pragma warning restore IL3050
             }
             else
             {
@@ -100,8 +104,7 @@ public static TReturn FuncThunk2<T1, T2, TReturn>(Func<object?[], object> handle
             return (TReturn)handler(new object?[]{t1, t2});
         }
 
-        private static MethodInfo GetEmptyObjectArrayMethod() =>
-            typeof(Array).GetMethod(nameof(Array.Empty))!.MakeGenericMethod(typeof(object));
+        private static MethodInfo GetEmptyObjectArrayMethod() => ((Func<object[]>)Array.Empty<object>).GetMethodInfo();
 
         private static MethodInfo[] GetActionThunks()
         {
@@ -121,6 +124,7 @@ private static MethodInfo[] GetFuncThunks()
 
         [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2060:MakeGenericMethod",
             Justification = "The above ActionThunk and FuncThunk methods don't have trimming annotations.")]
+        [RequiresDynamicCode(Expression.GenericMethodRequiresDynamicCode)]
         private static MethodInfo? GetCSharpThunk(Type returnType, bool hasReturnValue, ParameterInfo[] parameters)
         {
             try
@@ -193,6 +197,7 @@ private static MethodInfo[] GetFuncThunks()
         //      param0 = (T0)args[0];   // only generated for each byref argument
         // }
         // return (TRet)ret;
+        [RequiresDynamicCode("Ref emit requires dynamic code.")]
         private static Delegate CreateObjectArrayDelegateRefEmit(Type delegateType, Func<object?[], object?> handler)
         {
             if (!s_thunks.TryGetValue(delegateType, out MethodInfo? thunkMethod))
diff --git a/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/TypeUtils.cs b/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/TypeUtils.cs
index 1d0fca59e30680..f15f09139f70a1 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/TypeUtils.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/TypeUtils.cs
@@ -6,6 +6,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 
 namespace System.Dynamic.Utils
 {
@@ -20,6 +21,7 @@ internal static class TypeUtils
 
         public static Type GetNonNullableType(this Type type) => IsNullableType(type) ? type.GetGenericArguments()[0] : type;
 
+        [RequiresDynamicCode("Creating nullable types requires dynamic code.")]
         public static Type GetNullableType(this Type type)
         {
             Debug.Assert(type != null, "type cannot be null");
@@ -31,6 +33,66 @@ public static Type GetNullableType(this Type type)
             return type;
         }
 
+        /// <summary>
+        /// This is an alternative to <see cref="GetNullableType" /> that will throw
+        /// if dynamic code is required. Some common primitive types are special-cased.
+        /// </summary>
+        public static Type LiftPrimitiveOrThrow(this Type type)
+        {
+            if (RuntimeFeature.IsDynamicCodeSupported)
+            {
+#pragma warning disable IL3050
+                // Analyzer doesn't yet understand feature switches
+                return GetNullableType(type);
+#pragma warning restore IL3050
+            }
+            if (!type.IsValueType || IsNullableType(type))
+            {
+                return type;
+            }
+            switch (type.GetTypeCode())
+            {
+                case TypeCode.Boolean:
+                    return typeof(bool?);
+                case TypeCode.Int32:
+                    return typeof(int?);
+                case TypeCode.Int64:
+                    return typeof(long?);
+                case TypeCode.Single:
+                    return typeof(float?);
+                case TypeCode.Double:
+                    return typeof(double?);
+                case TypeCode.UInt32:
+                    return typeof(uint?);
+                case TypeCode.UInt64:
+                    return typeof(ulong?);
+                case TypeCode.Byte:
+                    return typeof(byte?);
+                case TypeCode.SByte:
+                    return typeof(sbyte?);
+                case TypeCode.Int16:
+                    return typeof(short?);
+                case TypeCode.UInt16:
+                    return typeof(ushort?);
+                case TypeCode.Char:
+                    return typeof(char?);
+                case TypeCode.Decimal:
+                    return typeof(decimal?);
+                case TypeCode.DateTime:
+                    return typeof(DateTime?);
+                default:
+                    if (type == typeof(DateTimeOffset))
+                    {
+                        return typeof(DateTimeOffset?);
+                    }
+                    else if (type == typeof(TimeSpan))
+                    {
+                        return typeof(TimeSpan?);
+                    }
+                    throw new NotSupportedException(Strings.LiftingInExpressionRequiresDynamicCode(type));
+            }
+        }
+
         public static ConstructorInfo GetNullableConstructor(Type nullableType)
         {
             Debug.Assert(nullableType.IsNullableType());
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/BinaryExpression.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/BinaryExpression.cs
index 4e54bed886f05b..620e091d5cf49f 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/BinaryExpression.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/BinaryExpression.cs
@@ -437,6 +437,8 @@ internal Expression ReduceUserdefinedLifted()
         [DynamicDependency("GetValueOrDefault", typeof(Nullable<>))]
         [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
             Justification = "The method will be preserved by the DynamicDependency.")]
+        [UnconditionalSuppressMessage("DynamicCode", "IL3050",
+            Justification = "GetValueOrDefault is not generic and therefore MakeGenericMethod will not be called")]
         private static MethodCallExpression CallGetValueOrDefault(ParameterExpression nullable)
         {
             return Call(nullable, "GetValueOrDefault", null);
@@ -615,7 +617,7 @@ public static BinaryExpression Assign(Expression left, Expression right)
                 {
                     if (method.ReturnType != typeof(bool) || liftToNull)
                     {
-                        return new MethodBinaryExpression(binaryType, left, right, method.ReturnType.GetNullableType(), method);
+                        return new MethodBinaryExpression(binaryType, left, right, method.ReturnType.LiftPrimitiveOrThrow(), method);
                     }
                     else
                     {
@@ -647,7 +649,7 @@ private static BinaryExpression GetMethodBasedBinaryOperator(ExpressionType bina
             {
                 if (method.ReturnType != typeof(bool) || liftToNull)
                 {
-                    return new MethodBinaryExpression(binaryType, left, right, method.ReturnType.GetNullableType(), method);
+                    return new MethodBinaryExpression(binaryType, left, right, method.ReturnType.LiftPrimitiveOrThrow(), method);
                 }
                 else
                 {
@@ -2236,7 +2238,7 @@ private static Type GetResultTypeOfShift(Type left, Type right)
             if (!left.IsNullableType() && right.IsNullableType())
             {
                 // lift the result type to Nullable<T>
-                return typeof(Nullable<>).MakeGenericType(left);
+                return left.LiftPrimitiveOrThrow();
             }
             return left;
         }
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/AssemblyGen.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/AssemblyGen.cs
index 1619aa3a0bf90b..bf4827050dff53 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/AssemblyGen.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/AssemblyGen.cs
@@ -10,6 +10,7 @@
 
 namespace System.Linq.Expressions.Compiler
 {
+    [RequiresDynamicCode("Assembly generation requires dynamic code generation.")]
     internal sealed class AssemblyGen
     {
         private static AssemblyGen? s_assembly;
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/CompilerScope.Storage.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/CompilerScope.Storage.cs
index e60561d19b28a5..084a13e25161d4 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/CompilerScope.Storage.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/CompilerScope.Storage.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using System.Reflection.Emit;
 using System.Runtime.CompilerServices;
@@ -98,6 +99,7 @@ internal override void EmitAddress()
             }
         }
 
+        [RequiresDynamicCode(Expression.StrongBoxRequiresDynamicCode)]
         private sealed class ElementBoxStorage : Storage
         {
             private readonly int _index;
@@ -153,6 +155,7 @@ internal void EmitLoadBox()
             }
         }
 
+        [RequiresDynamicCode(Expression.StrongBoxRequiresDynamicCode)]
         private sealed class LocalBoxStorage : Storage
         {
             private readonly LocalBuilder _boxLocal;
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/CompilerScope.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/CompilerScope.cs
index a866e7b7a779e7..0bf51d4af5d070 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/CompilerScope.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/CompilerScope.cs
@@ -9,6 +9,7 @@
 using System.Dynamic.Utils;
 using static System.Linq.Expressions.CachedReflectionInfo;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Linq.Expressions.Compiler
 {
@@ -28,6 +29,7 @@ internal enum VariableStorageKind
     /// Instances are produced by VariableBinder, which does a tree walk
     /// looking for scope nodes: LambdaExpression, BlockExpression, and CatchBlock.
     /// </summary>
+    [RequiresDynamicCode(Expression.StrongBoxRequiresDynamicCode)]
     internal sealed partial class CompilerScope
     {
         /// <summary>
@@ -394,6 +396,7 @@ private bool ShouldCache(ParameterExpression v)
             return ReferenceCount.TryGetValue(v, out refCount) && ShouldCache(v, refCount);
         }
 
+        [RequiresDynamicCode(Expression.StrongBoxRequiresDynamicCode)]
         private void CacheBoxToLocal(LambdaCompiler lc, ParameterExpression v)
         {
             Debug.Assert(ShouldCache(v) && !_locals.ContainsKey(v));
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/DelegateHelpers.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/DelegateHelpers.cs
index 651c1811938d3e..aa940367777db7 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/DelegateHelpers.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/DelegateHelpers.cs
@@ -119,10 +119,13 @@ private static System.Reflection.TypeInfo MakeNewCustomDelegate(Type[] types)
                 const MethodImplAttributes implAttributes = MethodImplAttributes.Runtime | MethodImplAttributes.Managed;
                 const MethodAttributes invokeAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual;
 
+#pragma warning disable IL3050
+                // Suppress analyzer warnings since they don't currently support feature flags
                 TypeBuilder builder = AssemblyGen.DefineDelegateType("Delegate" + types.Length);
                 builder.DefineConstructor(ctorAttributes, CallingConventions.Standard, delegateCtorSignature).SetImplementationFlags(implAttributes);
                 builder.DefineMethod("Invoke", invokeAttributes, returnType, parameters).SetImplementationFlags(implAttributes);
                 return builder.CreateTypeInfo();
+#pragma warning restore IL3050
             }
             else
             {
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Binary.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Binary.cs
index c4e448a2dce29f..63f2752b46f109 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Binary.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Binary.cs
@@ -5,6 +5,7 @@
 using System.Dynamic.Utils;
 using System.Reflection;
 using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
 using static System.Linq.Expressions.CachedReflectionInfo;
 
 namespace System.Linq.Expressions.Compiler
@@ -99,7 +100,7 @@ private void EmitBinaryMethod(BinaryExpression b, CompilationFlags flags)
                 Type resultType;
                 if (b.IsLiftedToNull)
                 {
-                    resultType = mc.Type.GetNullableType();
+                    resultType = mc.Type.LiftPrimitiveOrThrow();
                 }
                 else
                 {
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.cs
index 0f1417d514537a..2fc78ace54d033 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Dynamic.Utils;
 using System.Reflection;
 using System.Reflection.Emit;
@@ -23,6 +24,7 @@ internal interface ILocalCache
     /// contain multiple lambdas, the Compiler class is responsible for compiling the whole tree, individual
     /// lambdas are then compiled by the LambdaCompiler.
     /// </summary>
+    [RequiresDynamicCode(Expression.LambdaCompilerRequiresDynamicCode)]
     internal sealed partial class LambdaCompiler : ILocalCache
     {
         private static int s_lambdaMethodIndex;
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/StackSpiller.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/StackSpiller.cs
index 010ce554fa7465..4012dd1ebbd8b4 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/StackSpiller.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/StackSpiller.cs
@@ -462,6 +462,7 @@ private Result RewriteMethodCallExpression(Expression expr, Stack stack)
             return cr.Finish(expr);
         }
 
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         private Result RewriteNewArrayExpression(Expression expr, Stack stack)
         {
             var node = (NewArrayExpression)expr;
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/VariableBinder.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/VariableBinder.cs
index 49279e00688ef4..1fb5442ac73534 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/VariableBinder.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/VariableBinder.cs
@@ -13,6 +13,7 @@ namespace System.Linq.Expressions.Compiler
     /// Determines if variables are closed over in nested lambdas and need to
     /// be hoisted.
     /// </summary>
+    [RequiresDynamicCode(Expression.StrongBoxRequiresDynamicCode)]
     internal sealed class VariableBinder : ExpressionVisitor
     {
         private readonly AnalyzedTree _tree = new AnalyzedTree();
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Expression.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Expression.cs
index 1f522c0f8d3b25..690f234fae7298 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Expression.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Expression.cs
@@ -20,6 +20,11 @@ public abstract partial class Expression
         internal const string ExpressionRequiresUnreferencedCode = "Creating Expressions requires unreferenced code because the members being referenced by the Expression may be trimmed.";
         internal const string PropertyFromAccessorRequiresUnreferencedCode = "The Property metadata or other accessor may be trimmed.";
         internal const string GenericMethodRequiresUnreferencedCode = "Calling a generic method cannot be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. This can be suppressed if the method is not generic.";
+        internal const string GenericMethodRequiresDynamicCode = "Calling a generic method requires dynamic code generation. This can be suppressed if the method is not generic.";
+        internal const string CallSiteRequiresDynamicCode = "Creating a call site may require dynamic code generation.";
+        internal const string LambdaCompilerRequiresDynamicCode = "Compiling a lambda expression requires dynamic code generation.";
+        internal const string StrongBoxRequiresDynamicCode = "Creating a StrongBox requires dynamic code generation.";
+        internal const string NewArrayRequiresDynamicCode = "Creating arrays at runtime requires dynamic code generation.";
 
         private static readonly CacheDict<Type, MethodInfo> s_lambdaDelegateCache = new CacheDict<Type, MethodInfo>(40);
         private static volatile CacheDict<Type, Func<Expression, string?, bool, ReadOnlyCollection<ParameterExpression>, LambdaExpression>>? s_lambdaFactories;
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/ArrayOperations.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/ArrayOperations.cs
index ba16d0998d4ab9..bc8d0f13a2e31f 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/ArrayOperations.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/ArrayOperations.cs
@@ -1,8 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
+
 namespace System.Linq.Expressions.Interpreter
 {
+    [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
     internal sealed class NewArrayInitInstruction : Instruction
     {
         private readonly Type _elementType;
@@ -30,6 +33,7 @@ public override int Run(InterpretedFrame frame)
         }
     }
 
+    [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
     internal sealed class NewArrayInstruction : Instruction
     {
         private readonly Type _elementType;
@@ -54,6 +58,7 @@ public override int Run(InterpretedFrame frame)
         }
     }
 
+    [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
     internal sealed class NewArrayBoundsInstruction : Instruction
     {
         private readonly Type _elementType;
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/InstructionList.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/InstructionList.cs
index 1b0e18cc0318dc..c3cac4e6078a35 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/InstructionList.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/InstructionList.cs
@@ -9,6 +9,7 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Dynamic.Utils;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Linq.Expressions.Interpreter
 {
@@ -633,16 +634,16 @@ public void EmitSetArrayItem()
             Emit(SetArrayItemInstruction.Instance);
         }
 
-        public void EmitNewArray(Type elementType)
-        {
-            Emit(new NewArrayInstruction(elementType));
-        }
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
+        public void EmitNewArray(Type elementType) => Emit(new NewArrayInstruction(elementType));
 
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         public void EmitNewArrayBounds(Type elementType, int rank)
         {
             Emit(new NewArrayBoundsInstruction(elementType, rank));
         }
 
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         public void EmitNewArrayInit(Type elementType, int elementCount)
         {
             Emit(new NewArrayInitInstruction(elementType, elementCount));
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LightCompiler.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LightCompiler.cs
index 2424fd75c352e6..eae0ca0433a412 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LightCompiler.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LightCompiler.cs
@@ -2509,8 +2509,12 @@ private void CompileMember(Expression? from, MemberInfo member, bool forBinding)
             }
         }
 
+        [UnconditionalSuppressMessage("DynamicDependency", "IL3050",
+            Justification = "NewArrayExpression has RequiresDynamicCode, so the only way to get here is by already "
+                + "seeing a warning.")]
         private void CompileNewArrayExpression(Expression expr)
         {
+            Debug.Assert(typeof(NewArrayExpression).GetCustomAttribute<RequiresDynamicCodeAttribute>() is not null);
             var node = (NewArrayExpression)expr;
 
             foreach (Expression arg in node.Expressions)
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/LambdaExpression.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/LambdaExpression.cs
index f4c2aa2f74bafd..9b22fc9bc6e95b 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/LambdaExpression.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/LambdaExpression.cs
@@ -138,7 +138,10 @@ public Delegate Compile()
         {
             if (CanCompileToIL)
             {
+#pragma warning disable IL3050
+                // Analyzer doesn't yet understand feature switches
                 return Compiler.LambdaCompiler.Compile(this);
+#pragma warning restore IL3050
             }
             else
             {
@@ -218,7 +221,10 @@ internal Expression(Expression body)
         {
             if (CanCompileToIL)
             {
+#pragma warning disable IL3050
+                // Analyzer doesn't yet understand feature switches
                 return (TDelegate)(object)Compiler.LambdaCompiler.Compile(this);
+#pragma warning restore IL3050
             }
             else
             {
@@ -607,6 +613,8 @@ public partial class Expression
         /// Creates an Expression{T} given the delegate type. Caches the
         /// factory method to speed up repeated creations for the same T.
         /// </summary>
+        [UnconditionalSuppressMessage("DynamicCode", "IL3050",
+            Justification = "MakeGenericType is only used for a Type that should be a delegate type, which are always reference types.")]
         internal static LambdaExpression CreateLambda(Type delegateType, Expression body, string? name, bool tailCall, ReadOnlyCollection<ParameterExpression> parameters)
         {
             // Get or create a delegate to the public Expression.Lambda<T>
@@ -621,7 +629,10 @@ internal static LambdaExpression CreateLambda(Type delegateType, Expression body
                 MethodInfo create;
                 if (LambdaExpression.CanCompileToIL)
                 {
+#pragma warning disable IL3050
+                    // Analyzer doesn't yet understand feature switches
                     create = typeof(Expression<>).MakeGenericType(delegateType).GetMethod("Create", BindingFlags.Static | BindingFlags.NonPublic)!;
+#pragma warning restore IL3050
                 }
                 else
                 {
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/ListInitExpression.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/ListInitExpression.cs
index 42252e3eef617d..65360e48100c7e 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/ListInitExpression.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/ListInitExpression.cs
@@ -105,6 +105,7 @@ public partial class Expression
         /// <param name="initializers">An array of <see cref="Expression"/> objects to use to populate the <see cref="ListInitExpression.Initializers"/> collection.</param>
         /// <returns>A <see cref="ListInitExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.ListInit"/> and the <see cref="ListInitExpression.NewExpression"/> property set to the specified value.</returns>
         [RequiresUnreferencedCode(ExpressionRequiresUnreferencedCode)]
+        [RequiresDynamicCode(GenericMethodRequiresDynamicCode)]
         public static ListInitExpression ListInit(NewExpression newExpression, params Expression[] initializers)
         {
             return ListInit(newExpression, initializers as IEnumerable<Expression>);
@@ -117,6 +118,7 @@ public static ListInitExpression ListInit(NewExpression newExpression, params Ex
         /// <param name="initializers">An <see cref="IEnumerable{T}"/> that contains <see cref="Expressions.ElementInit"/> objects to use to populate the <see cref="ListInitExpression.Initializers"/> collection.</param>
         /// <returns>A <see cref="ListInitExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.ListInit"/> and the <see cref="ListInitExpression.NewExpression"/> property set to the specified value.</returns>
         [RequiresUnreferencedCode(ExpressionRequiresUnreferencedCode)]
+        [RequiresDynamicCode(GenericMethodRequiresDynamicCode)]
         public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable<Expression> initializers)
         {
             ArgumentNullException.ThrowIfNull(newExpression);
@@ -140,6 +142,7 @@ public static ListInitExpression ListInit(NewExpression newExpression, IEnumerab
         /// <param name="initializers">An array of <see cref="Expression"/> objects to use to populate the <see cref="ListInitExpression.Initializers"/> collection.</param>
         /// <returns>A <see cref="ListInitExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.ListInit"/> and the <see cref="ListInitExpression.NewExpression"/> property set to the specified value.</returns>
         [RequiresUnreferencedCode(ExpressionRequiresUnreferencedCode)]
+        [RequiresDynamicCode(GenericMethodRequiresDynamicCode)]
         public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo? addMethod, params Expression[] initializers)
         {
             return ListInit(newExpression, addMethod, initializers as IEnumerable<Expression>);
@@ -153,6 +156,7 @@ public static ListInitExpression ListInit(NewExpression newExpression, MethodInf
         /// <param name="initializers">An <see cref="IEnumerable{T}"/> that contains <see cref="Expression"/> objects to use to populate the Initializers collection.</param>
         /// <returns>A <see cref="ListInitExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.ListInit"/> and the <see cref="ListInitExpression.NewExpression"/> property set to the specified value.</returns>
         [RequiresUnreferencedCode(ExpressionRequiresUnreferencedCode)]
+        [RequiresDynamicCode(GenericMethodRequiresDynamicCode)]
         public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo? addMethod, IEnumerable<Expression> initializers)
         {
             if (addMethod == null)
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/MethodCallExpression.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/MethodCallExpression.cs
index edd4adc5a3dd2e..9bc4d295cb55d7 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/MethodCallExpression.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/MethodCallExpression.cs
@@ -1138,6 +1138,7 @@ public static MethodCallExpression Call(Expression? instance, MethodInfo method,
         /// <paramref name="instance"/> or <paramref name="methodName"/> is null.</exception>
         /// <exception cref="InvalidOperationException">No method whose name is <paramref name="methodName"/>, whose type parameters match <paramref name="typeArguments"/>, and whose parameter types match <paramref name="arguments"/> is found in <paramref name="instance"/>.Type or its base types.-or-More than one method whose name is <paramref name="methodName"/>, whose type parameters match <paramref name="typeArguments"/>, and whose parameter types match <paramref name="arguments"/> is found in <paramref name="instance"/>.Type or its base types.</exception>
         [RequiresUnreferencedCode(ExpressionRequiresUnreferencedCode)]
+        [RequiresDynamicCode(GenericMethodRequiresDynamicCode)]
         public static MethodCallExpression Call(Expression instance, string methodName, Type[]? typeArguments, params Expression[]? arguments)
         {
             ArgumentNullException.ThrowIfNull(instance);
@@ -1161,6 +1162,7 @@ public static MethodCallExpression Call(Expression instance, string methodName,
         /// <paramref name="type"/> or <paramref name="methodName"/> is null.</exception>
         /// <exception cref="InvalidOperationException">No method whose name is <paramref name="methodName"/>, whose type parameters match <paramref name="typeArguments"/>, and whose parameter types match <paramref name="arguments"/> is found in <paramref name="type"/> or its base types.-or-More than one method whose name is <paramref name="methodName"/>, whose type parameters match <paramref name="typeArguments"/>, and whose parameter types match <paramref name="arguments"/> is found in <paramref name="type"/> or its base types.</exception>
         [RequiresUnreferencedCode(GenericMethodRequiresUnreferencedCode)]
+        [RequiresDynamicCode(GenericMethodRequiresDynamicCode)]
         public static MethodCallExpression Call(
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type type,
             string methodName,
@@ -1291,6 +1293,7 @@ private static bool TryQuote(Type parameterType, ref Expression argument)
         }
 
         [RequiresUnreferencedCode(GenericMethodRequiresUnreferencedCode)]
+        [RequiresDynamicCode(GenericMethodRequiresDynamicCode)]
         private static MethodInfo? FindMethod(
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type type,
             string methodName,
@@ -1366,6 +1369,7 @@ private static bool IsCompatible(MethodBase m, Expression[] arguments)
         }
 
         [RequiresUnreferencedCode(GenericMethodRequiresUnreferencedCode)]
+        [RequiresDynamicCode(GenericMethodRequiresDynamicCode)]
         private static MethodInfo? ApplyTypeArgs(MethodInfo m, Type[]? typeArgs)
         {
             if (typeArgs == null || typeArgs.Length == 0)
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/NewArrayExpression.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/NewArrayExpression.cs
index 9f6fa33f801a86..05f97c0f15ad3f 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/NewArrayExpression.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/NewArrayExpression.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Dynamic.Utils;
 using System.Runtime.CompilerServices;
 
@@ -13,6 +14,7 @@ namespace System.Linq.Expressions
     /// Represents creating a new array and possibly initializing the elements of the new array.
     /// </summary>
     [DebuggerTypeProxy(typeof(NewArrayExpressionProxy))]
+    [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
     public class NewArrayExpression : Expression
     {
         internal NewArrayExpression(Type type, ReadOnlyCollection<Expression> expressions)
@@ -76,6 +78,7 @@ public NewArrayExpression Update(IEnumerable<Expression> expressions)
         }
     }
 
+    [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
     internal sealed class NewArrayInitExpression : NewArrayExpression
     {
         internal NewArrayInitExpression(Type type, ReadOnlyCollection<Expression> expressions)
@@ -91,6 +94,7 @@ internal NewArrayInitExpression(Type type, ReadOnlyCollection<Expression> expres
         public sealed override ExpressionType NodeType => ExpressionType.NewArrayInit;
     }
 
+    [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
     internal sealed class NewArrayBoundsExpression : NewArrayExpression
     {
         internal NewArrayBoundsExpression(Type type, ReadOnlyCollection<Expression> expressions)
@@ -115,6 +119,7 @@ public partial class Expression
         /// <param name="type">A Type that represents the element type of the array.</param>
         /// <param name="initializers">The expressions used to create the array elements.</param>
         /// <returns>A <see cref="NewArrayExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.NewArrayInit"/> and the <see cref="NewArrayExpression.Expressions"/> property set to the specified value.</returns>
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         public static NewArrayExpression NewArrayInit(Type type, params Expression[] initializers)
         {
             return NewArrayInit(type, (IEnumerable<Expression>)initializers);
@@ -126,6 +131,7 @@ public static NewArrayExpression NewArrayInit(Type type, params Expression[] ini
         /// <param name="type">A Type that represents the element type of the array.</param>
         /// <param name="initializers">The expressions used to create the array elements.</param>
         /// <returns>A <see cref="NewArrayExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.NewArrayInit"/> and the <see cref="NewArrayExpression.Expressions"/> property set to the specified value.</returns>
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         public static NewArrayExpression NewArrayInit(Type type, IEnumerable<Expression> initializers)
         {
             ArgumentNullException.ThrowIfNull(type);
@@ -172,6 +178,13 @@ public static NewArrayExpression NewArrayInit(Type type, IEnumerable<Expression>
             return NewArrayExpression.Make(ExpressionType.NewArrayInit, type.MakeArrayType(), initializerList);
         }
 
+        [UnconditionalSuppressMessage("DynamicCode", "IL3050",
+            Justification = "Creating object arrays should always be possible, as it is fundamental to the runtime.")]
+        internal static NewArrayExpression NewObjectArrayInit(IEnumerable<Expression> initializers)
+        {
+            return NewArrayInit(typeof(object), initializers);
+        }
+
         #endregion
 
         #region NewArrayBounds
@@ -182,6 +195,7 @@ public static NewArrayExpression NewArrayInit(Type type, IEnumerable<Expression>
         /// <param name="type">A <see cref="System.Type"/> that represents the element type of the array.</param>
         /// <param name="bounds">An array that contains Expression objects to use to populate the <see cref="NewArrayExpression.Expressions"/> collection.</param>
         /// <returns>A <see cref="NewArrayExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.NewArrayBounds"/> and the <see cref="NewArrayExpression.Expressions"/> property set to the specified value.</returns>
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         public static NewArrayExpression NewArrayBounds(Type type, params Expression[] bounds)
         {
             return NewArrayBounds(type, (IEnumerable<Expression>)bounds);
@@ -193,6 +207,7 @@ public static NewArrayExpression NewArrayBounds(Type type, params Expression[] b
         /// <param name="type">A <see cref="System.Type"/> that represents the element type of the array.</param>
         /// <param name="bounds">An <see cref="IEnumerable{T}"/> that contains <see cref="Expression"/> objects to use to populate the <see cref="NewArrayExpression.Expressions"/> collection.</param>
         /// <returns>A <see cref="NewArrayExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.NewArrayBounds"/> and the <see cref="NewArrayExpression.Expressions"/> property set to the specified value.</returns>
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         public static NewArrayExpression NewArrayBounds(Type type, IEnumerable<Expression> bounds)
         {
             ArgumentNullException.ThrowIfNull(type);
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Strings.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Strings.cs
index b1f53512b8dcd3..f94674d28dd8dd 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Strings.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Strings.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Runtime.CompilerServices;
+
 namespace System.Linq.Expressions
 {
     /// <summary>
@@ -8,6 +10,12 @@ namespace System.Linq.Expressions
     /// </summary>
     internal static class Strings
     {
+        /// <summary>
+        /// A string like "Operation is not supported when dynamic code generation is not available."
+        /// </summary>
+        internal static string LiftingInExpressionRequiresDynamicCode(Type type)
+                => SR.Format(SR.LiftingInExpressionRequiresDynamicCode, type.FullName);
+
         /// <summary>
         /// A string like "reducible nodes must override Expression.Reduce()"
         /// </summary>
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/UnaryExpression.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/UnaryExpression.cs
index 085249f96823ea..43fb67f9f419ef 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/UnaryExpression.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/UnaryExpression.cs
@@ -371,7 +371,7 @@ private static UnaryExpression GetUserDefinedUnaryOperatorOrThrow(ExpressionType
                 method = nnOperandType.GetAnyStaticMethodValidated(name, types);
                 if (method != null && method.ReturnType.IsValueType && !method.ReturnType.IsNullableType())
                 {
-                    return new UnaryExpression(unaryType, operand, method.ReturnType.GetNullableType(), method);
+                    return new UnaryExpression(unaryType, operand, method.ReturnType.LiftPrimitiveOrThrow(), method);
                 }
             }
             return null;
@@ -394,7 +394,7 @@ private static UnaryExpression GetMethodBasedUnaryOperator(ExpressionType unaryT
                 ParameterIsAssignable(pms[0], operand.Type.GetNonNullableType()) &&
                 method.ReturnType.IsValueType && !method.ReturnType.IsNullableType())
             {
-                return new UnaryExpression(unaryType, operand, method.ReturnType.GetNullableType(), method);
+                return new UnaryExpression(unaryType, operand, method.ReturnType.LiftPrimitiveOrThrow(), method);
             }
 
             throw Error.OperandTypesDoNotMatchParameters(unaryType, method.Name);
diff --git a/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSite.cs b/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSite.cs
index dce9473a287df2..bb3b579e4a1eed 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSite.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSite.cs
@@ -9,6 +9,8 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Threading;
+using System.Threading.Tasks;
+using System.Threading.Tasks.Sources;
 using static System.Linq.Expressions.CachedReflectionInfo;
 
 namespace System.Runtime.CompilerServices
@@ -80,6 +82,8 @@ internal CallSite(CallSiteBinder? binder)
         /// <param name="delegateType">The CallSite delegate type.</param>
         /// <param name="binder">The CallSite binder.</param>
         /// <returns>The new CallSite.</returns>
+        [UnconditionalSuppressMessage("DynamicCode", "IL3050",
+            Justification = "MakeGenericType is only used for a Type that should be a delegate type, which are always reference types.")]
         public static CallSite Create(Type delegateType, CallSiteBinder binder)
         {
             ArgumentNullException.ThrowIfNull(delegateType);
@@ -160,6 +164,7 @@ public T Update
         // Cached noMatch delegate for all sites with a given T
         private static volatile T? s_cachedNoMatch;
 
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         private CallSite(CallSiteBinder binder)
             : base(binder)
         {
@@ -206,6 +211,7 @@ internal void ReleaseMatchmaker(CallSite matchMaker)
         /// </summary>
         /// <param name="binder">The binder responsible for the runtime binding of the dynamic operations at this call site.</param>
         /// <returns>The new instance of dynamic call site.</returns>
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         public static CallSite<T> Create(CallSiteBinder binder)
         {
             if (!typeof(T).IsSubclassOf(typeof(MulticastDelegate))) throw System.Linq.Expressions.Error.TypeMustBeDerivedFromSystemDelegate();
@@ -213,6 +219,7 @@ public static CallSite<T> Create(CallSiteBinder binder)
             return new CallSite<T>(binder);
         }
 
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         private T GetUpdateDelegate()
         {
             // This is intentionally non-static to speed up creation - in particular MakeUpdateDelegate
@@ -221,6 +228,7 @@ private T GetUpdateDelegate()
             return GetUpdateDelegate(ref s_cachedUpdate);
         }
 
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         private T GetUpdateDelegate(ref T? addr) =>
             // reduce creation cost by not using Interlocked.CompareExchange.  Calling I.CE causes
             // us to spend 25% of our creation time in JIT_GenericHandle.  Instead we'll rarely
@@ -272,6 +280,7 @@ internal void MoveRule(int i)
             }
         }
 
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         internal T MakeUpdateDelegate()
         {
             Type target = typeof(T);
@@ -280,7 +289,10 @@ internal T MakeUpdateDelegate()
             if (System.Linq.Expressions.LambdaExpression.CanCompileToIL
                 && target.IsGenericType && IsSimpleSignature(invoke, out Type[] args))
             {
+#pragma warning disable IL3050
+                // Analyzer doesn't yet understand feature switches
                 return MakeUpdateDelegateWhenCanCompileToIL();
+#pragma warning restore IL3050
             }
 
             s_cachedNoMatch = CreateCustomNoMatchDelegate(invoke);
@@ -289,6 +301,7 @@ internal T MakeUpdateDelegate()
 
             [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2060:MakeGenericMethod",
                 Justification = "UpdateDelegates methods don't have ILLink annotations.")]
+            [RequiresDynamicCode(Expression.GenericMethodRequiresDynamicCode)]
             T MakeUpdateDelegateWhenCanCompileToIL()
             {
                 MethodInfo? method = null;
@@ -346,8 +359,7 @@ private static bool IsSimpleSignature(MethodInfo invoke, out Type[] sig)
             return supported;
         }
 
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2060:MakeGenericMethod",
-            Justification = "CallSiteOps methods don't have trimming annotations.")]
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         private T CreateCustomUpdateDelegate(MethodInfo invoke)
         {
             Type returnType = invoke.GetReturnType();
@@ -394,7 +406,9 @@ private T CreateCustomUpdateDelegate(MethodInfo invoke)
                 Expression.Assign(
                     site,
                     Expression.Call(
-                        CallSiteOps_CreateMatchmaker.MakeGenericMethod(typeArgs),
+#pragma warning disable CS0618 // CallSiteOps.CreateMatchmaker is obsolete
+                        CallSiteOpsReflectionCache<T>.CreateMatchmaker,
+#pragma warning restore CS0618
                         @this
                     )
                 )
@@ -409,7 +423,9 @@ private T CreateCustomUpdateDelegate(MethodInfo invoke)
             Expression invokeRule = Expression.Invoke(rule, new TrueReadOnlyCollection<Expression>(@params));
 
             Expression onMatch = Expression.Call(
-                CallSiteOps_UpdateRules.MakeGenericMethod(typeArgs),
+#pragma warning disable CS0618 // CallSiteOps is obsolete
+                CallSiteOpsReflectionCache<T>.UpdateRules,
+#pragma warning restore CS0618
                 @this,
                 index
             );
@@ -453,7 +469,9 @@ private T CreateCustomUpdateDelegate(MethodInfo invoke)
                         Expression.Assign(
                             applicable,
                             Expression.Call(
-                                CallSiteOps_GetRules.MakeGenericMethod(typeArgs),
+#pragma warning disable CS0618 // CallSiteOps is obsolete
+                                CallSiteOpsReflectionCache<T>.GetRules,
+#pragma warning restore CS0618
                                 @this
                             )
                         ),
@@ -502,14 +520,18 @@ private T CreateCustomUpdateDelegate(MethodInfo invoke)
             body.UncheckedAdd(
                 Expression.Assign(
                     cache,
-                    Expression.Call(CallSiteOps_GetRuleCache.MakeGenericMethod(typeArgs), @this)
+#pragma warning disable CS0618 // CallSiteOps is obsolete
+                    Expression.Call(CallSiteOpsReflectionCache<T>.GetRuleCache, @this)
+#pragma warning restore CS0618
                 )
             );
 
             body.UncheckedAdd(
                 Expression.Assign(
                     applicable,
-                    Expression.Call(CallSiteOps_GetCachedRules.MakeGenericMethod(typeArgs), cache)
+#pragma warning disable CS0618 // CallSiteOps is obsolete
+                    Expression.Call(CallSiteOpsReflectionCache<T>.GetCachedRules, cache)
+#pragma warning restore CS0618
                 )
             );
 
@@ -540,8 +562,10 @@ private T CreateCustomUpdateDelegate(MethodInfo invoke)
                 Expression.IfThen(
                     getMatch,
                     Expression.Block(
-                        Expression.Call(CallSiteOps_AddRule.MakeGenericMethod(typeArgs), @this, rule),
-                        Expression.Call(CallSiteOps_MoveRule.MakeGenericMethod(typeArgs), cache, rule, index)
+#pragma warning disable CS0618
+                        Expression.Call(CallSiteOpsReflectionCache<T>.AddRule, @this, rule),
+                        Expression.Call(CallSiteOpsReflectionCache<T>.MoveRule, cache, rule, index)
+#pragma warning restore CS0618
                     )
                 )
             );
@@ -578,7 +602,7 @@ private T CreateCustomUpdateDelegate(MethodInfo invoke)
             body.UncheckedAdd(
                 Expression.Assign(
                     args,
-                    Expression.NewArrayInit(typeof(object), new TrueReadOnlyCollection<Expression>(argsElements))
+                    Expression.NewObjectArrayInit(new TrueReadOnlyCollection<Expression>(argsElements))
                 )
             );
 
@@ -592,7 +616,9 @@ private T CreateCustomUpdateDelegate(MethodInfo invoke)
                 Expression.Assign(
                     rule,
                     Expression.Call(
-                        CallSiteOps_Bind.MakeGenericMethod(typeArgs),
+#pragma warning disable CS0618 // Type or member is obsolete
+                        CallSiteOpsReflectionCache<T>.Bind,
+#pragma warning restore CS0618
                         Expression.Property(@this, typeof(CallSite).GetProperty(nameof(Binder))!),
                         @this,
                         args
@@ -605,7 +631,9 @@ private T CreateCustomUpdateDelegate(MethodInfo invoke)
                 Expression.IfThen(
                     getMatch,
                     Expression.Call(
-                        CallSiteOps_AddRule.MakeGenericMethod(typeArgs),
+#pragma warning disable 0618 // CallSiteOps.AddRule_Internal is obsolete
+                        CallSiteOpsReflectionCache<T>.AddRule,
+#pragma warning restore 0618
                         @this,
                         rule
                     )
@@ -640,6 +668,7 @@ private T CreateCustomUpdateDelegate(MethodInfo invoke)
             return lambda.Compile();
         }
 
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         private T CreateCustomNoMatchDelegate(MethodInfo invoke)
         {
             ParameterExpression[] @params = Array.ConvertAll(invoke.GetParametersCached(), p => Expression.Parameter(p.ParameterType, p.Name));
diff --git a/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSiteBinder.cs b/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSiteBinder.cs
index 968b272e415a70..41df675b6aaf94 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSiteBinder.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSiteBinder.cs
@@ -4,10 +4,11 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Dynamic.Utils;
 using System.Linq.Expressions;
-using System.Threading;
 using System.Reflection;
+using System.Threading;
 using static System.Linq.Expressions.CachedReflectionInfo;
 
 namespace System.Runtime.CompilerServices
@@ -100,6 +101,7 @@ private LambdaSignature()
             return null;
         }
 
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         internal T BindCore<T>(CallSite<T> site, object[] args) where T : class
         {
             //
diff --git a/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSiteOps.cs b/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSiteOps.cs
index 4b3fd28ffdebe5..9460333c4efb5d 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSiteOps.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSiteOps.cs
@@ -3,6 +3,8 @@
 
 using System.ComponentModel;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
 
 namespace System.Runtime.CompilerServices
 {
@@ -151,6 +153,7 @@ public static T[] GetCachedRules<T>(RuleCache<T> cache) where T : class
         /// <param name="args">Arguments to the call site.</param>
         /// <returns>The new call site target.</returns>
         [Obsolete("CallSiteOps has been deprecated and is not supported.", error: true), EditorBrowsable(EditorBrowsableState.Never)]
+        [RequiresDynamicCode(Expression.NewArrayRequiresDynamicCode)]
         public static T Bind<T>(CallSiteBinder binder, CallSite<T> site, object[] args) where T : class
         {
             return binder.BindCore(site, args);
diff --git a/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSiteOpsReflectionCache.cs b/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSiteOpsReflectionCache.cs
new file mode 100644
index 00000000000000..8bc40b9361d718
--- /dev/null
+++ b/src/libraries/System.Linq.Expressions/src/System/Runtime/CompilerServices/CallSiteOpsReflectionCache.cs
@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace System.Runtime.CompilerServices;
+internal static class CallSiteOpsReflectionCache<T> where T : class
+{
+    [Obsolete("CallSiteOps has been deprecated and is not supported.", error: false), EditorBrowsable(EditorBrowsableState.Never)]
+    public static readonly MethodInfo CreateMatchmaker = ((Delegate)CallSiteOps.CreateMatchmaker<T>).GetMethodInfo();
+
+    [Obsolete("CallSiteOps has been deprecated and is not supported.", error: false), EditorBrowsable(EditorBrowsableState.Never)]
+    public static readonly MethodInfo UpdateRules = ((Delegate)CallSiteOps.UpdateRules<T>).GetMethodInfo();
+
+    [Obsolete("CallSiteOps has been deprecated and is not supported.", error: false), EditorBrowsable(EditorBrowsableState.Never)]
+    public static readonly MethodInfo GetRules = ((Delegate)CallSiteOps.GetRules<T>).GetMethodInfo();
+
+    [Obsolete("CallSiteOps has been deprecated and is not supported.", error: false), EditorBrowsable(EditorBrowsableState.Never)]
+    public static readonly MethodInfo GetRuleCache = ((Delegate)CallSiteOps.GetRuleCache<T>).GetMethodInfo();
+
+    [Obsolete("CallSiteOps has been deprecated and is not supported.", error: false), EditorBrowsable(EditorBrowsableState.Never)]
+    public static readonly MethodInfo GetCachedRules = ((Delegate)CallSiteOps.GetCachedRules<T>).GetMethodInfo();
+
+    [Obsolete("CallSiteOps has been deprecated and is not supported.", error: false), EditorBrowsable(EditorBrowsableState.Never)]
+    public static readonly MethodInfo AddRule = ((Delegate)CallSiteOps.AddRule<T>).GetMethodInfo();
+
+    [Obsolete("CallSiteOps has been deprecated and is not supported.", error: false), EditorBrowsable(EditorBrowsableState.Never)]
+    public static readonly MethodInfo MoveRule = ((Delegate)CallSiteOps.MoveRule<T>).GetMethodInfo();
+
+    [Obsolete("CallSiteOps has been deprecated and is not supported.", error: false), EditorBrowsable(EditorBrowsableState.Never)]
+    [UnconditionalSuppressMessage("DynamicCode", "IL3050",
+        Justification = "CallSiteOps is obsolete and CallSite has RUC. Propagating warnings through fields isn't worth it.")]
+    public static readonly MethodInfo Bind = ((Delegate)CallSiteOps.Bind<T>).GetMethodInfo();
+}
diff --git a/src/libraries/System.Linq.Expressions/tests/BinaryOperators/Arithmetic/BinaryMultiplyTests.cs b/src/libraries/System.Linq.Expressions/tests/BinaryOperators/Arithmetic/BinaryMultiplyTests.cs
index 9ff5a7beebad97..fac272e452e66f 100644
--- a/src/libraries/System.Linq.Expressions/tests/BinaryOperators/Arithmetic/BinaryMultiplyTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/BinaryOperators/Arithmetic/BinaryMultiplyTests.cs
@@ -602,15 +602,18 @@ public static void VBStyleOperatorOverloading(bool useInterpreter)
         [Theory, ClassData(typeof(CompilationTypes))]
         public static void VBStyleOperatorOverloadingLifted(bool useInterpreter)
         {
-            var b = Expression.Parameter(typeof(VBStyleExponentiation?));
-            var e = Expression.Parameter(typeof(VBStyleExponentiation?));
-            var func = Expression.Lambda<Func<VBStyleExponentiation?, VBStyleExponentiation?, VBStyleExponentiation?>>(
-                Expression.Power(b, e), b, e).Compile(useInterpreter);
-            Assert.Equal(8.0, func(2.0, 3.0).Value.Value);
-            Assert.Equal(10000.0, func(10.0, 4.0).Value.Value);
-            Assert.Null(func(2.0, null));
-            Assert.Null(func(null, 2.0));
-            Assert.Null(func(null, null));
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
+            {
+                var b = Expression.Parameter(typeof(VBStyleExponentiation?));
+                var e = Expression.Parameter(typeof(VBStyleExponentiation?));
+                var func = Expression.Lambda<Func<VBStyleExponentiation?, VBStyleExponentiation?, VBStyleExponentiation?>>(
+                    Expression.Power(b, e), b, e).Compile(useInterpreter);
+                Assert.Equal(8.0, func(2.0, 3.0).Value.Value);
+                Assert.Equal(10000.0, func(10.0, 4.0).Value.Value);
+                Assert.Null(func(2.0, null));
+                Assert.Null(func(null, 2.0));
+                Assert.Null(func(null, null));
+            });
         }
 
         // Simulate F#-style overloading of exponentiation operation
@@ -642,13 +645,16 @@ public static void FSStyleOperatorOverloadingLifted(bool useInterpreter)
         {
             var b = Expression.Parameter(typeof(FSStyleExponentiation?));
             var e = Expression.Parameter(typeof(FSStyleExponentiation?));
-            var func = Expression.Lambda<Func<FSStyleExponentiation?, FSStyleExponentiation?, FSStyleExponentiation?>>(
-                Expression.Power(b, e), b, e).Compile(useInterpreter);
-            Assert.Equal(8.0, func(2.0, 3.0).Value.Value);
-            Assert.Equal(10000.0, func(10.0, 4.0).Value.Value);
-            Assert.Null(func(2.0, null));
-            Assert.Null(func(null, 2.0));
-            Assert.Null(func(null, null));
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
+            {
+                var func = Expression.Lambda<Func<FSStyleExponentiation?, FSStyleExponentiation?, FSStyleExponentiation?>>(
+                    Expression.Power(b, e), b, e).Compile(useInterpreter);
+                Assert.Equal(8.0, func(2.0, 3.0).Value.Value);
+                Assert.Equal(10000.0, func(10.0, 4.0).Value.Value);
+                Assert.Null(func(2.0, null));
+                Assert.Null(func(null, 2.0));
+                Assert.Null(func(null, null));
+            });
         }
 
         [Fact]
diff --git a/src/libraries/System.Linq.Expressions/tests/HelperTypes.cs b/src/libraries/System.Linq.Expressions/tests/HelperTypes.cs
index ae01067743f9d1..bcc88b0fc85732 100644
--- a/src/libraries/System.Linq.Expressions/tests/HelperTypes.cs
+++ b/src/libraries/System.Linq.Expressions/tests/HelperTypes.cs
@@ -5,7 +5,9 @@
 using System.Collections.Generic;
 using System.Reflection;
 using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
 using Xunit;
+using Xunit.Sdk;
 
 namespace System.Linq.Expressions.Tests
 {
diff --git a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedAddCheckedNullableTests.cs b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedAddCheckedNullableTests.cs
index d1d35552739aed..7d4f01fa0f4f72 100644
--- a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedAddCheckedNullableTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedAddCheckedNullableTests.cs
@@ -169,14 +169,17 @@ public static void CheckLiftedAddCheckedNullableUShortTest(bool useInterpreter)
         [Theory, ClassData(typeof(CompilationTypes))]
         public static void CheckLiftedAddCheckedNullableNumberTest(bool useInterpreter)
         {
-            Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
-            for (int i = 0; i < values.Length; i++)
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
             {
-                for (int j = 0; j < values.Length; j++)
+                Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
+                for (int i = 0; i < values.Length; i++)
                 {
-                    VerifyAddCheckedNullableNumber(values[i], values[j], useInterpreter);
+                    for (int j = 0; j < values.Length; j++)
+                    {
+                        VerifyAddCheckedNullableNumber(values[i], values[j], useInterpreter);
+                    }
                 }
-            }
+            });
         }
 
         [Fact] // See https://github.com/dotnet/runtime/issues/19106
diff --git a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedAddNullableTests.cs b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedAddNullableTests.cs
index c52cb4b3c8dbb1..a6c7ed100e43e6 100644
--- a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedAddNullableTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedAddNullableTests.cs
@@ -169,14 +169,17 @@ public static void CheckLiftedAddNullableUShortTest(bool useInterpreter)
         [Theory, ClassData(typeof(CompilationTypes))]
         public static void CheckLiftedAddNullableNumberTest(bool useInterpreter)
         {
-            Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
-            for (int i = 0; i < values.Length; i++)
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
             {
-                for (int j = 0; j < values.Length; j++)
+                Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
+                for (int i = 0; i < values.Length; i++)
                 {
-                    VerifyAddNullableNumber(values[i], values[j], useInterpreter);
+                    for (int j = 0; j < values.Length; j++)
+                    {
+                        VerifyAddNullableNumber(values[i], values[j], useInterpreter);
+                    }
                 }
-            }
+            });
         }
 
         #endregion
diff --git a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedBitwiseAndNullableTests.cs b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedBitwiseAndNullableTests.cs
index 568044209d64bb..b222b5f4c425a3 100644
--- a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedBitwiseAndNullableTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedBitwiseAndNullableTests.cs
@@ -117,14 +117,17 @@ public static void CheckLiftedBitwiseAndNullableUShortTest(bool useInterpreter)
         [Theory, ClassData(typeof(CompilationTypes))]
         public static void CheckLiftedBitwiseAndNullableNumberTest(bool useInterpreter)
         {
-            Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
-            for (int i = 0; i < values.Length; i++)
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
             {
-                for (int j = 0; j < values.Length; j++)
+                Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
+                for (int i = 0; i < values.Length; i++)
                 {
-                    VerifyBitwiseAndNullableNumber(values[i], values[j], useInterpreter);
+                    for (int j = 0; j < values.Length; j++)
+                    {
+                        VerifyBitwiseAndNullableNumber(values[i], values[j], useInterpreter);
+                    }
                 }
-            }
+            });
         }
 
         #endregion
diff --git a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedBitwiseExclusiveOrNullableTests.cs b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedBitwiseExclusiveOrNullableTests.cs
index 4316f20ec6110e..b6f11a104450cc 100644
--- a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedBitwiseExclusiveOrNullableTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedBitwiseExclusiveOrNullableTests.cs
@@ -117,14 +117,17 @@ public static void CheckLiftedBitwiseExclusiveOrNullableUShortTest(bool useInter
         [Theory, ClassData(typeof(CompilationTypes))]
         public static void CheckLiftedBitwiseExclusiveOrNullableNumberTest(bool useInterpreter)
         {
-            Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
-            for (int i = 0; i < values.Length; i++)
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
             {
-                for (int j = 0; j < values.Length; j++)
+                Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
+                for (int i = 0; i < values.Length; i++)
                 {
-                    VerifyBitwiseExclusiveOrNullableNumber(values[i], values[j], useInterpreter);
+                    for (int j = 0; j < values.Length; j++)
+                    {
+                        VerifyBitwiseExclusiveOrNullableNumber(values[i], values[j], useInterpreter);
+                    }
                 }
-            }
+            });
         }
 
         #endregion
diff --git a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedBitwiseOrNullableTests.cs b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedBitwiseOrNullableTests.cs
index 3be67fe2ca1a7f..5b2578c0eff464 100644
--- a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedBitwiseOrNullableTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedBitwiseOrNullableTests.cs
@@ -117,14 +117,17 @@ public static void CheckLiftedBitwiseOrNullableUShortTest(bool useInterpreter)
         [Theory, ClassData(typeof(CompilationTypes))]
         public static void CheckLiftedBitwiseOrNullableNumberTest(bool useInterpreter)
         {
-            Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
-            for (int i = 0; i < values.Length; i++)
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
             {
-                for (int j = 0; j < values.Length; j++)
+                Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
+                for (int i = 0; i < values.Length; i++)
                 {
-                    VerifyBitwiseOrNullableNumber(values[i], values[j], useInterpreter);
+                    for (int j = 0; j < values.Length; j++)
+                    {
+                        VerifyBitwiseOrNullableNumber(values[i], values[j], useInterpreter);
+                    }
                 }
-            }
+            });
         }
 
         #endregion
diff --git a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedDivideNullableTests.cs b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedDivideNullableTests.cs
index b637dca86dffa2..ad1a14504a26cc 100644
--- a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedDivideNullableTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedDivideNullableTests.cs
@@ -179,14 +179,17 @@ public static void CheckLiftedDivideNullableUShortTest(bool useInterpreter)
         [ClassData(typeof(CompilationTypes))]
         public static void CheckLiftedDivideNullableNumberTest(bool useInterpreter)
         {
-            Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
-            for (int i = 0; i < values.Length; i++)
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
             {
-                for (int j = 0; j < values.Length; j++)
+                Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
+                for (int i = 0; i < values.Length; i++)
                 {
-                    VerifyDivideNullableNumber(values[i], values[j], useInterpreter);
+                    for (int j = 0; j < values.Length; j++)
+                    {
+                        VerifyDivideNullableNumber(values[i], values[j], useInterpreter);
+                    }
                 }
-            }
+            });
         }
 
         #endregion
diff --git a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedModuloNullableTests.cs b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedModuloNullableTests.cs
index e02292c7682730..3585e780aaa4eb 100644
--- a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedModuloNullableTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedModuloNullableTests.cs
@@ -179,14 +179,17 @@ public static void CheckLiftedModuloNullableUShortTest(bool useInterpreter)
         [ClassData(typeof(CompilationTypes))]
         public static void CheckLiftedModuloNullableNumberTest(bool useInterpreter)
         {
-            Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
-            for (int i = 0; i < values.Length; i++)
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
             {
-                for (int j = 0; j < values.Length; j++)
+                Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
+                for (int i = 0; i < values.Length; i++)
                 {
-                    VerifyModuloNullableNumber(values[i], values[j], useInterpreter);
+                    for (int j = 0; j < values.Length; j++)
+                    {
+                        VerifyModuloNullableNumber(values[i], values[j], useInterpreter);
+                    }
                 }
-            }
+            });
         }
 
         #endregion
diff --git a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedMultiplyCheckedNullableTests.cs b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedMultiplyCheckedNullableTests.cs
index 0e89eb032d1a77..5d2980778d7f00 100644
--- a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedMultiplyCheckedNullableTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedMultiplyCheckedNullableTests.cs
@@ -169,14 +169,17 @@ public static void CheckLiftedMultiplyCheckedNullableUShortTest(bool useInterpre
         [Theory, ClassData(typeof(CompilationTypes))]
         public static void CheckLiftedMultiplyCheckedNullableNumberTest(bool useInterpreter)
         {
-            Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
-            for (int i = 0; i < values.Length; i++)
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
             {
-                for (int j = 0; j < values.Length; j++)
+                Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
+                for (int i = 0; i < values.Length; i++)
                 {
-                    VerifyMultiplyCheckedNullableNumber(values[i], values[j], useInterpreter);
+                    for (int j = 0; j < values.Length; j++)
+                    {
+                        VerifyMultiplyCheckedNullableNumber(values[i], values[j], useInterpreter);
+                    }
                 }
-            }
+            });
         }
 
         #endregion
diff --git a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedMultiplyNullableTests.cs b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedMultiplyNullableTests.cs
index f3482720686b8c..0cdbd8b83ad949 100644
--- a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedMultiplyNullableTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedMultiplyNullableTests.cs
@@ -169,14 +169,17 @@ public static void CheckLiftedMultiplyNullableUShortTest(bool useInterpreter)
         [Theory, ClassData(typeof(CompilationTypes))]
         public static void CheckLiftedMultiplyNullableNumberTest(bool useInterpreter)
         {
-            Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
-            for (int i = 0; i < values.Length; i++)
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
             {
-                for (int j = 0; j < values.Length; j++)
+                Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
+                for (int i = 0; i < values.Length; i++)
                 {
-                    VerifyMultiplyNullableNumber(values[i], values[j], useInterpreter);
+                    for (int j = 0; j < values.Length; j++)
+                    {
+                        VerifyMultiplyNullableNumber(values[i], values[j], useInterpreter);
+                    }
                 }
-            }
+            });
         }
 
         #endregion
diff --git a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedSubtractCheckedNullableTests.cs b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedSubtractCheckedNullableTests.cs
index b89cf44b8b20e5..b91ccf45df3dad 100644
--- a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedSubtractCheckedNullableTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedSubtractCheckedNullableTests.cs
@@ -169,14 +169,17 @@ public static void CheckLiftedSubtractCheckedNullableUShortTest(bool useInterpre
         [Theory, ClassData(typeof(CompilationTypes))]
         public static void CheckLiftedSubtractCheckedNullableNumberTest(bool useInterpreter)
         {
-            Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
-            for (int i = 0; i < values.Length; i++)
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
             {
-                for (int j = 0; j < values.Length; j++)
+                Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
+                for (int i = 0; i < values.Length; i++)
                 {
-                    VerifySubtractCheckedNullableNumber(values[i], values[j], useInterpreter);
+                    for (int j = 0; j < values.Length; j++)
+                    {
+                        VerifySubtractCheckedNullableNumber(values[i], values[j], useInterpreter);
+                    }
                 }
-            }
+            });
         }
 
         #endregion
diff --git a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedSubtractNullableTests.cs b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedSubtractNullableTests.cs
index 9e70857a170024..d231543baa4659 100644
--- a/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedSubtractNullableTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/Lifted/LiftedSubtractNullableTests.cs
@@ -169,14 +169,17 @@ public static void CheckLiftedSubtractNullableUShortTest(bool useInterpreter)
         [Theory, ClassData(typeof(CompilationTypes))]
         public static void CheckLiftedSubtractNullableNumberTest(bool useInterpreter)
         {
-            Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
-            for (int i = 0; i < values.Length; i++)
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
             {
-                for (int j = 0; j < values.Length; j++)
+                Number?[] values = new Number?[] { null, new Number(0), new Number(1), Number.MaxValue };
+                for (int i = 0; i < values.Length; i++)
                 {
-                    VerifySubtractNullableNumber(values[i], values[j], useInterpreter);
+                    for (int j = 0; j < values.Length; j++)
+                    {
+                        VerifySubtractNullableNumber(values[i], values[j], useInterpreter);
+                    }
                 }
-            }
+            });
         }
 
         #endregion
diff --git a/src/libraries/System.Linq.Expressions/tests/SequenceTests/SequenceTests.cs b/src/libraries/System.Linq.Expressions/tests/SequenceTests/SequenceTests.cs
index edd53405b83c88..35f1723c8038b9 100644
--- a/src/libraries/System.Linq.Expressions/tests/SequenceTests/SequenceTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/SequenceTests/SequenceTests.cs
@@ -194,17 +194,17 @@ public static void TestUserDefinedOperators()
             TestUserDefinedMathOperators<U, U>();
             TestUserDefinedComparisonOperators<U, U>();
             TestUserDefinedBitwiseOperators<U, U>();
-            TestUserDefinedMathOperators<U?, U?>();
-            TestUserDefinedComparisonOperators<U?, U?>();
-            TestUserDefinedBitwiseOperators<U?, U?>();
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(TestUserDefinedMathOperators<U?, U?>);
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(TestUserDefinedComparisonOperators<U?, U?>);
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(TestUserDefinedBitwiseOperators<U?, U?>);
 
             TestUserDefinedComparisonOperators<B, B>();
             TestUserDefinedLogicalOperators<B, B>();
-            TestUserDefinedComparisonOperators<B?, B?>();
-            TestUserDefinedLogicalOperators<B?, B?>();
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(TestUserDefinedComparisonOperators<B?, B?>);
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(TestUserDefinedLogicalOperators<B?, B?>);
 
             TestUserDefinedMathOperators<M, N>();
-            TestUserDefinedMathOperators<M?, N?>();
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(TestUserDefinedMathOperators<M?, N?>);
         }
 
         internal static bool IsNullableType(Type type)
diff --git a/src/libraries/System.Linq.Expressions/tests/Unary/UnaryDecrementNullableTests.cs b/src/libraries/System.Linq.Expressions/tests/Unary/UnaryDecrementNullableTests.cs
index 6a0defc163be39..cfa420e1be1d5f 100644
--- a/src/libraries/System.Linq.Expressions/tests/Unary/UnaryDecrementNullableTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/Unary/UnaryDecrementNullableTests.cs
@@ -136,9 +136,12 @@ public static void DecrementNonArithmetic(object value)
         [Theory, PerCompilationType(nameof(DecrementableValues), true)]
         public static void CustomOpDecrement(Decrementable? operand, Decrementable? expected, bool useInterpreter)
         {
-            Func<Decrementable?> func = Expression.Lambda<Func<Decrementable?>>(
-                Expression.Decrement(Expression.Constant(operand, typeof(Decrementable?)))).Compile(useInterpreter);
-            Assert.Equal(expected, func());
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
+            {
+                Func<Decrementable?> func = Expression.Lambda<Func<Decrementable?>>(
+                            Expression.Decrement(Expression.Constant(operand, typeof(Decrementable?)))).Compile(useInterpreter);
+                Assert.Equal(expected, func());
+            });
         }
 
         [Theory, PerCompilationType(nameof(DecrementableWhenNullableValues))]
@@ -153,10 +156,13 @@ public static void NonLiftedNullableOpDecrement(
         [Theory, PerCompilationType(nameof(DoublyDecrementedDecrementableValues), true)]
         public static void UserDefinedOpDecrement(Decrementable? operand, Decrementable? expected, bool useInterpreter)
         {
-            MethodInfo method = typeof(IncrementDecrementTests).GetMethod(nameof(DoublyDecrement));
-            Func<Decrementable?> func = Expression.Lambda<Func<Decrementable?>>(
-                Expression.Decrement(Expression.Constant(operand, typeof(Decrementable?)), method)).Compile(useInterpreter);
-            Assert.Equal(expected, func());
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
+            {
+                MethodInfo method = typeof(IncrementDecrementTests).GetMethod(nameof(DoublyDecrement));
+                Func<Decrementable?> func = Expression.Lambda<Func<Decrementable?>>(
+                                Expression.Decrement(Expression.Constant(operand, typeof(Decrementable?)), method)).Compile(useInterpreter);
+                Assert.Equal(expected, func());
+            });
         }
 
         [Theory, PerCompilationType(nameof(DoublyDecrementedInt32s), true)]
diff --git a/src/libraries/System.Linq.Expressions/tests/Unary/UnaryDecrementTests.cs b/src/libraries/System.Linq.Expressions/tests/Unary/UnaryDecrementTests.cs
index 1555ff320bb549..36ebc9f727a682 100644
--- a/src/libraries/System.Linq.Expressions/tests/Unary/UnaryDecrementTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/Unary/UnaryDecrementTests.cs
@@ -110,7 +110,7 @@ public static void DecrementNonArithmetic(object value)
         public static void CustomOpDecrement(Decrementable operand, Decrementable expected, bool useInterpreter)
         {
             Func<Decrementable> func = Expression.Lambda<Func<Decrementable>>(
-                Expression.Decrement(Expression.Constant(operand))).Compile(useInterpreter);
+                            Expression.Decrement(Expression.Constant(operand))).Compile(useInterpreter);
             Assert.Equal(expected.Value, func().Value);
         }
 
diff --git a/src/libraries/System.Linq.Expressions/tests/Unary/UnaryIncrementNullableTests.cs b/src/libraries/System.Linq.Expressions/tests/Unary/UnaryIncrementNullableTests.cs
index d027033fe4c286..a70b486ae68563 100644
--- a/src/libraries/System.Linq.Expressions/tests/Unary/UnaryIncrementNullableTests.cs
+++ b/src/libraries/System.Linq.Expressions/tests/Unary/UnaryIncrementNullableTests.cs
@@ -138,9 +138,12 @@ public static void DecrementNonArithmetic(object value)
         [Theory, PerCompilationType(nameof(IncrementableValues), true)]
         public static void CustomOpIncrement(Incrementable? operand, Incrementable? expected, bool useInterpreter)
         {
-            Func<Incrementable?> func = Expression.Lambda<Func<Incrementable?>>(
-                Expression.Increment(Expression.Constant(operand, typeof(Incrementable?)))).Compile(useInterpreter);
-            Assert.Equal(expected, func());
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
+            {
+                Func<Incrementable?> func = Expression.Lambda<Func<Incrementable?>>(
+                    Expression.Increment(Expression.Constant(operand, typeof(Incrementable?)))).Compile(useInterpreter);
+                Assert.Equal(expected, func());
+            });
         }
 
         [Theory, PerCompilationType(nameof(IncrementableWhenNullableValues))]
@@ -155,10 +158,13 @@ public static void NonLiftedNullableOpIncrement(
         [Theory, PerCompilationType(nameof(DoublyIncrementedIncrementableValues), true)]
         public static void UserDefinedOpIncrement(Incrementable? operand, Incrementable? expected, bool useInterpreter)
         {
-            MethodInfo method = typeof(IncrementDecrementTests).GetMethod(nameof(DoublyIncrement));
-            Func<Incrementable?> func = Expression.Lambda<Func<Incrementable?>>(
-                Expression.Increment(Expression.Constant(operand, typeof(Incrementable?)), method)).Compile(useInterpreter);
-            Assert.Equal(expected, func());
+            AssertExtensions.ThrowsOnAot<NotSupportedException>(() =>
+            {
+                MethodInfo method = typeof(IncrementDecrementTests).GetMethod(nameof(DoublyIncrement));
+                Func<Incrementable?> func = Expression.Lambda<Func<Incrementable?>>(
+                    Expression.Increment(Expression.Constant(operand, typeof(Incrementable?)), method)).Compile(useInterpreter);
+                Assert.Equal(expected, func());
+            });
         }
 
         [Theory, PerCompilationType(nameof(DoublyIncrementedInt32s), true)]