diff --git a/src/DotNext.Metaprogramming/Linq/Expressions/CollectionAccessExpression.cs b/src/DotNext.Metaprogramming/Linq/Expressions/CollectionAccessExpression.cs
index 86f4787a3..e375307d8 100644
--- a/src/DotNext.Metaprogramming/Linq/Expressions/CollectionAccessExpression.cs
+++ b/src/DotNext.Metaprogramming/Linq/Expressions/CollectionAccessExpression.cs
@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq.Expressions;
 using System.Reflection;
 
@@ -156,4 +157,4 @@ protected override CollectionAccessExpression VisitChildren(ExpressionVisitor vi
         var collection = visitor.Visit(Collection);
         return ReferenceEquals(index, Index) && ReferenceEquals(collection, Collection) ? this : new(collection, index);
     }
-}
\ No newline at end of file
+}
diff --git a/src/DotNext.Metaprogramming/Linq/Expressions/ForEachExpression.cs b/src/DotNext.Metaprogramming/Linq/Expressions/ForEachExpression.cs
index 810a761a2..919262221 100644
--- a/src/DotNext.Metaprogramming/Linq/Expressions/ForEachExpression.cs
+++ b/src/DotNext.Metaprogramming/Linq/Expressions/ForEachExpression.cs
@@ -14,7 +14,7 @@ namespace DotNext.Linq.Expressions;
 /// Represents iteration over collection elements as expression.
 /// </summary>
 /// <seealso href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/foreach-in">foreach Statement</seealso>
-[RequiresUnreferencedCode("Dynamic access to GetEnumerator method and IEnumerable<T> interfaces.")]
+[RequiresUnreferencedCode("Dynamic access to GetEnumerator (GetAsyncEnumerator) method and IEnumerable<T> (IAsyncEnumerable<T>) interfaces.")]
 public sealed class ForEachExpression : CustomExpression, ILoopLabels
 {
     private const string EnumeratorVarName = "enumerator";
@@ -224,4 +224,4 @@ public override Expression Reduce()
 
         return Reduce(moveNextCall, disposeCall);
     }
-}
\ No newline at end of file
+}
diff --git a/src/DotNext.Metaprogramming/Linq/Expressions/MetaExpression.cs b/src/DotNext.Metaprogramming/Linq/Expressions/MetaExpression.cs
index 37b2245a3..cc8a5633b 100644
--- a/src/DotNext.Metaprogramming/Linq/Expressions/MetaExpression.cs
+++ b/src/DotNext.Metaprogramming/Linq/Expressions/MetaExpression.cs
@@ -1,4 +1,5 @@
-using System.Dynamic;
+using System.Diagnostics.CodeAnalysis;
+using System.Dynamic;
 using System.Linq.Expressions;
 using System.Reflection;
 using Debug = System.Diagnostics.Debug;
@@ -8,6 +9,7 @@ namespace DotNext.Linq.Expressions;
 
 using Intrinsics = Runtime.Intrinsics;
 
+[RequiresUnreferencedCode("Binds to arbitrary members.")]
 internal sealed class MetaExpression : DynamicMetaObject
 {
     private static readonly MethodInfo AsExpressionBuilderMethod = new Func<object?, ISupplier<Expression>?>(Unsafe.As<ISupplier<Expression>>).Method;
@@ -178,4 +180,4 @@ public override DynamicMetaObject BindCreateInstance(CreateInstanceBinder binder
 
         return new MetaExpression(binding, CreateRestrictions().Merge(restrictions));
     }
-}
\ No newline at end of file
+}
diff --git a/src/DotNext.Metaprogramming/Metaprogramming/AsyncLambdaExpression.cs b/src/DotNext.Metaprogramming/Metaprogramming/AsyncLambdaExpression.cs
index 7c0b3ecc1..3f6a63025 100644
--- a/src/DotNext.Metaprogramming/Metaprogramming/AsyncLambdaExpression.cs
+++ b/src/DotNext.Metaprogramming/Metaprogramming/AsyncLambdaExpression.cs
@@ -2,12 +2,14 @@
 
 namespace DotNext.Metaprogramming;
 
+using System.Diagnostics.CodeAnalysis;
 using Linq.Expressions;
 using Runtime.CompilerServices;
 using static Reflection.DelegateType;
 using List = Collections.Generic.List;
 
-internal sealed class AsyncLambdaExpression<TDelegate> : LambdaExpression, ILexicalScope<Expression<TDelegate>, Action<LambdaContext>>, ILexicalScope<Expression<TDelegate>, Action<LambdaContext, ParameterExpression>>
+[RequiresUnreferencedCode("Dynamic access to Transition and IAsyncStateMachine internal types.")]
+internal sealed class AsyncLambdaExpression<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TDelegate> : LambdaExpression, ILexicalScope<Expression<TDelegate>, Action<LambdaContext>>, ILexicalScope<Expression<TDelegate>, Action<LambdaContext, ParameterExpression>>
     where TDelegate : Delegate
 {
     private readonly bool usePooling;
@@ -99,4 +101,4 @@ public override void Dispose()
         recursion = null;
         base.Dispose();
     }
-}
\ No newline at end of file
+}
diff --git a/src/DotNext.Metaprogramming/Metaprogramming/AwaitForEachStatement.cs b/src/DotNext.Metaprogramming/Metaprogramming/AwaitForEachStatement.cs
index 6e62b8919..dbc230306 100644
--- a/src/DotNext.Metaprogramming/Metaprogramming/AwaitForEachStatement.cs
+++ b/src/DotNext.Metaprogramming/Metaprogramming/AwaitForEachStatement.cs
@@ -1,9 +1,11 @@
+using System.Diagnostics.CodeAnalysis;
 using System.Linq.Expressions;
 
 namespace DotNext.Metaprogramming;
 
 using ForEachExpression = Linq.Expressions.ForEachExpression;
 
+[RequiresUnreferencedCode("Dynamic access to GetAsyncEnumerator method and IAsyncEnumerable<T> interfaces.")]
 internal sealed class AwaitForEachStatement : LoopLexicalScope, ILexicalScope<ForEachExpression, Action<MemberExpression>>, ILexicalScope<ForEachExpression, Action<MemberExpression, LoopContext>>
 {
     private readonly Expression collection;
@@ -33,4 +35,4 @@ internal AwaitForEachStatement(Expression collection, Expression? cancellationTo
         result.Body = Build();
         return result;
     }
-}
\ No newline at end of file
+}
diff --git a/src/DotNext.Metaprogramming/Metaprogramming/CodeGenerator.cs b/src/DotNext.Metaprogramming/Metaprogramming/CodeGenerator.cs
index e175e6830..cffd1e36b 100644
--- a/src/DotNext.Metaprogramming/Metaprogramming/CodeGenerator.cs
+++ b/src/DotNext.Metaprogramming/Metaprogramming/CodeGenerator.cs
@@ -368,6 +368,7 @@ public static void NullSafeCall(Expression instance, MethodInfo method, params E
     /// <param name="methodName">The method to be called.</param>
     /// <param name="arguments">Method call arguments.</param>
     /// <exception cref="InvalidOperationException">Attempts to call this method out of lexical scope.</exception>
+    [RequiresUnreferencedCode("Dynamically accesses method <methodName>.")]
     public static void Call(Expression instance, string methodName, params Expression[] arguments)
         => Statement(instance.Call(methodName, arguments));
 
@@ -378,6 +379,7 @@ public static void Call(Expression instance, string methodName, params Expressio
     /// <param name="methodName">The method to be called.</param>
     /// <param name="arguments">Method call arguments.</param>
     /// <exception cref="InvalidOperationException">Attempts to call this method out of lexical scope.</exception>
+    [RequiresUnreferencedCode("Dynamically accesses method <methodName>.")]
     public static void NullSafeCall(Expression instance, string methodName, params Expression[] arguments)
         => Statement(instance.IfNotNull(target => target.Call(methodName, arguments)));
 
@@ -406,7 +408,8 @@ public static void CallStatic(MethodInfo method, params Expression[] arguments)
     /// <param name="methodName">The name of the static method.</param>
     /// <param name="arguments">The arguments to be passed into static method.</param>
     /// <exception cref="InvalidOperationException">Attempts to call this method out of lexical scope.</exception>
-    public static void CallStatic(Type type, string methodName, params Expression[] arguments)
+    public static void CallStatic(
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] Type type, string methodName, params Expression[] arguments)
         => Statement(type.CallStatic(methodName, arguments));
 
     /// <summary>
@@ -416,7 +419,7 @@ public static void CallStatic(Type type, string methodName, params Expression[]
     /// <param name="methodName">The name of the static method.</param>
     /// <param name="arguments">The arguments to be passed into static method.</param>
     /// <exception cref="InvalidOperationException">Attempts to call this method out of lexical scope.</exception>
-    public static void CallStatic<T>(string methodName, params Expression[] arguments)
+    public static void CallStatic<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] T>(string methodName, params Expression[] arguments)
         => CallStatic(typeof(T), methodName, arguments);
 
     /// <summary>
@@ -609,6 +612,7 @@ public static void DoWhile(Expression test, Action body)
     /// <param name="body">Loop body.</param>
     /// <exception cref="InvalidOperationException">Attempts to call this method out of lexical scope.</exception>
     /// <seealso href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/foreach-in">foreach Statement</seealso>
+    [RequiresUnreferencedCode("Dynamic access to GetEnumerator method and IEnumerable<T> interfaces.")]
     public static void ForEach(Expression collection, Action<MemberExpression, LoopContext> body)
     {
         using var statement = new ForEachStatement(collection);
@@ -622,6 +626,7 @@ public static void ForEach(Expression collection, Action<MemberExpression, LoopC
     /// <param name="body">Loop body.</param>
     /// <exception cref="InvalidOperationException">Attempts to call this method out of lexical scope.</exception>
     /// <seealso href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/foreach-in">foreach Statement</seealso>
+    [RequiresUnreferencedCode("Dynamic access to GetEnumerator method and IEnumerable<T> interfaces.")]
     public static void ForEach(Expression collection, Action<MemberExpression> body)
     {
         using var statement = new ForEachStatement(collection);
@@ -637,6 +642,7 @@ public static void ForEach(Expression collection, Action<MemberExpression> body)
     /// <param name="configureAwait"><see langword="true"/> to call <see cref="ValueTask.ConfigureAwait(bool)"/> with <see langword="false"/> argument when awaiting <see cref="IAsyncEnumerator{T}.MoveNextAsync"/> method.</param>
     /// <exception cref="InvalidOperationException">Attempts to call this method out of lexical scope.</exception>
     /// <seealso href="https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#asynchronous-streams">Async Streams</seealso>
+    [RequiresUnreferencedCode("Dynamic access to GetAsyncEnumerator method and IAsyncEnumerable<T> interfaces.")]
     public static void AwaitForEach(Expression collection, Action<MemberExpression, LoopContext> body, Expression? cancellationToken = null, bool configureAwait = false)
     {
         using var statement = new AwaitForEachStatement(collection, cancellationToken, configureAwait);
@@ -652,6 +658,7 @@ public static void AwaitForEach(Expression collection, Action<MemberExpression,
     /// <param name="configureAwait"><see langword="true"/> to call <see cref="ValueTask.ConfigureAwait(bool)"/> with <see langword="false"/> argument when awaiting <see cref="IAsyncEnumerator{T}.MoveNextAsync"/> method.</param>
     /// <exception cref="InvalidOperationException">Attempts to call this method out of lexical scope.</exception>
     /// <seealso href="https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#asynchronous-streams">Async Streams</seealso>
+    [RequiresUnreferencedCode("Dynamic access to GetAsyncEnumerator method and IAsyncEnumerable<T> interfaces.")]
     public static void AwaitForEach(Expression collection, Action<MemberExpression> body, Expression? cancellationToken = null, bool configureAwait = false)
     {
         using var statement = new AwaitForEachStatement(collection, cancellationToken, configureAwait);
@@ -934,7 +941,7 @@ public static void Return(Expression? result = null)
     /// <param name="tailCall"><see langword="true"/> if the lambda expression will be compiled with the tail call optimization, otherwise <see langword="false"/>.</param>
     /// <param name="body">Lambda function builder.</param>
     /// <returns>Constructed lambda expression.</returns>
-    public static Expression<TDelegate> Lambda<TDelegate>(bool tailCall, Action<LambdaContext> body)
+    public static Expression<TDelegate> Lambda<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TDelegate>(bool tailCall, Action<LambdaContext> body)
         where TDelegate : Delegate
     {
         using var expression = new LambdaExpression<TDelegate>(tailCall);
@@ -948,7 +955,7 @@ public static Expression<TDelegate> Lambda<TDelegate>(bool tailCall, Action<Lamb
     /// <param name="tailCall"><see langword="true"/> if the lambda expression will be compiled with the tail call optimization, otherwise <see langword="false"/>.</param>
     /// <param name="body">Lambda function builder.</param>
     /// <returns>Constructed lambda expression.</returns>
-    public static Expression<TDelegate> Lambda<TDelegate>(bool tailCall, Func<LambdaContext, Expression> body)
+    public static Expression<TDelegate> Lambda<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TDelegate>(bool tailCall, Func<LambdaContext, Expression> body)
         where TDelegate : Delegate
     {
         using var expression = new LambdaExpression<TDelegate>(tailCall);
@@ -961,7 +968,7 @@ public static Expression<TDelegate> Lambda<TDelegate>(bool tailCall, Func<Lambda
     /// <typeparam name="TDelegate">The delegate describing signature of lambda function.</typeparam>
     /// <param name="body">Lambda function builder.</param>
     /// <returns>Constructed lambda expression.</returns>
-    public static Expression<TDelegate> Lambda<TDelegate>(Func<LambdaContext, Expression> body)
+    public static Expression<TDelegate> Lambda<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TDelegate>(Func<LambdaContext, Expression> body)
         where TDelegate : Delegate
         => Lambda<TDelegate>(false, body);
 
@@ -972,7 +979,7 @@ public static Expression<TDelegate> Lambda<TDelegate>(Func<LambdaContext, Expres
     /// <param name="tailCall"><see langword="true"/> if the lambda expression will be compiled with the tail call optimization, otherwise <see langword="false"/>.</param>
     /// <param name="body">Lambda function builder.</param>
     /// <returns>Constructed lambda expression.</returns>
-    public static Expression<TDelegate> Lambda<TDelegate>(bool tailCall, Action<LambdaContext, ParameterExpression> body)
+    public static Expression<TDelegate> Lambda<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TDelegate>(bool tailCall, Action<LambdaContext, ParameterExpression> body)
         where TDelegate : Delegate
     {
         using var expression = new LambdaExpression<TDelegate>(tailCall);
@@ -985,7 +992,7 @@ public static Expression<TDelegate> Lambda<TDelegate>(bool tailCall, Action<Lamb
     /// <typeparam name="TDelegate">The delegate describing signature of lambda function.</typeparam>
     /// <param name="body">Lambda function builder.</param>
     /// <returns>Constructed lambda expression.</returns>
-    public static Expression<TDelegate> Lambda<TDelegate>(Action<LambdaContext> body)
+    public static Expression<TDelegate> Lambda<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TDelegate>(Action<LambdaContext> body)
         where TDelegate : Delegate
         => Lambda<TDelegate>(false, body);
 
@@ -995,7 +1002,7 @@ public static Expression<TDelegate> Lambda<TDelegate>(Action<LambdaContext> body
     /// <typeparam name="TDelegate">The delegate describing signature of lambda function.</typeparam>
     /// <param name="body">Lambda function builder.</param>
     /// <returns>Constructed lambda expression.</returns>
-    public static Expression<TDelegate> Lambda<TDelegate>(Action<LambdaContext, ParameterExpression> body)
+    public static Expression<TDelegate> Lambda<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TDelegate>(Action<LambdaContext, ParameterExpression> body)
         where TDelegate : Delegate
         => Lambda<TDelegate>(false, body);
 
@@ -1008,6 +1015,7 @@ public static Expression<TDelegate> Lambda<TDelegate>(Action<LambdaContext, Para
     /// <seealso cref="AwaitExpression"/>
     /// <seealso cref="AsyncResultExpression"/>
     /// <seealso href="https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/#BKMK_HowtoWriteanAsyncMethod">Async methods</seealso>
+    [RequiresUnreferencedCode("Dynamic access to Transition and IAsyncStateMachine internal types.")]
     public static Expression<TDelegate> AsyncLambda<TDelegate>(Action<LambdaContext> body)
         where TDelegate : Delegate
         => AsyncLambda<TDelegate>(false, body);
@@ -1025,6 +1033,7 @@ public static Expression<TDelegate> AsyncLambda<TDelegate>(Action<LambdaContext>
     /// <seealso cref="AwaitExpression"/>
     /// <seealso cref="AsyncResultExpression"/>
     /// <seealso href="https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/#BKMK_HowtoWriteanAsyncMethod">Async methods</seealso>
+    [RequiresUnreferencedCode("Dynamic access to Transition and IAsyncStateMachine internal types.")]
     public static Expression<TDelegate> AsyncLambda<TDelegate>(bool usePooling, Action<LambdaContext> body)
         where TDelegate : Delegate
         => new AsyncLambdaExpression<TDelegate>(usePooling).Build(body);
@@ -1038,6 +1047,7 @@ public static Expression<TDelegate> AsyncLambda<TDelegate>(bool usePooling, Acti
     /// <seealso cref="AwaitExpression"/>
     /// <seealso cref="AsyncResultExpression"/>
     /// <seealso href="https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/#BKMK_HowtoWriteanAsyncMethod">Async methods</seealso>
+    [RequiresUnreferencedCode("Dynamic access to Transition and IAsyncStateMachine internal types.")]
     public static Expression<TDelegate> AsyncLambda<TDelegate>(Action<LambdaContext, ParameterExpression> body)
         where TDelegate : Delegate
         => AsyncLambda<TDelegate>(false, body);
@@ -1055,6 +1065,7 @@ public static Expression<TDelegate> AsyncLambda<TDelegate>(Action<LambdaContext,
     /// <seealso cref="AwaitExpression"/>
     /// <seealso cref="AsyncResultExpression"/>
     /// <seealso href="https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/#BKMK_HowtoWriteanAsyncMethod">Async methods</seealso>
+    [RequiresUnreferencedCode("Dynamic access to Transition and IAsyncStateMachine internal types.")]
     public static Expression<TDelegate> AsyncLambda<TDelegate>(bool usePooling, Action<LambdaContext, ParameterExpression> body)
         where TDelegate : Delegate
         => new AsyncLambdaExpression<TDelegate>(usePooling).Build(body);
@@ -1104,4 +1115,4 @@ public static LambdaExpressionTree AsyncLambda(Type[] parameters, Type returnTyp
     /// <param name="expr">The expression to add.</param>
     public static void Statement(Expression expr)
         => LexicalScope.Current.AddStatement(expr);
-}
\ No newline at end of file
+}
diff --git a/src/DotNext.Metaprogramming/Metaprogramming/ForEachStatement.cs b/src/DotNext.Metaprogramming/Metaprogramming/ForEachStatement.cs
index 856e1657b..753db4b80 100644
--- a/src/DotNext.Metaprogramming/Metaprogramming/ForEachStatement.cs
+++ b/src/DotNext.Metaprogramming/Metaprogramming/ForEachStatement.cs
@@ -1,9 +1,11 @@
-using System.Linq.Expressions;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
 
 namespace DotNext.Metaprogramming;
 
 using ForEachExpression = Linq.Expressions.ForEachExpression;
 
+[RequiresUnreferencedCode("Dynamic access to GetEnumerator method and IEnumerable<T> interfaces.")]
 internal sealed class ForEachStatement : LoopLexicalScope, ILexicalScope<ForEachExpression, Action<MemberExpression>>, ILexicalScope<ForEachExpression, Action<MemberExpression, LoopContext>>
 {
     private readonly Expression collection;
@@ -26,4 +28,4 @@ internal sealed class ForEachStatement : LoopLexicalScope, ILexicalScope<ForEach
         result.Body = Build();
         return result;
     }
-}
\ No newline at end of file
+}
diff --git a/src/DotNext.Metaprogramming/Metaprogramming/LambdaExpression.cs b/src/DotNext.Metaprogramming/Metaprogramming/LambdaExpression.cs
index dc434fe34..407e6fb88 100644
--- a/src/DotNext.Metaprogramming/Metaprogramming/LambdaExpression.cs
+++ b/src/DotNext.Metaprogramming/Metaprogramming/LambdaExpression.cs
@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using System.Linq.Expressions;
 
 namespace DotNext.Metaprogramming;
@@ -43,7 +44,7 @@ private protected static IReadOnlyList<ParameterExpression> GetParameters(System
 /// Represents lambda function builder.
 /// </summary>
 /// <typeparam name="TDelegate">The delegate describing signature of lambda function.</typeparam>
-internal sealed class LambdaExpression<TDelegate> : LambdaExpression, ILexicalScope<Expression<TDelegate>, Action<LambdaContext>>, ILexicalScope<Expression<TDelegate>, Action<LambdaContext, ParameterExpression>>, ILexicalScope<Expression<TDelegate>, Func<LambdaContext, Expression>>
+internal sealed class LambdaExpression<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TDelegate> : LambdaExpression, ILexicalScope<Expression<TDelegate>, Action<LambdaContext>>, ILexicalScope<Expression<TDelegate>, Action<LambdaContext, ParameterExpression>>, ILexicalScope<Expression<TDelegate>, Func<LambdaContext, Expression>>
     where TDelegate : Delegate
 {
     private readonly Type returnType;
@@ -148,4 +149,4 @@ public override void Dispose()
         recursion = null;
         base.Dispose();
     }
-}
\ No newline at end of file
+}
diff --git a/src/DotNext.Metaprogramming/Metaprogramming/MatchBuilder.cs b/src/DotNext.Metaprogramming/Metaprogramming/MatchBuilder.cs
index 1ceeabeb6..b1ef61934 100644
--- a/src/DotNext.Metaprogramming/Metaprogramming/MatchBuilder.cs
+++ b/src/DotNext.Metaprogramming/Metaprogramming/MatchBuilder.cs
@@ -157,6 +157,7 @@ public MatchBuilder Case(Type expectedType, CaseStatement body)
     public MatchBuilder Case<T>(CaseStatement body)
         => Case(typeof(T), body);
 
+    [RequiresUnreferencedCode("Dynamically accesses properties/fields named in <structPattern>.")]
     private static Pattern StructuralPattern(IEnumerable<(string, Expression)> structPattern)
         => obj =>
         {
@@ -170,6 +171,7 @@ private static Pattern StructuralPattern(IEnumerable<(string, Expression)> struc
             return result ?? Expression.Constant(false);
         };
 
+    [RequiresUnreferencedCode("Dynamically accesses properties/fields named in <structPattern>.")]
     private MatchBuilder Case(IEnumerable<(string, Expression)> structPattern, CaseStatement body)
         => Case(StructuralPattern(structPattern), body);
 
@@ -180,6 +182,7 @@ private MatchBuilder Case(IEnumerable<(string, Expression)> structPattern, CaseS
     /// <param name="memberValue">The expected value of the field or property.</param>
     /// <param name="body">The action to be executed if object matches to the pattern.</param>
     /// <returns><c>this</c> builder.</returns>
+    [RequiresUnreferencedCode("Dynamically accesses property/field <memberName>.")]
     public MatchBuilder Case(string memberName, Expression memberValue, Func<MemberExpression, Expression> body)
         => Case(StructuralPattern(List.Singleton((memberName, memberValue))), value => body(Expression.PropertyOrField(value, memberName)));
 
@@ -192,6 +195,7 @@ public MatchBuilder Case(string memberName, Expression memberValue, Func<MemberE
     /// <param name="memberValue2">The expected value of the second field or property.</param>
     /// <param name="body">The action to be executed if object matches to the pattern.</param>
     /// <returns><c>this</c> builder.</returns>
+    [RequiresUnreferencedCode("Dynamically accesses properties/fields <memberName1>, <memberName2>.")]
     public MatchBuilder Case(string memberName1, Expression memberValue1, string memberName2, Expression memberValue2, Func<MemberExpression, MemberExpression, Expression> body)
         => Case(StructuralPattern([(memberName1, memberValue1), (memberName2, memberValue2)]), value => body(Expression.PropertyOrField(value, memberName1), Expression.PropertyOrField(value, memberName2)));
 
@@ -206,6 +210,7 @@ public MatchBuilder Case(string memberName1, Expression memberValue1, string mem
     /// <param name="memberValue3">The expected value of the third field or property.</param>
     /// <param name="body">The action to be executed if object matches to the pattern.</param>
     /// <returns><c>this</c> builder.</returns>
+    [RequiresUnreferencedCode("Dynamically accesses properties/fields <memberName1>, <memberName2>, <memberName3>.")]
     public MatchBuilder Case(string memberName1, Expression memberValue1, string memberName2, Expression memberValue2, string memberName3, Expression memberValue3, Func<MemberExpression, MemberExpression, MemberExpression, Expression> body)
         => Case(StructuralPattern([(memberName1, memberValue1), (memberName2, memberValue2), (memberName3, memberValue3)]), value => body(Expression.PropertyOrField(value, memberName1), Expression.PropertyOrField(value, memberName2), Expression.PropertyOrField(value, memberName3)));
 
@@ -239,6 +244,7 @@ private static IEnumerable<(string, Expression)> GetProperties(object structPatt
     /// <param name="structPattern">The structure pattern represented by instance of anonymous type.</param>
     /// <param name="body">The action to be executed if object matches to the pattern.</param>
     /// <returns><c>this</c> builder.</returns>
+    [RequiresUnreferencedCode("Dynamically accesses properties/fields represented in <structPattern>.")]
     public MatchBuilder Case(object structPattern, CaseStatement body)
         => Case(GetProperties(structPattern), body);
 
@@ -248,6 +254,7 @@ public MatchBuilder Case(object structPattern, CaseStatement body)
     /// <param name="structPattern">The structure pattern represented by instance of anonymous type.</param>
     /// <param name="value">The value to be supplied if the specified structural pattern matches to the passed object.</param>
     /// <returns><c>this</c> builder.</returns>
+    [RequiresUnreferencedCode("Dynamically accesses properties/fields represented in <structPattern>.")]
     public MatchBuilder Case(object structPattern, Expression value)
         => Case(structPattern, new CaseStatement(value.TrivialCaseStatement));
 
@@ -313,6 +320,7 @@ public MatchBuilder Case<T>(Pattern pattern, Action<ParameterExpression> body)
     /// <param name="structPattern">The structure pattern represented by instance of anonymous type.</param>
     /// <param name="body">The action to be executed if object matches to the pattern.</param>
     /// <returns><c>this</c> builder.</returns>
+    [RequiresUnreferencedCode("Dynamically accesses fields represented in <structPattern>.")]
     public MatchBuilder Case(object structPattern, Action<ParameterExpression> body)
     {
         using var statement = new MatchByConditionStatement(this, StructuralPattern(GetProperties(structPattern)));
@@ -483,6 +491,7 @@ internal CaseStatementBuilder(MatchByMemberStatement statement, string memberNam
                 this.statement = statement;
             }
 
+            [SuppressMessage("Trimming", "IL2026", Justification = "Public methods on MatchBuilder are annotated appropriately.")]
             Expression ISupplier<ParameterExpression, Expression>.Invoke(ParameterExpression value)
             {
                 memberHandler(Expression.PropertyOrField(value, memberName));
@@ -500,6 +509,7 @@ internal MatchByMemberStatement(MatchBuilder builder, string memberName, Express
             this.memberValue = memberValue;
         }
 
+        [SuppressMessage("Trimming", "IL2026", Justification = "Public methods on MatchBuilder are annotated appropriately.")]
         private protected override MatchBuilder Build(MatchBuilder builder, Action<MemberExpression> scope)
         {
             var pattern = StructuralPattern(List.Singleton((memberName, memberValue)));
@@ -524,6 +534,7 @@ internal CaseStatementBuilder(MatchByTwoMembersStatement statement, string membe
                 this.statement = statement;
             }
 
+            [SuppressMessage("Trimming", "IL2026", Justification = "Public methods on MatchBuilder are annotated appropriately.")]
             Expression ISupplier<ParameterExpression, Expression>.Invoke(ParameterExpression value)
             {
                 memberHandler(Expression.PropertyOrField(value, memberName1), Expression.PropertyOrField(value, memberName2));
@@ -543,6 +554,7 @@ internal MatchByTwoMembersStatement(MatchBuilder builder, string memberName1, Ex
             this.memberValue2 = memberValue2;
         }
 
+        [SuppressMessage("Trimming", "IL2026", Justification = "Public methods on MatchBuilder are annotated appropriately.")]
         private protected override MatchBuilder Build(MatchBuilder builder, Action<MemberExpression, MemberExpression> scope)
         {
             var pattern = StructuralPattern([(memberName1, memberValue1), (memberName2, memberValue2)]);
@@ -568,6 +580,7 @@ internal CaseStatementBuilder(MatchByThreeMembersStatement statement, string mem
                 this.statement = statement;
             }
 
+            [SuppressMessage("Trimming", "IL2026", Justification = "Public methods on MatchBuilder are annotated appropriately.")]
             Expression ISupplier<ParameterExpression, Expression>.Invoke(ParameterExpression value)
             {
                 memberHandler(Expression.PropertyOrField(value, memberName1), Expression.PropertyOrField(value, memberName2), Expression.PropertyOrField(value, memberName3));
@@ -589,6 +602,7 @@ internal MatchByThreeMembersStatement(MatchBuilder builder, string memberName1,
             this.memberValue3 = memberValue3;
         }
 
+        [SuppressMessage("Trimming", "IL2026", Justification = "Public methods on MatchBuilder are annotated appropriately.")]
         private protected override MatchBuilder Build(MatchBuilder builder, Action<MemberExpression, MemberExpression, MemberExpression> scope)
         {
             var pattern = StructuralPattern([(memberName1, memberValue1), (memberName2, memberValue2), (memberName3, memberValue3)]);
@@ -635,4 +649,4 @@ private protected override MatchBuilder Build(MatchBuilder builder, Action<Param
     [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1313", Justification = "Underscore is used to indicate that the parameter is unused")]
     internal static Expression TrivialCaseStatement(this Expression value, ParameterExpression _)
         => value;
-}
\ No newline at end of file
+}
diff --git a/src/DotNext.Metaprogramming/Runtime/CompilerServices/TaskType.cs b/src/DotNext.Metaprogramming/Runtime/CompilerServices/TaskType.cs
index da11274d4..64cf00ed8 100644
--- a/src/DotNext.Metaprogramming/Runtime/CompilerServices/TaskType.cs
+++ b/src/DotNext.Metaprogramming/Runtime/CompilerServices/TaskType.cs
@@ -54,4 +54,4 @@ internal MethodCallExpression AdjustTaskType(MethodCallExpression startMachineCa
     internal bool IsValueTask => taskType is { IsValueType: true };
 
     public static implicit operator Type(in TaskType type) => type.taskType ?? typeof(Task);
-}
\ No newline at end of file
+}