Change Build(Enhanced)LinePragma extensions to target CodeRenderingContext

Because `CodeRenderingContext` owns the `CodeWriter` instance used for code gen, and the `BuildLinePragma` and `BuildEnhancedLinePragma` extension methods target `CodeWriter` and also take a `CodeRenderingContext`, we can change them can target `CodeRenderingContext`.

In addition, this change changes the type that's returned to readonly ref struct. This requires a bit of adjustment to some of the calling code.

Author: DustinCampbell

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeRenderingContextExtensions.cs

@@ -5,6 +5,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using Microsoft.AspNetCore.Razor.Language.Intermediate;
+using Microsoft.AspNetCore.Razor.Utilities;
 using static Microsoft.AspNetCore.Razor.Language.CodeGeneration.CodeWriterExtensions;
 
 namespace Microsoft.AspNetCore.Razor.Language.CodeGeneration;
@@ -29,11 +30,12 @@ public static CSharpCodeWritingScope BuildNamespace(this CodeRenderingContext co
         else
         {
             writer.WriteLine();
-            using (writer.BuildEnhancedLinePragma(span, context))
+            using (context.BuildEnhancedLinePragma(span))
             {
                 writer.WriteLine(name);
             }
         }
+
         return new CSharpCodeWritingScope(writer);
     }
 
@@ -81,7 +83,7 @@ public static CSharpCodeWritingScope BuildClassDeclaration(
 
                 if (typeParameter.ParameterNameSource is { } source)
                 {
-                    WriteWithPragma(writer, typeParameter.ParameterName, context, source);
+                    WriteWithPragma(context, typeParameter.ParameterName, source);
                 }
                 else
                 {
@@ -137,7 +139,7 @@ public static CSharpCodeWritingScope BuildClassDeclaration(
                     if (typeParameter.ConstraintsSource is { } source)
                     {
                         Debug.Assert(context != null);
-                        WriteWithPragma(writer, constraint, context, source);
+                        WriteWithPragma(context, constraint, source);
                     }
                     else
                     {
@@ -167,27 +169,29 @@ void WriteToken(IntermediateToken token)
         {
             if (token.Source is { } source)
             {
-                WriteWithPragma(writer, token.Content, context, source);
+                WriteWithPragma(context, token.Content, source);
             }
             else
             {
                 writer.Write(token.Content);
             }
         }
 
-        static void WriteWithPragma(CodeWriter writer, string content, CodeRenderingContext context, SourceSpan source)
+        static void WriteWithPragma(CodeRenderingContext context, string content, SourceSpan source)
         {
+            var writer = context.CodeWriter;
+
             if (context.Options.DesignTime)
             {
-                using (writer.BuildLinePragma(source, context))
+                using (context.BuildLinePragma(source))
                 {
                     context.AddSourceMappingFor(source);
                     writer.Write(content);
                 }
             }
             else
             {
-                using (writer.BuildEnhancedLinePragma(source, context))
+                using (context.BuildEnhancedLinePragma(source))
                 {
                     writer.Write(content);
                 }
@@ -262,17 +266,152 @@ private static void WritePropertyDeclarationPreamble(
 
         static void WriteToken(CodeRenderingContext context, string content, SourceSpan? span)
         {
+            var writer = context.CodeWriter;
+
             if (span is not null && context.Options.DesignTime == false)
             {
-                using (context.CodeWriter.BuildEnhancedLinePragma(span, context))
+                using (context.BuildEnhancedLinePragma(span))
                 {
-                    context.CodeWriter.Write(content);
+                    writer.Write(content);
                 }
             }
             else
             {
-                context.CodeWriter.Write(content);
+                writer.Write(content);
+            }
+        }
+    }
+
+    public static LinePragmaScope BuildLinePragma(
+        this CodeRenderingContext context,
+        SourceSpan? span,
+        bool suppressLineDefaultAndHidden = false)
+    {
+        if (string.IsNullOrEmpty(span?.FilePath))
+        {
+            // Can't build a valid line pragma without a file path.
+            return default;
+        }
+
+        return new LinePragmaScope(context, span.Value, 0, useEnhancedLinePragma: false, suppressLineDefaultAndHidden);
+    }
+
+    public static LinePragmaScope BuildEnhancedLinePragma(
+        this CodeRenderingContext context,
+        SourceSpan? span,
+        int characterOffset = 0,
+        bool suppressLineDefaultAndHidden = false)
+    {
+        if (string.IsNullOrEmpty(span?.FilePath))
+        {
+            // Can't build a valid line pragma without a file path.
+            return default;
+        }
+
+        return new LinePragmaScope(context, span.Value, characterOffset, useEnhancedLinePragma: true, suppressLineDefaultAndHidden);
+    }
+
+    public readonly ref struct LinePragmaScope
+    {
+        private readonly CodeRenderingContext _context;
+        private readonly int _startIndent;
+        private readonly int _startLineIndex;
+        private readonly SourceSpan _span;
+        private readonly bool _suppressLineDefaultAndHidden;
+
+        public LinePragmaScope(
+            CodeRenderingContext context,
+            SourceSpan span,
+            int characterOffset,
+            bool useEnhancedLinePragma = false,
+            bool suppressLineDefaultAndHidden = false)
+        {
+            Debug.Assert(context.Options.DesignTime || useEnhancedLinePragma, "Runtime generation should only use enhanced line pragmas");
+
+            _context = context;
+            _suppressLineDefaultAndHidden = suppressLineDefaultAndHidden;
+            _span = span;
+
+            var writer = context.CodeWriter;
+            _startIndent = writer.CurrentIndent;
+            writer.CurrentIndent = 0;
+
+            var endsWithNewline = writer.LastChar is '\n';
+            if (!endsWithNewline)
+            {
+                writer.WriteLine();
+            }
+
+            if (!_context.Options.SuppressNullabilityEnforcement)
+            {
+                writer.WriteLine("#nullable restore");
+            }
+
+            var ensurePathBackslashes = context.Options.RemapLinePragmaPathsOnWindows && PlatformInformation.IsWindows;
+            if (useEnhancedLinePragma && _context.Options.UseEnhancedLinePragma)
+            {
+                writer.WriteEnhancedLineNumberDirective(span, characterOffset, ensurePathBackslashes);
+            }
+            else
+            {
+                writer.WriteLineNumberDirective(span, ensurePathBackslashes);
+            }
+
+            // Capture the line index after writing the #line directive.
+            _startLineIndex = writer.Location.LineIndex;
+
+            if (useEnhancedLinePragma)
+            {
+                // 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);
+                    characterOffset = 0;
+                }
+
+                context.AddSourceMappingFor(span, characterOffset);
+            }
+        }
+
+        public void Dispose()
+        {
+            if (_context is null)
+            {
+                return;
+            }
+
+            var writer = _context.CodeWriter;
+
+            // Need to add an additional line at the end IF there wasn't one already written.
+            // This is needed to work with the C# editor's handling of #line ...
+            var endsWithNewline = writer.LastChar is '\n';
+
+            // Always write at least 1 empty line to potentially separate code from pragmas.
+            writer.WriteLine();
+
+            // Check if the previous empty line wasn't enough to separate code from pragmas.
+            if (!endsWithNewline)
+            {
+                writer.WriteLine();
             }
+
+            var lineCount = writer.Location.LineIndex - _startLineIndex;
+            var linePragma = new LinePragma(_span.LineIndex, lineCount, _span.FilePath, _span.EndCharacterIndex, _span.EndCharacterIndex, _span.CharacterIndex);
+            _context.AddLinePragma(linePragma);
+
+            if (!_suppressLineDefaultAndHidden)
+            {
+                writer
+                    .WriteLine("#line default")
+                    .WriteLine("#line hidden");
+            }
+
+            if (!_context.Options.SuppressNullabilityEnforcement)
+            {
+                writer.WriteLine("#nullable disable");
+            }
+
+            writer.CurrentIndent = _startIndent;
         }
     }
 }

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriterExtensions.cs

@@ -9,8 +9,6 @@
 using System.Diagnostics;
 using System.Globalization;
 using System.Linq;
-using Microsoft.AspNetCore.Razor.Language.Intermediate;
-using Microsoft.AspNetCore.Razor.Utilities;
 
 namespace Microsoft.AspNetCore.Razor.Language.CodeGeneration;
 
@@ -417,28 +415,6 @@ public static CSharpCodeWritingScope BuildMethodDeclaration(
         return new CSharpCodeWritingScope(writer);
     }
 
-    public static IDisposable BuildLinePragma(this CodeWriter writer, SourceSpan? span, CodeRenderingContext context, bool suppressLineDefaultAndHidden = false)
-    {
-        if (string.IsNullOrEmpty(span?.FilePath))
-        {
-            // Can't build a valid line pragma without a file path.
-            return NullDisposable.Default;
-        }
-
-        return new LinePragmaWriter(writer, span.Value, context, 0, useEnhancedLinePragma: false, suppressLineDefaultAndHidden);
-    }
-
-    public static IDisposable BuildEnhancedLinePragma(this CodeWriter writer, SourceSpan? span, CodeRenderingContext context, int characterOffset = 0, bool suppressLineDefaultAndHidden = false)
-    {
-        if (string.IsNullOrEmpty(span?.FilePath))
-        {
-            // Can't build a valid line pragma without a file path.
-            return NullDisposable.Default;
-        }
-
-        return new LinePragmaWriter(writer, span.Value, context, characterOffset, useEnhancedLinePragma: true, suppressLineDefaultAndHidden);
-    }
-
     private static void WriteVerbatimStringLiteral(CodeWriter writer, ReadOnlyMemory<char> literal)
     {
         writer.Write("@\"");
@@ -595,121 +571,4 @@ _writer.LastChar is char ch &&
             }
         }
     }
-
-    private class LinePragmaWriter : IDisposable
-    {
-        private readonly CodeWriter _writer;
-        private readonly CodeRenderingContext _context;
-        private readonly int _startIndent;
-        private readonly int _startLineIndex;
-        private readonly SourceSpan _span;
-        private readonly bool _suppressLineDefaultAndHidden;
-
-        public LinePragmaWriter(
-            CodeWriter writer,
-            SourceSpan span,
-            CodeRenderingContext context,
-            int characterOffset,
-            bool useEnhancedLinePragma = false,
-            bool suppressLineDefaultAndHidden = false)
-        {
-            Debug.Assert(context.Options.DesignTime || useEnhancedLinePragma, "Runtime generation should only use enhanced line pragmas");
-
-            if (writer == null)
-            {
-                throw new ArgumentNullException(nameof(writer));
-            }
-
-            _writer = writer;
-            _context = context;
-            _suppressLineDefaultAndHidden = suppressLineDefaultAndHidden;
-            _startIndent = _writer.CurrentIndent;
-            _writer.CurrentIndent = 0;
-            _span = span;
-
-            var endsWithNewline = _writer.LastChar is '\n';
-            if (!endsWithNewline)
-            {
-                _writer.WriteLine();
-            }
-
-            if (!_context.Options.SuppressNullabilityEnforcement)
-            {
-                _writer.WriteLine("#nullable restore");
-            }
-
-            var ensurePathBackslashes = context.Options.RemapLinePragmaPathsOnWindows && PlatformInformation.IsWindows;
-            if (useEnhancedLinePragma && _context.Options.UseEnhancedLinePragma)
-            {
-                WriteEnhancedLineNumberDirective(writer, span, characterOffset, ensurePathBackslashes);
-            }
-            else
-            {
-                WriteLineNumberDirective(writer, span, ensurePathBackslashes);
-            }
-
-            // Capture the line index after writing the #line directive.
-            _startLineIndex = writer.Location.LineIndex;
-
-            if (useEnhancedLinePragma)
-            {
-                // 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)
-                {
-                    context.CodeWriter.WritePadding(0, span, context);
-                    characterOffset = 0;
-                }
-
-                context.AddSourceMappingFor(span, characterOffset);
-            }
-        }
-
-        public void Dispose()
-        {
-            // Need to add an additional line at the end IF there wasn't one already written.
-            // This is needed to work with the C# editor's handling of #line ...
-            var endsWithNewline = _writer.LastChar is '\n';
-
-            // Always write at least 1 empty line to potentially separate code from pragmas.
-            _writer.WriteLine();
-
-            // Check if the previous empty line wasn't enough to separate code from pragmas.
-            if (!endsWithNewline)
-            {
-                _writer.WriteLine();
-            }
-
-            var lineCount = _writer.Location.LineIndex - _startLineIndex;
-            var linePragma = new LinePragma(_span.LineIndex, lineCount, _span.FilePath, _span.EndCharacterIndex, _span.EndCharacterIndex, _span.CharacterIndex);
-            _context.AddLinePragma(linePragma);
-
-            if (!_suppressLineDefaultAndHidden)
-            {
-                _writer
-                    .WriteLine("#line default")
-                    .WriteLine("#line hidden");
-            }
-
-            if (!_context.Options.SuppressNullabilityEnforcement)
-            {
-                _writer.WriteLine("#nullable disable");
-            }
-
-            _writer.CurrentIndent = _startIndent;
-
-        }
-    }
-
-    private class NullDisposable : IDisposable
-    {
-        public static readonly NullDisposable Default = new NullDisposable();
-
-        private NullDisposable()
-        {
-        }
-
-        public void Dispose()
-        {
-        }
-    }
 }