Fix render named-argument shadowing by evaluating assignments before applying them (#924)

* Initial plan

* fix render tag named argument evaluation order

Co-authored-by: sebastienros <1165805+sebastienros@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: sebastienros <1165805+sebastienros@users.noreply.github.com>

Author: Copilot

Fluid.Tests/IncludeStatementTests.cs

@@ -655,6 +655,22 @@ public void RenderTag_With_MultipleNamedArguments()
             Assert.Equal("Text: Click Me, Size: large, Color: blue", result);
         }
 
+        [Fact]
+        public void RenderTag_NamedArguments_AreEvaluatedBeforeAssignment()
+        {
+            var fileProvider = new MockFileProvider();
+            fileProvider.Add("file.liquid", "{{ value }} {{ key }}");
+
+            var options = new TemplateOptions() { FileProvider = fileProvider };
+            var context = new TemplateContext(options);
+            context.SetValue("value", new { f1 = "Hello", f2 = "World" });
+            _parser.TryParse("{% render 'file', value: value.f1, key: value.f2 %}", out var template);
+
+            var result = template.Render(context);
+
+            Assert.Equal("Hello World", result);
+        }
+
         [Fact]
         public async Task RenderTag_For_And_NamedArguments()
         {

Fluid/Ast/RenderStatement.cs

@@ -105,11 +105,7 @@ public override async ValueTask<Completion> WriteToAsync(IFluidOutput output, Te
                     // Evaluate assign statements in the new scope if present
                     if (AssignStatements.Count > 0)
                     {
-                        var length = AssignStatements.Count;
-                        for (var i = 0; i < length; i++)
-                        {
-                            await AssignStatements[i].WriteToAsync(output, encoder, context);
-                        }
+                        await EvaluateAssignStatementsAsync(AssignStatements, context);
                     }
 
                     await template.RenderAsync(output, encoder, context);
@@ -133,11 +129,7 @@ public override async ValueTask<Completion> WriteToAsync(IFluidOutput output, Te
                         // Evaluate assign statements in the new scope before the loop if present
                         if (AssignStatements.Count > 0)
                         {
-                            var assignLength = AssignStatements.Count;
-                            for (var j = 0; j < assignLength; j++)
-                            {
-                                await AssignStatements[j].WriteToAsync(output, encoder, context);
-                            }
+                            await EvaluateAssignStatementsAsync(AssignStatements, context);
                         }
 
                         var length = forloop.Length = list.Count;
@@ -174,11 +166,7 @@ public override async ValueTask<Completion> WriteToAsync(IFluidOutput output, Te
                 }
                 else if (AssignStatements.Count > 0)
                 {
-                    var length = AssignStatements.Count;
-                    for (var i = 0; i < length; i++)
-                    {
-                        await AssignStatements[i].WriteToAsync(output, encoder, context);
-                    }
+                    await EvaluateAssignStatementsAsync(AssignStatements, context);
 
                     context.LocalScope = new Scope(context.RootScope);
                     previousScope.CopyTo(context.LocalScope);
@@ -204,6 +192,33 @@ public override async ValueTask<Completion> WriteToAsync(IFluidOutput output, Te
 
         protected internal override Statement Accept(AstVisitor visitor) => visitor.VisitRenderStatement(this);
 
+        private static async ValueTask EvaluateAssignStatementsAsync(IReadOnlyList<AssignStatement> assignStatements, TemplateContext context)
+        {
+            var length = assignStatements.Count;
+            var evaluatedValues = new KeyValuePair<string, FluidValue>[length];
+
+            for (var i = 0; i < length; i++)
+            {
+                context.IncrementSteps();
+
+                var assignStatement = assignStatements[i];
+                var value = await assignStatement.Value.EvaluateAsync(context);
+
+                if (context.Assigned != null)
+                {
+                    value = await context.Assigned.Invoke(assignStatement.Identifier, value, context);
+                }
+
+                evaluatedValues[i] = new KeyValuePair<string, FluidValue>(assignStatement.Identifier, value);
+            }
+
+            for (var i = 0; i < length; i++)
+            {
+                var entry = evaluatedValues[i];
+                context.SetValue(entry.Key, entry.Value);
+            }
+        }
+
         private sealed record CachedTemplate(IFluidTemplate Template, string Name);
     }
 }