Skip to content

fix(source-gen): stop parameter resolver keeping every non-public test-class method (IL2111) #6937

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
thomhurst merged 7 commits into from
Sep 29, 2026
Merged

fix(source-gen): stop parameter resolver keeping every non-public test-class method (IL2111) #6937

Show file tree
Hide file tree
Changes from 2 commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
f5ec879
fix(source-gen): stop parameter resolver keeping every non-public tes…
thomhurst Sep 29, 2026
0522fd8
test(aot): cover private DynamicallyAccessedMembers helpers and inter…
thomhurst Sep 29, 2026
09c3b01
fix(source-gen): root non-public generic test methods by name and mat…
thomhurst Sep 29, 2026
61b5f04
fix(source-gen): root non-public test methods by exact signature with…
thomhurst Sep 29, 2026
be2a683
test: keep the private helper in the non-public fallback test under N…
thomhurst Sep 29, 2026
8fc3967
fix: never treat a by-ref overload as an exact parameter-shape match
thomhurst Sep 29, 2026
4a32d8c
fix(source-gen): keep the DynamicDependency root in .NET Standard tes…
thomhurst Sep 29, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
24 changes: 24 additions & 0 deletions src/TUnit.Core.SourceGenerator/Utilities/MetadataGenerationHelper.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -236,6 +236,13 @@ private static void WriteReflectionInfoAttachStart(ICodeWriter writer, IMethodSy
{
writer.Append($"global::TUnit.Core.ParameterMetadataFactory.ForConstructor(typeof({containingType}), {usesTypeParameters.ToString().ToLowerInvariant()}, ");
}
else if (method.DeclaredAccessibility != Accessibility.Public)
{
// The factory's declaring-type annotation only keeps public methods, so trimming stays limited to what
// ClassMetadata.Type already keeps. A non-public method is rooted with its own intrinsic lookup instead
// of annotating the type with NonPublicMethods, which would keep (and warn about) every private helper.
writer.Append($"global::TUnit.Core.ParameterMetadataFactory.ForMethodLookup(\"{method.Name}\", static () => {GenerateNonPublicMethodLookup(method, containingType, usesTypeParameters)}, ");
Comment thread
thomhurst marked this conversation as resolved.
Outdated
}
else if (method.TypeParameters.Length > 0 || usesTypeParameters)
{
writer.Append($"global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof({containingType}), \"{method.Name}\", ");
Expand All @@ -246,6 +253,23 @@ private static void WriteReflectionInfoAttachStart(ICodeWriter writer, IMethodSy
}
}

private static string GenerateNonPublicMethodLookup(IMethodSymbol method, string containingType, bool usesTypeParameters)
{
if (method.TypeParameters.Length > 0 || usesTypeParameters)
{
return $"global::System.Linq.Enumerable.FirstOrDefault(typeof({containingType}).GetMethods(global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Instance | global::System.Reflection.BindingFlags.Static), m => m.Name == \"{method.Name}\" && m.GetParameters().Length == {method.Parameters.Length})";
Comment thread
thomhurst marked this conversation as resolved.
Outdated
Comment thread
greptile-apps[bot] marked this conversation as resolved.
Outdated
}

var bindingFlags = method.IsStatic
? "global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Static"
: "global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Instance";
var parameterTypes = method.Parameters.Length == 0
? "global::System.Type.EmptyTypes"
: $"new global::System.Type[] {{ {string.Join(", ", method.Parameters.Select(p => $"typeof({p.Type.GloballyQualified()})"))} }}";

return $"typeof({containingType}).GetMethod(\"{method.Name}\", {bindingFlags}, null, {parameterTypes}, null)";
}
Comment thread
coderabbitai[bot] marked this conversation as resolved.
Outdated

/// <summary>
/// Generates code for creating a PropertyMetadata instance
/// </summary>
Expand Down
58 changes: 44 additions & 14 deletions src/TUnit.Core/ParameterMetadataFactory.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,10 +12,15 @@ namespace TUnit.Core;
[EditorBrowsable(EditorBrowsableState.Never)]
public static class ParameterMetadataFactory
{
/// <remarks>
/// Deliberately limited to what <see cref="ClassMetadata.Type"/> already keeps for a test class. Requesting
/// non-public methods here would keep every private helper of the class and report IL2111 for any helper
/// with <see cref="DynamicallyAccessedMembersAttribute"/> parameters. Non-public test methods go through
/// <see cref="ForMethodLookup"/>, whose generated lookup roots only that method.
/// </remarks>
internal const DynamicallyAccessedMemberTypes DeclaringTypeMembers =
DynamicallyAccessedMemberTypes.PublicConstructors
| DynamicallyAccessedMemberTypes.PublicMethods
| DynamicallyAccessedMemberTypes.NonPublicMethods;
| DynamicallyAccessedMemberTypes.PublicMethods;

[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2067",
Justification = "Factory is only called from generated code that always passes concrete types")]
Expand Down Expand Up @@ -66,6 +71,19 @@ public static ParameterMetadata[] ForGenericMethod(
ParameterInfoResolver.Kind.MethodByParameterCount, parameters));
}

/// <summary>
/// Attaches lazy <see cref="ParameterMetadata.ReflectionInfo"/> resolution to the parameters of a non-public
/// method. <paramref name="lookup"/> runs once, on first access; the generator emits it as an intrinsic
/// reflection call so trimming keeps exactly that method.
/// </summary>
public static ParameterMetadata[] ForMethodLookup(
string methodName,
Func<MethodBase?> lookup,
params ParameterMetadata[] parameters)
{
return Attach(parameters, new ParameterInfoResolver(lookup, methodName, parameters));
}

/// <summary>
/// Attaches lazy <see cref="ParameterMetadata.ReflectionInfo"/> resolution to the parameters of a public
/// constructor. When <paramref name="matchByParameterCount"/> is true the constructor is matched by
Expand Down Expand Up @@ -110,12 +128,14 @@ internal enum Kind
MethodByParameterCount,
Constructor,
ConstructorByParameterCount,
Lookup,
}

private const BindingFlags AllMethods = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
private const BindingFlags PublicMethods = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static;

[DynamicallyAccessedMembers(ParameterMetadataFactory.DeclaringTypeMembers)]
private readonly Type _declaringType;
private readonly Type? _declaringType;
private readonly Func<MethodBase?>? _lookup;
private readonly string? _methodName;
private readonly Kind _kind;
private readonly ParameterMetadata[] _parameters;
Expand All @@ -133,6 +153,14 @@ public ParameterInfoResolver(
_parameters = parameters;
}

public ParameterInfoResolver(Func<MethodBase?> lookup, string methodName, ParameterMetadata[] parameters)
{
_lookup = lookup;
_methodName = methodName;
_kind = Kind.Lookup;
_parameters = parameters;
}

public ParameterInfo? Get(int index)
{
// Benign race: concurrent first accesses may each run Resolve(), but the lookup is idempotent and
Expand All @@ -145,23 +173,25 @@ internal string Describe()
{
return _kind switch
{
Kind.InstanceMethod => $"instance method '{_declaringType.FullName}.{_methodName}' with {_parameters.Length} parameter(s) matched by parameter types",
Kind.StaticMethod => $"static method '{_declaringType.FullName}.{_methodName}' with {_parameters.Length} parameter(s) matched by parameter types",
Kind.MethodByParameterCount => $"method '{_declaringType.FullName}.{_methodName}' matched by parameter count ({_parameters.Length})",
Kind.Constructor => $"constructor of '{_declaringType.FullName}' with {_parameters.Length} parameter(s) matched by parameter types",
_ => $"constructor of '{_declaringType.FullName}' matched by parameter count ({_parameters.Length})",
Kind.InstanceMethod => $"instance method '{_declaringType!.FullName}.{_methodName}' with {_parameters.Length} parameter(s) matched by parameter types",
Kind.StaticMethod => $"static method '{_declaringType!.FullName}.{_methodName}' with {_parameters.Length} parameter(s) matched by parameter types",
Kind.MethodByParameterCount => $"method '{_declaringType!.FullName}.{_methodName}' matched by parameter count ({_parameters.Length})",
Kind.Constructor => $"constructor of '{_declaringType!.FullName}' with {_parameters.Length} parameter(s) matched by parameter types",
Kind.ConstructorByParameterCount => $"constructor of '{_declaringType!.FullName}' matched by parameter count ({_parameters.Length})",
_ => $"non-public method '{_methodName}' with {_parameters.Length} parameter(s)",
};
}

private ParameterInfo[] Resolve()
{
MethodBase? member = _kind switch
{
Kind.InstanceMethod => _declaringType.GetMethod(_methodName!, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, GetParameterTypes(), null),
Kind.StaticMethod => _declaringType.GetMethod(_methodName!, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static, null, GetParameterTypes(), null),
Kind.MethodByParameterCount => FindByParameterCount(_declaringType.GetMethods(AllMethods)),
Kind.Constructor => _declaringType.GetConstructor(GetParameterTypes()),
_ => FindByParameterCount(_declaringType.GetConstructors()),
Kind.InstanceMethod => _declaringType!.GetMethod(_methodName!, BindingFlags.Public | BindingFlags.Instance, null, GetParameterTypes(), null),
Kind.StaticMethod => _declaringType!.GetMethod(_methodName!, BindingFlags.Public | BindingFlags.Static, null, GetParameterTypes(), null),
Kind.MethodByParameterCount => FindByParameterCount(_declaringType!.GetMethods(PublicMethods)),
Comment thread
greptile-apps[bot] marked this conversation as resolved.
Outdated
Kind.Constructor => _declaringType!.GetConstructor(GetParameterTypes()),
Kind.ConstructorByParameterCount => FindByParameterCount(_declaringType!.GetConstructors()),
_ => _lookup!(),
};

return member?.GetParameters() ?? [];
Expand Down
7 changes: 4 additions & 3 deletions tests/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.DotNet10_0.verified.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1140,9 +1140,10 @@ namespace
{
[.("ReflectionAnalysis", "IL2067", Justification="Factory is only called from generated code that always passes concrete types")]
public static .ParameterMetadata Create([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicProperties)] type, string name, .TypeInfo typeInfo, bool isNullable, <.ParameterInfo>? reflectionInfoFactory = null) { }
public static .ParameterMetadata[] ForConstructor([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..NonPublicMethods)] declaringType, bool matchByParameterCount, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForGenericMethod([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..NonPublicMethods)] declaringType, string methodName, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForMethod([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..NonPublicMethods)] declaringType, string methodName, bool isStatic, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForConstructor([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)] declaringType, bool matchByParameterCount, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForGenericMethod([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)] declaringType, string methodName, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForMethod([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)] declaringType, string methodName, bool isStatic, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForMethodLookup(string methodName, <.MethodBase?> lookup, params .ParameterMetadata[] parameters) { }
}
[.DebuggerDisplay("{Type} {Name}")]
public class ParameterMetadata<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicProperties)] T> : .ParameterMetadata, <.ParameterMetadata<T>>
Expand Down
7 changes: 4 additions & 3 deletions tests/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.DotNet8_0.verified.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1140,9 +1140,10 @@ namespace
{
[.("ReflectionAnalysis", "IL2067", Justification="Factory is only called from generated code that always passes concrete types")]
public static .ParameterMetadata Create([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicProperties)] type, string name, .TypeInfo typeInfo, bool isNullable, <.ParameterInfo>? reflectionInfoFactory = null) { }
public static .ParameterMetadata[] ForConstructor([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..NonPublicMethods)] declaringType, bool matchByParameterCount, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForGenericMethod([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..NonPublicMethods)] declaringType, string methodName, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForMethod([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..NonPublicMethods)] declaringType, string methodName, bool isStatic, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForConstructor([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)] declaringType, bool matchByParameterCount, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForGenericMethod([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)] declaringType, string methodName, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForMethod([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)] declaringType, string methodName, bool isStatic, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForMethodLookup(string methodName, <.MethodBase?> lookup, params .ParameterMetadata[] parameters) { }
}
[.DebuggerDisplay("{Type} {Name}")]
public class ParameterMetadata<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicProperties)] T> : .ParameterMetadata, <.ParameterMetadata<T>>
Expand Down
7 changes: 4 additions & 3 deletions tests/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.DotNet9_0.verified.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1140,9 +1140,10 @@ namespace
{
[.("ReflectionAnalysis", "IL2067", Justification="Factory is only called from generated code that always passes concrete types")]
public static .ParameterMetadata Create([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicProperties)] type, string name, .TypeInfo typeInfo, bool isNullable, <.ParameterInfo>? reflectionInfoFactory = null) { }
public static .ParameterMetadata[] ForConstructor([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..NonPublicMethods)] declaringType, bool matchByParameterCount, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForGenericMethod([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..NonPublicMethods)] declaringType, string methodName, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForMethod([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..NonPublicMethods)] declaringType, string methodName, bool isStatic, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForConstructor([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)] declaringType, bool matchByParameterCount, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForGenericMethod([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)] declaringType, string methodName, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForMethod([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)] declaringType, string methodName, bool isStatic, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForMethodLookup(string methodName, <.MethodBase?> lookup, params .ParameterMetadata[] parameters) { }
}
[.DebuggerDisplay("{Type} {Name}")]
public class ParameterMetadata<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicProperties)] T> : .ParameterMetadata, <.ParameterMetadata<T>>
Expand Down
1 change: 1 addition & 0 deletions tests/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.Net4_7.verified.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1103,6 +1103,7 @@ namespace
public static .ParameterMetadata[] ForConstructor( declaringType, bool matchByParameterCount, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForGenericMethod( declaringType, string methodName, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForMethod( declaringType, string methodName, bool isStatic, params .ParameterMetadata[] parameters) { }
public static .ParameterMetadata[] ForMethodLookup(string methodName, <.MethodBase?> lookup, params .ParameterMetadata[] parameters) { }
}
[.DebuggerDisplay("{Type} {Name}")]
public class ParameterMetadata<T> : .ParameterMetadata, <.ParameterMetadata<T>>
Expand Down
Loading
Loading