Unify outliner base classes

src/EditorFeatures/CSharp/CSharpEditorFeatures.csproj

@@ -152,7 +152,6 @@
     <Compile Include="NavigationBar\CSharpNavigationBarItemService.cs" />
     <Compile Include="Outlining\CSharpOutliningHelpers.cs" />
     <Compile Include="Outlining\CSharpOutliningService.cs" />
-    <Compile Include="Outlining\Outliners\AbstractSyntaxNodeOutliner.cs" />
     <Compile Include="Outlining\Outliners\AccessorDeclarationOutliner.cs" />
     <Compile Include="Outlining\Outliners\AnonymousMethodExpressionOutliner.cs" />
     <Compile Include="Outlining\Outliners\CompilationUnitOutliner.cs" />
@@ -262,4 +261,4 @@
   <ImportGroup Label="Targets">
     <Import Project="..\..\..\build\Targets\VSL.Imports.targets" />
   </ImportGroup>
-</Project>
+</Project>
\ No newline at end of file

src/EditorFeatures/CSharp/Outlining/CSharpOutliningService.cs

@@ -6,7 +6,6 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
-using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Roslyn.Utilities;
 
@@ -15,12 +14,12 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.Outlining
     [ExportLanguageService(typeof(IOutliningService), LanguageNames.CSharp), Shared]
     internal class CSharpOutliningService : AbstractOutliningService
     {
-        private static readonly ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxNodeOutliner>> s_defaultNodeOutlinerMap = CreateDefaultNodeOutlinerMap();
-        private static readonly ImmutableDictionary<int, ImmutableArray<AbstractSyntaxTriviaOutliner>> s_defaultTriviaOutlinerMap = CreateDefaultTriviaOutlinerMap();
+        private static readonly ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxOutliner>> s_defaultNodeOutlinerMap = CreateDefaultNodeOutlinerMap();
+        private static readonly ImmutableDictionary<int, ImmutableArray<AbstractSyntaxOutliner>> s_defaultTriviaOutlinerMap = CreateDefaultTriviaOutlinerMap();
 
-        private static ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxNodeOutliner>> CreateDefaultNodeOutlinerMap()
+        private static ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxOutliner>> CreateDefaultNodeOutlinerMap()
         {
-            var builder = ImmutableDictionary.CreateBuilder<Type, ImmutableArray<AbstractSyntaxNodeOutliner>>();
+            var builder = ImmutableDictionary.CreateBuilder<Type, ImmutableArray<AbstractSyntaxOutliner>>();
 
             builder.Add<AccessorDeclarationSyntax, AccessorDeclarationOutliner>();
             builder.Add<AnonymousMethodExpressionSyntax, AnonymousMethodExpressionOutliner>();
@@ -49,11 +48,11 @@ internal class CSharpOutliningService : AbstractOutliningService
             return builder.ToImmutable();
         }
 
-        private static ImmutableDictionary<int, ImmutableArray<AbstractSyntaxTriviaOutliner>> CreateDefaultTriviaOutlinerMap()
+        private static ImmutableDictionary<int, ImmutableArray<AbstractSyntaxOutliner>> CreateDefaultTriviaOutlinerMap()
         {
-            var builder = ImmutableDictionary.CreateBuilder<int, ImmutableArray<AbstractSyntaxTriviaOutliner>>();
+            var builder = ImmutableDictionary.CreateBuilder<int, ImmutableArray<AbstractSyntaxOutliner>>();
 
-            builder.Add((int)SyntaxKind.DisabledTextTrivia, ImmutableArray.Create<AbstractSyntaxTriviaOutliner>(new DisabledTextTriviaOutliner()));
+            builder.Add((int)SyntaxKind.DisabledTextTrivia, ImmutableArray.Create<AbstractSyntaxOutliner>(new DisabledTextTriviaOutliner()));
 
             return builder.ToImmutable();
         }

src/EditorFeatures/CSharp/Outlining/Outliners/AbstractSyntaxNodeOutliner.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Generic;
-using System.Threading;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis.Editor.CSharp.Outlining
-{
-    internal abstract class AbstractSyntaxNodeOutliner<TSyntaxNode> : AbstractSyntaxNodeOutliner
-        where TSyntaxNode : SyntaxNode
-    {
-        public override void CollectOutliningSpans(
-            Document document,
-            SyntaxNode node,
-            List<OutliningSpan> spans,
-            CancellationToken cancellationToken)
-        {
-            if (!SupportedInWorkspaceKind(document.Project.Solution.Workspace.Kind))
-            {
-                return;
-            }
-
-            CollectOutliningSpans(node, spans, cancellationToken);
-        }
-
-        internal void CollectOutliningSpans(SyntaxNode node, List<OutliningSpan> spans, CancellationToken cancellationToken)
-        {
-            if (node is TSyntaxNode)
-            {
-                CollectOutliningSpans((TSyntaxNode)node, spans, cancellationToken);
-            }
-        }
-
-        // For testing purposes
-        internal IEnumerable<OutliningSpan> GetOutliningSpans(SyntaxNode node, CancellationToken cancellationToken)
-        {
-            var spans = new List<OutliningSpan>();
-            this.CollectOutliningSpans(node, spans, cancellationToken);
-            return spans;
-        }
-
-        protected virtual bool SupportedInWorkspaceKind(string kind)
-        {
-            // We have other outliners specific to Metadata-as-Source.
-            return kind != WorkspaceKind.MetadataAsSource;
-        }
-
-        protected abstract void CollectOutliningSpans(TSyntaxNode node, List<OutliningSpan> spans, CancellationToken cancellationToken);
-    }
-}

src/EditorFeatures/Core/EditorFeatures.csproj

@@ -283,6 +283,7 @@
     <Compile Include="Implementation\GoToImplementation\AbstractGoToImplementationService.cs" />
     <Compile Include="Implementation\GoToImplementation\IGoToImplementationService.cs" />
     <Compile Include="Implementation\Intellisense\Completion\OptionSetExtensions.cs" />
+    <Compile Include="Implementation\Outlining\AbstractSyntaxOutliner.cs" />
     <Compile Include="Implementation\Outlining\InvalidOutliningRegionException.cs" />
     <Compile Include="Implementation\Suggestions\FixMultipleOccurrencesService.cs" />
     <Compile Include="Implementation\Suggestions\FixMultipleSuggestedAction.cs" />
@@ -817,4 +818,4 @@
   <ImportGroup Label="Targets">
     <Import Project="..\..\..\build\Targets\VSL.Imports.targets" />
   </ImportGroup>
-</Project>
+</Project>
\ No newline at end of file

src/EditorFeatures/Core/Implementation/Outlining/AbstractOutliningService.cs

@@ -12,12 +12,12 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.Outlining
 {
     internal abstract class AbstractOutliningService : IOutliningService
     {
-        private readonly ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxNodeOutliner>> _nodeOutlinerMap;
-        private readonly ImmutableDictionary<int, ImmutableArray<AbstractSyntaxTriviaOutliner>> _triviaOutlinerMap;
+        private readonly ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxOutliner>> _nodeOutlinerMap;
+        private readonly ImmutableDictionary<int, ImmutableArray<AbstractSyntaxOutliner>> _triviaOutlinerMap;
 
         protected AbstractOutliningService(
-            ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxNodeOutliner>> defaultNodeOutlinerMap,
-            ImmutableDictionary<int, ImmutableArray<AbstractSyntaxTriviaOutliner>> defaultTriviaOutlinerMap)
+            ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxOutliner>> defaultNodeOutlinerMap,
+            ImmutableDictionary<int, ImmutableArray<AbstractSyntaxOutliner>> defaultTriviaOutlinerMap)
         {
             _nodeOutlinerMap = defaultNodeOutlinerMap;
             _triviaOutlinerMap = defaultTriviaOutlinerMap;

src/EditorFeatures/Core/Implementation/Outlining/AbstractSyntaxNodeOutliner.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Threading;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.Outlining
 {
-    internal abstract class AbstractSyntaxNodeOutliner
+    internal abstract class AbstractSyntaxNodeOutliner<TSyntaxNode> : AbstractSyntaxOutliner
+        where TSyntaxNode : SyntaxNode
     {
-        public abstract void CollectOutliningSpans(Document document, SyntaxNode node, List<OutliningSpan> spans, CancellationToken cancellationToken);
+        public override void CollectOutliningSpans(
+            Document document,
+            SyntaxNode node,
+            List<OutliningSpan> spans,
+            CancellationToken cancellationToken)
+        {
+            if (!SupportedInWorkspaceKind(document.Project.Solution.Workspace.Kind))
+            {
+                return;
+            }
+
+            CollectOutliningSpans(node, spans, cancellationToken);
+        }
 
-        // For testing purposes.
-        internal IEnumerable<OutliningSpan> GetOutliningSpans(Document document, SyntaxNode node, CancellationToken cancellationToken)
+        public sealed override void CollectOutliningSpans(
+            Document document,
+            SyntaxTrivia trivia,
+            List<OutliningSpan> spans,
+            CancellationToken cancellationToken)
+        {
+            throw new NotSupportedException();
+        }
+
+        private void CollectOutliningSpans(SyntaxNode node, List<OutliningSpan> spans, CancellationToken cancellationToken)
+        {
+            if (node is TSyntaxNode)
+            {
+                CollectOutliningSpans((TSyntaxNode)node, spans, cancellationToken);
+            }
+        }
+
+        // For testing purposes
+        internal IEnumerable<OutliningSpan> GetOutliningSpans(SyntaxNode node, CancellationToken cancellationToken)
         {
             var spans = new List<OutliningSpan>();
-            this.CollectOutliningSpans(document, node, spans, cancellationToken);
+            this.CollectOutliningSpans(node, spans, cancellationToken);
             return spans;
         }
+
+        protected virtual bool SupportedInWorkspaceKind(string kind)
+        {
+            // We have other outliners specific to Metadata-as-Source.
+            return kind != WorkspaceKind.MetadataAsSource;
+        }
+
+        protected abstract void CollectOutliningSpans(TSyntaxNode node, List<OutliningSpan> spans, CancellationToken cancellationToken);
     }
 }

src/EditorFeatures/Core/Implementation/Outlining/AbstractSyntaxOutliner.cs

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.Outlining
+{
+    internal abstract class AbstractSyntaxOutliner
+    {
+        public abstract void CollectOutliningSpans(
+            Document document,
+            SyntaxNode node,
+            List<OutliningSpan> spans,
+            CancellationToken cancellationToken);
+
+        public abstract void CollectOutliningSpans(
+            Document document,
+            SyntaxTrivia trivia,
+            List<OutliningSpan> spans,
+            CancellationToken cancellationToken);
+    }
+}

src/EditorFeatures/Core/Implementation/Outlining/AbstractSyntaxTriviaOutliner.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Threading;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.Outlining
 {
-    internal abstract class AbstractSyntaxTriviaOutliner
+    internal abstract class AbstractSyntaxTriviaOutliner : AbstractSyntaxOutliner
     {
-        public abstract void CollectOutliningSpans(Document document, SyntaxTrivia trivia, List<OutliningSpan> spans, CancellationToken cancellationToken);
+        public sealed override void CollectOutliningSpans(
+            Document document,
+            SyntaxNode node,
+            List<OutliningSpan> spans,
+            CancellationToken cancellationToken)
+        {
+            throw new NotSupportedException();
+        }
 
         // For testing purposes.
         internal IEnumerable<OutliningSpan> GetOutliningSpans(Document document, SyntaxTrivia trivia, CancellationToken cancellationToken)

src/EditorFeatures/Core/Implementation/Outlining/OutliningExtensions.cs

@@ -8,20 +8,20 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.Outlining
     internal static class OutliningExtensions
     {
         public static void Add<TType, TOutliner>(
-            this ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxNodeOutliner>>.Builder builder)
+            this ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxOutliner>>.Builder builder)
             where TType : SyntaxNode
-            where TOutliner : AbstractSyntaxNodeOutliner, new()
+            where TOutliner : AbstractSyntaxOutliner, new()
         {
-            builder.Add(typeof(TType), ImmutableArray.Create<AbstractSyntaxNodeOutliner>(new TOutliner()));
+            builder.Add(typeof(TType), ImmutableArray.Create<AbstractSyntaxOutliner>(new TOutliner()));
         }
 
         public static void Add<TType, TOutliner1, TOutliner2>(
-            this ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxNodeOutliner>>.Builder builder)
+            this ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxOutliner>>.Builder builder)
             where TType : SyntaxNode
-            where TOutliner1 : AbstractSyntaxNodeOutliner, new()
-            where TOutliner2 : AbstractSyntaxNodeOutliner, new()
+            where TOutliner1 : AbstractSyntaxOutliner, new()
+            where TOutliner2 : AbstractSyntaxOutliner, new()
         {
-            builder.Add(typeof(TType), ImmutableArray.Create<AbstractSyntaxNodeOutliner>(new TOutliner1(), new TOutliner2()));
+            builder.Add(typeof(TType), ImmutableArray.Create<AbstractSyntaxOutliner>(new TOutliner1(), new TOutliner2()));
         }
     }
 }

src/EditorFeatures/Core/Implementation/Outlining/RegionCollector.cs

@@ -10,15 +10,15 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.Outlining
     internal class RegionCollector
     {
         private readonly SyntacticDocument _document;
-        private readonly ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxNodeOutliner>> _nodeOutlinerMap;
-        private readonly ImmutableDictionary<int, ImmutableArray<AbstractSyntaxTriviaOutliner>> _triviaOutlinerMap;
+        private readonly ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxOutliner>> _nodeOutlinerMap;
+        private readonly ImmutableDictionary<int, ImmutableArray<AbstractSyntaxOutliner>> _triviaOutlinerMap;
         private readonly List<OutliningSpan> _regions;
         private readonly CancellationToken _cancellationToken;
 
         private RegionCollector(
             SyntacticDocument document,
-            ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxNodeOutliner>> nodeOutlinerMap,
-            ImmutableDictionary<int, ImmutableArray<AbstractSyntaxTriviaOutliner>> triviaOutlinerMap,
+            ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxOutliner>> nodeOutlinerMap,
+            ImmutableDictionary<int, ImmutableArray<AbstractSyntaxOutliner>> triviaOutlinerMap,
             List<OutliningSpan> spans,
             CancellationToken cancellationToken)
         {
@@ -31,8 +31,8 @@ internal class RegionCollector
 
         public static void CollectOutliningSpans(
             SyntacticDocument document,
-            ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxNodeOutliner>> nodeOutlinerMap,
-            ImmutableDictionary<int, ImmutableArray<AbstractSyntaxTriviaOutliner>> triviaOutlinerMap,
+            ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxOutliner>> nodeOutlinerMap,
+            ImmutableDictionary<int, ImmutableArray<AbstractSyntaxOutliner>> triviaOutlinerMap,
             List<OutliningSpan> spans,
             CancellationToken cancellationToken)
         {
@@ -59,7 +59,7 @@ private void Collect(SyntaxNode root)
 
         private void GetOutliningSpans(SyntaxNode node)
         {
-            ImmutableArray<AbstractSyntaxNodeOutliner> outliners;
+            ImmutableArray<AbstractSyntaxOutliner> outliners;
             if (_nodeOutlinerMap.TryGetValue(node.GetType(), out outliners))
             {
                 foreach (var outliner in outliners)
@@ -83,7 +83,7 @@ private void GetOutliningSpans(SyntaxTriviaList triviaList)
             {
                 _cancellationToken.ThrowIfCancellationRequested();
 
-                ImmutableArray<AbstractSyntaxTriviaOutliner> outliners;
+                ImmutableArray<AbstractSyntaxOutliner> outliners;
                 if (_triviaOutlinerMap.TryGetValue(trivia.RawKind, out outliners))
                 {
                     foreach (var outliner in outliners)

src/EditorFeatures/VisualBasic/BasicEditorFeatures.vbproj

@@ -172,7 +172,6 @@
     <Compile Include="NavigationBar\GenerateMethodItem.vb" />
     <Compile Include="NavigationBar\VisualBasicNavigationBarItemService.vb" />
     <Compile Include="Outlining\BannerTextBuilder.vb" />
-    <Compile Include="Outlining\Outliners\AbstractSyntaxNodeOutliner.vb" />
     <Compile Include="Outlining\Outliners\AccessorDeclarationOutliner.vb" />
     <Compile Include="Outlining\Outliners\CompilationUnitOutliner.vb" />
     <Compile Include="Outlining\Outliners\ConstructorDeclarationOutliner.vb" />

src/EditorFeatures/VisualBasic/Outlining/Outliners/AbstractSyntaxNodeOutliner.vb

-' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-Imports System.Threading
-Imports Microsoft.CodeAnalysis.Editor.Implementation.Outlining
-
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.Outlining
-    Friend MustInherit Class AbstractSyntaxNodeOutliner(Of TSyntaxNode As SyntaxNode)
-        Inherits AbstractSyntaxNodeOutliner
-
-        Public Overrides Sub CollectOutliningSpans(document As Document, node As SyntaxNode, spans As List(Of OutliningSpan), cancellationToken As CancellationToken)
-            If Not SupportedInWorkspaceKind(document.Project.Solution.Workspace.Kind) Then
-                Return
-            End If
-
-            CollectOutliningSpans(node, spans, cancellationToken)
-        End Sub
-
-        Friend Overloads Sub CollectOutliningSpans(node As SyntaxNode, spans As List(Of OutliningSpan), cancellationToken As CancellationToken)
-            If TypeOf node Is TSyntaxNode Then
-                CollectOutliningSpans(DirectCast(node, TSyntaxNode), spans, cancellationToken)
-            End If
-        End Sub
-
-        ' For testing purposes
-        Friend Overloads Function GetOutliningSpans(node As SyntaxNode, cancellationToken As CancellationToken) As IEnumerable(Of OutliningSpan)
-            Dim spans = New List(Of OutliningSpan)
-            CollectOutliningSpans(node, spans, cancellationToken)
-            Return spans
-        End Function
-
-        Protected Overridable Function SupportedInWorkspaceKind(kind As String) As Boolean
-            ' We have other outliners specific to Metadata-as-Source
-            Return kind <> WorkspaceKind.MetadataAsSource
-        End Function
-
-
-        Protected MustOverride Overloads Sub CollectOutliningSpans(node As TSyntaxNode, spans As List(Of OutliningSpan), cancellationToken As CancellationToken)
-    End Class
-End Namespace

src/EditorFeatures/VisualBasic/Outlining/VisualBasicOutliningService.vb

 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports System.Collections.Immutable
-Imports System.Threading
-Imports System.Threading.Tasks
-Imports Microsoft.CodeAnalysis.Host
 Imports Microsoft.CodeAnalysis.Host.Mef
 Imports Microsoft.CodeAnalysis.Editor.Implementation.Outlining
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
@@ -14,11 +11,11 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.Outlining
     Friend Class VisualBasicOutliningService
         Inherits AbstractOutliningService
 
-        Private Shared ReadOnly s_defaultNodeOutlinerMap As ImmutableDictionary(Of Type, ImmutableArray(Of AbstractSyntaxNodeOutliner)) = CreateDefaultNodeOutlinerMap()
-        Private Shared ReadOnly s_defaultTriviaOutlinerMap As ImmutableDictionary(Of Integer, ImmutableArray(Of AbstractSyntaxTriviaOutliner)) = CreateDefaultTriviaOutlinerMap()
+        Private Shared ReadOnly s_defaultNodeOutlinerMap As ImmutableDictionary(Of Type, ImmutableArray(Of AbstractSyntaxOutliner)) = CreateDefaultNodeOutlinerMap()
+        Private Shared ReadOnly s_defaultTriviaOutlinerMap As ImmutableDictionary(Of Integer, ImmutableArray(Of AbstractSyntaxOutliner)) = CreateDefaultTriviaOutlinerMap()
 
-        Public Shared Function CreateDefaultNodeOutlinerMap() As ImmutableDictionary(Of Type, ImmutableArray(Of AbstractSyntaxNodeOutliner))
-            Dim builder = ImmutableDictionary.CreateBuilder(Of Type, ImmutableArray(Of AbstractSyntaxNodeOutliner))()
+        Public Shared Function CreateDefaultNodeOutlinerMap() As ImmutableDictionary(Of Type, ImmutableArray(Of AbstractSyntaxOutliner))
+            Dim builder = ImmutableDictionary.CreateBuilder(Of Type, ImmutableArray(Of AbstractSyntaxOutliner))()
 
             builder.Add(Of AccessorStatementSyntax, AccessorDeclarationOutliner)()
             builder.Add(Of ClassStatementSyntax, TypeDeclarationOutliner, MetadataAsSource.TypeDeclarationOutliner)()
@@ -49,10 +46,10 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.Outlining
             Return builder.ToImmutable()
         End Function
 
-        Public Shared Function CreateDefaultTriviaOutlinerMap() As ImmutableDictionary(Of Integer, ImmutableArray(Of AbstractSyntaxTriviaOutliner))
-            Dim builder = ImmutableDictionary.CreateBuilder(Of Integer, ImmutableArray(Of AbstractSyntaxTriviaOutliner))()
+        Public Shared Function CreateDefaultTriviaOutlinerMap() As ImmutableDictionary(Of Integer, ImmutableArray(Of AbstractSyntaxOutliner))
+            Dim builder = ImmutableDictionary.CreateBuilder(Of Integer, ImmutableArray(Of AbstractSyntaxOutliner))()
 
-            builder.Add(SyntaxKind.DisabledTextTrivia, ImmutableArray.Create(Of AbstractSyntaxTriviaOutliner)(New DisabledTextTriviaOutliner()))
+            builder.Add(SyntaxKind.DisabledTextTrivia, ImmutableArray.Create(Of AbstractSyntaxOutliner)(New DisabledTextTriviaOutliner()))
 
             Return builder.ToImmutable()
         End Function