From 750e1eb7704097caf529b7c4475918ffff15ae34 Mon Sep 17 00:00:00 2001 From: Manish Vasani Date: Mon, 30 Mar 2020 09:09:48 -0700 Subject: [PATCH] Move certain syntax generator internal methods down to shared layer --- .../Analyzers/CSharpFormattingAnalyzer.cs | 2 +- .../CSharpFormattingCodeFixProvider.cs | 2 +- .../VisualBasicFormattingAnalyzer.vb | 2 +- .../VisualBasicFormattingCodeFixProvider.vb | 2 +- .../CodeGeneration/CSharpSyntaxGenerator.cs | 14 +--- .../Core/Portable/Editing/SyntaxGenerator.cs | 11 +-- .../Core/Portable/Formatting/Formatter.cs | 68 +------------------ .../CSharpSyntaxFormattingService.cs | 5 +- .../Core/Formatting/FormattingExtensions.cs | 67 ++++++++++++++++++ .../CSharpSyntaxGeneratorInternal.cs | 21 ++++++ .../SyntaxGeneratorExtensions_Negate.cs | 19 +++--- .../SyntaxGeneratorInternal.cs | 16 +++++ .../Core/WorkspaceExtensions.projitems | 1 + .../VisualBasicSyntaxGeneratorInternal.vb | 24 +++++++ .../VisualBasicSyntaxGenerator.vb | 16 +---- .../VisualBasicSyntaxFormattingService.vb | 4 ++ 16 files changed, 162 insertions(+), 112 deletions(-) rename src/Workspaces/{Core/Portable/Shared => SharedUtilitiesAndExtensions/Workspace/Core}/Extensions/SyntaxGeneratorExtensions_Negate.cs (94%) diff --git a/src/CodeStyle/CSharp/Analyzers/CSharpFormattingAnalyzer.cs b/src/CodeStyle/CSharp/Analyzers/CSharpFormattingAnalyzer.cs index 00b89b3f8e6..e4e9dc42872 100644 --- a/src/CodeStyle/CSharp/Analyzers/CSharpFormattingAnalyzer.cs +++ b/src/CodeStyle/CSharp/Analyzers/CSharpFormattingAnalyzer.cs @@ -12,6 +12,6 @@ namespace Microsoft.CodeAnalysis.CodeStyle internal class CSharpFormattingAnalyzer : AbstractFormattingAnalyzer { protected override ISyntaxFormattingService SyntaxFormattingService - => new CSharpSyntaxFormattingService(); + => CSharpSyntaxFormattingService.Instance; } } diff --git a/src/CodeStyle/CSharp/CodeFixes/CSharpFormattingCodeFixProvider.cs b/src/CodeStyle/CSharp/CodeFixes/CSharpFormattingCodeFixProvider.cs index 0fcc5b66d2a..241c603dd46 100644 --- a/src/CodeStyle/CSharp/CodeFixes/CSharpFormattingCodeFixProvider.cs +++ b/src/CodeStyle/CSharp/CodeFixes/CSharpFormattingCodeFixProvider.cs @@ -21,6 +21,6 @@ public CSharpFormattingCodeFixProvider() { } - protected override ISyntaxFormattingService SyntaxFormattingService => new CSharpSyntaxFormattingService(); + protected override ISyntaxFormattingService SyntaxFormattingService => CSharpSyntaxFormattingService.Instance; } } diff --git a/src/CodeStyle/VisualBasic/Analyzers/VisualBasicFormattingAnalyzer.vb b/src/CodeStyle/VisualBasic/Analyzers/VisualBasicFormattingAnalyzer.vb index 8136d9ad994..6d4e5c68837 100644 --- a/src/CodeStyle/VisualBasic/Analyzers/VisualBasicFormattingAnalyzer.vb +++ b/src/CodeStyle/VisualBasic/Analyzers/VisualBasicFormattingAnalyzer.vb @@ -13,7 +13,7 @@ Namespace Microsoft.CodeAnalysis.CodeStyle Protected Overrides ReadOnly Property SyntaxFormattingService As ISyntaxFormattingService Get - Return New VisualBasicSyntaxFormattingService() + Return VisualBasicSyntaxFormattingService.Instance End Get End Property End Class diff --git a/src/CodeStyle/VisualBasic/CodeFixes/VisualBasicFormattingCodeFixProvider.vb b/src/CodeStyle/VisualBasic/CodeFixes/VisualBasicFormattingCodeFixProvider.vb index 93d777bf64b..f46110e6b3c 100644 --- a/src/CodeStyle/VisualBasic/CodeFixes/VisualBasicFormattingCodeFixProvider.vb +++ b/src/CodeStyle/VisualBasic/CodeFixes/VisualBasicFormattingCodeFixProvider.vb @@ -21,7 +21,7 @@ Namespace Microsoft.CodeAnalysis.CodeStyle Protected Overrides ReadOnly Property SyntaxFormattingService As ISyntaxFormattingService Get - Return New VisualBasicSyntaxFormattingService() + Return VisualBasicSyntaxFormattingService.Instance End Get End Property End Class diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs index bf1163a590a..e6f7fce0795 100644 --- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs +++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs @@ -15,7 +15,6 @@ using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.Editing; using Microsoft.CodeAnalysis.Host.Mef; -using Microsoft.CodeAnalysis.LanguageServices; using Microsoft.CodeAnalysis.PooledObjects; using Microsoft.CodeAnalysis.Shared.Extensions; using Microsoft.CodeAnalysis.Simplification; @@ -43,8 +42,6 @@ public CSharpSyntaxGenerator() internal override bool RequiresExplicitImplementationForInterfaceMembers => false; - internal override ISyntaxFacts SyntaxFacts => CSharpSyntaxFacts.Instance; - internal override SyntaxGeneratorInternal SyntaxGeneratorInternal => CSharpSyntaxGeneratorInternal.Instance; internal override SyntaxTrivia EndOfLine(string text) @@ -2940,9 +2937,6 @@ public override SyntaxNode NameOfExpression(SyntaxNode expression) public override SyntaxNode ReturnStatement(SyntaxNode expressionOpt = null) => SyntaxFactory.ReturnStatement((ExpressionSyntax)expressionOpt); - internal override SyntaxNode YieldReturnStatement(SyntaxNode expressionOpt = null) - => SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, (ExpressionSyntax)expressionOpt); - public override SyntaxNode ThrowStatement(SyntaxNode expressionOpt = null) => SyntaxFactory.ThrowStatement((ExpressionSyntax)expressionOpt); @@ -3134,11 +3128,8 @@ public override SyntaxNode DefaultExpression(ITypeSymbol type) return DefaultExpression(type.GenerateTypeSyntax()); } - internal override SyntaxNode AddParentheses(SyntaxNode expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true) - => Parenthesize(expression, includeElasticTrivia, addSimplifierAnnotation); - private static ExpressionSyntax Parenthesize(SyntaxNode expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true) - => ((ExpressionSyntax)expression).Parenthesize(includeElasticTrivia, addSimplifierAnnotation); + => CSharpSyntaxGeneratorInternal.Parenthesize(expression, includeElasticTrivia, addSimplifierAnnotation); public override SyntaxNode IsTypeExpression(SyntaxNode expression, SyntaxNode type) => SyntaxFactory.BinaryExpression(SyntaxKind.IsExpression, Parenthesize(expression), (TypeSyntax)type); @@ -3479,9 +3470,6 @@ internal override SyntaxNode NamedAnonymousObjectMemberDeclarator(SyntaxNode ide (ExpressionSyntax)expression); } - internal override SyntaxNode RefExpression(SyntaxNode expression) - => SyntaxFactory.RefExpression((ExpressionSyntax)expression); - public override SyntaxNode TupleExpression(IEnumerable arguments) => SyntaxFactory.TupleExpression(SyntaxFactory.SeparatedList(arguments.Select(AsArgument))); diff --git a/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs b/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs index 18fac2876a8..d0ae9bd1d41 100644 --- a/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs +++ b/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs @@ -36,7 +36,7 @@ public abstract class SyntaxGenerator : ILanguageService internal abstract SyntaxTrivia CarriageReturnLineFeed { get; } internal abstract SyntaxTrivia ElasticCarriageReturnLineFeed { get; } internal abstract bool RequiresExplicitImplementationForInterfaceMembers { get; } - internal abstract ISyntaxFacts SyntaxFacts { get; } + internal ISyntaxFacts SyntaxFacts => SyntaxGeneratorInternal.SyntaxFacts; internal abstract SyntaxGeneratorInternal SyntaxGeneratorInternal { get; } internal abstract SyntaxTrivia EndOfLine(string text); @@ -1353,7 +1353,8 @@ protected static SyntaxList RemoveRange(SyntaxList list, in /// Creates a statement that can be used to yield a value from an iterator method. /// /// An expression that can be yielded. - internal abstract SyntaxNode YieldReturnStatement(SyntaxNode expression); + internal SyntaxNode YieldReturnStatement(SyntaxNode expression) + => SyntaxGeneratorInternal.YieldReturnStatement(expression); /// /// Creates a statement that can be used to throw an exception. @@ -1924,7 +1925,8 @@ public virtual SyntaxNode MemberAccessExpression(SyntaxNode expression, SyntaxNo internal abstract SyntaxNode MemberAccessExpressionWorker(SyntaxNode expression, SyntaxNode memberName); - internal abstract SyntaxNode RefExpression(SyntaxNode expression); + internal SyntaxNode RefExpression(SyntaxNode expression) + => SyntaxGeneratorInternal.RefExpression(expression); /// /// Creates a member access expression. @@ -2140,7 +2142,8 @@ public SyntaxNode LambdaParameter(string identifier, ITypeSymbol type) /// /// Wraps with parens. /// - internal abstract SyntaxNode AddParentheses(SyntaxNode expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true); + internal SyntaxNode AddParentheses(SyntaxNode expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true) + => SyntaxGeneratorInternal.AddParentheses(expression, includeElasticTrivia, addSimplifierAnnotation); /// /// Creates an nameof expression. diff --git a/src/Workspaces/Core/Portable/Formatting/Formatter.cs b/src/Workspaces/Core/Portable/Formatting/Formatter.cs index 3a8ab52940a..cea4ab7d272 100644 --- a/src/Workspaces/Core/Portable/Formatting/Formatter.cs +++ b/src/Workspaces/Core/Portable/Formatting/Formatter.cs @@ -14,6 +14,7 @@ using Microsoft.CodeAnalysis.Shared.Extensions; using Microsoft.CodeAnalysis.Text; using Roslyn.Utilities; +using static Microsoft.CodeAnalysis.Formatting.FormattingExtensions; namespace Microsoft.CodeAnalysis.Formatting { @@ -298,73 +299,6 @@ internal static IList GetFormattedTextChanges(SyntaxNode node, IEnum : formattingResult.GetTextChanges(cancellationToken); } - private static IEnumerable GetAnnotatedSpans(SyntaxNode node, SyntaxAnnotation annotation) - { - foreach (var nodeOrToken in node.GetAnnotatedNodesAndTokens(annotation)) - { - var firstToken = nodeOrToken.IsNode ? nodeOrToken.AsNode().GetFirstToken(includeZeroWidth: true) : nodeOrToken.AsToken(); - var lastToken = nodeOrToken.IsNode ? nodeOrToken.AsNode().GetLastToken(includeZeroWidth: true) : nodeOrToken.AsToken(); - yield return GetSpan(firstToken, lastToken); - } - } - - private static TextSpan GetSpan(SyntaxToken firstToken, SyntaxToken lastToken) - { - var previousToken = firstToken.GetPreviousToken(); - var nextToken = lastToken.GetNextToken(); - - if (previousToken.RawKind != 0) - { - firstToken = previousToken; - } - - if (nextToken.RawKind != 0) - { - lastToken = nextToken; - } - - return TextSpan.FromBounds(firstToken.SpanStart, lastToken.Span.End); - } - - private static IEnumerable GetElasticSpans(SyntaxNode root) - { - var tokens = root.GetAnnotatedTrivia(SyntaxAnnotation.ElasticAnnotation).Select(tr => tr.Token).Distinct(); - return AggregateSpans(tokens.Select(t => GetElasticSpan(t))); - } - - private static TextSpan GetElasticSpan(SyntaxToken token) - => GetSpan(token, token); - - private static IEnumerable AggregateSpans(IEnumerable spans) - { - var aggregateSpans = new List(); - - var last = default(TextSpan); - foreach (var span in spans) - { - if (last == default) - { - last = span; - } - else if (span.IntersectsWith(last)) - { - last = TextSpan.FromBounds(last.Start, span.End); - } - else - { - aggregateSpans.Add(last); - last = span; - } - } - - if (last != default) - { - aggregateSpans.Add(last); - } - - return aggregateSpans; - } - /// /// Organizes the imports in the document. /// diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/CSharpSyntaxFormattingService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/CSharpSyntaxFormattingService.cs index 46f16d81c90..38028ec2541 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/CSharpSyntaxFormattingService.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/CSharpSyntaxFormattingService.cs @@ -26,7 +26,10 @@ internal class CSharpSyntaxFormattingService : AbstractSyntaxFormattingService { private readonly ImmutableList _rules; -#if !CODE_STYLE +#if CODE_STYLE + public static readonly CSharpSyntaxFormattingService Instance = new CSharpSyntaxFormattingService(); + +#else [ImportingConstructor] [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] #endif diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingExtensions.cs index a29e09555e6..b4a7a175c83 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingExtensions.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingExtensions.cs @@ -279,5 +279,72 @@ public static TextChange SimpleDiff(this TextChange textChange, string text) return new TextChange(span, newText); } + + internal static IEnumerable GetAnnotatedSpans(SyntaxNode node, SyntaxAnnotation annotation) + { + foreach (var nodeOrToken in node.GetAnnotatedNodesAndTokens(annotation)) + { + var firstToken = nodeOrToken.IsNode ? nodeOrToken.AsNode().GetFirstToken(includeZeroWidth: true) : nodeOrToken.AsToken(); + var lastToken = nodeOrToken.IsNode ? nodeOrToken.AsNode().GetLastToken(includeZeroWidth: true) : nodeOrToken.AsToken(); + yield return GetSpan(firstToken, lastToken); + } + } + + internal static TextSpan GetSpan(SyntaxToken firstToken, SyntaxToken lastToken) + { + var previousToken = firstToken.GetPreviousToken(); + var nextToken = lastToken.GetNextToken(); + + if (previousToken.RawKind != 0) + { + firstToken = previousToken; + } + + if (nextToken.RawKind != 0) + { + lastToken = nextToken; + } + + return TextSpan.FromBounds(firstToken.SpanStart, lastToken.Span.End); + } + + internal static IEnumerable GetElasticSpans(SyntaxNode root) + { + var tokens = root.GetAnnotatedTrivia(SyntaxAnnotation.ElasticAnnotation).Select(tr => tr.Token).Distinct(); + return AggregateSpans(tokens.Select(t => GetElasticSpan(t))); + } + + internal static TextSpan GetElasticSpan(SyntaxToken token) + => GetSpan(token, token); + + private static IEnumerable AggregateSpans(IEnumerable spans) + { + var aggregateSpans = new List(); + + var last = default(TextSpan); + foreach (var span in spans) + { + if (last == default) + { + last = span; + } + else if (span.IntersectsWith(last)) + { + last = TextSpan.FromBounds(last.Start, span.End); + } + else + { + aggregateSpans.Add(last); + last = span; + } + } + + if (last != default) + { + aggregateSpans.Add(last); + } + + return aggregateSpans; + } } } diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSyntaxGeneratorInternal.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSyntaxGeneratorInternal.cs index 823e40984a1..c78bf4f09d7 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSyntaxGeneratorInternal.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSyntaxGeneratorInternal.cs @@ -4,9 +4,12 @@ using System.Composition; using System.Diagnostics.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp.Extensions; +using Microsoft.CodeAnalysis.CSharp.LanguageServices; using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.Editing; using Microsoft.CodeAnalysis.Host.Mef; +using Microsoft.CodeAnalysis.LanguageServices; namespace Microsoft.CodeAnalysis.CSharp.CodeGeneration { @@ -21,6 +24,8 @@ public CSharpSyntaxGeneratorInternal() public static readonly SyntaxGeneratorInternal Instance = new CSharpSyntaxGeneratorInternal(); + internal override ISyntaxFacts SyntaxFacts => CSharpSyntaxFacts.Instance; + internal override SyntaxNode LocalDeclarationStatement(SyntaxNode type, SyntaxToken name, SyntaxNode initializer, bool isConst) { return SyntaxFactory.LocalDeclarationStatement( @@ -52,5 +57,21 @@ internal override SyntaxNode ConditionalAccessExpression(SyntaxNode expression, internal override SyntaxNode MemberBindingExpression(SyntaxNode name) => SyntaxFactory.MemberBindingExpression((SimpleNameSyntax)name); + + internal override SyntaxNode RefExpression(SyntaxNode expression) + => SyntaxFactory.RefExpression((ExpressionSyntax)expression); + + internal override SyntaxNode AddParentheses(SyntaxNode expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true) + { + return Parenthesize(expression, includeElasticTrivia, addSimplifierAnnotation); + } + + internal static ExpressionSyntax Parenthesize(SyntaxNode expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true) + { + return ((ExpressionSyntax)expression).Parenthesize(includeElasticTrivia, addSimplifierAnnotation); + } + + internal override SyntaxNode YieldReturnStatement(SyntaxNode expressionOpt = null) + => SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, (ExpressionSyntax)expressionOpt); } } diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxGeneratorExtensions_Negate.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/SyntaxGeneratorExtensions_Negate.cs similarity index 94% rename from src/Workspaces/Core/Portable/Shared/Extensions/SyntaxGeneratorExtensions_Negate.cs rename to src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/SyntaxGeneratorExtensions_Negate.cs index acb64743947..d4301e0269c 100644 --- a/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxGeneratorExtensions_Negate.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/SyntaxGeneratorExtensions_Negate.cs @@ -33,25 +33,28 @@ internal static partial class SyntaxGeneratorExtensions public static SyntaxNode Negate( this SyntaxGenerator generator, + SyntaxGeneratorInternal generatorInternal, SyntaxNode expression, SemanticModel semanticModel, CancellationToken cancellationToken) { - return Negate(generator, expression, semanticModel, negateBinary: true, cancellationToken); + return Negate(generator, generatorInternal, expression, semanticModel, negateBinary: true, cancellationToken); } public static SyntaxNode Negate( this SyntaxGenerator generator, + SyntaxGeneratorInternal generatorInternal, SyntaxNode expression, SemanticModel semanticModel, bool negateBinary, CancellationToken cancellationToken) { - var syntaxFacts = generator.SyntaxFacts; + var syntaxFacts = generatorInternal.SyntaxFacts; if (syntaxFacts.IsParenthesizedExpression(expression)) { - return generator.AddParentheses( + return generatorInternal.AddParentheses( generator.Negate( + generatorInternal, syntaxFacts.GetExpressionOfParenthesizedExpression(expression), semanticModel, negateBinary, @@ -60,7 +63,7 @@ internal static partial class SyntaxGeneratorExtensions } if (negateBinary && syntaxFacts.IsBinaryExpression(expression)) { - return GetNegationOfBinaryExpression(expression, generator, semanticModel, cancellationToken); + return GetNegationOfBinaryExpression(expression, generator, generatorInternal, semanticModel, cancellationToken); } else if (syntaxFacts.IsLiteralExpression(expression)) { @@ -77,10 +80,11 @@ internal static partial class SyntaxGeneratorExtensions private static SyntaxNode GetNegationOfBinaryExpression( SyntaxNode expressionNode, SyntaxGenerator generator, + SyntaxGeneratorInternal generatorInternal, SemanticModel semanticModel, CancellationToken cancellationToken) { - var syntaxFacts = generator.SyntaxFacts; + var syntaxFacts = generatorInternal.SyntaxFacts; syntaxFacts.GetPartsOfBinaryExpression(expressionNode, out var leftOperand, out var operatorToken, out var rightOperand); var binaryOperation = semanticModel.GetOperation(expressionNode, cancellationToken) as IBinaryOperation; @@ -122,8 +126,8 @@ internal static partial class SyntaxGeneratorExtensions var newRightOperand = rightOperand; if (negateOperands) { - newLeftOperand = generator.Negate(leftOperand, semanticModel, cancellationToken); - newRightOperand = generator.Negate(rightOperand, semanticModel, cancellationToken); + newLeftOperand = generator.Negate(generatorInternal, leftOperand, semanticModel, cancellationToken); + newRightOperand = generator.Negate(generatorInternal, rightOperand, semanticModel, cancellationToken); } var newBinaryExpressionSyntax = NewBinaryOperation(binaryOperation, newLeftOperand, negatedKind, newRightOperand, generator, cancellationToken) @@ -135,7 +139,6 @@ internal static partial class SyntaxGeneratorExtensions } } - private static SyntaxNode NewBinaryOperation( IBinaryOperation binaryOperation, SyntaxNode leftOperand, diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SyntaxGeneratorInternalExtensions/SyntaxGeneratorInternal.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SyntaxGeneratorInternalExtensions/SyntaxGeneratorInternal.cs index 25135de1ab2..68cca9f55cc 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SyntaxGeneratorInternalExtensions/SyntaxGeneratorInternal.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SyntaxGeneratorInternalExtensions/SyntaxGeneratorInternal.cs @@ -3,6 +3,7 @@ // See the LICENSE file in the project root for more information. using Microsoft.CodeAnalysis.Host; +using Microsoft.CodeAnalysis.LanguageServices; namespace Microsoft.CodeAnalysis.Editing { @@ -15,6 +16,8 @@ namespace Microsoft.CodeAnalysis.Editing /// internal abstract class SyntaxGeneratorInternal : ILanguageService { + internal abstract ISyntaxFacts SyntaxFacts { get; } + /// /// Creates a statement that declares a single local variable with an optional initializer. /// @@ -36,5 +39,18 @@ internal SyntaxNode LocalDeclarationStatement(SyntaxToken name, SyntaxNode initi internal abstract SyntaxNode ConditionalAccessExpression(SyntaxNode expression, SyntaxNode whenNotNull); internal abstract SyntaxNode MemberBindingExpression(SyntaxNode name); + + internal abstract SyntaxNode RefExpression(SyntaxNode expression); + + /// + /// Wraps with parens. + /// + internal abstract SyntaxNode AddParentheses(SyntaxNode expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true); + + /// + /// Creates a statement that can be used to yield a value from an iterator method. + /// + /// An expression that can be yielded. + internal abstract SyntaxNode YieldReturnStatement(SyntaxNode expression); } } diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/WorkspaceExtensions.projitems b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/WorkspaceExtensions.projitems index 1313eaf7212..30cb1cc7299 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/WorkspaceExtensions.projitems +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/WorkspaceExtensions.projitems @@ -12,6 +12,7 @@ + diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicSyntaxGeneratorInternal.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicSyntaxGeneratorInternal.vb index 059b7a78d3e..d9c2159f1a5 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicSyntaxGeneratorInternal.vb +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicSyntaxGeneratorInternal.vb @@ -6,6 +6,8 @@ Imports System.Composition Imports System.Diagnostics.CodeAnalysis Imports Microsoft.CodeAnalysis.Editing Imports Microsoft.CodeAnalysis.Host.Mef +Imports Microsoft.CodeAnalysis.LanguageServices +Imports Microsoft.CodeAnalysis.VisualBasic.LanguageServices Imports Microsoft.CodeAnalysis.VisualBasic.Syntax Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration @@ -20,6 +22,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration Public Sub New() End Sub + Friend Overrides ReadOnly Property SyntaxFacts As ISyntaxFacts + Get + Return VisualBasicSyntaxFacts.Instance + End Get + End Property + Friend Overloads Overrides Function LocalDeclarationStatement(type As SyntaxNode, identifier As SyntaxToken, Optional initializer As SyntaxNode = Nothing, Optional isConst As Boolean = False) As SyntaxNode Return SyntaxFactory.LocalDeclarationStatement( SyntaxFactory.TokenList(SyntaxFactory.Token(If(isConst, SyntaxKind.ConstKeyword, SyntaxKind.DimKeyword))), @@ -56,5 +64,21 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration Friend Overrides Function MemberBindingExpression(name As SyntaxNode) As SyntaxNode Return SyntaxFactory.SimpleMemberAccessExpression(DirectCast(name, SimpleNameSyntax)) End Function + + Friend Overrides Function RefExpression(expression As SyntaxNode) As SyntaxNode + Return expression + End Function + + Friend Overrides Function AddParentheses(expression As SyntaxNode, Optional includeElasticTrivia As Boolean = True, Optional addSimplifierAnnotation As Boolean = True) As SyntaxNode + Return Parenthesize(expression, addSimplifierAnnotation) + End Function + + Friend Shared Function Parenthesize(expression As SyntaxNode, Optional addSimplifierAnnotation As Boolean = True) As ParenthesizedExpressionSyntax + Return DirectCast(expression, ExpressionSyntax).Parenthesize(addSimplifierAnnotation) + End Function + + Friend Overrides Function YieldReturnStatement(expression As SyntaxNode) As SyntaxNode + Return SyntaxFactory.YieldStatement(DirectCast(expression, ExpressionSyntax)) + End Function End Class End Namespace diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb index 3bddab37ccd..c90bf2dfa96 100644 --- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb +++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb @@ -31,8 +31,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration Friend Overrides ReadOnly Property RequiresExplicitImplementationForInterfaceMembers As Boolean = True - Friend Overrides ReadOnly Property SyntaxFacts As ISyntaxFacts = VisualBasicSyntaxFacts.Instance - Friend Overrides ReadOnly Property SyntaxGeneratorInternal As SyntaxGeneratorInternal = VisualBasicSyntaxGeneratorInternal.Instance Friend Overrides Function EndOfLine(text As String) As SyntaxTrivia @@ -73,12 +71,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration Return SyntaxFactory.TupleExpression(SyntaxFactory.SeparatedList(arguments.Select(AddressOf AsSimpleArgument))) End Function - Friend Overrides Function AddParentheses(expression As SyntaxNode, Optional includeElasticTrivia As Boolean = True, Optional addSimplifierAnnotation As Boolean = True) As SyntaxNode - Return Parenthesize(expression, addSimplifierAnnotation) - End Function - Private Function Parenthesize(expression As SyntaxNode, Optional addSimplifierAnnotation As Boolean = True) As ParenthesizedExpressionSyntax - Return DirectCast(expression, ExpressionSyntax).Parenthesize(addSimplifierAnnotation) + Return VisualBasicSyntaxGeneratorInternal.Parenthesize(expression, addSimplifierAnnotation) End Function Public Overrides Function AddExpression(left As SyntaxNode, right As SyntaxNode) As SyntaxNode @@ -377,10 +371,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration Return SyntaxFactory.ReturnStatement(DirectCast(expressionOpt, ExpressionSyntax)) End Function - Friend Overrides Function YieldReturnStatement(expression As SyntaxNode) As SyntaxNode - Return SyntaxFactory.YieldStatement(DirectCast(expression, ExpressionSyntax)) - End Function - Public Overrides Function ThisExpression() As SyntaxNode Return SyntaxFactory.MeExpression() End Function @@ -679,10 +669,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration Throw New NotSupportedException() End Function - Friend Overrides Function RefExpression(expression As SyntaxNode) As SyntaxNode - Return expression - End Function - #End Region #Region "Declarations" diff --git a/src/Workspaces/VisualBasic/Portable/Formatting/VisualBasicSyntaxFormattingService.vb b/src/Workspaces/VisualBasic/Portable/Formatting/VisualBasicSyntaxFormattingService.vb index ec1b8b2363c..cd786053007 100644 --- a/src/Workspaces/VisualBasic/Portable/Formatting/VisualBasicSyntaxFormattingService.vb +++ b/src/Workspaces/VisualBasic/Portable/Formatting/VisualBasicSyntaxFormattingService.vb @@ -26,6 +26,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting Private ReadOnly _rules As ImmutableList(Of AbstractFormattingRule) +#If CODE_STYLE Then + Public Shared ReadOnly Instance As New VisualBasicSyntaxFormattingService +#End If + #If Not CODE_STYLE Then -- GitLab