Cleanup.

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

@@ -53,13 +53,8 @@ public bool SupportsThrowExpression(ParseOptions options)
         public SyntaxToken ParseToken(string text)
             => SyntaxFactory.ParseToken(text);
 
-        public bool IsAwaitKeyword(SyntaxToken token) => token.IsKind(SyntaxKind.AwaitKeyword);
-
-        public bool IsIdentifier(SyntaxToken token) => token.IsKind(SyntaxKind.IdentifierToken);
-
-        public bool IsGlobalNamespaceKeyword(SyntaxToken token) => token.IsKind(SyntaxKind.GlobalKeyword);
-
-        public bool IsVerbatimIdentifier(SyntaxToken token) => token.IsVerbatimIdentifier();
+        public bool IsVerbatimIdentifier(SyntaxToken token)
+            => token.IsVerbatimIdentifier();
 
         public bool IsOperator(SyntaxToken token)
         {
@@ -81,11 +76,6 @@ public bool IsContextualKeyword(SyntaxToken token)
         public bool IsPreprocessorKeyword(SyntaxToken token)
             => SyntaxFacts.IsPreprocessorKeyword(token.Kind());
 
-        public bool IsHashToken(SyntaxToken token)
-        {
-            return (SyntaxKind)token.RawKind == SyntaxKind.HashToken;
-        }
-
         public bool IsInInactiveRegion(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken)
         {
             if (syntaxTree == null)
@@ -194,14 +184,7 @@ public SyntaxNode GetParameterList(SyntaxNode node)
             => CSharpSyntaxGenerator.GetParameterList(node);
 
         public bool IsSkippedTokensTrivia(SyntaxNode node)
-        {
-            return node is SkippedTokensTriviaSyntax;
-        }
-
-        public bool HasIncompleteParentMember(SyntaxNode node)
-        {
-            return node.IsParentKind(SyntaxKind.IncompleteMember);
-        }
+            => node is SkippedTokensTriviaSyntax;
 
         public SyntaxToken GetIdentifierOfGenericName(SyntaxNode genericName)
         {
@@ -218,9 +201,7 @@ public bool IsUsingDirectiveName(SyntaxNode node)
         }
 
         public bool IsForEachStatement(SyntaxNode node)
-        {
-            return node is ForEachStatementSyntax;
-        }
+            => node is ForEachStatementSyntax;
 
         public bool IsDeconstructionForEachStatement(SyntaxNode node)
             => node is ForEachVariableStatementSyntax;
@@ -241,12 +222,6 @@ public Location GetDeconstructionReferenceLocation(SyntaxNode node)
         public bool IsLockStatement(SyntaxNode node)
             => node is LockStatementSyntax;
 
-        public bool IsUsingStatement(SyntaxNode node)
-            => node.Kind() == SyntaxKind.UsingStatement;
-
-        public bool IsReturnStatement(SyntaxNode node)
-            => node.Kind() == SyntaxKind.ReturnStatement;
-
         public bool IsStatement(SyntaxNode node)
            => node is StatementSyntax;
 
@@ -356,14 +331,10 @@ private PredefinedType GetPredefinedType(SyntaxToken token)
         }
 
         public bool IsPredefinedOperator(SyntaxToken token)
-        {
-            return TryGetPredefinedOperator(token, out var actualOperator) && actualOperator != PredefinedOperator.None;
-        }
+            => TryGetPredefinedOperator(token, out var actualOperator) && actualOperator != PredefinedOperator.None;
 
         public bool IsPredefinedOperator(SyntaxToken token, PredefinedOperator op)
-        {
-            return TryGetPredefinedOperator(token, out var actualOperator) && actualOperator == op;
-        }
+            => TryGetPredefinedOperator(token, out var actualOperator) && actualOperator == op;
 
         public bool TryGetPredefinedOperator(SyntaxToken token, out PredefinedOperator op)
         {
@@ -445,24 +416,16 @@ private PredefinedOperator GetPredefinedOperator(SyntaxToken token)
         }
 
         public string GetText(int kind)
-        {
-            return SyntaxFacts.GetText((SyntaxKind)kind);
-        }
+            => SyntaxFacts.GetText((SyntaxKind)kind);
 
         public bool IsIdentifierStartCharacter(char c)
-        {
-            return SyntaxFacts.IsIdentifierStartCharacter(c);
-        }
+            => SyntaxFacts.IsIdentifierStartCharacter(c);
 
         public bool IsIdentifierPartCharacter(char c)
-        {
-            return SyntaxFacts.IsIdentifierPartCharacter(c);
-        }
+            => SyntaxFacts.IsIdentifierPartCharacter(c);
 
         public bool IsIdentifierEscapeCharacter(char c)
-        {
-            return c == '@';
-        }
+            => c == '@';
 
         public bool IsValidIdentifier(string identifier)
         {
@@ -476,15 +439,10 @@ public bool IsVerbatimIdentifier(string identifier)
             return IsIdentifier(token) && !token.ContainsDiagnostics && token.ToString().Length == identifier.Length && token.IsVerbatimIdentifier();
         }
 
-        public bool IsTypeCharacter(char c)
-        {
-            return false;
-        }
+        public bool IsTypeCharacter(char c) => false;
 
         public bool IsStartOfUnicodeEscapeSequence(char c)
-        {
-            return c == '\\';
-        }
+            => c == '\\';
 
         public bool IsLiteral(SyntaxToken token)
         {
@@ -501,20 +459,16 @@ public bool IsLiteral(SyntaxToken token)
                 case SyntaxKind.InterpolatedVerbatimStringStartToken:
                 case SyntaxKind.InterpolatedStringTextToken:
                     return true;
-            }
-
+                default:
                     return false;
             }
+        }
 
         public bool IsStringLiteralOrInterpolatedStringLiteral(SyntaxToken token)
-        {
-            return token.IsKind(SyntaxKind.StringLiteralToken, SyntaxKind.InterpolatedStringTextToken);
-        }
+            => token.IsKind(SyntaxKind.StringLiteralToken, SyntaxKind.InterpolatedStringTextToken);
 
         public bool IsNumericLiteralExpression(SyntaxNode node)
-        {
-            return node?.IsKind(SyntaxKind.NumericLiteralExpression) == true;
-        }
+            => node?.IsKind(SyntaxKind.NumericLiteralExpression) == true;
 
         public bool IsTypeNamedVarInVariableOrFieldDeclaration(SyntaxToken token, SyntaxNode parent)
         {
@@ -635,24 +589,16 @@ public SyntaxNode GetExpressionOfInterpolation(SyntaxNode node)
             => (node as InterpolationSyntax)?.Expression;
 
         public bool IsInStaticContext(SyntaxNode node)
-        {
-            return node.IsInStaticContext();
-        }
+            => node.IsInStaticContext();
 
         public bool IsInNamespaceOrTypeContext(SyntaxNode node)
-        {
-            return SyntaxFacts.IsInNamespaceOrTypeContext(node as ExpressionSyntax);
-        }
+            => SyntaxFacts.IsInNamespaceOrTypeContext(node as ExpressionSyntax);
 
         public bool IsBaseTypeList(SyntaxNode node)
-        {
-            return node.IsKind(SyntaxKind.BaseList);
-        }
+            => node.IsKind(SyntaxKind.BaseList);
 
         public SyntaxNode GetExpressionOfArgument(SyntaxNode node)
-        {
-            return ((ArgumentSyntax)node).Expression;
-        }
+            => ((ArgumentSyntax)node).Expression;
 
         public RefKind GetRefKindOfArgument(SyntaxNode node)
             => (node as ArgumentSyntax).GetRefKind();
@@ -674,45 +620,28 @@ public bool IsTypeConstraint(SyntaxNode node)
             => node.IsKind(SyntaxKind.TypeConstraint);
 
         public bool IsInConstantContext(SyntaxNode node)
-        {
-            return (node as ExpressionSyntax).IsInConstantContext();
-        }
+            => (node as ExpressionSyntax).IsInConstantContext();
 
         public bool IsInConstructor(SyntaxNode node)
-        {
-            return node.GetAncestor<ConstructorDeclarationSyntax>() != null;
-        }
+            => node.GetAncestor<ConstructorDeclarationSyntax>() != null;
 
         public bool IsUnsafeContext(SyntaxNode node)
-        {
-            return node.IsUnsafeContext();
-        }
+            => node.IsUnsafeContext();
 
         public SyntaxNode GetNameOfAttribute(SyntaxNode node)
-        {
-            return ((AttributeSyntax)node).Name;
-        }
+            => ((AttributeSyntax)node).Name;
 
         public bool IsParenthesizedExpression(SyntaxNode node)
-        {
-            return node.Kind() == SyntaxKind.ParenthesizedExpression;
-        }
+            => node.Kind() == SyntaxKind.ParenthesizedExpression;
 
         public SyntaxNode GetExpressionOfParenthesizedExpression(SyntaxNode node)
-        {
-            return ((ParenthesizedExpressionSyntax)node).Expression;
-        }
+            => ((ParenthesizedExpressionSyntax)node).Expression;
 
         public bool IsAttribute(SyntaxNode node)
-        {
-            return node is AttributeSyntax;
-        }
+            => node is AttributeSyntax;
 
         public bool IsAttributeNamedArgumentIdentifier(SyntaxNode node)
-        {
-            var identifier = node as IdentifierNameSyntax;
-            return identifier.IsAttributeNamedArgumentIdentifier();
-        }
+            => (node as IdentifierNameSyntax).IsAttributeNamedArgumentIdentifier();
 
         public SyntaxNode GetContainingTypeDeclaration(SyntaxNode root, int position)
         {
@@ -733,9 +662,7 @@ public SyntaxNode GetContainingTypeDeclaration(SyntaxNode root, int position)
         }
 
         public SyntaxNode GetContainingVariableDeclaratorOfFieldDeclaration(SyntaxNode node)
-        {
-            throw ExceptionUtilities.Unreachable;
-        }
+            => throw ExceptionUtilities.Unreachable;
 
         public SyntaxToken FindTokenOnLeftOfPosition(
             SyntaxNode node, int position, bool includeSkipped, bool includeDirectives, bool includeDocumentationComments)
@@ -813,9 +740,7 @@ public SyntaxNode Parenthesize(SyntaxNode expression, bool includeElasticTrivia,
         }
 
         public bool IsIndexerMemberCRef(SyntaxNode node)
-        {
-            return node.Kind() == SyntaxKind.IndexerMemberCref;
-        }
+            => node.Kind() == SyntaxKind.IndexerMemberCref;
 
         public SyntaxNode GetContainingMemberDeclaration(SyntaxNode root, int position, bool useFullSpan = true)
         {
@@ -852,7 +777,10 @@ public SyntaxNode GetContainingMemberDeclaration(SyntaxNode root, int position,
 
         public bool IsMethodLevelMember(SyntaxNode node)
         {
-            return node is BaseMethodDeclarationSyntax || node is BasePropertyDeclarationSyntax || node is EnumMemberDeclarationSyntax || node is BaseFieldDeclarationSyntax;
+            return node is BaseMethodDeclarationSyntax ||
+                node is BasePropertyDeclarationSyntax ||
+                node is EnumMemberDeclarationSyntax ||
+                node is BaseFieldDeclarationSyntax;
         }
 
         public bool IsTopLevelNodeWithMembers(SyntaxNode node)
@@ -1338,19 +1266,13 @@ public bool IsLeftSideOfExplicitInterfaceSpecifier(SyntaxNode node)
             => (node as NameSyntax).IsLeftSideOfExplicitInterfaceSpecifier();
 
         public bool IsLeftSideOfAssignment(SyntaxNode node)
-        {
-            return (node as ExpressionSyntax).IsLeftSideOfAssignExpression();
-        }
+            => (node as ExpressionSyntax).IsLeftSideOfAssignExpression();
 
         public bool IsLeftSideOfAnyAssignment(SyntaxNode node)
-        {
-            return (node as ExpressionSyntax).IsLeftSideOfAnyAssignExpression();
-        }
+            => (node as ExpressionSyntax).IsLeftSideOfAnyAssignExpression();
 
         public SyntaxNode GetRightHandSideOfAssignment(SyntaxNode node)
-        {
-            return (node as AssignmentExpressionSyntax)?.Right;
-        }
+            => (node as AssignmentExpressionSyntax)?.Right;
 
         public bool IsInferredAnonymousObjectMemberDeclarator(SyntaxNode node)
         {
@@ -1573,32 +1495,22 @@ public bool IsDeclaratorOfLocalDeclarationStatement(SyntaxNode declarator, Synta
         }
 
         public bool AreEquivalent(SyntaxToken token1, SyntaxToken token2)
-        {
-            return SyntaxFactory.AreEquivalent(token1, token2);
-        }
+            => SyntaxFactory.AreEquivalent(token1, token2);
 
         public bool AreEquivalent(SyntaxNode node1, SyntaxNode node2)
-        {
-            return SyntaxFactory.AreEquivalent(node1, node2);
-        }
+            => SyntaxFactory.AreEquivalent(node1, node2);
 
         public bool IsExpressionOfInvocationExpression(SyntaxNode node)
-        {
-            return node != null && (node.Parent as InvocationExpressionSyntax)?.Expression == node;
-        }
+            => (node?.Parent as InvocationExpressionSyntax)?.Expression == node;
 
         public bool IsAwaitExpression(SyntaxNode node)
             => node.IsKind(SyntaxKind.AwaitExpression);
 
         public bool IsExpressionOfAwaitExpression(SyntaxNode node)
-        {
-            return node != null && (node.Parent as AwaitExpressionSyntax)?.Expression == node;
-        }
+            => (node?.Parent as AwaitExpressionSyntax)?.Expression == node;
 
         public bool IsExpressionOfMemberAccessExpression(SyntaxNode node)
-        {
-            return node != null && (node.Parent as MemberAccessExpressionSyntax)?.Expression == node;
-        }
+            => (node?.Parent as MemberAccessExpressionSyntax)?.Expression == node;
 
         public SyntaxNode GetExpressionOfInvocationExpression(SyntaxNode node)
             => ((InvocationExpressionSyntax)node).Expression;

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

@@ -21,6 +21,18 @@ private CSharpSyntaxKindsService()
         public override int LogicalAndExpression => (int)SyntaxKind.LogicalAndExpression;
         public override int LogicalOrExpression => (int)SyntaxKind.LogicalOrExpression;
         public override int EndOfFileToken => (int)SyntaxKind.EndOfFileToken;
+        public override int AwaitKeyword => (int)SyntaxKind.AwaitKeyword;
 
+        public override int IdentifierToken => (int)SyntaxKind.IdentifierToken;
+
+        public override int GlobalKeyword => (int)SyntaxKind.GlobalKeyword;
+
+        public override int IncompleteMember => (int)SyntaxKind.IncompleteMember;
+
+        public override int UsingStatement => (int)SyntaxKind.UsingStatement;
+
+        public override int ReturnStatement => (int)SyntaxKind.ReturnStatement;
+
+        public override int HashToken => (int)SyntaxKind.HashToken;
     }
 }

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

@@ -550,5 +550,26 @@ protected int GetStartOfNodeExcludingAttributes(SyntaxNode node)
         }
 
         public abstract SyntaxList<SyntaxNode> GetAttributeLists(SyntaxNode node);
+
+        public bool IsAwaitKeyword(SyntaxToken token)
+            => token.RawKind == SyntaxKinds.AwaitKeyword;
+
+        public bool IsIdentifier(SyntaxToken token)
+            => token.RawKind == SyntaxKinds.IdentifierToken;
+
+        public bool IsGlobalNamespaceKeyword(SyntaxToken token)
+            => token.RawKind == SyntaxKinds.GlobalKeyword;
+
+        public bool IsHashToken(SyntaxToken token)
+            => token.RawKind == SyntaxKinds.HashToken;
+
+        public bool HasIncompleteParentMember(SyntaxNode node)
+            => node?.Parent?.RawKind == SyntaxKinds.IncompleteMember;
+
+        public bool IsUsingStatement(SyntaxNode node)
+            => node.RawKind == SyntaxKinds.UsingStatement;
+
+        public bool IsReturnStatement(SyntaxNode node)
+            => node.RawKind == SyntaxKinds.ReturnStatement;
     }
 }

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

@@ -26,6 +26,13 @@ internal interface ISyntaxKindsService : ILanguageService
         int LogicalOrExpression { get; }
 
         int EndOfFileToken { get; }
+        int AwaitKeyword { get; }
+        int IdentifierToken { get; }
+        int GlobalKeyword { get; }
+        int IncompleteMember { get; }
+        int UsingStatement { get; }
+        int ReturnStatement { get; }
+        int HashToken { get; }
     }
 
     internal abstract class AbstractSyntaxKindsService : ISyntaxKindsService
@@ -37,6 +44,15 @@ internal abstract class AbstractSyntaxKindsService : ISyntaxKindsService
 
         public abstract int LogicalAndExpression { get; }
         public abstract int LogicalOrExpression { get; }
+
         public abstract int EndOfFileToken { get; }
+        public abstract int IdentifierToken { get; }
+
+        public abstract int AwaitKeyword { get; }
+        public abstract int GlobalKeyword { get; }
+        public abstract int IncompleteMember { get; }
+        public abstract int UsingStatement { get; }
+        public abstract int ReturnStatement { get; }
+        public abstract int HashToken { get; }
     }
 }

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

@@ -67,16 +67,16 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return SyntaxFactory.ParseToken(text, startStatement:=True)
         End Function
 
-        Public Function IsAwaitKeyword(token As SyntaxToken) As Boolean Implements ISyntaxFactsService.IsAwaitKeyword
-            Return token.Kind = SyntaxKind.AwaitKeyword
+        Private Function ISyntaxFactsService_IsAwaitKeyword(token As SyntaxToken) As Boolean Implements ISyntaxFactsService.IsAwaitKeyword
+            Return IsAwaitKeyword(token)
         End Function
 
-        Public Function IsIdentifier(token As SyntaxToken) As Boolean Implements ISyntaxFactsService.IsIdentifier
-            Return token.Kind = SyntaxKind.IdentifierToken
+        Private Function ISyntaxFactsService_IsIdentifier(token As SyntaxToken) As Boolean Implements ISyntaxFactsService.IsIdentifier
+            Return IsIdentifier(token)
         End Function
 
-        Public Function IsGlobalNamespaceKeyword(token As SyntaxToken) As Boolean Implements ISyntaxFactsService.IsGlobalNamespaceKeyword
-            Return token.Kind = SyntaxKind.GlobalKeyword
+        Private Function ISyntaxFactsService_IsGlobalNamespaceKeyword(token As SyntaxToken) As Boolean Implements ISyntaxFactsService.IsGlobalNamespaceKeyword
+            Return IsGlobalNamespaceKeyword(token)
         End Function
 
         Public Function IsVerbatimIdentifier(token As SyntaxToken) As Boolean Implements ISyntaxFactsService.IsVerbatimIdentifier
@@ -100,8 +100,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return token.IsPreprocessorKeyword()
         End Function
 
-        Public Function IsHashToken(token As SyntaxToken) As Boolean Implements ISyntaxFactsService.IsHashToken
-            Return token.Kind = SyntaxKind.HashToken
+        Public Function ISyntaxFactsService_IsHashToken(token As SyntaxToken) As Boolean Implements ISyntaxFactsService.IsHashToken
+            Return IsHashToken(token)
         End Function
 
         Public Function TryGetCorrespondingOpenBrace(token As SyntaxToken, ByRef openBrace As SyntaxToken) As Boolean Implements ISyntaxFactsService.TryGetCorrespondingOpenBrace
@@ -224,8 +224,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return TypeOf node Is SkippedTokensTriviaSyntax
         End Function
 
-        Public Function HasIncompleteParentMember(node As SyntaxNode) As Boolean Implements ISyntaxFactsService.HasIncompleteParentMember
-            Return node.IsParentKind(SyntaxKind.IncompleteMember)
+        Public Function ISyntaxFactsService_HasIncompleteParentMember(node As SyntaxNode) As Boolean Implements ISyntaxFactsService.HasIncompleteParentMember
+            Return HasIncompleteParentMember(node)
         End Function
 
         Public Function GetIdentifierOfGenericName(genericName As SyntaxNode) As SyntaxToken Implements ISyntaxFactsService.GetIdentifierOfGenericName
@@ -254,12 +254,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return TypeOf node Is SyncLockStatementSyntax
         End Function
 
-        Public Function IsUsingStatement(node As SyntaxNode) As Boolean Implements ISyntaxFactsService.IsUsingStatement
-            Return node.Kind() = SyntaxKind.UsingStatement
+        Private Function ISyntaxFactsService_IsUsingStatement(node As SyntaxNode) As Boolean Implements ISyntaxFactsService.IsUsingStatement
+            Return IsUsingStatement(node)
         End Function
 
-        Public Function IsReturnStatement(node As SyntaxNode) As Boolean Implements ISyntaxFactsService.IsReturnStatement
-            Return node.Kind() = SyntaxKind.ReturnStatement
+        Private Function ISyntaxFactsService_IsReturnStatement(node As SyntaxNode) As Boolean Implements ISyntaxFactsService.IsReturnStatement
+            Return IsReturnStatement(node)
         End Function
 
         Public Function IsStatement(node As SyntaxNode) As Boolean Implements ISyntaxFactsService.IsStatement

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

@@ -20,5 +20,13 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices
         Public Overrides ReadOnly Property LogicalAndExpression As Integer = SyntaxKind.AndAlsoExpression
         Public Overrides ReadOnly Property LogicalOrExpression As Integer = SyntaxKind.OrElseExpression
         Public Overrides ReadOnly Property EndOfFileToken As Integer = SyntaxKind.EndOfFileToken
+        Public Overrides ReadOnly Property AwaitKeyword As Integer = SyntaxKind.AwaitKeyword
+
+        Public Overrides ReadOnly Property IdentifierToken As Integer = SyntaxKind.IdentifierToken
+        Public Overrides ReadOnly Property GlobalKeyword As Integer = SyntaxKind.GlobalKeyword
+        Public Overrides ReadOnly Property IncompleteMember As Integer = SyntaxKind.IncompleteMember
+        Public Overrides ReadOnly Property UsingStatement As Integer = SyntaxKind.UsingStatement
+        Public Overrides ReadOnly Property ReturnStatement As Integer = SyntaxKind.ReturnStatement
+        Public Overrides ReadOnly Property HashToken As Integer = SyntaxKind.HashToken
     End Class
 End Namespace