Revert revert of the component start tag mapping, but without line directives this time

davidwengier · davidwengier · commit d269f6d6bd57 · 2025-11-18T08:51:30.000+11:00
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
@@ -563,7 +563,7 @@ public override void WriteComponent(CodeRenderingContext context, ComponentInter
 
     public override void WriteComponentTypeInferenceMethod(CodeRenderingContext context, ComponentTypeInferenceMethodIntermediateNode node)
     {
-        base.WriteComponentTypeInferenceMethod(context, node, returnComponentType: true, allowNameof: false);
+        base.WriteComponentTypeInferenceMethod(context, node, returnComponentType: true, allowNameof: false, mapComponentStartTag: false);
     }
 
     private void WriteTypeInferenceMethodParameterInnards(CodeRenderingContext context, TypeInferenceMethodParameter parameter)
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Components/ComponentLoweringPass.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Components/ComponentLoweringPass.cs
@@ -5,6 +5,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using Microsoft.AspNetCore.Razor.Language.Intermediate;
@@ -142,12 +143,14 @@ static TagHelperDescriptor GetTagHelperOrAddDiagnostic(TagHelperIntermediateNode
 
     private static ComponentIntermediateNode RewriteAsComponent(TagHelperIntermediateNode node, TagHelperDescriptor tagHelper)
     {
+        Debug.Assert(node.StartTagSpan.HasValue, "Component tags should always have a start tag span.");
         var component = new ComponentIntermediateNode()
         {
             Component = tagHelper,
             Source = node.Source,
             TagName = node.TagName,
             TypeName = tagHelper.TypeName,
+            StartTagSpan = node.StartTagSpan.AssumeNotNull(),
         };
 
         component.AddDiagnosticsFromNode(node);
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Components/ComponentNodeWriter.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Components/ComponentNodeWriter.cs
@@ -75,7 +75,7 @@ protected bool ShouldSuppressTypeInferenceCall(ComponentIntermediateNode node)
         return node.Diagnostics.Any(d => d.Id == ComponentDiagnosticFactory.GenericComponentTypeInferenceUnderspecified.Id);
     }
 
-    protected void WriteComponentTypeInferenceMethod(CodeRenderingContext context, ComponentTypeInferenceMethodIntermediateNode node, bool returnComponentType, bool allowNameof)
+    protected void WriteComponentTypeInferenceMethod(CodeRenderingContext context, ComponentTypeInferenceMethodIntermediateNode node, bool returnComponentType, bool allowNameof, bool mapComponentStartTag)
     {
         if (context == null)
         {
@@ -166,7 +166,18 @@ protected void WriteComponentTypeInferenceMethod(CodeRenderingContext context, C
         context.CodeWriter.Write(".");
         context.CodeWriter.Write(ComponentsApi.RenderTreeBuilder.OpenComponent);
         context.CodeWriter.Write("<");
-        context.CodeWriter.Write(node.Component.TypeName);
+
+        if (mapComponentStartTag)
+        {
+            var nonGenericTypeName = TypeNameHelper.GetNonGenericTypeName(node.Component.TypeName, out var genericTypeParameterList);
+            WriteComponentTypeName(context, node.Component, nonGenericTypeName);
+            context.CodeWriter.Write(genericTypeParameterList);
+        }
+        else
+        {
+            context.CodeWriter.Write(node.Component.TypeName);
+        }
+
         context.CodeWriter.Write(">(");
         context.CodeWriter.Write("seq");
         context.CodeWriter.Write(");");
@@ -530,6 +541,40 @@ protected static void WriteGloballyQualifiedTypeName(CodeRenderingContext contex
         }
     }
 
+    protected static void WriteComponentTypeName(CodeRenderingContext context, ComponentIntermediateNode node, ReadOnlyMemory<char> nonGenericTypeName)
+    {
+        // The type name we are given may or may not be globally qualified, and we want to map it to the component start
+        // tag, which may or may not be fully qualified. ie "global::My.Fun.Component" could map to just "Component"
+
+        // Write out "global::" if it's present, and trim it off
+        var lastColon = nonGenericTypeName.Span.LastIndexOf(':');
+        if (lastColon > -1)
+        {
+            lastColon++;
+            context.CodeWriter.Write(nonGenericTypeName[0..lastColon]);
+            nonGenericTypeName = nonGenericTypeName.Slice(lastColon);
+        }
+
+        // If the start tag is shorter than the type name, then it must not be a fully qualified tag, so write out
+        // the namespace parts and trim. Razor components don't support nested types, so this logic doesn't either.
+        if (node.StartTagSpan.Length < nonGenericTypeName.Length)
+        {
+            var lastDot = nonGenericTypeName.Span.LastIndexOf('.');
+            if (lastDot > -1)
+            {
+                lastDot++;
+                context.CodeWriter.Write(nonGenericTypeName[0..lastDot]);
+                nonGenericTypeName = nonGenericTypeName.Slice(lastDot);
+            }
+        }
+
+        var offset = nonGenericTypeName.Span.StartsWith('@')
+            ? 1
+            : 0;
+        context.AddSourceMappingFor(node.StartTagSpan, offset);
+        context.CodeWriter.Write(nonGenericTypeName);
+    }
+
     [DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]
     protected internal readonly struct SeqName(int index) : IWriteableValue
     {
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Components/ComponentRuntimeNodeWriter.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Components/ComponentRuntimeNodeWriter.cs
@@ -378,7 +378,10 @@ public override void WriteComponent(CodeRenderingContext context, ComponentInter
             context.CodeWriter.Write(ComponentsApi.RenderTreeBuilder.OpenComponent);
             context.CodeWriter.Write("<");
 
-            TypeNameHelper.WriteGloballyQualifiedName(context.CodeWriter, TypeNameHelper.GetNonGenericTypeName(node.TypeName));
+            var nonGenericTypeName = TypeNameHelper.GetNonGenericTypeName(node.TypeName, out _);
+            TypeNameHelper.WriteGlobalPrefixIfNeeded(context.CodeWriter, nonGenericTypeName);
+            WriteComponentTypeName(context, node, nonGenericTypeName);
+
             if (!node.OrderedTypeArguments.IsDefaultOrEmpty)
             {
                 context.CodeWriter.Write("<");
@@ -540,7 +543,7 @@ public override void WriteComponent(CodeRenderingContext context, ComponentInter
 
     public override void WriteComponentTypeInferenceMethod(CodeRenderingContext context, ComponentTypeInferenceMethodIntermediateNode node)
     {
-        WriteComponentTypeInferenceMethod(context, node, returnComponentType: false, allowNameof: true);
+        WriteComponentTypeInferenceMethod(context, node, returnComponentType: false, allowNameof: true, mapComponentStartTag: true);
     }
 
     private void WriteTypeInferenceMethodParameterInnards(CodeRenderingContext context, TypeInferenceMethodParameter parameter)
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Components/TypeNameHelper.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Components/TypeNameHelper.cs
@@ -79,6 +79,15 @@ public static void WriteGloballyQualifiedName(CodeWriter codeWriter, string type
     }
 
     internal static void WriteGloballyQualifiedName(CodeWriter codeWriter, ReadOnlyMemory<char> typeName)
+    {
+        WriteGlobalPrefixIfNeeded(codeWriter, typeName);
+        codeWriter.Write(typeName);
+    }
+
+    /// <summary>
+    /// Writes "global::" if the typename doesn't already start with it and isn't a predefined type.
+    /// </summary>
+    internal static void WriteGlobalPrefixIfNeeded(CodeWriter codeWriter, ReadOnlyMemory<char> typeName)
     {
         if (typeName.Length == 0)
         {
@@ -89,7 +98,6 @@ internal static void WriteGloballyQualifiedName(CodeWriter codeWriter, ReadOnlyM
 
         if (typeNameSpan.StartsWith(GlobalPrefix.AsSpan(), StringComparison.Ordinal))
         {
-            codeWriter.Write(typeName);
             return;
         }
 
@@ -98,7 +106,6 @@ internal static void WriteGloballyQualifiedName(CodeWriter codeWriter, ReadOnlyM
         // just skip prefixing tuples.
         if (typeNameSpan[0] == '(')
         {
-            codeWriter.Write(typeName);
             return;
         }
 
@@ -107,24 +114,25 @@ internal static void WriteGloballyQualifiedName(CodeWriter codeWriter, ReadOnlyM
         if (typeNameSpan.Length < 3 || typeNameSpan.Length > 7)
         {
             codeWriter.Write(GlobalPrefix);
-            codeWriter.Write(typeName);
             return;
         }
 
         if (PredefinedTypeNames.Contains(typeName))
         {
-            codeWriter.Write(typeName);
             return;
         }
 
         codeWriter.Write(GlobalPrefix);
-        codeWriter.Write(typeName);
     }
 
-    internal static ReadOnlyMemory<char> GetNonGenericTypeName(string typeName)
+    internal static ReadOnlyMemory<char> GetNonGenericTypeName(string typeName, out ReadOnlyMemory<char> genericTypeParameterList)
     {
         var memory = typeName.AsMemory();
         var index = memory.Span.IndexOf('<');
+
+        genericTypeParameterList = index == -1
+            ? default
+            : memory[index..];
         return index == -1 ? memory : memory[..index];
     }
 }
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultRazorIntermediateNodeLoweringPhase.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultRazorIntermediateNodeLoweringPhase.cs
@@ -1753,7 +1753,8 @@ public override void VisitMarkupTagHelperElement(MarkupTagHelperElementSyntax no
                 TagName = tagName,
                 TagMode = info.TagMode,
                 Source = BuildSourceSpanFromNode(node),
-                TagHelpers = info.BindingResult.Descriptors
+                TagHelpers = info.BindingResult.Descriptors,
+                StartTagSpan = node.StartTag.Name.GetSourceSpan(SourceDocument)
             };
 
             if (node.StartTag != null &&
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Intermediate/ComponentIntermediateNode.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Intermediate/ComponentIntermediateNode.cs
@@ -49,6 +49,8 @@ public sealed class ComponentIntermediateNode : IntermediateNode
 
     public string TypeName { get; set; }
 
+    public SourceSpan StartTagSpan { get; init; }
+
     public override void Accept(IntermediateNodeVisitor visitor)
     {
         if (visitor == null)
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Intermediate/TagHelperIntermediateNode.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Intermediate/TagHelperIntermediateNode.cs
@@ -11,6 +11,11 @@ public sealed class TagHelperIntermediateNode : IntermediateNode
     public required TagMode TagMode { get; init; }
     public required string TagName { get; init; }
 
+    /// <summary>
+    /// The source span of the start tag of the component that this tag helper represents, or null for an Mvc tag helper
+    /// </summary>
+    public SourceSpan? StartTagSpan { get; init; }
+
     public ImmutableArray<TagHelperDescriptor> TagHelpers { get; init => field = value.NullToEmpty(); } = [];
 
     public override IntermediateNodeCollection Children { get => field ??= []; }
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/CSharpOnTypeFormattingPass.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/CSharpOnTypeFormattingPass.cs
@@ -900,6 +900,11 @@ private static bool ShouldFormat(FormattingContext context, TextSpan mappingSpan
             return false;
         }
 
+        if (IsComponentStartTagName())
+        {
+            return false;
+        }
+
         if (IsInHtmlAttributeValue())
         {
             return false;
@@ -1004,6 +1009,19 @@ bool IsInBoundComponentAttributeName()
             } && !options.IsLineRequest;
         }
 
+        bool IsComponentStartTagName()
+        {
+            // E.g, (| is position)
+            //
+            // `<|Component>` - true
+            //
+            // As above, we map component elements, so GTD and FAR works, there could be C# mapping for them.
+            // We don't want the mapping to make the formatting engine think it needs to apply C# indentation rules.
+
+            return owner is MarkupTagHelperStartTagSyntax startTag &&
+                startTag.Name.Span.Contains(mappingSpan.Start);
+        }
+
         bool IsInHtmlAttributeValue()
         {
             // E.g, (| is position)
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/GoToDefinition/AbstractDefinitionService.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/GoToDefinition/AbstractDefinitionService.cs
@@ -9,7 +9,6 @@
 using Microsoft.CodeAnalysis.Razor.DocumentMapping;
 using Microsoft.CodeAnalysis.Razor.Logging;
 using Microsoft.CodeAnalysis.Razor.ProjectSystem;
-using Microsoft.CodeAnalysis.Razor.Protocol;
 using Microsoft.CodeAnalysis.Razor.Workspaces;
 using Microsoft.CodeAnalysis.Text;
 using CSharpSyntaxKind = Microsoft.CodeAnalysis.CSharp.SyntaxKind;
@@ -35,13 +34,6 @@ internal abstract class AbstractDefinitionService(
         bool includeMvcTagHelpers,
         CancellationToken cancellationToken)
     {
-
-        // If we're in C# then there is no point checking for a component tag, because there won't be one
-        if (positionInfo.LanguageKind == RazorLanguageKind.CSharp)
-        {
-            return null;
-        }
-
         if (!includeMvcTagHelpers && !documentSnapshot.FileKind.IsComponent())
         {
             _logger.LogInformation($"'{documentSnapshot.FileKind}' is not a component type.");
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/SemanticTokens/AbstractRazorSemanticTokensInfoService.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/SemanticTokens/AbstractRazorSemanticTokensInfoService.cs
@@ -191,15 +191,15 @@ private void AddAdditionalCSharpWhitespaceRanges(List<SemanticRange> razorRanges
             ContainsOnlySpacesOrTabs(razorSource, previousSpanEndIndex + 1, startChar - previousRange.End.Character - 1))
         {
             // we're on the same line as previous, lets extend ours to include whitespace between us and the proceeding range
-            razorRanges.Add(new SemanticRange(textClassification, startLine, previousRange.End.Character, startLine, startChar, _semanticTokensLegendService.TokenModifiers.RazorCodeModifier, fromRazor: false));
+            razorRanges.Add(new SemanticRange(textClassification, startLine, previousRange.End.Character, startLine, startChar, _semanticTokensLegendService.TokenModifiers.RazorCodeModifier, fromRazor: false, isCSharpWhitespace: true));
         }
         else if (startChar > 0 &&
             previousRazorSemanticRange?.End.Line != startLine &&
             razorSource.TryGetAbsoluteIndex(originalRange.Start, out var originalRangeStartIndex) &&
             ContainsOnlySpacesOrTabs(razorSource, originalRangeStartIndex - startChar + 1, startChar - 1))
         {
             // We're on a new line, and the start of the line is only whitespace, so give that a background color too
-            razorRanges.Add(new SemanticRange(textClassification, startLine, 0, startLine, startChar, _semanticTokensLegendService.TokenModifiers.RazorCodeModifier, fromRazor: false));
+            razorRanges.Add(new SemanticRange(textClassification, startLine, 0, startLine, startChar, _semanticTokensLegendService.TokenModifiers.RazorCodeModifier, fromRazor: false, isCSharpWhitespace: true));
         }
     }
 
@@ -300,10 +300,10 @@ private static int[] ConvertSemanticRangesToSemanticTokensData(
             if (TryWriteToken(range, previousRange, isFirstRange, sourceText, tokens.AsSpan(index, TokenSize)))
             {
                 index += TokenSize;
+                previousRange = range;
             }
 
             isFirstRange = false;
-            previousRange = range;
         }
 
         // The common case is that the ConvertIntoDataArray calls didn't find any overlap, and we can just directly use the
@@ -366,6 +366,16 @@ static bool TryWriteToken(
                 deltaStart = currentRange.StartCharacter;
             }
 
+            // If this is a C# whitespace range, and the previous range is on the same line, and from Razor
+            // then we don't want to emit this. This happens when we have leftover whitespace from between
+            // two C# ranges, that were superseded by Razor ranges.
+            if (currentRange.IsCSharpWhitespace &&
+                previousRange.FromRazor &&
+                currentRange.StartLine == previousRange.EndLine)
+            {
+                return false;
+            }
+
             destination[0] = deltaLine;
             destination[1] = deltaStart;
 
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/SemanticTokens/SemanticRange.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/SemanticTokens/SemanticRange.cs
@@ -8,7 +8,7 @@ namespace Microsoft.CodeAnalysis.Razor.SemanticTokens;
 
 internal readonly struct SemanticRange : IComparable<SemanticRange>
 {
-    public SemanticRange(int kind, int startLine, int startCharacter, int endLine, int endCharacter, int modifier, bool fromRazor)
+    public SemanticRange(int kind, int startLine, int startCharacter, int endLine, int endCharacter, int modifier, bool fromRazor, bool isCSharpWhitespace)
     {
         Kind = kind;
         StartLine = startLine;
@@ -17,6 +17,7 @@ public SemanticRange(int kind, int startLine, int startCharacter, int endLine, i
         EndCharacter = endCharacter;
         Modifier = modifier;
         FromRazor = fromRazor;
+        IsCSharpWhitespace = isCSharpWhitespace;
     }
 
     public SemanticRange(int kind, LinePositionSpan range, int modifier, bool fromRazor)
@@ -25,7 +26,12 @@ public SemanticRange(int kind, LinePositionSpan range, int modifier, bool fromRa
     }
 
     public SemanticRange(int kind, LinePosition start, LinePosition end, int modifier, bool fromRazor)
-        : this(kind, start.Line, start.Character, end.Line, end.Character, modifier, fromRazor)
+        : this(kind, start.Line, start.Character, end.Line, end.Character, modifier, fromRazor, isCSharpWhitespace: false)
+    {
+    }
+
+    public SemanticRange(int kind, int startLine, int startCharacter, int endLine, int endCharacter, int modifier, bool fromRazor)
+        : this(kind, startLine, startCharacter, endLine, endCharacter, modifier, fromRazor, isCSharpWhitespace: false)
     {
     }
 
@@ -45,6 +51,8 @@ public SemanticRange(int kind, LinePosition start, LinePosition end, int modifie
     /// </summary>
     public bool FromRazor { get; }
 
+    public bool IsCSharpWhitespace { get; }
+
     public LinePositionSpan AsLinePositionSpan()
         => new(new(StartLine, StartCharacter), new(EndLine, EndCharacter));
 
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/GoToDefinition/RemoteGoToDefinitionService.cs b/src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/GoToDefinition/RemoteGoToDefinitionService.cs
diff --git a/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/HoverAssertions.cs b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/HoverAssertions.cs
diff --git a/src/Razor/test/Microsoft.VisualStudioCode.RazorExtension.Test/Endpoints/Shared/CohostFindAllReferencesEndpointTest.cs b/src/Razor/test/Microsoft.VisualStudioCode.RazorExtension.Test/Endpoints/Shared/CohostFindAllReferencesEndpointTest.cs
diff --git a/src/Razor/test/Microsoft.VisualStudioCode.RazorExtension.Test/Endpoints/Shared/CohostGoToDefinitionEndpointTest.cs b/src/Razor/test/Microsoft.VisualStudioCode.RazorExtension.Test/Endpoints/Shared/CohostGoToDefinitionEndpointTest.cs
diff --git a/src/Razor/test/Microsoft.VisualStudioCode.RazorExtension.Test/Endpoints/Shared/CohostHoverEndpointTest.cs b/src/Razor/test/Microsoft.VisualStudioCode.RazorExtension.Test/Endpoints/Shared/CohostHoverEndpointTest.cs

Original file line number	Diff line number	Diff line change
`@@ -563,7 +563,7 @@ public override void WriteComponent(CodeRenderingContext context, ComponentInter`
`563`	`563`
`564`	`564`	`public override void WriteComponentTypeInferenceMethod(CodeRenderingContext context, ComponentTypeInferenceMethodIntermediateNode node)`
`565`	`565`	`{`
`566`		`- base.WriteComponentTypeInferenceMethod(context, node, returnComponentType: true, allowNameof: false);`
	`566`	`+ base.WriteComponentTypeInferenceMethod(context, node, returnComponentType: true, allowNameof: false, mapComponentStartTag: false);`
`567`	`567`	`}`
`568`	`568`
`569`	`569`	`private void WriteTypeInferenceMethodParameterInnards(CodeRenderingContext context, TypeInferenceMethodParameter parameter)`
Original file line number	Diff line number	Diff line change
`@@ -378,7 +378,10 @@ public override void WriteComponent(CodeRenderingContext context, ComponentInter`
`378`	`378`	`context.CodeWriter.Write(ComponentsApi.RenderTreeBuilder.OpenComponent);`
`379`	`379`	`context.CodeWriter.Write("<");`
`380`	`380`
`381`		`- TypeNameHelper.WriteGloballyQualifiedName(context.CodeWriter, TypeNameHelper.GetNonGenericTypeName(node.TypeName));`
	`381`	`+ var nonGenericTypeName = TypeNameHelper.GetNonGenericTypeName(node.TypeName, out _);`
	`382`	`+ TypeNameHelper.WriteGlobalPrefixIfNeeded(context.CodeWriter, nonGenericTypeName);`
	`383`	`+ WriteComponentTypeName(context, node, nonGenericTypeName);`
	`384`	`+`
`382`	`385`	`if (!node.OrderedTypeArguments.IsDefaultOrEmpty)`
`383`	`386`	`{`
`384`	`387`	`context.CodeWriter.Write("<");`
`@@ -540,7 +543,7 @@ public override void WriteComponent(CodeRenderingContext context, ComponentInter`
`540`	`543`
`541`	`544`	`public override void WriteComponentTypeInferenceMethod(CodeRenderingContext context, ComponentTypeInferenceMethodIntermediateNode node)`
`542`	`545`	`{`
`543`		`- WriteComponentTypeInferenceMethod(context, node, returnComponentType: false, allowNameof: true);`
	`546`	`+ WriteComponentTypeInferenceMethod(context, node, returnComponentType: false, allowNameof: true, mapComponentStartTag: true);`
`544`	`547`	`}`
`545`	`548`
`546`	`549`	`private void WriteTypeInferenceMethodParameterInnards(CodeRenderingContext context, TypeInferenceMethodParameter parameter)`
Original file line number	Diff line number	Diff line change
`@@ -79,6 +79,15 @@ public static void WriteGloballyQualifiedName(CodeWriter codeWriter, string type`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`internal static void WriteGloballyQualifiedName(CodeWriter codeWriter, ReadOnlyMemory<char> typeName)`
	`82`	`+ {`
	`83`	`+ WriteGlobalPrefixIfNeeded(codeWriter, typeName);`
	`84`	`+ codeWriter.Write(typeName);`
	`85`	`+ }`
	`86`	`+`
	`87`	`+ /// <summary>`
	`88`	`+ /// Writes "global::" if the typename doesn't already start with it and isn't a predefined type.`
	`89`	`+ /// </summary>`
	`90`	`+ internal static void WriteGlobalPrefixIfNeeded(CodeWriter codeWriter, ReadOnlyMemory<char> typeName)`
`82`	`91`	`{`
`83`	`92`	`if (typeName.Length == 0)`
`84`	`93`	`{`
`@@ -89,7 +98,6 @@ internal static void WriteGloballyQualifiedName(CodeWriter codeWriter, ReadOnlyM`
`89`	`98`
`90`	`99`	`if (typeNameSpan.StartsWith(GlobalPrefix.AsSpan(), StringComparison.Ordinal))`
`91`	`100`	`{`
`92`		`- codeWriter.Write(typeName);`
`93`	`101`	`return;`
`94`	`102`	`}`
`95`	`103`
`@@ -98,7 +106,6 @@ internal static void WriteGloballyQualifiedName(CodeWriter codeWriter, ReadOnlyM`
`98`	`106`	`// just skip prefixing tuples.`
`99`	`107`	`if (typeNameSpan[0] == '(')`
`100`	`108`	`{`
`101`		`- codeWriter.Write(typeName);`
`102`	`109`	`return;`
`103`	`110`	`}`
`104`	`111`
`@@ -107,24 +114,25 @@ internal static void WriteGloballyQualifiedName(CodeWriter codeWriter, ReadOnlyM`
`107`	`114`	`if (typeNameSpan.Length < 3 \|\| typeNameSpan.Length > 7)`
`108`	`115`	`{`
`109`	`116`	`codeWriter.Write(GlobalPrefix);`
`110`		`- codeWriter.Write(typeName);`
`111`	`117`	`return;`
`112`	`118`	`}`
`113`	`119`
`114`	`120`	`if (PredefinedTypeNames.Contains(typeName))`
`115`	`121`	`{`
`116`		`- codeWriter.Write(typeName);`
`117`	`122`	`return;`
`118`	`123`	`}`
`119`	`124`
`120`	`125`	`codeWriter.Write(GlobalPrefix);`
`121`		`- codeWriter.Write(typeName);`
`122`	`126`	`}`
`123`	`127`
`124`		`- internal static ReadOnlyMemory<char> GetNonGenericTypeName(string typeName)`
	`128`	`+ internal static ReadOnlyMemory<char> GetNonGenericTypeName(string typeName, out ReadOnlyMemory<char> genericTypeParameterList)`
`125`	`129`	`{`
`126`	`130`	`var memory = typeName.AsMemory();`
`127`	`131`	`var index = memory.Span.IndexOf('<');`
	`132`	`+`
	`133`	`+ genericTypeParameterList = index == -1`
	`134`	`+ ? default`
	`135`	`+ : memory[index..];`
`128`	`136`	`return index == -1 ? memory : memory[..index];`
`129`	`137`	`}`
`130`	`138`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,8 @@ public sealed class ComponentIntermediateNode : IntermediateNode`
`49`	`49`
`50`	`50`	`public string TypeName { get; set; }`
`51`	`51`
	`52`	`+ public SourceSpan StartTagSpan { get; init; }`
	`53`	`+`
`52`	`54`	`public override void Accept(IntermediateNodeVisitor visitor)`
`53`	`55`	`{`
`54`	`56`	`if (visitor == null)`