[Blazor] Avoids parsing type names and caching results which might cause null reference exception (#73)

* Capture the type containing namespace and the type name without generic arguments from the Roslyn symbols.
* Save the type namespace and type name without generic arguments in the TagHelperDescriptor metadata.
* Replace parsing logic with checks on the already computed metadata.

Author: javiercn

src/Microsoft.AspNetCore.Razor.Language/src/Components/ComponentDesignTimeNodeWriter.cs

@@ -519,7 +519,7 @@ public override void WriteComponent(CodeRenderingContext context, ComponentInter
                 if (!node.TagName.Contains("."))
                 {
                     // The tag is not fully qualified
-                    context.CodeWriter.Write(node.Component.ParsedTypeInfo.Value.Namespace);
+                    context.CodeWriter.Write(node.Component.GetTypeNamespace());
                     context.CodeWriter.Write(".");
                 }
                 context.CodeWriter.Write(node.TagName);

src/Microsoft.AspNetCore.Razor.Language/src/Components/ComponentLoweringPass.cs

@@ -100,7 +100,7 @@ static TagHelperDescriptor GetTagHelperOrAddDiagnostic(TagHelperIntermediateNode
                 for (var j = 0; j < usings.Count; j++)
                 {
                     var usingNamespace = usings[j].Content;
-                    if (string.Equals(tagHelper.ParsedTypeInfo.Value.Namespace.Value, usingNamespace, StringComparison.Ordinal))
+                    if (string.Equals(tagHelper.GetTypeNamespace(), usingNamespace, StringComparison.Ordinal))
                     {
                         if (candidate == null)
                         {

src/Microsoft.AspNetCore.Razor.Language/src/DefaultRazorTagHelperBinderPhase.cs

@@ -265,8 +265,7 @@ public ComponentDirectiveVisitor(string filePath, IReadOnlyList<TagHelperDescrip
                 {
                     // If this is a child content tag helper, we want to add it if it's original type is in scope.
                     // E.g, if the type name is `Test.MyComponent.ChildContent`, we want to add it if `Test.MyComponent` is in scope.
-                    TrySplitNamespaceAndType(tagHelper, out var typeNamespace);
-                    if (!typeNamespace.IsEmpty && IsTypeInScope(typeNamespace, currentNamespace))
+                    if (IsTypeInScope(tagHelper, currentNamespace))
                     {
                         Matches.Add(tagHelper);
                     }
@@ -352,8 +351,7 @@ public override void VisitRazorDirective(RazorDirectiveSyntax node)
                         {
                             // If this is a child content tag helper, we want to add it if it's original type is in scope of the given namespace.
                             // E.g, if the type name is `Test.MyComponent.ChildContent`, we want to add it if `Test.MyComponent` is in this namespace.
-                            TrySplitNamespaceAndType(tagHelper, out var typeName);
-                            if (!typeName.IsEmpty && IsTypeInNamespace(typeName, @namespace))
+                            if (IsTypeInNamespace(tagHelper, @namespace))
                             {
                                 Matches.Add(tagHelper);
                             }
@@ -368,26 +366,15 @@ public override void VisitRazorDirective(RazorDirectiveSyntax node)
             }
         }
 
-        internal static bool IsTypeInNamespace(StringSegment typeName, string @namespace)
-        {
-            if (!TrySplitNamespaceAndType(typeName, out var typeNamespace, out var _) || typeNamespace.IsEmpty)
-            {
-                // Either the typeName is not the full type name or this type is at the top level.
-                return true;
-            }
-
-            return typeNamespace.Equals(@namespace, StringComparison.Ordinal);
-        }
-
         internal static bool IsTypeInNamespace(TagHelperDescriptor tagHelper, string @namespace)
         {
-            if (!TrySplitNamespaceAndType(tagHelper, out var typeNamespace) || typeNamespace.IsEmpty)
+            return IsTypeInNamespace(tagHelper.GetTypeNamespace(), @namespace);
+
+            static bool IsTypeInNamespace(string typeNamespace, string @namespace)
             {
                 // Either the typeName is not the full type name or this type is at the top level.
-                return true;
+                return string.IsNullOrEmpty(typeNamespace) || typeNamespace.Equals(@namespace, StringComparison.Ordinal);
             }
-
-            return typeNamespace.Equals(@namespace, StringComparison.Ordinal);
         }
 
         // Check if the given type is already in scope given the namespace of the current document.
@@ -397,34 +384,18 @@ internal static bool IsTypeInNamespace(TagHelperDescriptor tagHelper, string @na
         // Whereas `MyComponents.SomethingElse.OtherComponent` is not in scope.
         internal static bool IsTypeInScope(TagHelperDescriptor descriptor, string currentNamespace)
         {
-            if (!TrySplitNamespaceAndType(descriptor, out var typeNamespace, out _) || typeNamespace.IsEmpty)
-            {
-                // Either the typeName is not the full type name or this type is at the top level.
-                return true;
-            }
-
-            return IsTypeInScopeCore(currentNamespace, typeNamespace);
+            return IsTypeInScopeCore(currentNamespace, descriptor.GetTypeNamespace());
         }
 
-        // Check if the given type is already in scope given the namespace of the current document.
-        // E.g,
-        // If the namespace of the document is `MyComponents.Components.Shared`,
-        // then the types `MyComponents.FooComponent`, `MyComponents.Components.BarComponent`, `MyComponents.Components.Shared.BazComponent` are all in scope.
-        // Whereas `MyComponents.SomethingElse.OtherComponent` is not in scope.
-        internal static bool IsTypeInScope(StringSegment typeName, string currentNamespace)
+        private static bool IsTypeInScopeCore(string currentNamespace, string typeNamespace)
         {
-            if (!TrySplitNamespaceAndType(typeName, out var typeNamespace, out _) || typeNamespace.IsEmpty)
+            if (string.IsNullOrEmpty(typeNamespace))
             {
                 // Either the typeName is not the full type name or this type is at the top level.
                 return true;
             }
 
-            return IsTypeInScopeCore(currentNamespace, typeNamespace);
-        }
-
-        private static bool IsTypeInScopeCore(string currentNamespace, StringSegment typeNamespace)
-        {
-            if (!new StringSegment(currentNamespace).StartsWith(typeNamespace, StringComparison.Ordinal))
+            if (!currentNamespace.StartsWith(typeNamespace, StringComparison.Ordinal))
             {
                 // typeName: MyComponents.Shared.SomeCoolNamespace
                 // currentNamespace: MyComponents.Shared
@@ -445,83 +416,7 @@ private static bool IsTypeInScopeCore(string currentNamespace, StringSegment typ
         // open file in the editor. We mangle the class name for its generated code, so using that here to filter these out.
         internal static bool IsTagHelperFromMangledClass(TagHelperDescriptor tagHelper)
         {
-            StringSegment className;
-            if (tagHelper.IsChildContentTagHelper())
-            {
-                // If this is a child content tag helper, we want to look at it's original type.
-                // E.g, if the type name is `Test.__generated__MyComponent.ChildContent`, we want to look at `Test.__generated__MyComponent`.
-                TrySplitNamespaceAndType(tagHelper, out var typeNamespace);
-                return TrySplitNamespaceAndType(typeNamespace, out var _, out className)
-                    && ComponentMetadata.IsMangledClass(className);
-            }
-
-            return TrySplitNamespaceAndType(tagHelper, out var _, out className) &&
-                ComponentMetadata.IsMangledClass(className);
-        }
-
-        internal static bool TrySplitNamespaceAndType(TagHelperDescriptor tagHelperDescriptor, out StringSegment @namespace)
-            => TrySplitNamespaceAndType(tagHelperDescriptor, out @namespace, out _);
-
-        internal static bool TrySplitNamespaceAndType(TagHelperDescriptor tagHelperDescriptor, out StringSegment @namespace, out StringSegment typeName)
-        {
-            if (tagHelperDescriptor.ParsedTypeInfo is { } value)
-            {
-                @namespace = value.Namespace;
-                typeName = value.TypeName;
-                return value.Success;
-            }
-
-            var success = TrySplitNamespaceAndType(tagHelperDescriptor.GetTypeName(), out @namespace, out typeName);
-            tagHelperDescriptor.ParsedTypeInfo = new(success, @namespace, typeName);
-            return success;
-        }
-
-        // Internal for testing.
-        internal static bool TrySplitNamespaceAndType(StringSegment fullTypeName, out StringSegment @namespace, out StringSegment typeName)
-        {
-            @namespace = StringSegment.Empty;
-            typeName = StringSegment.Empty;
-
-            if (fullTypeName.IsEmpty)
-            {
-                return false;
-            }
-
-            var nestingLevel = 0;
-            var splitLocation = -1;
-            for (var i = fullTypeName.Length - 1; i >= 0; i--)
-            {
-                var c = fullTypeName[i];
-                if (c == Type.Delimiter && nestingLevel == 0)
-                {
-                    splitLocation = i;
-                    break;
-                }
-                else if (c == '>')
-                {
-                    nestingLevel++;
-                }
-                else if (c == '<')
-                {
-                    nestingLevel--;
-                }
-            }
-
-            if (splitLocation == -1)
-            {
-                typeName = fullTypeName;
-                return true;
-            }
-
-            @namespace = fullTypeName.Subsegment(0, splitLocation);
-
-            var typeNameStartLocation = splitLocation + 1;
-            if (typeNameStartLocation < fullTypeName.Length)
-            {
-                typeName = fullTypeName.Subsegment(typeNameStartLocation, fullTypeName.Length - typeNameStartLocation);
-            }
-
-            return true;
+            return ComponentMetadata.IsMangledClass(tagHelper.GetTypeNameIdentifier());
         }
     }
 }

src/Microsoft.AspNetCore.Razor.Language/src/TagHelperDescriptor.cs

@@ -47,7 +47,7 @@ protected TagHelperDescriptor(string kind)
     private int? _hashCode;
     internal bool? IsComponentFullyQualifiedNameMatchCache { get; set; }
     internal bool? IsChildContentTagHelperCache { get; set; }
-    internal ParsedTypeInformation? ParsedTypeInfo { get; set; }
+
     internal BoundAttributeDescriptor[] EditorRequiredAttributes
     {
         get

src/Microsoft.AspNetCore.Razor.Language/src/TagHelperDescriptorBuilderExtensions.cs

@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 #nullable disable
@@ -9,6 +9,36 @@ namespace Microsoft.AspNetCore.Razor.Language;
 
 public static class TagHelperDescriptorBuilderExtensions
 {
+    public static void SetTypeNamespace(this TagHelperDescriptorBuilder builder, string typeNamespace)
+    {
+        if (builder == null)
+        {
+            throw new ArgumentNullException(nameof(builder));
+        }
+
+        if (typeNamespace == null)
+        {
+            throw new ArgumentNullException(nameof(typeNamespace));
+        }
+
+        builder.Metadata[TagHelperMetadata.Common.TypeNamespace] = typeNamespace;
+    }
+
+    public static void SetTypeNameIdentifier(this TagHelperDescriptorBuilder builder, string typeNameIdentifier)
+    {
+        if (builder == null)
+        {
+            throw new ArgumentNullException(nameof(builder));
+        }
+
+        if (typeNameIdentifier == null)
+        {
+            throw new ArgumentNullException(nameof(typeNameIdentifier));
+        }
+
+        builder.Metadata[TagHelperMetadata.Common.TypeNameIdentifier] = typeNameIdentifier;
+    }
+
     public static void SetTypeName(this TagHelperDescriptorBuilder builder, string typeName)
     {
         if (builder == null)

src/Microsoft.AspNetCore.Razor.Language/src/TagHelperDescriptorExtensions.cs

@@ -21,6 +21,28 @@ public static string GetTypeName(this TagHelperDescriptor tagHelper)
         return typeName;
     }
 
+    public static string GetTypeNamespace(this TagHelperDescriptor tagHelper)
+    {
+        if (tagHelper == null)
+        {
+            throw new ArgumentNullException(nameof(tagHelper));
+        }
+
+        tagHelper.Metadata.TryGetValue(TagHelperMetadata.Common.TypeNamespace, out var typeNamespace);
+        return typeNamespace;
+    }
+
+    public static string GetTypeNameIdentifier(this TagHelperDescriptor tagHelper)
+    {
+        if (tagHelper == null)
+        {
+            throw new ArgumentNullException(nameof(tagHelper));
+        }
+
+        tagHelper.Metadata.TryGetValue(TagHelperMetadata.Common.TypeNameIdentifier, out var typeNameIdentifier);
+        return typeNameIdentifier;
+    }
+
     public static bool IsDefaultKind(this TagHelperDescriptor tagHelper)
     {
         if (tagHelper == null)

src/Microsoft.AspNetCore.Razor.Language/src/TagHelperMetadata.cs

@@ -13,6 +13,10 @@ public static class Common
 
         public static readonly string TypeName = "Common.TypeName";
 
+        public static readonly string TypeNamespace = "Common.TypeNamespace";
+
+        public static readonly string TypeNameIdentifier = "Common.TypeNameIdentifier";
+
         public static readonly string GloballyQualifiedTypeName = "Common.GloballyQualifiedTypeName";
 
         public static readonly string ClassifyAttributesOnly = "Common.ClassifyAttributesOnly";