Use ISyntaxKinds to simplify doing kind checks.

src/EditorFeatures/CSharp/Wrapping/ChainedExpression/CSharpChainedExpressionWrapper.cs

@@ -10,7 +10,7 @@ internal class CSharpChainedExpressionWrapper :
         AbstractChainedExpressionWrapper<NameSyntax, BaseArgumentListSyntax>
     {
         public CSharpChainedExpressionWrapper()
-            : base(CSharpSyntaxFactsService.Instance, (int)SyntaxKind.DotToken, (int)SyntaxKind.QuestionToken)
+            : base(CSharpSyntaxFactsService.Instance)
         {
         }
 

src/EditorFeatures/Core/Wrapping/ChainedExpression/AbstractChainedExpressionWrapper.cs

@@ -48,17 +48,14 @@ internal abstract partial class AbstractChainedExpressionWrapper<
         where TBaseArgumentListSyntax : SyntaxNode
     {
         private readonly ISyntaxFactsService _syntaxFacts;
-        private readonly int _dotTokenKind;
-        private readonly int _questionTokenKind;
+        private readonly int _dotToken;
+        private readonly int _questionToken;
 
-        protected AbstractChainedExpressionWrapper(
-            ISyntaxFactsService syntaxFacts,
-            int dotTokenKind,
-            int questionTokenKind)
+        protected AbstractChainedExpressionWrapper(ISyntaxFactsService syntaxFacts)
         {
             _syntaxFacts = syntaxFacts;
-            _dotTokenKind = dotTokenKind;
-            _questionTokenKind = questionTokenKind;
+            _dotToken = syntaxFacts.SyntaxKinds.DotToken;
+            _questionToken = syntaxFacts.SyntaxKinds.QuestionToken;
         }
 
         /// <summary>
@@ -203,11 +200,12 @@ private ImmutableArray<ImmutableArray<SyntaxNodeOrToken>> GetChainChunks(SyntaxN
         {
             for (var i = index; i < pieces.Count; i++)
             {
-                if (IsToken(_dotTokenKind, pieces, i) &&
+                if (IsToken(_dotToken, pieces, i) &&
                     IsNode<TNameSyntax>(pieces, i + 1) &&
                     IsNode<TBaseArgumentListSyntax>(pieces, i + 2))
                 {
-                    if (firstChunk || !IsToken(_questionTokenKind, pieces, i - 1))
+                    if (firstChunk ||
+                        !IsToken(_questionToken, pieces, i - 1))
                     {
                         return i;
                     }

src/EditorFeatures/VisualBasic/Wrapping/ChainedExpression/VisualBasicChainedExpressionWrapper.vb

@@ -8,7 +8,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.Wrapping.ChainedExpression
         Inherits AbstractChainedExpressionWrapper(Of NameSyntax, ArgumentListSyntax)
 
         Public Sub New()
-            MyBase.New(VisualBasicSyntaxFactsService.Instance, SyntaxKind.DotToken, SyntaxKind.QuestionToken)
+            MyBase.New(VisualBasicSyntaxFactsService.Instance)
         End Sub
 
         Protected Overrides Function GetNewLineBeforeOperatorTrivia(newLine As SyntaxTriviaList) As SyntaxTriviaList

src/Workspaces/CSharp/Portable/LanguageServices/CSharpSyntaxFactsService.cs

@@ -38,6 +38,8 @@ public SyntaxTrivia ElasticMarker
         public SyntaxTrivia ElasticCarriageReturnLineFeed
             => SyntaxFactory.ElasticCarriageReturnLineFeed;
 
+        public ISyntaxKindsService SyntaxKinds { get; } = CSharpSyntaxKindsService.Instance;
+
         protected override IDocumentationCommentService DocumentationCommentService
             => CSharpDocumentationCommentService.Instance;
 

src/Workspaces/CSharp/Portable/LanguageServices/CSharpSyntaxKindsService.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 Microsoft.CodeAnalysis.LanguageServices;
+
+namespace Microsoft.CodeAnalysis.CSharp
+{
+    internal class CSharpSyntaxKindsService : AbstractSyntaxKindsService
+    {
+        public static readonly CSharpSyntaxKindsService Instance = new CSharpSyntaxKindsService();
+
+        private CSharpSyntaxKindsService()
+        {
+        }
+
+        public override int DotToken => (int)SyntaxKind.DotToken;
+        public override int QuestionToken => (int)SyntaxKind.QuestionToken;
+    }
+}

src/Workspaces/CSharp/Portable/LanguageServices/CSharpSyntaxKindsServiceFactory.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.Composition;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.LanguageServices;
+
+namespace Microsoft.CodeAnalysis.CSharp
+{
+    [ExportLanguageServiceFactory(typeof(ISyntaxKindsService), LanguageNames.CSharp), Shared]
+    internal class CSharpSyntaxKindsServiceFactory : ILanguageServiceFactory
+    {
+        public ILanguageService CreateLanguageService(HostLanguageServices languageServices)
+            => CSharpSyntaxKindsService.Instance;
+    }
+}

src/Workspaces/Core/Portable/LanguageServices/SyntaxFactsService/ISyntaxFactsService.cs

@@ -17,6 +17,8 @@ internal interface ISyntaxFactsService : ILanguageService
         SyntaxTrivia ElasticMarker { get; }
         SyntaxTrivia ElasticCarriageReturnLineFeed { get; }
 
+        ISyntaxKindsService SyntaxKinds { get; }
+
         bool SupportsIndexingInitializer(ParseOptions options);
         bool SupportsThrowExpression(ParseOptions options);
 

src/Workspaces/Core/Portable/LanguageServices/SyntaxFactsService/ISyntaxKindsService.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 Microsoft.CodeAnalysis.Host;
+
+namespace Microsoft.CodeAnalysis.LanguageServices
+{
+    /// <summary>
+    /// Provides a uniform view of SyntaxKinds over C# and VB for constructs they have
+    /// in common.
+    /// </summary>
+    internal interface ISyntaxKindsService : ILanguageService
+    {
+        int DotToken { get; }
+        int QuestionToken { get; }
+    }
+
+    internal abstract class AbstractSyntaxKindsService : ISyntaxKindsService
+    {
+        public abstract int DotToken { get; }
+        public abstract int QuestionToken { get; }
+    }
+}

src/Workspaces/VisualBasic/Portable/LanguageServices/VisualBasicSyntaxFactsService.vb

@@ -5,8 +5,6 @@ Imports System.Composition
 Imports System.Text
 Imports System.Threading
 Imports Microsoft.CodeAnalysis
-Imports Microsoft.CodeAnalysis.Host
-Imports Microsoft.CodeAnalysis.Host.Mef
 Imports Microsoft.CodeAnalysis.LanguageServices
 Imports Microsoft.CodeAnalysis.PooledObjects
 Imports Microsoft.CodeAnalysis.Text
@@ -16,13 +14,16 @@ Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 Imports Microsoft.CodeAnalysis.VisualBasic.SyntaxFacts
 
 Namespace Microsoft.CodeAnalysis.VisualBasic
-    <ExportLanguageServiceFactory(GetType(ISyntaxFactsService), LanguageNames.VisualBasic), [Shared]>
-    Friend Class VisualBasicSyntaxFactsServiceFactory
-        Implements ILanguageServiceFactory
+    Friend Class VisualBasicSyntaxKindsService
+        Inherits AbstractSyntaxKindsService
 
-        Public Function CreateLanguageService(languageServices As HostLanguageServices) As ILanguageService Implements ILanguageServiceFactory.CreateLanguageService
-            Return VisualBasicSyntaxFactsService.Instance
-        End Function
+        Public Shared ReadOnly Instance As New VisualBasicSyntaxKindsService()
+
+        Private Sub New()
+        End Sub
+
+        Public Overrides ReadOnly Property DotToken As Integer = SyntaxKind.DotToken
+        Public Overrides ReadOnly Property QuestionToken As Integer = SyntaxKind.QuestionToken
     End Class
 
     Friend Class VisualBasicSyntaxFactsService
@@ -58,6 +59,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
 
+        Public ReadOnly Property SyntaxKinds As ISyntaxKindsService = VisualBasicSyntaxKindsService.Instance Implements ISyntaxFactsService.SyntaxKinds
+
         Protected Overrides ReadOnly Property DocumentationCommentService As IDocumentationCommentService
             Get
                 Return VisualBasicDocumentationCommentService.Instance

src/Workspaces/VisualBasic/Portable/LanguageServices/VisualBasicSyntaxFactsServiceFactory.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.Composition
+Imports Microsoft.CodeAnalysis.Host
+Imports Microsoft.CodeAnalysis.Host.Mef
+Imports Microsoft.CodeAnalysis.LanguageServices
+
+Namespace Microsoft.CodeAnalysis.VisualBasic
+    <ExportLanguageServiceFactory(GetType(ISyntaxFactsService), LanguageNames.VisualBasic), [Shared]>
+    Friend Class VisualBasicSyntaxFactsServiceFactory
+        Implements ILanguageServiceFactory
+
+        Public Function CreateLanguageService(languageServices As HostLanguageServices) As ILanguageService Implements ILanguageServiceFactory.CreateLanguageService
+            Return VisualBasicSyntaxFactsService.Instance
+        End Function
+    End Class
+End Namespace

src/Workspaces/VisualBasic/Portable/LanguageServices/VisualBasicSyntaxKindsServiceFactory.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.Composition
+Imports Microsoft.CodeAnalysis.Host
+Imports Microsoft.CodeAnalysis.Host.Mef
+Imports Microsoft.CodeAnalysis.LanguageServices
+
+Namespace Microsoft.CodeAnalysis.VisualBasic
+    <ExportLanguageServiceFactory(GetType(ISyntaxKindsService), LanguageNames.VisualBasic), [Shared]>
+    Friend Class VisualBasicSyntaxKindsServiceFactory
+        Implements ILanguageServiceFactory
+
+        Public Function CreateLanguageService(languageServices As HostLanguageServices) As ILanguageService Implements ILanguageServiceFactory.CreateLanguageService
+            Return VisualBasicSyntaxKindsService.Instance
+        End Function
+    End Class
+End Namespace