Change WritePadding extension to target CodeRenderingContext

DustinCampbell · DustinCampbell · commit 07d59c6fb52c · 2025-07-09T17:58:30.000-07:00
Because `CodeRenderingContext` owns the `CodeWriter` instance used for code gen, and the `WritePadding` extension method targets `CodeWriter` and also takes a `CodeRenderingContext`, we can change it  can target `CodeRenderingContext`.
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeRenderingContextExtensions.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeRenderingContextExtensions.cs
@@ -6,12 +6,55 @@
 using System.Diagnostics;
 using Microsoft.AspNetCore.Razor.Language.Intermediate;
 using Microsoft.AspNetCore.Razor.Utilities;
+using Microsoft.CodeAnalysis.Text;
 using static Microsoft.AspNetCore.Razor.Language.CodeGeneration.CodeWriterExtensions;
 
 namespace Microsoft.AspNetCore.Razor.Language.CodeGeneration;
 
 internal static class CodeRenderingContextExtensions
 {
+    public static void WritePadding(this CodeRenderingContext context, int offset, SourceSpan? span)
+    {
+        if (span is not SourceSpan spanValue)
+        {
+            return;
+        }
+
+        var sourceDocument = context.SourceDocument;
+
+        if (sourceDocument.FilePath != null &&
+            !string.Equals(sourceDocument.FilePath, spanValue.FilePath, StringComparison.OrdinalIgnoreCase))
+        {
+            // We don't want to generate padding for nodes from imports.
+            return;
+        }
+
+        var basePadding = CalculatePadding(sourceDocument.Text, spanValue);
+        var resolvedPadding = Math.Max(basePadding - offset, 0);
+
+        context.CodeWriter.Indent(resolvedPadding);
+
+        static int CalculatePadding(SourceText text, SourceSpan span)
+        {
+            var spaceCount = 0;
+            for (var i = span.AbsoluteIndex - 1; i >= 0; i--)
+            {
+                var @char = text[i];
+                if (@char == '\n' || @char == '\r')
+                {
+                    break;
+                }
+                else
+                {
+                    // Note that a tab is also replaced with a single space so character indices match.
+                    spaceCount++;
+                }
+            }
+
+            return spaceCount;
+        }
+    }
+
     public static CSharpCodeWritingScope BuildNamespace(this CodeRenderingContext context, string? name, SourceSpan? span)
     {
         var writer = context.CodeWriter;
@@ -365,7 +408,7 @@ public LinePragmaScope(
                 // If the caller requested an enhanced line directive, but we fell back to regular ones, write out the extra padding that is required
                 if (!_context.Options.UseEnhancedLinePragma)
                 {
-                    writer.WritePadding(0, span, context);
+                    context.WritePadding(offset: 0, span);
                     characterOffset = 0;
                 }
 
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriterExtensions.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriterExtensions.cs
@@ -37,48 +37,6 @@ public static bool IsAtBeginningOfLine(this CodeWriter writer)
         return writer.LastChar is '\n';
     }
 
-    public static CodeWriter WritePadding(this CodeWriter writer, int offset, SourceSpan? span, CodeRenderingContext context)
-    {
-        if (span == null)
-        {
-            return writer;
-        }
-
-        if (context.SourceDocument.FilePath != null &&
-            !string.Equals(context.SourceDocument.FilePath, span.Value.FilePath, StringComparison.OrdinalIgnoreCase))
-        {
-            // We don't want to generate padding for nodes from imports.
-            return writer;
-        }
-
-        var basePadding = CalculatePadding();
-        var resolvedPadding = Math.Max(basePadding - offset, 0);
-
-        writer.Indent(resolvedPadding);
-
-        return writer;
-
-        int CalculatePadding()
-        {
-            var spaceCount = 0;
-            for (var i = span.Value.AbsoluteIndex - 1; i >= 0; i--)
-            {
-                var @char = context.SourceDocument.Text[i];
-                if (@char == '\n' || @char == '\r')
-                {
-                    break;
-                }
-                else
-                {
-                    // Note that a tab is also replaced with a single space so character indices match.
-                    spaceCount++;
-                }
-            }
-
-            return spaceCount;
-        }
-    }
-
     public static CodeWriter WriteVariableDeclaration(this CodeWriter writer, string type, string name, string value)
     {
         writer.Write(type).Write(" ").Write(name);
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/DesignTimeNodeWriter.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/DesignTimeNodeWriter.cs
@@ -50,20 +50,22 @@ public override void WriteCSharpExpression(CodeRenderingContext context, CSharpE
             return;
         }
 
+        var writer = context.CodeWriter;
+
         if (node.Source is SourceSpan source)
         {
             using (context.BuildLinePragma(source))
             {
                 var offset = DesignTimeDirectivePass.DesignTimeVariable.Length + " = ".Length;
-                context.CodeWriter.WritePadding(offset, source, context);
-                context.CodeWriter.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);
+                context.WritePadding(offset, source);
+                writer.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);
 
                 foreach (var child in node.Children)
                 {
                     if (child is IntermediateToken { IsCSharp: true } token)
                     {
                         context.AddSourceMappingFor(token);
-                        context.CodeWriter.Write(token.Content);
+                        writer.Write(token.Content);
                     }
                     else
                     {
@@ -72,25 +74,27 @@ public override void WriteCSharpExpression(CodeRenderingContext context, CSharpE
                     }
                 }
 
-                context.CodeWriter.WriteLine(";");
+                writer.WriteLine(";");
             }
         }
         else
         {
-            context.CodeWriter.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);
-            for (var i = 0; i < node.Children.Count; i++)
+            writer.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);
+
+            foreach (var child in node.Children)
             {
-                if (node.Children[i] is IntermediateToken token && token.IsCSharp)
+                if (child is IntermediateToken { IsCSharp: true } token)
                 {
-                    context.CodeWriter.Write(token.Content);
+                    writer.Write(token.Content);
                 }
                 else
                 {
                     // There may be something else inside the expression like a Template or another extension node.
-                    context.RenderNode(node.Children[i]);
+                    context.RenderNode(child);
                 }
             }
-            context.CodeWriter.WriteLine(";");
+
+            writer.WriteLine(";");
         }
     }
 
@@ -102,7 +106,7 @@ public override void WriteCSharpCode(CodeRenderingContext context, CSharpCodeInt
         {
             using (context.BuildLinePragma(source))
             {
-                writer.WritePadding(0, source, context);
+                context.WritePadding(offset: 0, source);
                 RenderChildren(context, node);
             }
         }
@@ -157,35 +161,38 @@ public override void WriteCSharpExpressionAttributeValue(CodeRenderingContext co
             return;
         }
 
+        var writer = context.CodeWriter;
+
         var firstChild = node.Children[0];
         if (firstChild.Source is SourceSpan source)
         {
             using (context.BuildLinePragma(source))
             {
                 var offset = DesignTimeDirectivePass.DesignTimeVariable.Length + " = ".Length;
-                context.CodeWriter.WritePadding(offset, source, context);
-                context.CodeWriter.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);
+                context.WritePadding(offset, source);
+                writer.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);
 
-                for (var i = 0; i < node.Children.Count; i++)
+                foreach (var child in node.Children)
                 {
-                    if (node.Children[i] is IntermediateToken token && token.IsCSharp)
+                    if (child is IntermediateToken { IsCSharp: true } token)
                     {
                         context.AddSourceMappingFor(token);
-                        context.CodeWriter.Write(token.Content);
+                        writer.Write(token.Content);
                     }
                     else
                     {
                         // There may be something else inside the expression like a Template or another extension node.
-                        context.RenderNode(node.Children[i]);
+                        context.RenderNode(child);
                     }
                 }
 
-                context.CodeWriter.WriteLine(";");
+                writer.WriteLine(";");
             }
         }
         else
         {
-            context.CodeWriter.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);
+            writer.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);
+
             for (var i = 0; i < node.Children.Count; i++)
             {
                 if (node.Children[i] is IntermediateToken token && token.IsCSharp)
@@ -195,15 +202,16 @@ public override void WriteCSharpExpressionAttributeValue(CodeRenderingContext co
                         context.AddSourceMappingFor(token);
                     }
 
-                    context.CodeWriter.Write(token.Content);
+                    writer.Write(token.Content);
                 }
                 else
                 {
                     // There may be something else inside the expression like a Template or another extension node.
                     context.RenderNode(node.Children[i]);
                 }
             }
-            context.CodeWriter.WriteLine(";");
+
+            writer.WriteLine(";");
         }
     }
 
@@ -221,7 +229,7 @@ public override void WriteCSharpCodeAttributeValue(CodeRenderingContext context,
                     {
                         using (context.BuildLinePragma(source))
                         {
-                            context.CodeWriter.WritePadding(0, source, context);
+                            context.WritePadding(offset: 0, source);
 
                             context.AddSourceMappingFor(token);
                             context.CodeWriter.Write(token.Content);
@@ -230,7 +238,7 @@ public override void WriteCSharpCodeAttributeValue(CodeRenderingContext context,
                         continue;
                     }
 
-                    context.CodeWriter.WritePadding(0, source, context);
+                    context.WritePadding(offset: 0, source);
                 }
                 else if (isWhitespaceStatement)
                 {
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Components/ComponentDesignTimeNodeWriter.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Components/ComponentDesignTimeNodeWriter.cs
@@ -109,6 +109,8 @@ private void WriteCSharpExpressionInnards(CodeRenderingContext context, CSharpEx
             return;
         }
 
+        var writer = context.CodeWriter;
+
         if (node.Source is SourceSpan source)
         {
             using (context.BuildLinePragma(source))
@@ -120,49 +122,51 @@ private void WriteCSharpExpressionInnards(CodeRenderingContext context, CSharpEx
                     offset += type.Length + 2; // two parenthesis
                 }
 
-                context.CodeWriter.WritePadding(offset, source, context);
-                context.CodeWriter.WriteStartAssignment(DesignTimeVariable);
+                context.WritePadding(offset, source);
+                writer.WriteStartAssignment(DesignTimeVariable);
 
                 if (type != null)
                 {
-                    context.CodeWriter.Write("(");
-                    TypeNameHelper.WriteGloballyQualifiedName(context.CodeWriter, type);
-                    context.CodeWriter.Write(")");
+                    writer.Write("(");
+                    TypeNameHelper.WriteGloballyQualifiedName(writer, type);
+                    writer.Write(")");
                 }
 
-                for (var i = 0; i < node.Children.Count; i++)
+                foreach (var child in node.Children)
                 {
-                    if (node.Children[i] is IntermediateToken token && token.IsCSharp)
+                    if (child is IntermediateToken { IsCSharp: true } token)
                     {
                         context.AddSourceMappingFor(token);
-                        context.CodeWriter.Write(token.Content);
+                        writer.Write(token.Content);
                     }
                     else
                     {
                         // There may be something else inside the expression like a Template or another extension node.
-                        context.RenderNode(node.Children[i]);
+                        context.RenderNode(child);
                     }
                 }
 
-                context.CodeWriter.WriteLine(";");
+                writer.WriteLine(";");
             }
         }
         else
         {
-            context.CodeWriter.WriteStartAssignment(DesignTimeVariable);
-            for (var i = 0; i < node.Children.Count; i++)
+            writer.WriteStartAssignment(DesignTimeVariable);
+
+            foreach (var child in node.Children)
             {
-                if (node.Children[i] is IntermediateToken token && token.IsCSharp)
+                if (child is IntermediateToken { IsCSharp: true } token)
                 {
-                    context.CodeWriter.Write(token.Content);
+                    writer.Write(token.Content);
                 }
                 else
                 {
                     // There may be something else inside the expression like a Template or another extension node.
-                    context.RenderNode(node.Children[i]);
+                    context.RenderNode(child);
                 }
             }
-            context.CodeWriter.WriteLine(";");
+
+            writer.WriteLine(";");
         }
     }
 
@@ -184,14 +188,14 @@ public override void WriteCSharpCode(CodeRenderingContext context, CSharpCodeInt
             {
                 using (context.BuildLinePragma(source))
                 {
-                    context.CodeWriter.WritePadding(0, source, context);
+                    context.WritePadding(offset: 0, source);
                     RenderChildren(context, node);
                 }
 
                 return;
             }
 
-            context.CodeWriter.WritePadding(0, source, context);
+            context.WritePadding(offset: 0, source);
         }
         else if (isWhitespaceStatement)
         {
@@ -731,7 +735,7 @@ private void WritePropertyAccess(CodeRenderingContext context, ComponentAttribut
 
         using (context.BuildLinePragma(attributeSourceSpan))
         {
-            context.CodeWriter.WritePadding(0, attributeSourceSpan, context);
+            context.WritePadding(offset: 0, attributeSourceSpan);
             context.CodeWriter.WriteIdentifierEscapeIfNeeded(node.PropertyName);
             context.AddSourceMappingFor(attributeSourceSpan);
             context.CodeWriter.WriteLine(node.PropertyName);
@@ -1233,15 +1237,16 @@ private void WriteCSharpToken(CodeRenderingContext context, IntermediateToken to
             return;
         }
 
-        if (token.Source?.FilePath == null)
+        if (token.Source is not SourceSpan source ||
+            source.FilePath == null)
         {
             context.CodeWriter.Write(token.Content);
             return;
         }
 
-        using (context.BuildLinePragma(token.Source))
+        using (context.BuildLinePragma(source))
         {
-            context.CodeWriter.WritePadding(0, token.Source.Value, context);
+            context.WritePadding(offset: 0, source);
             context.AddSourceMappingFor(token);
             context.CodeWriter.Write(token.Content);
         }
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Extensions/DefaultTagHelperTargetExtension.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Extensions/DefaultTagHelperTargetExtension.cs

Original file line number	Diff line number	Diff line change
`@@ -50,20 +50,22 @@ public override void WriteCSharpExpression(CodeRenderingContext context, CSharpE`
`50`	`50`	`return;`
`51`	`51`	`}`
`52`	`52`
	`53`	`+ var writer = context.CodeWriter;`
	`54`	`+`
`53`	`55`	`if (node.Source is SourceSpan source)`
`54`	`56`	`{`
`55`	`57`	`using (context.BuildLinePragma(source))`
`56`	`58`	`{`
`57`	`59`	`var offset = DesignTimeDirectivePass.DesignTimeVariable.Length + " = ".Length;`
`58`		`- context.CodeWriter.WritePadding(offset, source, context);`
`59`		`- context.CodeWriter.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);`
	`60`	`+ context.WritePadding(offset, source);`
	`61`	`+ writer.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);`
`60`	`62`
`61`	`63`	`foreach (var child in node.Children)`
`62`	`64`	`{`
`63`	`65`	`if (child is IntermediateToken { IsCSharp: true } token)`
`64`	`66`	`{`
`65`	`67`	`context.AddSourceMappingFor(token);`
`66`		`- context.CodeWriter.Write(token.Content);`
	`68`	`+ writer.Write(token.Content);`
`67`	`69`	`}`
`68`	`70`	`else`
`69`	`71`	`{`
`@@ -72,25 +74,27 @@ public override void WriteCSharpExpression(CodeRenderingContext context, CSharpE`
`72`	`74`	`}`
`73`	`75`	`}`
`74`	`76`
`75`		`- context.CodeWriter.WriteLine(";");`
	`77`	`+ writer.WriteLine(";");`
`76`	`78`	`}`
`77`	`79`	`}`
`78`	`80`	`else`
`79`	`81`	`{`
`80`		`- context.CodeWriter.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);`
`81`		`- for (var i = 0; i < node.Children.Count; i++)`
	`82`	`+ writer.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);`
	`83`	`+`
	`84`	`+ foreach (var child in node.Children)`
`82`	`85`	`{`
`83`		`- if (node.Children[i] is IntermediateToken token && token.IsCSharp)`
	`86`	`+ if (child is IntermediateToken { IsCSharp: true } token)`
`84`	`87`	`{`
`85`		`- context.CodeWriter.Write(token.Content);`
	`88`	`+ writer.Write(token.Content);`
`86`	`89`	`}`
`87`	`90`	`else`
`88`	`91`	`{`
`89`	`92`	`// There may be something else inside the expression like a Template or another extension node.`
`90`		`- context.RenderNode(node.Children[i]);`
	`93`	`+ context.RenderNode(child);`
`91`	`94`	`}`
`92`	`95`	`}`
`93`		`- context.CodeWriter.WriteLine(";");`
	`96`	`+`
	`97`	`+ writer.WriteLine(";");`
`94`	`98`	`}`
`95`	`99`	`}`
`96`	`100`
`@@ -102,7 +106,7 @@ public override void WriteCSharpCode(CodeRenderingContext context, CSharpCodeInt`
`102`	`106`	`{`
`103`	`107`	`using (context.BuildLinePragma(source))`
`104`	`108`	`{`
`105`		`- writer.WritePadding(0, source, context);`
	`109`	`+ context.WritePadding(offset: 0, source);`
`106`	`110`	`RenderChildren(context, node);`
`107`	`111`	`}`
`108`	`112`	`}`
`@@ -157,35 +161,38 @@ public override void WriteCSharpExpressionAttributeValue(CodeRenderingContext co`
`157`	`161`	`return;`
`158`	`162`	`}`
`159`	`163`
	`164`	`+ var writer = context.CodeWriter;`
	`165`	`+`
`160`	`166`	`var firstChild = node.Children[0];`
`161`	`167`	`if (firstChild.Source is SourceSpan source)`
`162`	`168`	`{`
`163`	`169`	`using (context.BuildLinePragma(source))`
`164`	`170`	`{`
`165`	`171`	`var offset = DesignTimeDirectivePass.DesignTimeVariable.Length + " = ".Length;`
`166`		`- context.CodeWriter.WritePadding(offset, source, context);`
`167`		`- context.CodeWriter.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);`
	`172`	`+ context.WritePadding(offset, source);`
	`173`	`+ writer.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);`
`168`	`174`
`169`		`- for (var i = 0; i < node.Children.Count; i++)`
	`175`	`+ foreach (var child in node.Children)`
`170`	`176`	`{`
`171`		`- if (node.Children[i] is IntermediateToken token && token.IsCSharp)`
	`177`	`+ if (child is IntermediateToken { IsCSharp: true } token)`
`172`	`178`	`{`
`173`	`179`	`context.AddSourceMappingFor(token);`
`174`		`- context.CodeWriter.Write(token.Content);`
	`180`	`+ writer.Write(token.Content);`
`175`	`181`	`}`
`176`	`182`	`else`
`177`	`183`	`{`
`178`	`184`	`// There may be something else inside the expression like a Template or another extension node.`
`179`		`- context.RenderNode(node.Children[i]);`
	`185`	`+ context.RenderNode(child);`
`180`	`186`	`}`
`181`	`187`	`}`
`182`	`188`
`183`		`- context.CodeWriter.WriteLine(";");`
	`189`	`+ writer.WriteLine(";");`
`184`	`190`	`}`
`185`	`191`	`}`
`186`	`192`	`else`
`187`	`193`	`{`
`188`		`- context.CodeWriter.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);`
	`194`	`+ writer.WriteStartAssignment(DesignTimeDirectivePass.DesignTimeVariable);`
	`195`	`+`
`189`	`196`	`for (var i = 0; i < node.Children.Count; i++)`
`190`	`197`	`{`
`191`	`198`	`if (node.Children[i] is IntermediateToken token && token.IsCSharp)`
`@@ -195,15 +202,16 @@ public override void WriteCSharpExpressionAttributeValue(CodeRenderingContext co`
`195`	`202`	`context.AddSourceMappingFor(token);`
`196`	`203`	`}`
`197`	`204`
`198`		`- context.CodeWriter.Write(token.Content);`
	`205`	`+ writer.Write(token.Content);`
`199`	`206`	`}`
`200`	`207`	`else`
`201`	`208`	`{`
`202`	`209`	`// There may be something else inside the expression like a Template or another extension node.`
`203`	`210`	`context.RenderNode(node.Children[i]);`
`204`	`211`	`}`
`205`	`212`	`}`
`206`		`- context.CodeWriter.WriteLine(";");`
	`213`	`+`
	`214`	`+ writer.WriteLine(";");`
`207`	`215`	`}`
`208`	`216`	`}`
`209`	`217`
`@@ -221,7 +229,7 @@ public override void WriteCSharpCodeAttributeValue(CodeRenderingContext context,`
`221`	`229`	`{`
`222`	`230`	`using (context.BuildLinePragma(source))`
`223`	`231`	`{`
`224`		`- context.CodeWriter.WritePadding(0, source, context);`
	`232`	`+ context.WritePadding(offset: 0, source);`
`225`	`233`
`226`	`234`	`context.AddSourceMappingFor(token);`
`227`	`235`	`context.CodeWriter.Write(token.Content);`
`@@ -230,7 +238,7 @@ public override void WriteCSharpCodeAttributeValue(CodeRenderingContext context,`
`230`	`238`	`continue;`
`231`	`239`	`}`
`232`	`240`
`233`		`- context.CodeWriter.WritePadding(0, source, context);`
	`241`	`+ context.WritePadding(offset: 0, source);`
`234`	`242`	`}`
`235`	`243`	`else if (isWhitespaceStatement)`
`236`	`244`	`{`
Original file line number	Diff line number	Diff line change
`@@ -109,6 +109,8 @@ private void WriteCSharpExpressionInnards(CodeRenderingContext context, CSharpEx`
`109`	`109`	`return;`
`110`	`110`	`}`
`111`	`111`
	`112`	`+ var writer = context.CodeWriter;`
	`113`	`+`
`112`	`114`	`if (node.Source is SourceSpan source)`
`113`	`115`	`{`
`114`	`116`	`using (context.BuildLinePragma(source))`
`@@ -120,49 +122,51 @@ private void WriteCSharpExpressionInnards(CodeRenderingContext context, CSharpEx`
`120`	`122`	`offset += type.Length + 2; // two parenthesis`
`121`	`123`	`}`
`122`	`124`
`123`		`- context.CodeWriter.WritePadding(offset, source, context);`
`124`		`- context.CodeWriter.WriteStartAssignment(DesignTimeVariable);`
	`125`	`+ context.WritePadding(offset, source);`
	`126`	`+ writer.WriteStartAssignment(DesignTimeVariable);`
`125`	`127`
`126`	`128`	`if (type != null)`
`127`	`129`	`{`
`128`		`- context.CodeWriter.Write("(");`
`129`		`- TypeNameHelper.WriteGloballyQualifiedName(context.CodeWriter, type);`
`130`		`- context.CodeWriter.Write(")");`
	`130`	`+ writer.Write("(");`
	`131`	`+ TypeNameHelper.WriteGloballyQualifiedName(writer, type);`
	`132`	`+ writer.Write(")");`
`131`	`133`	`}`
`132`	`134`
`133`		`- for (var i = 0; i < node.Children.Count; i++)`
	`135`	`+ foreach (var child in node.Children)`
`134`	`136`	`{`
`135`		`- if (node.Children[i] is IntermediateToken token && token.IsCSharp)`
	`137`	`+ if (child is IntermediateToken { IsCSharp: true } token)`
`136`	`138`	`{`
`137`	`139`	`context.AddSourceMappingFor(token);`
`138`		`- context.CodeWriter.Write(token.Content);`
	`140`	`+ writer.Write(token.Content);`
`139`	`141`	`}`
`140`	`142`	`else`
`141`	`143`	`{`
`142`	`144`	`// There may be something else inside the expression like a Template or another extension node.`
`143`		`- context.RenderNode(node.Children[i]);`
	`145`	`+ context.RenderNode(child);`
`144`	`146`	`}`
`145`	`147`	`}`
`146`	`148`
`147`		`- context.CodeWriter.WriteLine(";");`
	`149`	`+ writer.WriteLine(";");`
`148`	`150`	`}`
`149`	`151`	`}`
`150`	`152`	`else`
`151`	`153`	`{`
`152`		`- context.CodeWriter.WriteStartAssignment(DesignTimeVariable);`
`153`		`- for (var i = 0; i < node.Children.Count; i++)`
	`154`	`+ writer.WriteStartAssignment(DesignTimeVariable);`
	`155`	`+`
	`156`	`+ foreach (var child in node.Children)`
`154`	`157`	`{`
`155`		`- if (node.Children[i] is IntermediateToken token && token.IsCSharp)`
	`158`	`+ if (child is IntermediateToken { IsCSharp: true } token)`
`156`	`159`	`{`
`157`		`- context.CodeWriter.Write(token.Content);`
	`160`	`+ writer.Write(token.Content);`
`158`	`161`	`}`
`159`	`162`	`else`
`160`	`163`	`{`
`161`	`164`	`// There may be something else inside the expression like a Template or another extension node.`
`162`		`- context.RenderNode(node.Children[i]);`
	`165`	`+ context.RenderNode(child);`
`163`	`166`	`}`
`164`	`167`	`}`
`165`		`- context.CodeWriter.WriteLine(";");`
	`168`	`+`
	`169`	`+ writer.WriteLine(";");`
`166`	`170`	`}`
`167`	`171`	`}`
`168`	`172`
`@@ -184,14 +188,14 @@ public override void WriteCSharpCode(CodeRenderingContext context, CSharpCodeInt`
`184`	`188`	`{`
`185`	`189`	`using (context.BuildLinePragma(source))`
`186`	`190`	`{`
`187`		`- context.CodeWriter.WritePadding(0, source, context);`
	`191`	`+ context.WritePadding(offset: 0, source);`
`188`	`192`	`RenderChildren(context, node);`
`189`	`193`	`}`
`190`	`194`
`191`	`195`	`return;`
`192`	`196`	`}`
`193`	`197`
`194`		`- context.CodeWriter.WritePadding(0, source, context);`
	`198`	`+ context.WritePadding(offset: 0, source);`
`195`	`199`	`}`
`196`	`200`	`else if (isWhitespaceStatement)`
`197`	`201`	`{`
`@@ -731,7 +735,7 @@ private void WritePropertyAccess(CodeRenderingContext context, ComponentAttribut`
`731`	`735`
`732`	`736`	`using (context.BuildLinePragma(attributeSourceSpan))`
`733`	`737`	`{`
`734`		`- context.CodeWriter.WritePadding(0, attributeSourceSpan, context);`
	`738`	`+ context.WritePadding(offset: 0, attributeSourceSpan);`
`735`	`739`	`context.CodeWriter.WriteIdentifierEscapeIfNeeded(node.PropertyName);`
`736`	`740`	`context.AddSourceMappingFor(attributeSourceSpan);`
`737`	`741`	`context.CodeWriter.WriteLine(node.PropertyName);`
`@@ -1233,15 +1237,16 @@ private void WriteCSharpToken(CodeRenderingContext context, IntermediateToken to`
`1233`	`1237`	`return;`
`1234`	`1238`	`}`
`1235`	`1239`
`1236`		`- if (token.Source?.FilePath == null)`
	`1240`	`+ if (token.Source is not SourceSpan source \|\|`
	`1241`	`+ source.FilePath == null)`
`1237`	`1242`	`{`
`1238`	`1243`	`context.CodeWriter.Write(token.Content);`
`1239`	`1244`	`return;`
`1240`	`1245`	`}`
`1241`	`1246`
`1242`		`- using (context.BuildLinePragma(token.Source))`
	`1247`	`+ using (context.BuildLinePragma(source))`
`1243`	`1248`	`{`
`1244`		`- context.CodeWriter.WritePadding(0, token.Source.Value, context);`
	`1249`	`+ context.WritePadding(offset: 0, source);`
`1245`	`1250`	`context.AddSourceMappingFor(token);`
`1246`	`1251`	`context.CodeWriter.Write(token.Content);`
`1247`	`1252`	`}`