diff --git a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/DefaultRazorTagHelperBinderPhaseTest.cs b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/DefaultRazorTagHelperBinderPhaseTest.cs
index 9a539690d29..abea6f12392 100644
--- a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/DefaultRazorTagHelperBinderPhaseTest.cs
+++ b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/DefaultRazorTagHelperBinderPhaseTest.cs
@@ -295,7 +295,7 @@ public void Execute_DirectiveWithoutQuotes_RewritesTagHelpers_TagHelperMatchesEl
 
         var formTagHelper = Assert.Single(tagHelperNodes);
         Assert.Equal("form", formTagHelper.TagHelperInfo.TagName);
-        Assert.Equal(2, formTagHelper.TagHelperInfo.BindingResult.Mappings[tagHelper].Length);
+        Assert.Equal(2, formTagHelper.TagHelperInfo.BindingResult.GetBoundRules(tagHelper).Length);
     }
 
     [Fact]
@@ -340,7 +340,7 @@ public void Execute_DirectiveWithQuotes_RewritesTagHelpers_TagHelperMatchesEleme
 
         var formTagHelper = Assert.Single(tagHelperNodes);
         Assert.Equal("form", formTagHelper.TagHelperInfo.TagName);
-        Assert.Equal(2, formTagHelper.TagHelperInfo.BindingResult.Mappings[tagHelper].Length);
+        Assert.Equal(2, formTagHelper.TagHelperInfo.BindingResult.GetBoundRules(tagHelper).Length);
     }
 
     [Fact]
@@ -441,6 +441,7 @@ public void Execute_SetsTagHelperDocumentContext()
 
         // Assert
         var context = codeDocument.GetTagHelperContext();
+        Assert.NotNull(context);
         Assert.Null(context.Prefix);
         Assert.Empty(context.TagHelpers);
     }
diff --git a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/IntegrationTests/ComponentDiscoveryIntegrationTest.cs b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/IntegrationTests/ComponentDiscoveryIntegrationTest.cs
index dac3556aad0..bd4a7604ba8 100644
--- a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/IntegrationTests/ComponentDiscoveryIntegrationTest.cs
+++ b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/IntegrationTests/ComponentDiscoveryIntegrationTest.cs
@@ -32,8 +32,9 @@ public class MyComponent : ComponentBase
         var result = CompileToCSharp(string.Empty);
 
         // Assert
-        var bindings = result.CodeDocument.GetTagHelperContext();
-        Assert.Contains(bindings.TagHelpers, t => t.Name == "Test.MyComponent");
+        var context = result.CodeDocument.GetTagHelperContext();
+        Assert.NotNull(context);
+        Assert.Contains(context.TagHelpers, t => t.Name == "Test.MyComponent");
     }
 
     [Fact]
@@ -55,15 +56,16 @@ public class MyComponent : ComponentBase
         var result = CompileToCSharp(string.Empty);
 
         // Assert
-        var bindings = result.CodeDocument.GetTagHelperContext();
+        var context = result.CodeDocument.GetTagHelperContext();
+        Assert.NotNull(context);
 
-        Assert.Contains(bindings.TagHelpers, t =>
+        Assert.Contains(context.TagHelpers, t =>
         {
             return t.Name == "Test.AnotherNamespace.MyComponent" &&
                 t.IsComponentFullyQualifiedNameMatch;
         });
 
-        Assert.DoesNotContain(bindings.TagHelpers, t =>
+        Assert.DoesNotContain(context.TagHelpers, t =>
         {
             return t.Name == "Test.AnotherNamespace.MyComponent" &&
                 !t.IsComponentFullyQualifiedNameMatch;
@@ -79,8 +81,10 @@ public void ComponentDiscovery_CanFindComponent_DefinedinCshtml()
         var result = CompileToCSharp("UniqueName.cshtml", cshtmlContent: string.Empty);
 
         // Assert
-        var bindings = result.CodeDocument.GetTagHelperContext();
-        Assert.Contains(bindings.TagHelpers, t => t.Name == "Test.UniqueName");
+        var context = result.CodeDocument.GetTagHelperContext();
+        Assert.NotNull(context);
+
+        Assert.Contains(context.TagHelpers, t => t.Name == "Test.UniqueName");
     }
 
     [Fact]
@@ -96,8 +100,10 @@ @typeparam TItem
 }");
 
         // Assert
-        var bindings = result.CodeDocument.GetTagHelperContext();
-        Assert.Contains(bindings.TagHelpers, t => t.Name == "Test.UniqueName<TItem>");
+        var context = result.CodeDocument.GetTagHelperContext();
+        Assert.NotNull(context);
+
+        Assert.Contains(context.TagHelpers, t => t.Name == "Test.UniqueName<TItem>");
     }
 
     [Fact]
@@ -113,8 +119,10 @@ public void ComponentDiscovery_CanFindComponent_WithTypeParameterAndSemicolon()
 }");
 
         // Assert
-        var bindings = result.CodeDocument.GetTagHelperContext();
-        Assert.Contains(bindings.TagHelpers, t => t.Name == "Test.UniqueName<TItem>");
+        var context = result.CodeDocument.GetTagHelperContext();
+        Assert.NotNull(context);
+
+        Assert.Contains(context.TagHelpers, t => t.Name == "Test.UniqueName<TItem>");
     }
 
     [Fact]
@@ -132,8 +140,10 @@ @typeparam TItem3
 }");
 
         // Assert
-        var bindings = result.CodeDocument.GetTagHelperContext();
-        Assert.Contains(bindings.TagHelpers, t => t.Name == "Test.UniqueName<TItem1, TItem2, TItem3>");
+        var context = result.CodeDocument.GetTagHelperContext();
+        Assert.NotNull(context);
+
+        Assert.Contains(context.TagHelpers, t => t.Name == "Test.UniqueName<TItem1, TItem2, TItem3>");
     }
 
     [Fact]
@@ -151,7 +161,9 @@ @typeparam TItem3
 }");
 
         // Assert
-        var bindings = result.CodeDocument.GetTagHelperContext();
-        Assert.Contains(bindings.TagHelpers, t => t.Name == "Test.UniqueName<TItem1, TItem2, TItem3>");
+        var context = result.CodeDocument.GetTagHelperContext();
+        Assert.NotNull(context);
+
+        Assert.Contains(context.TagHelpers, t => t.Name == "Test.UniqueName<TItem1, TItem2, TItem3>");
     }
 }
diff --git a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/RazorCodeDocumentExtensionsTest.cs b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/RazorCodeDocumentExtensionsTest.cs
index dd2d1d0ec60..fd21f3abb82 100644
--- a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/RazorCodeDocumentExtensionsTest.cs
+++ b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/RazorCodeDocumentExtensionsTest.cs
@@ -137,13 +137,13 @@ public void SetCSharpDocument_SetsCSharpDocument()
     }
 
     [Fact]
-    public void GetTagHelperContext_ReturnsTagHelperContext()
+    public void GetAndSetTagHelperContext_ReturnsTagHelperContext()
     {
         // Arrange
         var codeDocument = TestRazorCodeDocument.CreateEmpty();
 
         var expected = TagHelperDocumentContext.Create(prefix: null, tagHelpers: []);
-        codeDocument.Items[typeof(TagHelperDocumentContext)] = expected;
+        codeDocument.SetTagHelperContext(expected);
 
         // Act
         var actual = codeDocument.GetTagHelperContext();
@@ -152,21 +152,6 @@ public void GetTagHelperContext_ReturnsTagHelperContext()
         Assert.Same(expected, actual);
     }
 
-    [Fact]
-    public void SetTagHelperContext_SetsTagHelperContext()
-    {
-        // Arrange
-        var codeDocument = TestRazorCodeDocument.CreateEmpty();
-
-        var expected = TagHelperDocumentContext.Create(prefix: null, tagHelpers: []);
-
-        // Act
-        codeDocument.SetTagHelperContext(expected);
-
-        // Assert
-        Assert.Same(expected, codeDocument.Items[typeof(TagHelperDocumentContext)]);
-    }
-
     [Fact]
     public void TryComputeNamespace_RootNamespaceNotSet_ReturnsNull()
     {
diff --git a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/TagHelperBinderTest.cs b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/TagHelperBinderTest.cs
index c413db5a176..5473b4cb924 100644
--- a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/TagHelperBinderTest.cs
+++ b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/TagHelperBinderTest.cs
@@ -38,8 +38,8 @@ public void GetBinding_ReturnsBindingWithInformation()
         Assert.Equal("th:div", bindingResult.TagName);
         Assert.Equal("body", bindingResult.ParentTagName);
         Assert.Equal<KeyValuePair<string, string>>(expectedAttributes, bindingResult.Attributes);
-        Assert.Equal("th:", bindingResult.TagHelperPrefix);
-        Assert.Equal<TagMatchingRuleDescriptor>(divTagHelper.TagMatchingRules, bindingResult.Mappings[divTagHelper]);
+        Assert.Equal("th:", bindingResult.TagNamePrefix);
+        Assert.Equal<TagMatchingRuleDescriptor>(divTagHelper.TagMatchingRules, bindingResult.GetBoundRules(divTagHelper));
     }
 
     [Fact]
@@ -81,7 +81,7 @@ void TestTagName(string tagName, TagMatchingRuleDescriptor expectedBindingResult
                 Assert.Equal<TagHelperDescriptor>(expectedDescriptors, bindingResult.Descriptors);
 
                 Assert.Equal(tagName, bindingResult.TagName);
-                var mapping = Assert.Single(bindingResult.Mappings[multiTagHelper]);
+                var mapping = Assert.Single(bindingResult.GetBoundRules(multiTagHelper));
                 Assert.Equal(expectedBindingResult, mapping);
             }
         }
@@ -136,7 +136,7 @@ void TestTagName(string tagName, TagHelperDescriptor[] expectedDescriptors, TagM
 
                 for (int i = 0; i < expectedDescriptors.Length; i++)
                 {
-                    var mapping = Assert.Single(bindingResult.Mappings[expectedDescriptors[i]]);
+                    var mapping = Assert.Single(bindingResult.GetBoundRules(expectedDescriptors[i]));
                     Assert.Equal(expectedBindingResults[i], mapping);
                 }
             }
@@ -598,7 +598,7 @@ public void GetBinding_DescriptorWithMultipleRules_CorrectlySelectsMatchingRules
         // Assert
         var boundDescriptor = Assert.Single(binding.Descriptors);
         Assert.Same(multiRuleDescriptor, boundDescriptor);
-        var boundRules = binding.Mappings[boundDescriptor];
+        var boundRules = binding.GetBoundRules(boundDescriptor);
         var boundRule = Assert.Single(boundRules);
         Assert.Equal("div", boundRule.TagName);
     }
@@ -626,7 +626,7 @@ public void GetBinding_PrefixedParent_ReturnsBinding()
         // Assert
         var boundDescriptor = Assert.Single(bindingResult.Descriptors);
         Assert.Same(divDescriptor, boundDescriptor);
-        var boundRules = bindingResult.Mappings[boundDescriptor];
+        var boundRules = bindingResult.GetBoundRules(boundDescriptor);
         var boundRule = Assert.Single(boundRules);
         Assert.Equal("div", boundRule.TagName);
         Assert.Equal("p", boundRule.ParentTag);
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultRazorTagHelperRewritePhase.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultRazorTagHelperRewritePhase.cs
index 4507e4e60e6..03e8a80f753 100644
--- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultRazorTagHelperRewritePhase.cs
+++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultRazorTagHelperRewritePhase.cs
@@ -12,7 +12,7 @@ protected override void ExecuteCore(RazorCodeDocument codeDocument, Cancellation
     {
         var syntaxTree = codeDocument.GetPreTagHelperSyntaxTree();
         var context = codeDocument.GetTagHelperContext();
-        if (syntaxTree is null || context.TagHelpers.Length == 0)
+        if (syntaxTree is null || context is not { TagHelpers.Length: > 0 })
         {
             // No descriptors, no-op.
             return;
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperBlockRewriter.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperBlockRewriter.cs
index 3d5afbce23d..3dbbd550198 100644
--- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperBlockRewriter.cs
+++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperBlockRewriter.cs
@@ -27,10 +27,9 @@ public static TagMode GetTagMode(
         }
 
         var hasDirectiveAttribute = false;
-        foreach (var descriptor in bindingResult.Descriptors)
+        foreach (var boundRulesInfo in bindingResult.AllBoundRules)
         {
-            var boundRules = bindingResult.Mappings[descriptor];
-            var nonDefaultRule = boundRules.FirstOrDefault(static rule => rule.TagStructure != TagStructure.Unspecified);
+            var nonDefaultRule = boundRulesInfo.Rules.FirstOrDefault(static rule => rule.TagStructure != TagStructure.Unspecified);
 
             if (nonDefaultRule?.TagStructure == TagStructure.WithoutEndTag)
             {
@@ -42,6 +41,7 @@ public static TagMode GetTagMode(
             // <input @onclick="..."> vs <input onclick="..." />
             //
             // We don't want this to become an error just because you added a directive attribute.
+            var descriptor = boundRulesInfo.Descriptor;
             if (descriptor.IsAnyComponentDocumentTagHelper() && !descriptor.IsComponentOrChildContentTagHelper)
             {
                 hasDirectiveAttribute = true;
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperParseTreeRewriter.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperParseTreeRewriter.cs
index 5e1a323a65e..c75e373ea72 100644
--- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperParseTreeRewriter.cs
+++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperParseTreeRewriter.cs
@@ -34,9 +34,9 @@ public static RazorSyntaxTree Rewrite(RazorSyntaxTree syntaxTree, TagHelperBinde
         builder.AddRange(treeDiagnostics);
         builder.AddRange(sinkDiagnostics);
 
-        foreach (var tagHelper in binder.TagHelpers)
+        foreach (var descriptor in binder.Descriptors)
         {
-            foreach (var diagnostic in tagHelper.GetAllDiagnostics())
+            foreach (var diagnostic in descriptor.GetAllDiagnostics())
             {
                 builder.Add(diagnostic);
             }
@@ -137,7 +137,7 @@ public override SyntaxNode VisitMarkupElement(MarkupElementSyntax node)
                     else
                     {
                         // Tag helper start tag. Keep track.
-                        var tracker = new TagHelperTracker(_binder.TagHelperPrefix, tagHelperInfo);
+                        var tracker = new TagHelperTracker(_binder.TagNamePrefix, tagHelperInfo);
                         _trackerStack.Push(tracker);
                     }
                 }
@@ -347,10 +347,9 @@ private bool TryRewriteTagHelperEnd(
                     return false;
                 }
 
-                foreach (var descriptor in tagHelperBinding.Descriptors)
+                foreach (var boundRulesInfo in tagHelperBinding.AllBoundRules)
                 {
-                    var boundRules = tagHelperBinding.Mappings[descriptor];
-                    var invalidRule = boundRules.FirstOrDefault(static rule => rule.TagStructure == TagStructure.WithoutEndTag);
+                    var invalidRule = boundRulesInfo.Rules.FirstOrDefault(static rule => rule.TagStructure == TagStructure.WithoutEndTag);
 
                     if (invalidRule != null)
                     {
@@ -359,7 +358,7 @@ private bool TryRewriteTagHelperEnd(
                             RazorDiagnosticFactory.CreateParsing_TagHelperMustNotHaveAnEndTag(
                                 new SourceSpan(SourceLocationTracker.Advance(endTag.GetSourceLocation(_source), "</"), tagName.Length),
                                 tagName,
-                                descriptor.DisplayName,
+                                boundRulesInfo.Descriptor.DisplayName,
                                 invalidRule.TagStructure));
 
                         return false;
@@ -462,10 +461,11 @@ private void ValidateBinding(
             TagHelperDescriptor? baseDescriptor = null;
             TagStructure? baseStructure = null;
 
-            foreach (var descriptor in bindingResult.Descriptors)
+            foreach (var boundRulesInfo in bindingResult.AllBoundRules)
             {
-                var boundRules = bindingResult.Mappings[descriptor];
-                foreach (var rule in boundRules)
+                var descriptor = boundRulesInfo.Descriptor;
+
+                foreach (var rule in boundRulesInfo.Rules)
                 {
                     if (rule.TagStructure != TagStructure.Unspecified)
                     {
@@ -726,7 +726,7 @@ private record TagHelperTracker : TagTracker
         {
             public uint OpenMatchingTags;
 
-            private readonly string? _tagHelperPrefix;
+            private readonly string? _tagNamePrefix;
             private readonly TagHelperBinding _binding;
 
             private readonly Lazy<(ImmutableArray<string> Names, HashSet<string> NameSet)> _lazyAllowedChildren;
@@ -734,10 +734,10 @@ private record TagHelperTracker : TagTracker
 
             public ImmutableArray<string> AllowedChildren => _lazyAllowedChildren.Value.Names;
 
-            public TagHelperTracker(string? tagHelperPrefix, TagHelperInfo info)
+            public TagHelperTracker(string? tagNamePrefix, TagHelperInfo info)
                 : base(info.TagName, IsTagHelper: true)
             {
-                _tagHelperPrefix = tagHelperPrefix;
+                _tagNamePrefix = tagNamePrefix;
                 _binding = info.BindingResult;
 
                 _lazyAllowedChildren = new(CreateAllowedChildren);
@@ -773,7 +773,7 @@ public bool AllowsChild(string tagName, bool nameIncludesPrefix)
 
             private HashSet<string> CreatePrefixedAllowedChildren()
             {
-                if (_tagHelperPrefix is not string tagHelperPrefix)
+                if (_tagNamePrefix is not string tagNamePrefix)
                 {
                     return _lazyAllowedChildren.Value.NameSet;
                 }
@@ -782,7 +782,7 @@ private HashSet<string> CreatePrefixedAllowedChildren()
 
                 foreach (var childName in AllowedChildren)
                 {
-                    distinctSet.Add(tagHelperPrefix + childName);
+                    distinctSet.Add(tagNamePrefix + childName);
                 }
 
                 return distinctSet;
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/RazorCodeDocument.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/RazorCodeDocument.cs
index ebaabeb434b..a8cd7cc9807 100644
--- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/RazorCodeDocument.cs
+++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/RazorCodeDocument.cs
@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis;
 
 namespace Microsoft.AspNetCore.Razor.Language;
@@ -17,6 +19,8 @@ public sealed class RazorCodeDocument
 
     public string FileKind => ParserOptions.FileKind;
 
+    private TagHelperDocumentContext? _tagHelperContext;
+
     private RazorCodeDocument(
         RazorSourceDocument source,
         ImmutableArray<RazorSourceDocument> imports,
@@ -52,4 +56,23 @@ public static RazorCodeDocument Create(
 
         return new RazorCodeDocument(source, imports, parserOptions, codeGenerationOptions);
     }
+
+    internal bool TryGetTagHelperContext([NotNullWhen(true)] out TagHelperDocumentContext? result)
+    {
+        result = _tagHelperContext;
+        return result is not null;
+    }
+
+    internal TagHelperDocumentContext? GetTagHelperContext()
+        => _tagHelperContext;
+
+    internal TagHelperDocumentContext GetRequiredTagHelperContext()
+        => _tagHelperContext.AssumeNotNull();
+
+    internal void SetTagHelperContext(TagHelperDocumentContext context)
+    {
+        ArgHelper.ThrowIfNull(context);
+
+        _tagHelperContext = context;
+    }
 }
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/RazorCodeDocumentExtensions.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/RazorCodeDocumentExtensions.cs
index 58f1924a09e..3b4f69c5ad2 100644
--- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/RazorCodeDocumentExtensions.cs
+++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/RazorCodeDocumentExtensions.cs
@@ -22,26 +22,6 @@ public static class RazorCodeDocumentExtensions
     private static readonly object CssScopeKey = new();
     private static readonly object NamespaceKey = new();
 
-    internal static TagHelperDocumentContext GetTagHelperContext(this RazorCodeDocument document)
-    {
-        if (document == null)
-        {
-            throw new ArgumentNullException(nameof(document));
-        }
-
-        return (TagHelperDocumentContext)document.Items[typeof(TagHelperDocumentContext)];
-    }
-
-    internal static void SetTagHelperContext(this RazorCodeDocument document, TagHelperDocumentContext context)
-    {
-        if (document == null)
-        {
-            throw new ArgumentNullException(nameof(document));
-        }
-
-        document.Items[typeof(TagHelperDocumentContext)] = context;
-    }
-
     internal static IReadOnlyList<TagHelperDescriptor> GetTagHelpers(this RazorCodeDocument document)
     {
         if (document == null)
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/TagHelperBinder.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/TagHelperBinder.cs
index 24d3b5a09a2..64ea5058623 100644
--- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/TagHelperBinder.cs
+++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/TagHelperBinder.cs
@@ -2,9 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
-using System.Collections.Frozen;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
 using Microsoft.AspNetCore.Razor.PooledObjects;
 
 namespace Microsoft.AspNetCore.Razor.Language;
@@ -14,30 +15,75 @@ namespace Microsoft.AspNetCore.Razor.Language;
 /// </summary>
 internal sealed class TagHelperBinder
 {
-    private readonly Dictionary<string, HashSet<TagHelperDescriptor>> _registrations;
+    private readonly ImmutableArray<TagHelperDescriptor> _catchAllDescriptors;
+    private readonly ReadOnlyDictionary<string, ImmutableArray<TagHelperDescriptor>> _tagNameToDescriptorsMap;
 
-    public string? TagHelperPrefix { get; }
-    public ImmutableArray<TagHelperDescriptor> TagHelpers { get; }
+    public string? TagNamePrefix { get; }
+    public ImmutableArray<TagHelperDescriptor> Descriptors { get; }
 
     /// <summary>
     /// Instantiates a new instance of the <see cref="TagHelperBinder"/>.
     /// </summary>
-    /// <param name="tagHelperPrefix">The tag helper prefix being used by the document.</param>
-    /// <param name="tagHelpers">The <see cref="TagHelperDescriptor"/>s that the <see cref="TagHelperBinder"/>
+    /// <param name="tagNamePrefix">The tag helper prefix being used by the document.</param>
+    /// <param name="descriptors">The <see cref="TagHelperDescriptor"/>s that the <see cref="TagHelperBinder"/>
     /// will pull from.</param>
-    public TagHelperBinder(string? tagHelperPrefix, ImmutableArray<TagHelperDescriptor> tagHelpers)
+    public TagHelperBinder(string? tagNamePrefix, ImmutableArray<TagHelperDescriptor> descriptors)
     {
-        TagHelperPrefix = tagHelperPrefix;
-        TagHelpers = tagHelpers;
+        TagNamePrefix = tagNamePrefix;
+        Descriptors = descriptors.NullToEmpty();
 
-        // To reduce the frequency of dictionary resizes we use the incoming number of descriptors as a heuristic
-        _registrations = new Dictionary<string, HashSet<TagHelperDescriptor>>(tagHelpers.Length, StringComparer.OrdinalIgnoreCase);
+        ProcessDescriptors(descriptors, tagNamePrefix, out _tagNameToDescriptorsMap, out _catchAllDescriptors);
+    }
+
+    private static void ProcessDescriptors(
+        ImmutableArray<TagHelperDescriptor> descriptors,
+        string? tagNamePrefix,
+        out ReadOnlyDictionary<string, ImmutableArray<TagHelperDescriptor>> tagNameToDescriptorsMap,
+        out ImmutableArray<TagHelperDescriptor> catchAllDescriptors)
+    {
+        using var catchAllBuilder = new PooledArrayBuilder<TagHelperDescriptor>();
+        using var pooledMap = StringDictionaryPool<ImmutableArray<TagHelperDescriptor>.Builder>.OrdinalIgnoreCase.GetPooledObject(out var mapBuilder);
+        using var pooledSet = HashSetPool<TagHelperDescriptor>.GetPooledObject(out var distinctSet);
 
-        // Populate our registrations
-        foreach (var descriptor in tagHelpers)
+        // Build a map of tag name -> tag helpers.
+        foreach (var descriptor in descriptors)
         {
-            Register(descriptor);
+            if (!distinctSet.Add(descriptor))
+            {
+                // We're already seen this descriptor, skip it.
+                continue;
+            }
+
+            foreach (var rule in descriptor.TagMatchingRules)
+            {
+                if (rule.TagName == TagHelperMatchingConventions.ElementCatchAllName)
+                {
+                    // This is a catch-all descriptor, we can keep track of it separately.
+                    catchAllBuilder.Add(descriptor);
+                }
+                else
+                {
+                    // This is a specific tag name, we need to add it to the map.
+                    var tagName = tagNamePrefix + rule.TagName;
+                    var builder = mapBuilder.GetOrAdd(tagName, _ => ImmutableArray.CreateBuilder<TagHelperDescriptor>());
+
+                    builder.Add(descriptor);
+                }
+            }
+        }
+
+        // Build the final dictionary with immutable arrays.
+        var map = new Dictionary<string, ImmutableArray<TagHelperDescriptor>>(capacity: mapBuilder.Count, StringComparer.OrdinalIgnoreCase);
+
+        foreach (var (key, value) in mapBuilder)
+        {
+            map.Add(key, value.DrainToImmutable());
         }
+
+        tagNameToDescriptorsMap = new ReadOnlyDictionary<string, ImmutableArray<TagHelperDescriptor>>(map);
+
+        // Build the catch all descriptors array.
+        catchAllDescriptors = catchAllBuilder.DrainToImmutable();
     }
 
     /// <summary>
@@ -49,105 +95,94 @@ public TagHelperBinder(string? tagHelperPrefix, ImmutableArray<TagHelperDescript
     /// <param name="parentTagName">The parent tag name of the given <paramref name="tagName"/> tag.</param>
     /// <param name="parentIsTagHelper">Is the parent tag of the given <paramref name="tagName"/> tag a tag helper.</param>
     /// <returns><see cref="TagHelperDescriptor"/>s that apply to the given HTML tag criteria.
-    /// Will return <c>null</c> if no <see cref="TagHelperDescriptor"/>s are a match.</returns>
+    /// Will return <see langword="null"/> if no <see cref="TagHelperDescriptor"/>s are a match.</returns>
     public TagHelperBinding? GetBinding(
         string tagName,
         ImmutableArray<KeyValuePair<string, string>> attributes,
         string? parentTagName,
         bool parentIsTagHelper)
     {
-        if (!TagHelperPrefix.IsNullOrEmpty() &&
-            (tagName.Length <= TagHelperPrefix.Length ||
-             !tagName.StartsWith(TagHelperPrefix, StringComparison.OrdinalIgnoreCase)))
-        {
-            // The tagName doesn't have the tag helper prefix, we can short circuit.
-            return null;
-        }
+        var tagNameSpan = tagName.AsSpan();
+        var parentTagNameSpan = parentTagName.AsSpan();
+        var tagNamePrefixSpan = TagNamePrefix.AsSpan();
 
-        var tagNameWithoutPrefix = tagName.AsSpanOrDefault();
-        var parentTagNameWithoutPrefix = parentTagName.AsSpanOrDefault();
-
-        if (TagHelperPrefix is { Length: var length and > 0 })
+        if (!tagNamePrefixSpan.IsEmpty)
         {
-            tagNameWithoutPrefix = tagNameWithoutPrefix[length..];
+            if (!tagNameSpan.StartsWith(tagNamePrefixSpan, StringComparison.OrdinalIgnoreCase))
+            {
+                // The tag name doesn't start with the prefix. So, we're done.
+                return null;
+            }
+
+            tagNameSpan = tagNameSpan[tagNamePrefixSpan.Length..];
 
             if (parentIsTagHelper)
             {
-                parentTagNameWithoutPrefix = parentTagNameWithoutPrefix[length..];
+                Debug.Assert(
+                    parentTagNameSpan.StartsWith(tagNamePrefixSpan, StringComparison.OrdinalIgnoreCase),
+                    "If the parent is a tag helper, it must start with the tag name prefix.");
+
+                parentTagNameSpan = parentTagNameSpan[tagNamePrefixSpan.Length..];
             }
         }
 
-        using var _ = DictionaryPool<TagHelperDescriptor, ImmutableArray<TagMatchingRuleDescriptor>>.GetPooledObject(out var applicableDescriptors);
+        using var resultsBuilder = new PooledArrayBuilder<TagHelperBoundRulesInfo>();
+        using var tempRulesBuilder = new PooledArrayBuilder<TagMatchingRuleDescriptor>();
+        using var pooledSet = HashSetPool<TagHelperDescriptor>.GetPooledObject(out var distinctSet);
 
         // First, try any tag helpers with this tag name.
-        if (_registrations.TryGetValue(tagName, out var matchingDescriptors))
+        if (_tagNameToDescriptorsMap.TryGetValue(tagName, out var matchingDescriptors))
         {
-            FindApplicableDescriptors(matchingDescriptors, tagNameWithoutPrefix, parentTagNameWithoutPrefix, attributes, applicableDescriptors);
+            CollectBoundRulesInfo(
+                matchingDescriptors,
+                tagNameSpan, parentTagNameSpan, attributes,
+                ref resultsBuilder.AsRef(), ref tempRulesBuilder.AsRef(), distinctSet);
         }
 
         // Next, try any "catch all" descriptors.
-        if (_registrations.TryGetValue(TagHelperMatchingConventions.ElementCatchAllName, out var catchAllDescriptors))
-        {
-            FindApplicableDescriptors(catchAllDescriptors, tagNameWithoutPrefix, parentTagNameWithoutPrefix, attributes, applicableDescriptors);
-        }
-
-        if (applicableDescriptors.Count == 0)
-        {
-            return null;
-        }
-
-        return new TagHelperBinding(
-            tagName,
-            attributes,
-            parentTagName,
-            applicableDescriptors.ToFrozenDictionary(),
-            TagHelperPrefix);
-
-        static void FindApplicableDescriptors(
-            HashSet<TagHelperDescriptor> descriptors,
-            ReadOnlySpan<char> tagNameWithoutPrefix,
-            ReadOnlySpan<char> parentTagNameWithoutPrefix,
+        CollectBoundRulesInfo(
+            _catchAllDescriptors,
+            tagNameSpan, parentTagNameSpan, attributes,
+            ref resultsBuilder.AsRef(), ref tempRulesBuilder.AsRef(), distinctSet);
+
+        return resultsBuilder.Count > 0
+            ? new(resultsBuilder.DrainToImmutable(), tagName, parentTagName, attributes, TagNamePrefix)
+            : null;
+
+        static void CollectBoundRulesInfo(
+            ImmutableArray<TagHelperDescriptor> descriptors,
+            ReadOnlySpan<char> tagName,
+            ReadOnlySpan<char> parentTagName,
             ImmutableArray<KeyValuePair<string, string>> attributes,
-            Dictionary<TagHelperDescriptor, ImmutableArray<TagMatchingRuleDescriptor>> applicableDescriptors)
+            ref PooledArrayBuilder<TagHelperBoundRulesInfo> resultsBuilder,
+            ref PooledArrayBuilder<TagMatchingRuleDescriptor> tempRulesBuilder,
+            HashSet<TagHelperDescriptor> distinctSet)
         {
-            using var applicableRules = new PooledArrayBuilder<TagMatchingRuleDescriptor>();
-
             foreach (var descriptor in descriptors)
             {
+                if (!distinctSet.Add(descriptor))
+                {
+                    // We're already seen this descriptor, skip it.
+                    continue;
+                }
+
+                Debug.Assert(tempRulesBuilder.Count == 0);
+
                 foreach (var rule in descriptor.TagMatchingRules)
                 {
-                    if (TagHelperMatchingConventions.SatisfiesRule(rule, tagNameWithoutPrefix, parentTagNameWithoutPrefix, attributes))
+                    if (TagHelperMatchingConventions.SatisfiesRule(rule, tagName, parentTagName, attributes))
                     {
-                        applicableRules.Add(rule);
+                        tempRulesBuilder.Add(rule);
                     }
                 }
 
-                if (applicableRules.Count > 0)
+                if (tempRulesBuilder.Count > 0)
                 {
-                    applicableDescriptors[descriptor] = applicableRules.DrainToImmutable();
+                    resultsBuilder.Add(new(descriptor, tempRulesBuilder.ToImmutable()));
                 }
 
-                applicableRules.Clear();
+                tempRulesBuilder.Clear();
             }
         }
     }
-
-    private void Register(TagHelperDescriptor descriptor)
-    {
-        foreach (var rule in descriptor.TagMatchingRules)
-        {
-            var registrationKey = rule.TagName == TagHelperMatchingConventions.ElementCatchAllName
-                ? TagHelperMatchingConventions.ElementCatchAllName
-                : TagHelperPrefix + rule.TagName;
-
-            // Ensure there's a HashSet to add the descriptor to.
-            if (!_registrations.TryGetValue(registrationKey, out var descriptorSet))
-            {
-                descriptorSet = [];
-                _registrations[registrationKey] = descriptorSet;
-            }
-
-            descriptorSet.Add(descriptor);
-        }
-    }
 }
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/TagHelperBinding.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/TagHelperBinding.cs
index 378586eb70e..efd2091857a 100644
--- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/TagHelperBinding.cs
+++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/TagHelperBinding.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
-using System.Collections.Frozen;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 
@@ -10,55 +9,79 @@ namespace Microsoft.AspNetCore.Razor.Language;
 
 internal sealed class TagHelperBinding
 {
+    public ImmutableArray<TagHelperBoundRulesInfo> AllBoundRules { get; }
+    public string? TagNamePrefix { get; }
     public string TagName { get; }
     public string? ParentTagName { get; }
     public ImmutableArray<KeyValuePair<string, string>> Attributes { get; }
-    public FrozenDictionary<TagHelperDescriptor, ImmutableArray<TagMatchingRuleDescriptor>> Mappings { get; }
-    public string? TagHelperPrefix { get; }
 
-    public ImmutableArray<TagHelperDescriptor> Descriptors => Mappings.Keys;
+    private ImmutableArray<TagHelperDescriptor> _descriptors;
+    private bool? _isAttributeMatch;
 
     internal TagHelperBinding(
+        ImmutableArray<TagHelperBoundRulesInfo> allBoundRules,
         string tagName,
-        ImmutableArray<KeyValuePair<string, string>> attributes,
         string? parentTagName,
-        FrozenDictionary<TagHelperDescriptor, ImmutableArray<TagMatchingRuleDescriptor>> mappings,
-        string? tagHelperPrefix)
+        ImmutableArray<KeyValuePair<string, string>> attributes,
+        string? tagNamePrefix)
     {
+        AllBoundRules = allBoundRules;
         TagName = tagName;
-        Attributes = attributes;
         ParentTagName = parentTagName;
-        Mappings = mappings;
-        TagHelperPrefix = tagHelperPrefix;
+        Attributes = attributes;
+        TagNamePrefix = tagNamePrefix;
     }
 
+    public ImmutableArray<TagHelperDescriptor> Descriptors
+    {
+        get
+        {
+            if (_descriptors.IsDefault)
+            {
+                ImmutableInterlocked.InterlockedInitialize(ref _descriptors, AllBoundRules.SelectAsArray(x => x.Descriptor));
+            }
+
+            return _descriptors;
+        }
+    }
+
+    public ImmutableArray<TagMatchingRuleDescriptor> GetBoundRules(TagHelperDescriptor descriptor)
+        => AllBoundRules.First(descriptor, static (info, d) => info.Descriptor.Equals(d)).Rules;
+
     /// <summary>
-    /// Gets a value that indicates whether the the binding matched on attributes only.
+    ///  Gets a value that indicates whether the the binding matched on attributes only.
     /// </summary>
-    /// <returns><c>false</c> if the entire element should be classified as a tag helper.</returns>
+    /// <returns>
+    ///  Returns <see langword="false"/> if the entire element should be classified as a tag helper.
+    /// </returns>
     /// <remarks>
-    /// If this returns <c>true</c>, use <c>TagHelperFactsService.GetBoundTagHelperAttributes</c> to find the
-    /// set of attributes that should be considered part of the match.
+    ///  If this returns <see langword="true"/>, use <c>TagHelperFactsService.GetBoundTagHelperAttributes</c> to find the
+    ///  set of attributes that should be considered part of the match.
     /// </remarks>
     public bool IsAttributeMatch
     {
         get
         {
-            foreach (var descriptor in Mappings.Keys)
+            return _isAttributeMatch ??= ComputeIsAttributeMatch(Descriptors);
+
+            static bool ComputeIsAttributeMatch(ImmutableArray<TagHelperDescriptor> descriptors)
             {
-                if (!descriptor.Metadata.TryGetValue(TagHelperMetadata.Common.ClassifyAttributesOnly, out var value) ||
-                    !string.Equals(value, bool.TrueString, StringComparison.OrdinalIgnoreCase))
+                foreach (var descriptor in descriptors)
                 {
-                    return false;
+                    if (!descriptor.Metadata.TryGetValue(TagHelperMetadata.Common.ClassifyAttributesOnly, out var value) ||
+                        !string.Equals(value, bool.TrueString, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return false;
+                    }
                 }
-            }
 
-            // All the matching tag helpers want to be classified with **attributes only**.
-            //
-            // Ex: (components)
-            //
-            //      <button onclick="..." />
-            return true;
+                // All the matching tag helpers want to be classified with **attributes only**.
+                //
+                // Ex: (components)
+                //
+                //      <button onclick="..." />
+                return true;
+            }
         }
     }
 }
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/TagHelperBoundRulesInfo.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/TagHelperBoundRulesInfo.cs
new file mode 100644
index 00000000000..67a3a68b57b
--- /dev/null
+++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/TagHelperBoundRulesInfo.cs
@@ -0,0 +1,14 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Immutable;
+
+namespace Microsoft.AspNetCore.Razor.Language;
+
+internal readonly struct TagHelperBoundRulesInfo(
+    TagHelperDescriptor descriptor,
+    ImmutableArray<TagMatchingRuleDescriptor> boundRules)
+{
+    public TagHelperDescriptor Descriptor { get; } = descriptor;
+    public ImmutableArray<TagMatchingRuleDescriptor> Rules { get; } = boundRules;
+}
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/SourceGenerators/SourceGeneratorProjectEngine.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/SourceGenerators/SourceGeneratorProjectEngine.cs
index 26f875f94c3..f9568da54c9 100644
--- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/SourceGenerators/SourceGeneratorProjectEngine.cs
+++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/SourceGenerators/SourceGeneratorProjectEngine.cs
@@ -83,13 +83,13 @@ public SourceGeneratorRazorCodeDocument ProcessTagHelpers(SourceGeneratorRazorCo
             else
             {
                 // tag helpers have changed, figure out if we need to re-write
-                var previousTagHelpersInScope = codeDocument.GetTagHelperContext().TagHelpers;
+                var previousTagHelpersInScope = codeDocument.GetRequiredTagHelperContext().TagHelpers;
                 var previousUsedTagHelpers = codeDocument.GetReferencedTagHelpers();
 
                 // re-run discovery to figure out which tag helpers are now in scope for this document
                 codeDocument.SetTagHelpers(tagHelpers);
                 _discoveryPhase.Execute(codeDocument);
-                var tagHelpersInScope = codeDocument.GetTagHelperContext().TagHelpers;
+                var tagHelpersInScope = codeDocument.GetRequiredTagHelperContext().TagHelpers;
 
                 // Check if any new tag helpers were added or ones we previously used were removed
                 var newVisibleTagHelpers = tagHelpersInScope.Except(previousTagHelpersInScope);
diff --git a/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/IRazorCodeDocument.cs b/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/IRazorCodeDocument.cs
index 32696b40e76..fbafba60b76 100644
--- a/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/IRazorCodeDocument.cs
+++ b/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/IRazorCodeDocument.cs
@@ -13,7 +13,7 @@ internal interface IRazorCodeDocument
 
     ImmutableArray<RazorSourceMapping> GetSourceMappings();
     ImmutableArray<IRazorDiagnostic> GetDiagnostics();
-    IRazorTagHelperDocumentContext GetTagHelperContext();
+    IRazorTagHelperDocumentContext? GetTagHelperContext();
 
     int? GetDesiredIndentation(ITextSnapshot snapshot, ITextSnapshotLine line, int indentSize, int tabSize);
 
diff --git a/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/InternalAPI.Unshipped.txt b/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/InternalAPI.Unshipped.txt
index 2a81278f823..dd121e1b3ad 100644
--- a/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/InternalAPI.Unshipped.txt
+++ b/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/InternalAPI.Unshipped.txt
@@ -1,6 +1,7 @@
 #nullable enable
 Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.ClassifiedSpan.Deconstruct(out Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.RazorSourceSpan Span, out Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.RazorSourceSpan BlockSpan, out Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.SpanKind SpanKind, out Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.BlockKind BlockKind, out Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.AcceptedCharacters AcceptedCharacters) -> void
 Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.ClassifiedSpan.Equals(Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.ClassifiedSpan other) -> bool
+Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.IRazorCodeDocument.GetTagHelperContext() -> Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.IRazorTagHelperDocumentContext?
 Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.IRazorTagHelperDocumentContext.Prefix.get -> string?
 Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.RazorSourceChange.<Clone>$() -> Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.RazorSourceChange!
 Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.RazorSourceChange.Deconstruct(out Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor.RazorSourceSpan Span, out string! NewText) -> void
diff --git a/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/RazorWrapperFactory.CodeDocumentWrapper.cs b/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/RazorWrapperFactory.CodeDocumentWrapper.cs
index d9c65f10f89..f33e926b07d 100644
--- a/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/RazorWrapperFactory.CodeDocumentWrapper.cs
+++ b/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/RazorWrapperFactory.CodeDocumentWrapper.cs
@@ -66,8 +66,10 @@ public ImmutableArray<IRazorDiagnostic> GetDiagnostics()
             return WrapAll(diagnostics, Wrap);
         }
 
-        public IRazorTagHelperDocumentContext GetTagHelperContext()
-            => WrapTagHelperDocumentContext(Object.GetTagHelperContext());
+        public IRazorTagHelperDocumentContext? GetTagHelperContext()
+            => Object.TryGetTagHelperContext(out var tagHelperContext)
+                ? WrapTagHelperDocumentContext(tagHelperContext)
+                : null;
 
         public int? GetDesiredIndentation(ITextSnapshot snapshot, ITextSnapshotLine line, int indentSize, int tabSize)
             => RazorIndentationFacts.GetDesiredIndentation(Object.GetSyntaxTree(), snapshot, line, indentSize, tabSize);
diff --git a/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/RazorWrapperFactory.TagHelperBindingWrapper.cs b/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/RazorWrapperFactory.TagHelperBindingWrapper.cs
index d96f0d34e8e..34aa49599f3 100644
--- a/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/RazorWrapperFactory.TagHelperBindingWrapper.cs
+++ b/src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.LegacyEditor/RazorWrapperFactory.TagHelperBindingWrapper.cs
@@ -17,7 +17,7 @@ public ImmutableArray<IRazorTagHelperDescriptor> Descriptors
 
         public ImmutableArray<IRazorTagMatchingRuleDescriptor> GetBoundRules(IRazorTagHelperDescriptor descriptor)
         {
-            return WrapAll(Object.Mappings[Unwrap(descriptor)], Wrap);
+            return WrapAll(Object.GetBoundRules(Unwrap(descriptor)), Wrap);
         }
     }
 }
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/AutoInsert/AutoClosingTagOnAutoInsertProvider.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/AutoInsert/AutoClosingTagOnAutoInsertProvider.cs
index c532fa188c6..ceb6a357122 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/AutoInsert/AutoClosingTagOnAutoInsertProvider.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/AutoInsert/AutoClosingTagOnAutoInsertProvider.cs
@@ -153,10 +153,9 @@ private static bool TryGetTagHelperAutoClosingBehavior(TagHelperBinding bindingR
     {
         var resolvedTagStructure = TagStructure.Unspecified;
 
-        foreach (var descriptor in bindingResult.Descriptors)
+        foreach (var boundRulesInfo in bindingResult.AllBoundRules)
         {
-            var tagMatchingRules = bindingResult.Mappings[descriptor];
-            foreach (var tagMatchingRule in tagMatchingRules)
+            foreach (var tagMatchingRule in boundRulesInfo.Rules)
             {
                 if (tagMatchingRule.TagStructure == TagStructure.Unspecified)
                 {
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/ComponentAccessibilityCodeActionProvider.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/ComponentAccessibilityCodeActionProvider.cs
index d5d272bbc85..c658a865f60 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/ComponentAccessibilityCodeActionProvider.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/ComponentAccessibilityCodeActionProvider.cs
@@ -133,7 +133,7 @@ private static async Task AddComponentAccessFromTagAsync(RazorCodeActionContext
         var haveAddedNonQualifiedFix = false;
 
         // First see if there are any components that match in name, but not case, without qualification
-        foreach (var t in context.CodeDocument.GetTagHelperContext().TagHelpers)
+        foreach (var t in context.CodeDocument.GetRequiredTagHelperContext().TagHelpers)
         {
             if (t.TagMatchingRules is [{ CaseSensitive: true } rule] &&
                 rule.TagName.Equals(startTag.Name.Content, StringComparison.OrdinalIgnoreCase) &&
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorCodeDocumentExtensions.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorCodeDocumentExtensions.cs
index a563aa045c4..f92bab42017 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorCodeDocumentExtensions.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorCodeDocumentExtensions.cs
@@ -55,9 +55,6 @@ public static RazorSyntaxTree GetRequiredSyntaxTree(this RazorCodeDocument codeD
     public static Syntax.SyntaxNode GetRequiredSyntaxRoot(this RazorCodeDocument codeDocument)
         => codeDocument.GetRequiredSyntaxTree().Root;
 
-    public static TagHelperDocumentContext GetRequiredTagHelperContext(this RazorCodeDocument codeDocument)
-        => codeDocument.GetTagHelperContext().AssumeNotNull();
-
     public static SourceText GetCSharpSourceText(this RazorCodeDocument document)
         => document.GetCSharpDocument().Text;
 
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Hover/HoverFactory.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Hover/HoverFactory.cs
index 7d41224c3c4..e061424d361 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Hover/HoverFactory.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Hover/HoverFactory.cs
@@ -49,7 +49,7 @@ internal static class HoverFactory
             owner = owner.Parent;
         }
 
-        var tagHelperDocumentContext = codeDocument.GetTagHelperContext();
+        var tagHelperContext = codeDocument.GetRequiredTagHelperContext();
 
         if (HtmlFacts.TryGetElementInfo(owner, out var containingTagNameToken, out var attributes, closingForwardSlashOrCloseAngleToken: out _) &&
             containingTagNameToken.Span.IntersectsWith(absoluteIndex))
@@ -73,7 +73,7 @@ internal static class HoverFactory
             var (parentTag, parentIsTagHelper) = TagHelperFacts.GetNearestAncestorTagInfo(ancestors);
             var stringifiedAttributes = TagHelperFacts.StringifyAttributes(attributes);
             var binding = TagHelperFacts.GetTagHelperBinding(
-                tagHelperDocumentContext,
+                tagHelperContext,
                 containingTagNameToken.Content,
                 stringifiedAttributes,
                 parentTag: parentTag,
@@ -111,7 +111,7 @@ internal static class HoverFactory
             var stringifiedAttributes = TagHelperFacts.StringifyAttributes(attributes);
 
             var binding = TagHelperFacts.GetTagHelperBinding(
-                tagHelperDocumentContext,
+                tagHelperContext,
                 containingTagNameToken.Content,
                 stringifiedAttributes,
                 parentTag: parentTag,
@@ -125,7 +125,7 @@ internal static class HoverFactory
 
             Debug.Assert(binding.Descriptors.Any());
             var tagHelperAttributes = TagHelperFacts.GetBoundTagHelperAttributes(
-                tagHelperDocumentContext,
+                tagHelperContext,
                 selectedAttributeName.AssumeNotNull(),
                 binding);
 
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/ProjectSystem/DocumentContext.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/ProjectSystem/DocumentContext.cs
index e5bc8836804..286b4ad9759 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/ProjectSystem/DocumentContext.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/ProjectSystem/DocumentContext.cs
@@ -105,7 +105,7 @@ public ValueTask<TagHelperDocumentContext> GetTagHelperContextAsync(Cancellation
 
         static TagHelperDocumentContext GetTagHelperContextCore(RazorCodeDocument codeDocument)
         {
-            return codeDocument.GetTagHelperContext().AssumeNotNull();
+            return codeDocument.GetRequiredTagHelperContext();
         }
 
         async ValueTask<TagHelperDocumentContext> GetTagHelperContextCoreAsync(CancellationToken cancellationToken)
diff --git a/src/Razor/src/Microsoft.VisualStudio.LegacyEditor.Razor/Completion/RazorDirectiveAttributeCompletionSource.cs b/src/Razor/src/Microsoft.VisualStudio.LegacyEditor.Razor/Completion/RazorDirectiveAttributeCompletionSource.cs
index 1c653b9c4c6..f6b61da1633 100644
--- a/src/Razor/src/Microsoft.VisualStudio.LegacyEditor.Razor/Completion/RazorDirectiveAttributeCompletionSource.cs
+++ b/src/Razor/src/Microsoft.VisualStudio.LegacyEditor.Razor/Completion/RazorDirectiveAttributeCompletionSource.cs
@@ -72,13 +72,13 @@ public async Task<CompletionContext> GetCompletionContextAsync(IAsyncCompletionS
             }
 
             var syntaxTree = codeDocument.GetSyntaxTree();
-            var tagHelperDocumentContext = codeDocument.GetTagHelperContext();
+            var tagHelperContext = codeDocument.GetRequiredTagHelperContext();
             var absoluteIndex = triggerLocation.Position;
             var queryableChange = new SourceChange(absoluteIndex, length: 0, newText: string.Empty);
 #pragma warning disable CS0618 // Type or member is obsolete, will be removed in an upcoming change
             var owner = syntaxTree.Root.LocateOwner(queryableChange);
 #pragma warning restore CS0618 // Type or member is obsolete
-            var razorCompletionContext = new RazorCompletionContext(absoluteIndex, owner, syntaxTree, tagHelperDocumentContext);
+            var razorCompletionContext = new RazorCompletionContext(absoluteIndex, owner, syntaxTree, tagHelperContext);
             var razorCompletionItems = _completionFactsService.GetCompletionItems(razorCompletionContext);
 
             if (razorCompletionItems.Length == 0)
diff --git a/src/Razor/src/Microsoft.VisualStudio.LegacyEditor.Razor/Completion/RazorDirectiveCompletionSource.cs b/src/Razor/src/Microsoft.VisualStudio.LegacyEditor.Razor/Completion/RazorDirectiveCompletionSource.cs
index 3d09a12a764..8bcea2b97e7 100644
--- a/src/Razor/src/Microsoft.VisualStudio.LegacyEditor.Razor/Completion/RazorDirectiveCompletionSource.cs
+++ b/src/Razor/src/Microsoft.VisualStudio.LegacyEditor.Razor/Completion/RazorDirectiveCompletionSource.cs
@@ -74,13 +74,13 @@ public async Task<CompletionContext> GetCompletionContextAsync(
 
             var location = new SourceSpan(triggerLocation.Position, 0);
             var syntaxTree = codeDocument.GetSyntaxTree();
-            var tagHelperDocumentContext = codeDocument.GetTagHelperContext();
+            var tagHelperContext = codeDocument.GetRequiredTagHelperContext();
             var absoluteIndex = triggerLocation.Position;
             var queryableChange = new SourceChange(absoluteIndex, length: 0, newText: string.Empty);
 #pragma warning disable CS0618 // Type or member is obsolete, will be removed in an upcoming change
             var owner = syntaxTree.Root.LocateOwner(queryableChange);
 #pragma warning restore CS0618 // Type or member is obsolete
-            var razorCompletionContext = new RazorCompletionContext(absoluteIndex, owner, syntaxTree, tagHelperDocumentContext);
+            var razorCompletionContext = new RazorCompletionContext(absoluteIndex, owner, syntaxTree, tagHelperContext);
             var razorCompletionItems = _completionFactsService.GetCompletionItems(razorCompletionContext);
 
             using var _ = ArrayBuilderPool<CompletionItem>.GetPooledObject(out var completionItems);
diff --git a/src/Razor/src/Microsoft.VisualStudio.LegacyEditor.Razor/Parsing/VisualStudioRazorParser.cs b/src/Razor/src/Microsoft.VisualStudio.LegacyEditor.Razor/Parsing/VisualStudioRazorParser.cs
index cbe2bf5b7f9..da87ba756d1 100644
--- a/src/Razor/src/Microsoft.VisualStudio.LegacyEditor.Razor/Parsing/VisualStudioRazorParser.cs
+++ b/src/Razor/src/Microsoft.VisualStudio.LegacyEditor.Razor/Parsing/VisualStudioRazorParser.cs
@@ -340,6 +340,11 @@ private void TextBuffer_OnChanged(object sender, TextContentChangedEventArgs arg
                 codeDocument.Items[item.Key] = item.Value;
             }
 
+            if (currentCodeDocument.TryGetTagHelperContext(out var tagHelperContext))
+            {
+                codeDocument.SetTagHelperContext(tagHelperContext);
+            }
+
             codeDocument.SetSyntaxTree(partialParseSyntaxTree);
             TryUpdateLatestParsedSyntaxTreeSnapshot(codeDocument, snapshot);
         }
diff --git a/src/Razor/src/Microsoft.VisualStudio.RazorExtension/SyntaxVisualizer/SyntaxVisualizerControl.xaml.cs b/src/Razor/src/Microsoft.VisualStudio.RazorExtension/SyntaxVisualizer/SyntaxVisualizerControl.xaml.cs
index f71ea15dca7..9e965720242 100644
--- a/src/Razor/src/Microsoft.VisualStudio.RazorExtension/SyntaxVisualizer/SyntaxVisualizerControl.xaml.cs
+++ b/src/Razor/src/Microsoft.VisualStudio.RazorExtension/SyntaxVisualizer/SyntaxVisualizerControl.xaml.cs
@@ -8,6 +8,7 @@
 using System.Threading;
 using System.Windows;
 using System.Windows.Controls;
+using Microsoft.AspNetCore.Razor;
 using Microsoft.AspNetCore.Razor.Language;
 using Microsoft.AspNetCore.Razor.Serialization.Json;
 using Microsoft.CodeAnalysis.Razor.Formatting.New;
@@ -187,11 +188,11 @@ public void ShowSerializedTagHelpers(TagHelperDisplayMode displayKind)
     {
         ThreadHelper.ThrowIfNotOnUIThread();
 
-        var codeDocument = GetCodeDocument();
+        var codeDocument = GetCodeDocument().AssumeNotNull();
         var tagHelpers = displayKind switch
         {
             TagHelperDisplayMode.All => codeDocument.GetTagHelpers(),
-            TagHelperDisplayMode.InScope => codeDocument.GetTagHelperContext().TagHelpers,
+            TagHelperDisplayMode.InScope => codeDocument.GetRequiredTagHelperContext().TagHelpers,
             TagHelperDisplayMode.Referenced => (IEnumerable<TagHelperDescriptor>)codeDocument.GetReferencedTagHelpers(),
             _ => []
         };
diff --git a/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Completion/TagHelperCompletionProviderTest.cs b/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Completion/TagHelperCompletionProviderTest.cs
index 75f73f6d764..d329b2471e6 100644
--- a/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Completion/TagHelperCompletionProviderTest.cs
+++ b/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Completion/TagHelperCompletionProviderTest.cs
@@ -5,8 +5,6 @@
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Threading;
-using System.Threading.Tasks;
 using Microsoft.AspNetCore.Razor.Language;
 using Microsoft.AspNetCore.Razor.Language.Syntax;
 using Microsoft.AspNetCore.Razor.Test.Common;
@@ -941,10 +939,10 @@ private static RazorCompletionContext CreateRazorCompletionContext(string markup
         TestFileMarkupParser.GetPosition(markup, out var documentContent, out var position);
         var codeDocument = CreateCodeDocument(documentContent, isRazorFile, tagHelpers);
         var syntaxTree = codeDocument.GetSyntaxTree();
-        var tagHelperDocumentContext = codeDocument.GetTagHelperContext();
+        var context = codeDocument.GetRequiredTagHelperContext();
 
         var owner = syntaxTree.Root.FindInnermostNode(position, includeWhitespace: true, walkMarkersBack: true);
         owner = AbstractRazorCompletionFactsService.AdjustSyntaxNodeForWordBoundary(owner, position);
-        return new RazorCompletionContext(position, owner, syntaxTree, tagHelperDocumentContext, Options: options);
+        return new RazorCompletionContext(position, owner, syntaxTree, context, Options: options);
     }
 }
diff --git a/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/CodeDirectiveFormattingTest.cs b/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/CodeDirectiveFormattingTest.cs
index a98b870009f..d434b1c86aa 100644
--- a/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/CodeDirectiveFormattingTest.cs
+++ b/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/CodeDirectiveFormattingTest.cs
@@ -182,7 +182,7 @@ @attribute [CascadingTypeParameter(nameof(TItem))]
 
         var generated = CompileToCSharp("TestGeneric.razor", input, throwOnFailure: true, fileKind: FileKinds.Component);
 
-        return generated.CodeDocument.GetTagHelperContext().TagHelpers.ToImmutableArray();
+        return generated.CodeDocument.GetRequiredTagHelperContext().TagHelpers;
     }
 
     private ImmutableArray<TagHelperDescriptor> GetComponentWithTwoCascadingTypeParameter()
@@ -207,6 +207,6 @@ @attribute [CascadingTypeParameter(nameof(TItemTwo))]
 
         var generated = CompileToCSharp("TestGenericTwo.razor", input, throwOnFailure: true, fileKind: FileKinds.Component);
 
-        return generated.CodeDocument.GetTagHelperContext().TagHelpers.ToImmutableArray();
+        return generated.CodeDocument.GetRequiredTagHelperContext().TagHelpers;
     }
 }
diff --git a/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/HtmlFormattingTest.cs b/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/HtmlFormattingTest.cs
index 2350d27926b..c5f48891d72 100644
--- a/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/HtmlFormattingTest.cs
+++ b/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/HtmlFormattingTest.cs
@@ -435,8 +435,8 @@ @typeparam TValue
             var selectItemComponent = CompileToCSharp("SelectItem.razor", selectItem, throwOnFailure: true, fileKind: FileKinds.Component);
 
             using var _ = ArrayBuilderPool<TagHelperDescriptor>.GetPooledObject(out var tagHelpers);
-            tagHelpers.AddRange(selectComponent.CodeDocument.GetTagHelperContext().TagHelpers);
-            tagHelpers.AddRange(selectItemComponent.CodeDocument.GetTagHelperContext().TagHelpers);
+            tagHelpers.AddRange(selectComponent.CodeDocument.GetRequiredTagHelperContext().TagHelpers);
+            tagHelpers.AddRange(selectItemComponent.CodeDocument.GetRequiredTagHelperContext().TagHelpers);
 
             return tagHelpers.ToImmutable();
         }
@@ -540,6 +540,6 @@ public class Component1 : ComponentBase
 
         var generated = CompileToCSharp("Test.razor", string.Empty, throwOnFailure: false, fileKind: FileKinds.Component);
 
-        return generated.CodeDocument.GetTagHelperContext().TagHelpers.ToImmutableArray();
+        return generated.CodeDocument.GetRequiredTagHelperContext().TagHelpers;
     }
 }
diff --git a/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/Completion/DirectiveAttributeCompletionItemProviderTest.cs b/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/Completion/DirectiveAttributeCompletionItemProviderTest.cs
index 7b8aac24b61..66bbe471017 100644
--- a/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/Completion/DirectiveAttributeCompletionItemProviderTest.cs
+++ b/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/Completion/DirectiveAttributeCompletionItemProviderTest.cs
@@ -16,7 +16,7 @@ namespace Microsoft.CodeAnalysis.Razor.Completion;
 public class DirectiveAttributeCompletionItemProviderTest : RazorToolingIntegrationTestBase
 {
     private readonly DirectiveAttributeCompletionItemProvider _provider;
-    private readonly TagHelperDocumentContext _defaultTagHelperDocumentContext;
+    private readonly TagHelperDocumentContext _defaultTagHelperContext;
 
     internal override string FileKind => FileKinds.Component;
     internal override bool UseTwoPhaseCompilation => true;
@@ -32,7 +32,7 @@ public DirectiveAttributeCompletionItemProviderTest(ITestOutputHelper testOutput
             "@using Microsoft.AspNetCore.Components.Web"));
 
         var codeDocument = GetCodeDocument(string.Empty);
-        _defaultTagHelperDocumentContext = codeDocument.GetTagHelperContext();
+        _defaultTagHelperContext = codeDocument.GetRequiredTagHelperContext();
     }
 
     private RazorCodeDocument GetCodeDocument(string content)
@@ -194,7 +194,7 @@ public void GetAttributeCompletions_SelectedDirectiveAttribute_IsIncludedInCompl
         var attributeNames = ImmutableArray.Create("@bind");
 
         // Act
-        var completions = DirectiveAttributeCompletionItemProvider.GetAttributeCompletions("@bind", "input", attributeNames, _defaultTagHelperDocumentContext);
+        var completions = DirectiveAttributeCompletionItemProvider.GetAttributeCompletions("@bind", "input", attributeNames, _defaultTagHelperContext);
 
         // Assert
         AssertContains(completions, "bind", "@bind", ["=", ":"]);
@@ -206,7 +206,7 @@ public void GetAttributeCompletions_NonIndexer_ReturnsCompletion()
         // Arrange
 
         // Act
-        var completions = DirectiveAttributeCompletionItemProvider.GetAttributeCompletions("@", "input", [], _defaultTagHelperDocumentContext);
+        var completions = DirectiveAttributeCompletionItemProvider.GetAttributeCompletions("@", "input", [], _defaultTagHelperContext);
 
         // Assert
         AssertContains(completions, "bind", "@bind", ["=", ":"]);
@@ -218,7 +218,7 @@ public void GetAttributeCompletions_Indexer_ReturnsCompletion()
         // Arrange
 
         // Act
-        var completions = DirectiveAttributeCompletionItemProvider.GetAttributeCompletions("@", "input", [], _defaultTagHelperDocumentContext);
+        var completions = DirectiveAttributeCompletionItemProvider.GetAttributeCompletions("@", "input", [], _defaultTagHelperContext);
 
         // Assert
         AssertContains(completions, "bind-", "@bind-...", []);
@@ -231,7 +231,7 @@ public void GetAttributeCompletions_BaseDirectiveAttributeAlreadyExists_Includes
         var attributeNames = ImmutableArray.Create("@bind", "@");
 
         // Act
-        var completions = DirectiveAttributeCompletionItemProvider.GetAttributeCompletions("@", "input", attributeNames, _defaultTagHelperDocumentContext);
+        var completions = DirectiveAttributeCompletionItemProvider.GetAttributeCompletions("@", "input", attributeNames, _defaultTagHelperContext);
 
         // Assert
         AssertContains(completions, "bind", "@bind", ["=", ":"]);
@@ -252,7 +252,7 @@ public void GetAttributeCompletions_BaseDirectiveAttributeAndParameterVariations
             "@");
 
         // Act
-        var completions = DirectiveAttributeCompletionItemProvider.GetAttributeCompletions("@", "input", attributeNames, _defaultTagHelperDocumentContext);
+        var completions = DirectiveAttributeCompletionItemProvider.GetAttributeCompletions("@", "input", attributeNames, _defaultTagHelperContext);
 
         // Assert
         AssertDoesNotContain(completions, "bind", "@bind");
@@ -282,11 +282,11 @@ private RazorCompletionContext CreateRazorCompletionContext(int absoluteIndex, s
     {
         var codeDocument = GetCodeDocument(documentContent);
         var syntaxTree = codeDocument.GetSyntaxTree();
-        var tagHelperDocumentContext = codeDocument.GetTagHelperContext();
+        var tagHelperContext = codeDocument.GetRequiredTagHelperContext();
 
         var owner = syntaxTree.Root.FindInnermostNode(absoluteIndex, includeWhitespace: true, walkMarkersBack: true);
         owner = AbstractRazorCompletionFactsService.AdjustSyntaxNodeForWordBoundary(owner, absoluteIndex);
 
-        return new RazorCompletionContext(absoluteIndex, owner, syntaxTree, tagHelperDocumentContext);
+        return new RazorCompletionContext(absoluteIndex, owner, syntaxTree, tagHelperContext);
     }
 }
diff --git a/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/Completion/DirectiveAttributeParameterCompletionItemProviderTest.cs b/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/Completion/DirectiveAttributeParameterCompletionItemProviderTest.cs
index 61a1d95d575..2984d2372b4 100644
--- a/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/Completion/DirectiveAttributeParameterCompletionItemProviderTest.cs
+++ b/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/Completion/DirectiveAttributeParameterCompletionItemProviderTest.cs
@@ -14,7 +14,7 @@ namespace Microsoft.CodeAnalysis.Razor.Completion;
 public class DirectiveAttributeParameterCompletionItemProviderTest : RazorToolingIntegrationTestBase
 {
     private readonly DirectiveAttributeParameterCompletionItemProvider _provider;
-    private readonly TagHelperDocumentContext _defaultTagHelperDocumentContext;
+    private readonly TagHelperDocumentContext _defaultTagHelperContext;
 
     internal override string FileKind => FileKinds.Component;
     internal override bool UseTwoPhaseCompilation => true;
@@ -30,7 +30,7 @@ public DirectiveAttributeParameterCompletionItemProviderTest(ITestOutputHelper t
             "@using Microsoft.AspNetCore.Components.Web"));
 
         var codeDocument = GetCodeDocument(string.Empty);
-        _defaultTagHelperDocumentContext = codeDocument.GetTagHelperContext();
+        _defaultTagHelperContext = codeDocument.GetRequiredTagHelperContext();
     }
 
     private RazorCodeDocument GetCodeDocument(string content)
@@ -120,7 +120,7 @@ public void GetAttributeParameterCompletions_SelectedDirectiveAttributeParameter
         var attributeNames = ImmutableArray.Create("@bind");
 
         // Act
-        var completions = DirectiveAttributeParameterCompletionItemProvider.GetAttributeParameterCompletions("@bind", "format", "input", attributeNames, _defaultTagHelperDocumentContext);
+        var completions = DirectiveAttributeParameterCompletionItemProvider.GetAttributeParameterCompletions("@bind", "format", "input", attributeNames, _defaultTagHelperContext);
 
         // Assert
         AssertDoesNotContain(completions, "format");
@@ -132,7 +132,7 @@ public void GetAttributeParameterCompletions_ReturnsCompletion()
         // Arrange
 
         // Act
-        var completions = DirectiveAttributeParameterCompletionItemProvider.GetAttributeParameterCompletions("@bind", string.Empty, "input", [], _defaultTagHelperDocumentContext);
+        var completions = DirectiveAttributeParameterCompletionItemProvider.GetAttributeParameterCompletions("@bind", string.Empty, "input", [], _defaultTagHelperContext);
 
         // Assert
         AssertContains(completions, "format");
@@ -149,7 +149,7 @@ public void GetAttributeParameterCompletions_BaseDirectiveAttributeAndParameterV
             "@");
 
         // Act
-        var completions = DirectiveAttributeParameterCompletionItemProvider.GetAttributeParameterCompletions("@bind", string.Empty, "input", attributeNames, _defaultTagHelperDocumentContext);
+        var completions = DirectiveAttributeParameterCompletionItemProvider.GetAttributeParameterCompletions("@bind", string.Empty, "input", attributeNames, _defaultTagHelperContext);
 
         // Assert
         AssertDoesNotContain(completions, "format");
@@ -174,10 +174,10 @@ private RazorCompletionContext CreateRazorCompletionContext(int absoluteIndex, s
     {
         var codeDocument = GetCodeDocument(documentContent);
         var syntaxTree = codeDocument.GetSyntaxTree();
-        var tagHelperDocumentContext = codeDocument.GetTagHelperContext();
+        var tagHelperContext = codeDocument.GetRequiredTagHelperContext();
 
         var owner = syntaxTree.Root.FindInnermostNode(absoluteIndex);
         owner = AbstractRazorCompletionFactsService.AdjustSyntaxNodeForWordBoundary(owner, absoluteIndex);
-        return new RazorCompletionContext(absoluteIndex, owner, syntaxTree, tagHelperDocumentContext);
+        return new RazorCompletionContext(absoluteIndex, owner, syntaxTree, tagHelperContext);
     }
 }
diff --git a/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/Completion/RazorCompletionListProviderTest.cs b/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/Completion/RazorCompletionListProviderTest.cs
index 3beaadff6db..e703c60dce1 100644
--- a/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/Completion/RazorCompletionListProviderTest.cs
+++ b/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/Completion/RazorCompletionListProviderTest.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Text.Json;
 using Microsoft.AspNetCore.Razor.Language;
@@ -436,9 +437,7 @@ public void GetCompletionList_ProvidesInjectOnIncomplete_KeywordIn()
         builder.TagMatchingRule(rule => rule.TagName = "Test");
         builder.Metadata(TypeName("TestNamespace.TestTagHelper"));
         var tagHelper = builder.Build();
-        var tagHelperContext = TagHelperDocumentContext.Create(prefix: string.Empty, [tagHelper]);
-        var codeDocument = CreateCodeDocument("@in", documentPath);
-        codeDocument.SetTagHelperContext(tagHelperContext);
+        var codeDocument = CreateCodeDocument("@in", documentPath, [tagHelper]);
         var provider = new RazorCompletionListProvider(_completionFactsService, _completionListCache, LoggerFactory);
         var completionContext = new VSInternalCompletionContext()
         {
@@ -466,9 +465,7 @@ public void GetCompletionList_DoesNotProvideInjectOnInvoked()
         builder.TagMatchingRule(rule => rule.TagName = "Test");
         builder.Metadata(TypeName("TestNamespace.TestTagHelper"));
         var tagHelper = builder.Build();
-        var tagHelperContext = TagHelperDocumentContext.Create(prefix: string.Empty, [tagHelper]);
-        var codeDocument = CreateCodeDocument("@inje", documentPath);
-        codeDocument.SetTagHelperContext(tagHelperContext);
+        var codeDocument = CreateCodeDocument("@inje", documentPath, [tagHelper]);
         var provider = new RazorCompletionListProvider(_completionFactsService, _completionListCache, LoggerFactory);
         var completionContext = new VSInternalCompletionContext()
         {
@@ -494,9 +491,7 @@ public void GetCompletionList_ProvidesInjectOnIncomplete()
         builder.TagMatchingRule(rule => rule.TagName = "Test");
         builder.Metadata(TypeName("TestNamespace.TestTagHelper"));
         var tagHelper = builder.Build();
-        var tagHelperContext = TagHelperDocumentContext.Create(prefix: string.Empty, [tagHelper]);
-        var codeDocument = CreateCodeDocument("@inje", documentPath);
-        codeDocument.SetTagHelperContext(tagHelperContext);
+        var codeDocument = CreateCodeDocument("@inje", documentPath, [tagHelper]);
         var provider = new RazorCompletionListProvider(_completionFactsService, _completionListCache, LoggerFactory);
         var completionContext = new VSInternalCompletionContext()
         {
@@ -525,9 +520,7 @@ public void GetCompletionList_ProvidesTagHelperElementCompletionItems()
         builder.TagMatchingRule(rule => rule.TagName = "Test");
         builder.Metadata(TypeName("TestNamespace.TestTagHelper"));
         var tagHelper = builder.Build();
-        var tagHelperContext = TagHelperDocumentContext.Create(prefix: string.Empty, [tagHelper]);
-        var codeDocument = CreateCodeDocument("<", documentPath);
-        codeDocument.SetTagHelperContext(tagHelperContext);
+        var codeDocument = CreateCodeDocument("<", documentPath, [tagHelper]);
         var provider = new RazorCompletionListProvider(_completionFactsService, _completionListCache, LoggerFactory);
 
         // Act
@@ -555,9 +548,7 @@ public void GetCompletionList_ProvidesTagHelperAttributeItems()
         });
         builder.Metadata(TypeName("TestNamespace.TestTagHelper"));
         var tagHelper = builder.Build();
-        var tagHelperContext = TagHelperDocumentContext.Create(prefix: string.Empty, [tagHelper]);
-        var codeDocument = CreateCodeDocument("<test  ", documentPath);
-        codeDocument.SetTagHelperContext(tagHelperContext);
+        var codeDocument = CreateCodeDocument("<test  ", documentPath, [tagHelper]);
         var provider = new RazorCompletionListProvider(_completionFactsService, _completionListCache, LoggerFactory);
 
         // Act
@@ -584,9 +575,7 @@ public void GetCompletionList_ProvidesTagHelperAttributeItems_AttributeQuotesOff
         });
         builder.SetMetadata(TypeName("TestNamespace.TestTagHelper"));
         var tagHelper = builder.Build();
-        var tagHelperContext = TagHelperDocumentContext.Create(prefix: string.Empty, [tagHelper]);
-        var codeDocument = CreateCodeDocument("<test  ", documentPath);
-        codeDocument.SetTagHelperContext(tagHelperContext);
+        var codeDocument = CreateCodeDocument("<test  ", documentPath, [tagHelper]);
 
         // Set up desired options
         var razorCompletionOptions = new RazorCompletionOptions(SnippetsSupported: true, AutoInsertAttributeQuotes: false, CommitElementsWithSpace: true);
@@ -603,13 +592,13 @@ public void GetCompletionList_ProvidesTagHelperAttributeItems_AttributeQuotesOff
         Assert.Contains(completionList.Items, item => item.InsertText == "testAttribute=$0");
     }
 
-    private static RazorCodeDocument CreateCodeDocument(string text, string documentFilePath)
+    private static RazorCodeDocument CreateCodeDocument(string text, string documentFilePath, ImmutableArray<TagHelperDescriptor> tagHelpers = default)
     {
         var codeDocument = TestRazorCodeDocument.CreateEmpty();
         var sourceDocument = TestRazorSourceDocument.Create(text, filePath: documentFilePath);
         var syntaxTree = RazorSyntaxTree.Parse(sourceDocument);
         codeDocument.SetSyntaxTree(syntaxTree);
-        var tagHelperDocumentContext = TagHelperDocumentContext.Create(prefix: string.Empty, tagHelpers: []);
+        var tagHelperDocumentContext = TagHelperDocumentContext.Create(prefix: null, tagHelpers.NullToEmpty());
         codeDocument.SetTagHelperContext(tagHelperDocumentContext);
         return codeDocument;
     }
diff --git a/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/TagHelperFactsTest.cs b/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/TagHelperFactsTest.cs
index a1b00abdcbc..5f9a5ab4151 100644
--- a/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/TagHelperFactsTest.cs
+++ b/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/TagHelperFactsTest.cs
@@ -77,7 +77,7 @@ public void GetTagHelperBinding_WorksAsExpected()
         // Assert
         var descriptor = Assert.Single(binding.Descriptors);
         Assert.Equal(documentDescriptors[0], descriptor);
-        var boundRule = Assert.Single(binding.Mappings[descriptor]);
+        var boundRule = Assert.Single(binding.GetBoundRules(descriptor));
         Assert.Equal(documentDescriptors[0].TagMatchingRules.First(), boundRule);
     }