Fix IL2067 warning reporting wrong parameter with named arguments in record constructors (#121637)

## Fix IL2067 Warning for Named Arguments in Record Primary Constructors
✅

**Issue**: Fixes #121629 -
IL2067 warning incorrectly reports the wrong parameter when using named
arguments in record primary constructor base calls.

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: sbomer <787361+sbomer@users.noreply.github.com>
Co-authored-by: Jackson Schuster <36744439+jtschuster@users.noreply.github.com>

Author: 3 people

src/tools/illink/src/ILLink.RoslynAnalyzer/DataFlow/LocalDataFlowVisitor.cs

@@ -934,6 +934,10 @@ private TValue ProcessMethodCall(
                 instanceValue = TopValue;
             }
 
+            // Build a map from parameter to argument so we can handle named/out-of-order arguments correctly
+            var parameters = method.Parameters;
+            var argumentsByParameter = new TValue?[parameters.Length];
+
             foreach (var argument in arguments)
             {
                 // For __arglist argument there might not be any parameter
@@ -943,7 +947,19 @@ private TValue ProcessMethodCall(
                 if (argument?.Parameter == null)
                     break;
 
-                argumentsBuilder.Add(VisitArgument(argument, state));
+                var parameter = argument.Parameter;
+                // Use Ordinal to get the parameter's position
+                int parameterIndex = parameter.Ordinal;
+                if (parameterIndex >= 0 && parameterIndex < parameters.Length)
+                {
+                    argumentsByParameter[parameterIndex] = VisitArgument(argument, state);
+                }
+            }
+
+            // Add arguments in parameter order, using TopValue for missing arguments (e.g., optional parameters)
+            for (int i = 0; i < parameters.Length; i++)
+            {
+                argumentsBuilder.Add(argumentsByParameter[i] ?? TopValue);
             }
 
             // For local functions with generic arguments, the substituted method symbol's containing

src/tools/illink/test/ILLink.RoslynAnalyzer.Tests/generated/ILLink.RoslynAnalyzer.Tests.Generator/ILLink.RoslynAnalyzer.Tests.TestCaseGenerator/Reflection.DependenciesTests.g.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace ILLink.RoslynAnalyzer.Tests.Reflection
+{
+    public sealed partial class DependenciesTests : LinkerTestBase
+    {
+
+        protected override string TestSuiteName => "Reflection.Dependencies";
+
+        [Fact]
+        public Task TypeMapReferencedAssembly()
+        {
+            return RunTest(allowMissingWarnings: true);
+        }
+
+    }
+}

src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/MethodParametersDataFlow.cs

@@ -49,6 +49,7 @@ public static void Main()
             AnnotationOnByRefParameter.Test();
             WriteCapturedParameter.Test();
             OperatorParameters.Test();
+            NamedArgumentsWithAnnotations.Test();
         }
 
         // Validate the error message when annotated parameter is passed to another annotated parameter
@@ -512,5 +513,52 @@ private static Type GetUnknownType()
         {
             return null;
         }
+
+        // https://github.com/dotnet/runtime/issues/121629
+        class NamedArgumentsWithAnnotations
+        {
+            record BaseRecord(
+                string? OptionalParameter = null,
+                [property: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
+                [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
+                Type? AnnotatedParameter = null,
+                object? UnannotatedParameter = null
+            );
+
+            // This should not warn about 'UnannotatedParameter'
+            record DerivedRecord(
+                [param: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor | DynamicallyAccessedMemberTypes.PublicConstructors)]
+                Type? AnnotatedParameter = default,
+                object? UnannotatedParameter = default
+            ) : BaseRecord(
+                AnnotatedParameter: AnnotatedParameter,
+                UnannotatedParameter: UnannotatedParameter
+            );
+
+            static void RequiresPublicConstructors(
+                string? optionalParameter = null,
+                [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
+                Type? annotatedParameter = null,
+                object? unannotatedParameter = null)
+            {
+            }
+
+            // This should not warn about 'unannotatedParameter'
+            static void CallWithNamedArguments(
+                [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor | DynamicallyAccessedMemberTypes.PublicConstructors)]
+                Type? annotatedParameter,
+                object? unannotatedParameter)
+            {
+                RequiresPublicConstructors(
+                    annotatedParameter: annotatedParameter,
+                    unannotatedParameter: unannotatedParameter);
+            }
+
+            public static void Test()
+            {
+                var x = new DerivedRecord(typeof(string), "data");
+                CallWithNamedArguments(typeof(string), "data");
+            }
+        }
     }
 }