From 7adc1215b2af31ba601b75e0d2e49ebdbdb0d2ec Mon Sep 17 00:00:00 2001 From: Manish Vasani Date: Sat, 14 Mar 2020 09:15:06 -0700 Subject: [PATCH] Move certain Syntax querying APIs down from SyntaxGenerator to ISyntaxFacts. These APIs are used by accessibility related analyzers. This change also requires explicitly linking in the public type DeclarationKind into CodeStyle layer. --- .../Microsoft.CodeAnalysis.CodeStyle.csproj | 1 + .../Core/Analyzers/PublicAPI.Unshipped.txt | 30 ++ .../CodeGeneration/CSharpSyntaxGenerator.cs | 311 +------------- .../Core/Portable/Editing/DeclarationKind.cs | 5 +- .../Core/Portable/Editing/SyntaxGenerator.cs | 2 - .../Services/SyntaxFacts/CSharpSyntaxFacts.cs | 300 ++++++++++++++ .../SyntaxFacts/AbstractSyntaxFacts.cs | 16 + .../Core/Services/SyntaxFacts/ISyntaxFacts.cs | 22 + .../SyntaxFacts/VisualBasicSyntaxFacts.vb | 361 +++++++++++++++++ .../VisualBasicSyntaxGenerator.vb | 381 ++---------------- 10 files changed, 770 insertions(+), 659 deletions(-) diff --git a/src/CodeStyle/Core/Analyzers/Microsoft.CodeAnalysis.CodeStyle.csproj b/src/CodeStyle/Core/Analyzers/Microsoft.CodeAnalysis.CodeStyle.csproj index 1b023c00ad1..8513ea29d57 100644 --- a/src/CodeStyle/Core/Analyzers/Microsoft.CodeAnalysis.CodeStyle.csproj +++ b/src/CodeStyle/Core/Analyzers/Microsoft.CodeAnalysis.CodeStyle.csproj @@ -26,6 +26,7 @@ + diff --git a/src/CodeStyle/Core/Analyzers/PublicAPI.Unshipped.txt b/src/CodeStyle/Core/Analyzers/PublicAPI.Unshipped.txt index 0e3aedf652b..97fe5ed1ea3 100644 --- a/src/CodeStyle/Core/Analyzers/PublicAPI.Unshipped.txt +++ b/src/CodeStyle/Core/Analyzers/PublicAPI.Unshipped.txt @@ -1,3 +1,33 @@ +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.AddAccessor = 26 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Attribute = 22 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Class = 2 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.CompilationUnit = 1 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Constructor = 10 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.ConversionOperator = 9 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.CustomEvent = 17 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Delegate = 6 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Destructor = 11 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Enum = 5 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.EnumMember = 15 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Event = 16 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Field = 12 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.GetAccessor = 24 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Indexer = 14 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Interface = 4 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.LambdaExpression = 23 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Method = 7 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Namespace = 18 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.NamespaceImport = 19 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.None = 0 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Operator = 8 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Parameter = 20 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Property = 13 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.RaiseAccessor = 28 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.RemoveAccessor = 27 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.SetAccessor = 25 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Struct = 3 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind +Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind.Variable = 21 -> Microsoft.CodeAnalysis.Internal.Editing.DeclarationKind Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers.Equals(Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers modifiers) -> bool Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers.IsAbstract.get -> bool diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs index 97eb1c4d07f..46fd387914e 100644 --- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs +++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs @@ -767,7 +767,7 @@ internal override SyntaxNode AsInterfaceMember(SyntaxNode m) // convert field into property case SyntaxKind.FieldDeclaration: var f = (FieldDeclarationSyntax)member; - GetAccessibilityAndModifiers(f.Modifiers, out acc, out modifiers); + SyntaxFacts.GetAccessibilityAndModifiers(f.Modifiers, out acc, out modifiers, out _); return this.AsInterfaceMember( this.PropertyDeclaration(this.GetName(f), this.ClearTrivia(this.GetType(f)), acc, modifiers, getAccessorStatements: null, setAccessorStatements: null)); @@ -1319,79 +1319,12 @@ private SyntaxNode AsMemberOf(SyntaxNode declaration, SyntaxNode member) } } - internal override bool CanHaveAccessibility(SyntaxNode declaration) - { - switch (declaration.Kind()) - { - case SyntaxKind.ClassDeclaration: - case SyntaxKind.StructDeclaration: - case SyntaxKind.InterfaceDeclaration: - case SyntaxKind.EnumDeclaration: - case SyntaxKind.DelegateDeclaration: - case SyntaxKind.OperatorDeclaration: - case SyntaxKind.ConversionOperatorDeclaration: - case SyntaxKind.FieldDeclaration: - case SyntaxKind.EventFieldDeclaration: - case SyntaxKind.GetAccessorDeclaration: - case SyntaxKind.SetAccessorDeclaration: - case SyntaxKind.AddAccessorDeclaration: - case SyntaxKind.RemoveAccessorDeclaration: - return true; - - case SyntaxKind.VariableDeclaration: - case SyntaxKind.VariableDeclarator: - var declarationKind = this.GetDeclarationKind(declaration); - return declarationKind == DeclarationKind.Field || declarationKind == DeclarationKind.Event; - - case SyntaxKind.ConstructorDeclaration: - // Static constructor can't have accessibility - return !((ConstructorDeclarationSyntax)declaration).Modifiers.Any(SyntaxKind.StaticKeyword); - - case SyntaxKind.PropertyDeclaration: - return ((PropertyDeclarationSyntax)declaration).ExplicitInterfaceSpecifier == null; - - case SyntaxKind.IndexerDeclaration: - return ((IndexerDeclarationSyntax)declaration).ExplicitInterfaceSpecifier == null; - - case SyntaxKind.MethodDeclaration: - var method = (MethodDeclarationSyntax)declaration; - if (method.ExplicitInterfaceSpecifier != null) - { - // explicit interface methods can't have accessibility. - return false; - } - - if (method.Modifiers.Any(SyntaxKind.PartialKeyword)) - { - // partial methods can't have accessibility modifiers. - return false; - } - - return true; - - case SyntaxKind.EventDeclaration: - return ((EventDeclarationSyntax)declaration).ExplicitInterfaceSpecifier == null; - - default: - return false; - } - } - public override Accessibility GetAccessibility(SyntaxNode declaration) - { - if (!this.CanHaveAccessibility(declaration)) - { - return Accessibility.NotApplicable; - } - - var modifierTokens = GetModifierTokens(declaration); - GetAccessibilityAndModifiers(modifierTokens, out var accessibility, out _); - return accessibility; - } + => SyntaxFacts.GetAccessibility(declaration); public override SyntaxNode WithAccessibility(SyntaxNode declaration, Accessibility accessibility) { - if (!this.CanHaveAccessibility(declaration) && + if (!SyntaxFacts.CanHaveAccessibility(declaration) && accessibility != Accessibility.NotApplicable) { return declaration; @@ -1399,8 +1332,8 @@ public override SyntaxNode WithAccessibility(SyntaxNode declaration, Accessibili return this.Isolate(declaration, d => { - var tokens = GetModifierTokens(d); - GetAccessibilityAndModifiers(tokens, out _, out var modifiers); + var tokens = SyntaxFacts.GetModifierTokens(d); + SyntaxFacts.GetAccessibilityAndModifiers(tokens, out _, out var modifiers, out _); var newTokens = Merge(tokens, AsModifierList(accessibility, modifiers)); return SetModifierTokens(d, newTokens); }); @@ -1559,8 +1492,8 @@ private static DeclarationModifiers GetAllowedModifiers(SyntaxKind kind) public override DeclarationModifiers GetModifiers(SyntaxNode declaration) { - var modifierTokens = GetModifierTokens(declaration); - GetAccessibilityAndModifiers(modifierTokens, out _, out var modifiers); + var modifierTokens = SyntaxFacts.GetModifierTokens(declaration); + SyntaxFacts.GetAccessibilityAndModifiers(modifierTokens, out _, out var modifiers, out _); return modifiers; } @@ -1578,8 +1511,8 @@ private SyntaxNode WithModifiersInternal(SyntaxNode declaration, DeclarationModi { return this.Isolate(declaration, d => { - var tokens = GetModifierTokens(d); - GetAccessibilityAndModifiers(tokens, out var accessibility, out var tmp); + var tokens = SyntaxFacts.GetModifierTokens(d); + SyntaxFacts.GetAccessibilityAndModifiers(tokens, out var accessibility, out var tmp, out _); var newTokens = Merge(tokens, AsModifierList(accessibility, modifiers)); return SetModifierTokens(d, newTokens); }); @@ -1591,19 +1524,6 @@ private SyntaxNode WithModifiersInternal(SyntaxNode declaration, DeclarationModi } } - private static SyntaxTokenList GetModifierTokens(SyntaxNode declaration) - => declaration switch - { - MemberDeclarationSyntax memberDecl => memberDecl.Modifiers, - ParameterSyntax parameter => parameter.Modifiers, - LocalDeclarationStatementSyntax localDecl => localDecl.Modifiers, - LocalFunctionStatementSyntax localFunc => localFunc.Modifiers, - AccessorDeclarationSyntax accessor => accessor.Modifiers, - VariableDeclarationSyntax varDecl => GetModifierTokens(varDecl.Parent), - VariableDeclaratorSyntax varDecl => GetModifierTokens(varDecl.Parent), - _ => default, - }; - private static SyntaxNode SetModifierTokens(SyntaxNode declaration, SyntaxTokenList modifiers) => declaration switch { @@ -1696,51 +1616,6 @@ private static SyntaxTokenList AsModifierList(Accessibility accessibility, Decla return SyntaxFactory.TokenList(list); } - private static void GetAccessibilityAndModifiers(SyntaxTokenList modifierList, out Accessibility accessibility, out DeclarationModifiers modifiers) - { - accessibility = Accessibility.NotApplicable; - modifiers = DeclarationModifiers.None; - - foreach (var token in modifierList) - { - accessibility = (token.Kind(), accessibility) switch - { - (SyntaxKind.PublicKeyword, _) => Accessibility.Public, - - (SyntaxKind.PrivateKeyword, Accessibility.Protected) => Accessibility.ProtectedAndInternal, - (SyntaxKind.PrivateKeyword, _) => Accessibility.Private, - - (SyntaxKind.InternalKeyword, Accessibility.Protected) => Accessibility.ProtectedOrInternal, - (SyntaxKind.InternalKeyword, _) => Accessibility.Internal, - - (SyntaxKind.ProtectedKeyword, Accessibility.Private) => Accessibility.ProtectedAndInternal, - (SyntaxKind.ProtectedKeyword, Accessibility.Internal) => Accessibility.ProtectedOrInternal, - (SyntaxKind.ProtectedKeyword, _) => Accessibility.Protected, - - _ => accessibility, - }; - - modifiers |= token.Kind() switch - { - SyntaxKind.AbstractKeyword => DeclarationModifiers.Abstract, - SyntaxKind.NewKeyword => DeclarationModifiers.New, - SyntaxKind.OverrideKeyword => DeclarationModifiers.Override, - SyntaxKind.VirtualKeyword => DeclarationModifiers.Virtual, - SyntaxKind.StaticKeyword => DeclarationModifiers.Static, - SyntaxKind.AsyncKeyword => DeclarationModifiers.Async, - SyntaxKind.ConstKeyword => DeclarationModifiers.Const, - SyntaxKind.ReadOnlyKeyword => DeclarationModifiers.ReadOnly, - SyntaxKind.SealedKeyword => DeclarationModifiers.Sealed, - SyntaxKind.UnsafeKeyword => DeclarationModifiers.Unsafe, - SyntaxKind.PartialKeyword => DeclarationModifiers.Partial, - SyntaxKind.RefKeyword => DeclarationModifiers.Ref, - SyntaxKind.VolatileKeyword => DeclarationModifiers.Volatile, - SyntaxKind.ExternKeyword => DeclarationModifiers.Extern, - _ => DeclarationModifiers.None, - }; - } - } - private static TypeParameterListSyntax AsTypeParameterList(IEnumerable typeParameterNames) { var typeParameters = typeParameterNames != null @@ -1854,167 +1729,7 @@ public override SyntaxNode WithTypeConstraint(SyntaxNode declaration, string typ } public override DeclarationKind GetDeclarationKind(SyntaxNode declaration) - { - switch (declaration.Kind()) - { - case SyntaxKind.ClassDeclaration: - return DeclarationKind.Class; - case SyntaxKind.StructDeclaration: - return DeclarationKind.Struct; - case SyntaxKind.InterfaceDeclaration: - return DeclarationKind.Interface; - case SyntaxKind.EnumDeclaration: - return DeclarationKind.Enum; - case SyntaxKind.DelegateDeclaration: - return DeclarationKind.Delegate; - - case SyntaxKind.MethodDeclaration: - return DeclarationKind.Method; - case SyntaxKind.OperatorDeclaration: - return DeclarationKind.Operator; - case SyntaxKind.ConversionOperatorDeclaration: - return DeclarationKind.ConversionOperator; - case SyntaxKind.ConstructorDeclaration: - return DeclarationKind.Constructor; - case SyntaxKind.DestructorDeclaration: - return DeclarationKind.Destructor; - - case SyntaxKind.PropertyDeclaration: - return DeclarationKind.Property; - case SyntaxKind.IndexerDeclaration: - return DeclarationKind.Indexer; - case SyntaxKind.EventDeclaration: - return DeclarationKind.CustomEvent; - case SyntaxKind.EnumMemberDeclaration: - return DeclarationKind.EnumMember; - case SyntaxKind.CompilationUnit: - return DeclarationKind.CompilationUnit; - case SyntaxKind.NamespaceDeclaration: - return DeclarationKind.Namespace; - case SyntaxKind.UsingDirective: - return DeclarationKind.NamespaceImport; - case SyntaxKind.Parameter: - return DeclarationKind.Parameter; - - case SyntaxKind.ParenthesizedLambdaExpression: - case SyntaxKind.SimpleLambdaExpression: - return DeclarationKind.LambdaExpression; - - case SyntaxKind.FieldDeclaration: - var fd = (FieldDeclarationSyntax)declaration; - if (fd.Declaration != null && fd.Declaration.Variables.Count == 1) - { - // this node is considered the declaration if it contains only one variable. - return DeclarationKind.Field; - } - else - { - return DeclarationKind.None; - } - - case SyntaxKind.EventFieldDeclaration: - var ef = (EventFieldDeclarationSyntax)declaration; - if (ef.Declaration != null && ef.Declaration.Variables.Count == 1) - { - // this node is considered the declaration if it contains only one variable. - return DeclarationKind.Event; - } - else - { - return DeclarationKind.None; - } - - case SyntaxKind.LocalDeclarationStatement: - var ld = (LocalDeclarationStatementSyntax)declaration; - if (ld.Declaration != null && ld.Declaration.Variables.Count == 1) - { - // this node is considered the declaration if it contains only one variable. - return DeclarationKind.Variable; - } - else - { - return DeclarationKind.None; - } - - case SyntaxKind.VariableDeclaration: - { - var vd = (VariableDeclarationSyntax)declaration; - if (vd.Variables.Count == 1 && vd.Parent == null) - { - // this node is the declaration if it contains only one variable and has no parent. - return DeclarationKind.Variable; - } - else - { - return DeclarationKind.None; - } - } - - case SyntaxKind.VariableDeclarator: - { - var vd = declaration.Parent as VariableDeclarationSyntax; - - // this node is considered the declaration if it is one among many, or it has no parent - if (vd == null || vd.Variables.Count > 1) - { - if (ParentIsFieldDeclaration(vd)) - { - return DeclarationKind.Field; - } - else if (ParentIsEventFieldDeclaration(vd)) - { - return DeclarationKind.Event; - } - else - { - return DeclarationKind.Variable; - } - } - break; - } - - case SyntaxKind.AttributeList: - var list = (AttributeListSyntax)declaration; - if (list.Attributes.Count == 1) - { - return DeclarationKind.Attribute; - } - break; - - case SyntaxKind.Attribute: - if (!(declaration.Parent is AttributeListSyntax parentList) || parentList.Attributes.Count > 1) - { - return DeclarationKind.Attribute; - } - break; - - case SyntaxKind.GetAccessorDeclaration: - return DeclarationKind.GetAccessor; - case SyntaxKind.SetAccessorDeclaration: - return DeclarationKind.SetAccessor; - case SyntaxKind.AddAccessorDeclaration: - return DeclarationKind.AddAccessor; - case SyntaxKind.RemoveAccessorDeclaration: - return DeclarationKind.RemoveAccessor; - } - - return DeclarationKind.None; - } - - private static bool ParentIsFieldDeclaration(SyntaxNode node) - { - return node?.Parent.IsKind(SyntaxKind.FieldDeclaration) ?? false; - } - - private static bool ParentIsEventFieldDeclaration(SyntaxNode node) - { - return node?.Parent.IsKind(SyntaxKind.EventFieldDeclaration) ?? false; - } - - private static bool ParentIsLocalDeclarationStatement(SyntaxNode node) - { - return node?.Parent.IsKind(SyntaxKind.LocalDeclarationStatement) ?? false; - } + => SyntaxFacts.GetDeclarationKind(declaration); public override string GetName(SyntaxNode declaration) { @@ -2295,9 +2010,9 @@ private static SyntaxNode GetFullDeclaration(SyntaxNode declaration) { case SyntaxKind.VariableDeclaration: var vd = (VariableDeclarationSyntax)declaration; - if (ParentIsFieldDeclaration(vd) - || ParentIsEventFieldDeclaration(vd) - || ParentIsLocalDeclarationStatement(vd)) + if (CSharpSyntaxFacts.ParentIsFieldDeclaration(vd) + || CSharpSyntaxFacts.ParentIsEventFieldDeclaration(vd) + || CSharpSyntaxFacts.ParentIsLocalDeclarationStatement(vd)) { return vd.Parent; } diff --git a/src/Workspaces/Core/Portable/Editing/DeclarationKind.cs b/src/Workspaces/Core/Portable/Editing/DeclarationKind.cs index ff2d649122d..84e943c981b 100644 --- a/src/Workspaces/Core/Portable/Editing/DeclarationKind.cs +++ b/src/Workspaces/Core/Portable/Editing/DeclarationKind.cs @@ -2,8 +2,11 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. - +#if CODE_STYLE +namespace Microsoft.CodeAnalysis.Internal.Editing +#else namespace Microsoft.CodeAnalysis.Editing +#endif { public enum DeclarationKind { diff --git a/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs b/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs index 2ba1653c4d2..6d3850be0de 100644 --- a/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs +++ b/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs @@ -1064,8 +1064,6 @@ public SyntaxNode AddMembers(SyntaxNode declaration, params SyntaxNode[] members /// public abstract SyntaxNode WithAccessibility(SyntaxNode declaration, Accessibility accessibility); - internal abstract bool CanHaveAccessibility(SyntaxNode declaration); - /// /// Gets the for the declaration. /// diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs index fed3c6c0b10..937585f2944 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs @@ -18,6 +18,12 @@ using Microsoft.CodeAnalysis.Text; using Roslyn.Utilities; +#if CODE_STYLE +using Microsoft.CodeAnalysis.Internal.Editing; +#else +using Microsoft.CodeAnalysis.Editing; +#endif + namespace Microsoft.CodeAnalysis.CSharp.LanguageServices { internal class CSharpSyntaxFacts : AbstractSyntaxFacts, ISyntaxFacts @@ -1700,5 +1706,299 @@ public void GetPartsOfCastExpression(SyntaxNode node, out SyntaxNode type, out S public override SyntaxList GetAttributeLists(SyntaxNode node) => node.GetAttributeLists(); + + public override bool CanHaveAccessibility(SyntaxNode declaration) + { + switch (declaration.Kind()) + { + case SyntaxKind.ClassDeclaration: + case SyntaxKind.StructDeclaration: + case SyntaxKind.InterfaceDeclaration: + case SyntaxKind.EnumDeclaration: + case SyntaxKind.DelegateDeclaration: + case SyntaxKind.OperatorDeclaration: + case SyntaxKind.ConversionOperatorDeclaration: + case SyntaxKind.FieldDeclaration: + case SyntaxKind.EventFieldDeclaration: + case SyntaxKind.GetAccessorDeclaration: + case SyntaxKind.SetAccessorDeclaration: + case SyntaxKind.AddAccessorDeclaration: + case SyntaxKind.RemoveAccessorDeclaration: + return true; + + case SyntaxKind.VariableDeclaration: + case SyntaxKind.VariableDeclarator: + var declarationKind = this.GetDeclarationKind(declaration); + return declarationKind == DeclarationKind.Field || declarationKind == DeclarationKind.Event; + + case SyntaxKind.ConstructorDeclaration: + // Static constructor can't have accessibility + return !((ConstructorDeclarationSyntax)declaration).Modifiers.Any(SyntaxKind.StaticKeyword); + + case SyntaxKind.PropertyDeclaration: + return ((PropertyDeclarationSyntax)declaration).ExplicitInterfaceSpecifier == null; + + case SyntaxKind.IndexerDeclaration: + return ((IndexerDeclarationSyntax)declaration).ExplicitInterfaceSpecifier == null; + + case SyntaxKind.MethodDeclaration: + var method = (MethodDeclarationSyntax)declaration; + if (method.ExplicitInterfaceSpecifier != null) + { + // explicit interface methods can't have accessibility. + return false; + } + + if (method.Modifiers.Any(SyntaxKind.PartialKeyword)) + { + // partial methods can't have accessibility modifiers. + return false; + } + + return true; + + case SyntaxKind.EventDeclaration: + return ((EventDeclarationSyntax)declaration).ExplicitInterfaceSpecifier == null; + + default: + return false; + } + } + + public override Accessibility GetAccessibility(SyntaxNode declaration) + { + if (!CanHaveAccessibility(declaration)) + { + return Accessibility.NotApplicable; + } + + var modifierTokens = GetModifierTokens(declaration); + GetAccessibilityAndModifiers(modifierTokens, out var accessibility, out _, out _); + return accessibility; + } + + public override void GetAccessibilityAndModifiers(SyntaxTokenList modifierList, out Accessibility accessibility, out DeclarationModifiers modifiers, out bool isDefault) + { + accessibility = Accessibility.NotApplicable; + modifiers = DeclarationModifiers.None; + isDefault = false; + + foreach (var token in modifierList) + { + accessibility = (token.Kind(), accessibility) switch + { + (SyntaxKind.PublicKeyword, _) => Accessibility.Public, + + (SyntaxKind.PrivateKeyword, Accessibility.Protected) => Accessibility.ProtectedAndInternal, + (SyntaxKind.PrivateKeyword, _) => Accessibility.Private, + + (SyntaxKind.InternalKeyword, Accessibility.Protected) => Accessibility.ProtectedOrInternal, + (SyntaxKind.InternalKeyword, _) => Accessibility.Internal, + + (SyntaxKind.ProtectedKeyword, Accessibility.Private) => Accessibility.ProtectedAndInternal, + (SyntaxKind.ProtectedKeyword, Accessibility.Internal) => Accessibility.ProtectedOrInternal, + (SyntaxKind.ProtectedKeyword, _) => Accessibility.Protected, + + _ => accessibility, + }; + + modifiers |= token.Kind() switch + { + SyntaxKind.AbstractKeyword => DeclarationModifiers.Abstract, + SyntaxKind.NewKeyword => DeclarationModifiers.New, + SyntaxKind.OverrideKeyword => DeclarationModifiers.Override, + SyntaxKind.VirtualKeyword => DeclarationModifiers.Virtual, + SyntaxKind.StaticKeyword => DeclarationModifiers.Static, + SyntaxKind.AsyncKeyword => DeclarationModifiers.Async, + SyntaxKind.ConstKeyword => DeclarationModifiers.Const, + SyntaxKind.ReadOnlyKeyword => DeclarationModifiers.ReadOnly, + SyntaxKind.SealedKeyword => DeclarationModifiers.Sealed, + SyntaxKind.UnsafeKeyword => DeclarationModifiers.Unsafe, + SyntaxKind.PartialKeyword => DeclarationModifiers.Partial, + SyntaxKind.RefKeyword => DeclarationModifiers.Ref, + SyntaxKind.VolatileKeyword => DeclarationModifiers.Volatile, + SyntaxKind.ExternKeyword => DeclarationModifiers.Extern, + _ => DeclarationModifiers.None, + }; + + isDefault |= token.Kind() == SyntaxKind.DefaultKeyword; + } + } + + public override SyntaxTokenList GetModifierTokens(SyntaxNode declaration) + => declaration switch + { + MemberDeclarationSyntax memberDecl => memberDecl.Modifiers, + ParameterSyntax parameter => parameter.Modifiers, + LocalDeclarationStatementSyntax localDecl => localDecl.Modifiers, + LocalFunctionStatementSyntax localFunc => localFunc.Modifiers, + AccessorDeclarationSyntax accessor => accessor.Modifiers, + VariableDeclarationSyntax varDecl => GetModifierTokens(varDecl.Parent), + VariableDeclaratorSyntax varDecl => GetModifierTokens(varDecl.Parent), + _ => default, + }; + + public override DeclarationKind GetDeclarationKind(SyntaxNode declaration) + { + switch (declaration.Kind()) + { + case SyntaxKind.ClassDeclaration: + return DeclarationKind.Class; + case SyntaxKind.StructDeclaration: + return DeclarationKind.Struct; + case SyntaxKind.InterfaceDeclaration: + return DeclarationKind.Interface; + case SyntaxKind.EnumDeclaration: + return DeclarationKind.Enum; + case SyntaxKind.DelegateDeclaration: + return DeclarationKind.Delegate; + + case SyntaxKind.MethodDeclaration: + return DeclarationKind.Method; + case SyntaxKind.OperatorDeclaration: + return DeclarationKind.Operator; + case SyntaxKind.ConversionOperatorDeclaration: + return DeclarationKind.ConversionOperator; + case SyntaxKind.ConstructorDeclaration: + return DeclarationKind.Constructor; + case SyntaxKind.DestructorDeclaration: + return DeclarationKind.Destructor; + + case SyntaxKind.PropertyDeclaration: + return DeclarationKind.Property; + case SyntaxKind.IndexerDeclaration: + return DeclarationKind.Indexer; + case SyntaxKind.EventDeclaration: + return DeclarationKind.CustomEvent; + case SyntaxKind.EnumMemberDeclaration: + return DeclarationKind.EnumMember; + case SyntaxKind.CompilationUnit: + return DeclarationKind.CompilationUnit; + case SyntaxKind.NamespaceDeclaration: + return DeclarationKind.Namespace; + case SyntaxKind.UsingDirective: + return DeclarationKind.NamespaceImport; + case SyntaxKind.Parameter: + return DeclarationKind.Parameter; + + case SyntaxKind.ParenthesizedLambdaExpression: + case SyntaxKind.SimpleLambdaExpression: + return DeclarationKind.LambdaExpression; + + case SyntaxKind.FieldDeclaration: + var fd = (FieldDeclarationSyntax)declaration; + if (fd.Declaration != null && fd.Declaration.Variables.Count == 1) + { + // this node is considered the declaration if it contains only one variable. + return DeclarationKind.Field; + } + else + { + return DeclarationKind.None; + } + + case SyntaxKind.EventFieldDeclaration: + var ef = (EventFieldDeclarationSyntax)declaration; + if (ef.Declaration != null && ef.Declaration.Variables.Count == 1) + { + // this node is considered the declaration if it contains only one variable. + return DeclarationKind.Event; + } + else + { + return DeclarationKind.None; + } + + case SyntaxKind.LocalDeclarationStatement: + var ld = (LocalDeclarationStatementSyntax)declaration; + if (ld.Declaration != null && ld.Declaration.Variables.Count == 1) + { + // this node is considered the declaration if it contains only one variable. + return DeclarationKind.Variable; + } + else + { + return DeclarationKind.None; + } + + case SyntaxKind.VariableDeclaration: + { + var vd = (VariableDeclarationSyntax)declaration; + if (vd.Variables.Count == 1 && vd.Parent == null) + { + // this node is the declaration if it contains only one variable and has no parent. + return DeclarationKind.Variable; + } + else + { + return DeclarationKind.None; + } + } + + case SyntaxKind.VariableDeclarator: + { + var vd = declaration.Parent as VariableDeclarationSyntax; + + // this node is considered the declaration if it is one among many, or it has no parent + if (vd == null || vd.Variables.Count > 1) + { + if (ParentIsFieldDeclaration(vd)) + { + return DeclarationKind.Field; + } + else if (ParentIsEventFieldDeclaration(vd)) + { + return DeclarationKind.Event; + } + else + { + return DeclarationKind.Variable; + } + } + break; + } + + case SyntaxKind.AttributeList: + var list = (AttributeListSyntax)declaration; + if (list.Attributes.Count == 1) + { + return DeclarationKind.Attribute; + } + break; + + case SyntaxKind.Attribute: + if (!(declaration.Parent is AttributeListSyntax parentList) || parentList.Attributes.Count > 1) + { + return DeclarationKind.Attribute; + } + break; + + case SyntaxKind.GetAccessorDeclaration: + return DeclarationKind.GetAccessor; + case SyntaxKind.SetAccessorDeclaration: + return DeclarationKind.SetAccessor; + case SyntaxKind.AddAccessorDeclaration: + return DeclarationKind.AddAccessor; + case SyntaxKind.RemoveAccessorDeclaration: + return DeclarationKind.RemoveAccessor; + } + + return DeclarationKind.None; + } + + internal static bool ParentIsFieldDeclaration(SyntaxNode node) + { + return node?.Parent.IsKind(SyntaxKind.FieldDeclaration) ?? false; + } + + internal static bool ParentIsEventFieldDeclaration(SyntaxNode node) + { + return node?.Parent.IsKind(SyntaxKind.EventFieldDeclaration) ?? false; + } + + internal static bool ParentIsLocalDeclarationStatement(SyntaxNode node) + { + return node?.Parent.IsKind(SyntaxKind.LocalDeclarationStatement) ?? false; + } } } diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/AbstractSyntaxFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/AbstractSyntaxFacts.cs index 20da7a91634..5b02597b6b5 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/AbstractSyntaxFacts.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/AbstractSyntaxFacts.cs @@ -14,6 +14,12 @@ using Microsoft.CodeAnalysis.Text; using Roslyn.Utilities; +#if CODE_STYLE +using Microsoft.CodeAnalysis.Internal.Editing; +#else +using Microsoft.CodeAnalysis.Editing; +#endif + namespace Microsoft.CodeAnalysis.LanguageServices { internal abstract class AbstractSyntaxFacts @@ -504,5 +510,15 @@ protected int GetStartOfNodeExcludingAttributes(SyntaxNode root, SyntaxNode node public bool HasIncompleteParentMember(SyntaxNode node) => node?.Parent?.RawKind == SyntaxKinds.IncompleteMember; + + public abstract bool CanHaveAccessibility(SyntaxNode declaration); + + public abstract Accessibility GetAccessibility(SyntaxNode declaration); + + public abstract void GetAccessibilityAndModifiers(SyntaxTokenList modifierList, out Accessibility accessibility, out DeclarationModifiers modifiers, out bool isDefault); + + public abstract SyntaxTokenList GetModifierTokens(SyntaxNode declaration); + + public abstract DeclarationKind GetDeclarationKind(SyntaxNode declaration); } } diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFacts.cs index 321520a6a1b..6c2325be7de 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFacts.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFacts.cs @@ -9,6 +9,12 @@ using System.Threading; using Microsoft.CodeAnalysis.Text; +#if CODE_STYLE +using Microsoft.CodeAnalysis.Internal.Editing; +#else +using Microsoft.CodeAnalysis.Editing; +#endif + namespace Microsoft.CodeAnalysis.LanguageServices { internal partial interface ISyntaxFacts @@ -417,6 +423,22 @@ internal partial interface ISyntaxFacts SyntaxToken? GetDeclarationIdentifierIfOverride(SyntaxToken token); bool SpansPreprocessorDirective(IEnumerable nodes); + + bool CanHaveAccessibility(SyntaxNode declaration); + + /// + /// Gets the accessibility of the declaration. + /// + Accessibility GetAccessibility(SyntaxNode declaration); + + public abstract void GetAccessibilityAndModifiers(SyntaxTokenList modifierList, out Accessibility accessibility, out DeclarationModifiers modifiers, out bool isDefault); + + public abstract SyntaxTokenList GetModifierTokens(SyntaxNode declaration); + + /// + /// Gets the for the declaration. + /// + DeclarationKind GetDeclarationKind(SyntaxNode declaration); } [Flags] diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb index 2060f958edb..d5a0af03882 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb @@ -12,6 +12,12 @@ Imports Microsoft.CodeAnalysis.Text Imports Microsoft.CodeAnalysis.VisualBasic.Syntax Imports Microsoft.CodeAnalysis.VisualBasic.SyntaxFacts +#If CODE_STYLE Then +Imports Microsoft.CodeAnalysis.Internal.Editing +#Else +Imports Microsoft.CodeAnalysis.Editing +#End If + Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices Friend Class VisualBasicSyntaxFacts Inherits AbstractSyntaxFacts @@ -1869,5 +1875,360 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices Return False End Function + + Public Overrides Function CanHaveAccessibility(declaration As SyntaxNode) As Boolean Implements ISyntaxFacts.CanHaveAccessibility + Select Case declaration.Kind + Case SyntaxKind.ClassBlock, + SyntaxKind.ClassStatement, + SyntaxKind.StructureBlock, + SyntaxKind.StructureStatement, + SyntaxKind.InterfaceBlock, + SyntaxKind.InterfaceStatement, + SyntaxKind.EnumBlock, + SyntaxKind.EnumStatement, + SyntaxKind.ModuleBlock, + SyntaxKind.ModuleStatement, + SyntaxKind.DelegateFunctionStatement, + SyntaxKind.DelegateSubStatement, + SyntaxKind.FieldDeclaration, + SyntaxKind.FunctionBlock, + SyntaxKind.SubBlock, + SyntaxKind.FunctionStatement, + SyntaxKind.SubStatement, + SyntaxKind.PropertyBlock, + SyntaxKind.PropertyStatement, + SyntaxKind.OperatorBlock, + SyntaxKind.OperatorStatement, + SyntaxKind.EventBlock, + SyntaxKind.EventStatement, + SyntaxKind.GetAccessorBlock, + SyntaxKind.GetAccessorStatement, + SyntaxKind.SetAccessorBlock, + SyntaxKind.SetAccessorStatement, + SyntaxKind.AddHandlerAccessorBlock, + SyntaxKind.AddHandlerAccessorStatement, + SyntaxKind.RemoveHandlerAccessorBlock, + SyntaxKind.RemoveHandlerAccessorStatement, + SyntaxKind.RaiseEventAccessorBlock, + SyntaxKind.RaiseEventAccessorStatement + Return True + + Case SyntaxKind.ConstructorBlock, + SyntaxKind.SubNewStatement + ' Shared constructor cannot have modifiers in VB. + Return Not declaration.GetModifiers().Any(SyntaxKind.SharedKeyword) + + Case SyntaxKind.ModifiedIdentifier + Return If(IsChildOf(declaration, SyntaxKind.VariableDeclarator), + CanHaveAccessibility(declaration.Parent), + False) + + Case SyntaxKind.VariableDeclarator + Return If(IsChildOfVariableDeclaration(declaration), + CanHaveAccessibility(declaration.Parent), + False) + + Case Else + Return False + End Select + End Function + + Friend Shared Function IsChildOf(node As SyntaxNode, kind As SyntaxKind) As Boolean + Return node.Parent IsNot Nothing AndAlso node.Parent.IsKind(kind) + End Function + + Friend Shared Function IsChildOfVariableDeclaration(node As SyntaxNode) As Boolean + Return IsChildOf(node, SyntaxKind.FieldDeclaration) OrElse IsChildOf(node, SyntaxKind.LocalDeclarationStatement) + End Function + + Public Overrides Function GetAccessibility(declaration As SyntaxNode) As Accessibility Implements ISyntaxFacts.GetAccessibility + If Not CanHaveAccessibility(declaration) Then + Return Accessibility.NotApplicable + End If + + Dim tokens = GetModifierTokens(declaration) + Dim acc As Accessibility + Dim mods As DeclarationModifiers + Dim isDefault As Boolean + GetAccessibilityAndModifiers(tokens, acc, mods, isDefault) + Return acc + End Function + + Public Overrides Function GetModifierTokens(declaration As SyntaxNode) As SyntaxTokenList Implements ISyntaxFacts.GetModifierTokens + Select Case declaration.Kind + Case SyntaxKind.ClassBlock + Return DirectCast(declaration, ClassBlockSyntax).BlockStatement.Modifiers + Case SyntaxKind.ClassStatement + Return DirectCast(declaration, ClassStatementSyntax).Modifiers + Case SyntaxKind.StructureBlock + Return DirectCast(declaration, StructureBlockSyntax).BlockStatement.Modifiers + Case SyntaxKind.StructureStatement + Return DirectCast(declaration, StructureStatementSyntax).Modifiers + Case SyntaxKind.InterfaceBlock + Return DirectCast(declaration, InterfaceBlockSyntax).BlockStatement.Modifiers + Case SyntaxKind.InterfaceStatement + Return DirectCast(declaration, InterfaceStatementSyntax).Modifiers + Case SyntaxKind.EnumBlock + Return DirectCast(declaration, EnumBlockSyntax).EnumStatement.Modifiers + Case SyntaxKind.EnumStatement + Return DirectCast(declaration, EnumStatementSyntax).Modifiers + Case SyntaxKind.ModuleBlock + Return DirectCast(declaration, ModuleBlockSyntax).ModuleStatement.Modifiers + Case SyntaxKind.ModuleStatement + Return DirectCast(declaration, ModuleStatementSyntax).Modifiers + Case SyntaxKind.DelegateFunctionStatement, + SyntaxKind.DelegateSubStatement + Return DirectCast(declaration, DelegateStatementSyntax).Modifiers + Case SyntaxKind.FieldDeclaration + Return DirectCast(declaration, FieldDeclarationSyntax).Modifiers + Case SyntaxKind.FunctionBlock, + SyntaxKind.SubBlock + Return DirectCast(declaration, MethodBlockSyntax).BlockStatement.Modifiers + Case SyntaxKind.ConstructorBlock + Return DirectCast(declaration, ConstructorBlockSyntax).BlockStatement.Modifiers + Case SyntaxKind.FunctionStatement, + SyntaxKind.SubStatement + Return DirectCast(declaration, MethodStatementSyntax).Modifiers + Case SyntaxKind.SubNewStatement + Return DirectCast(declaration, SubNewStatementSyntax).Modifiers + Case SyntaxKind.PropertyBlock + Return DirectCast(declaration, PropertyBlockSyntax).PropertyStatement.Modifiers + Case SyntaxKind.PropertyStatement + Return DirectCast(declaration, PropertyStatementSyntax).Modifiers + Case SyntaxKind.OperatorBlock + Return DirectCast(declaration, OperatorBlockSyntax).BlockStatement.Modifiers + Case SyntaxKind.OperatorStatement + Return DirectCast(declaration, OperatorStatementSyntax).Modifiers + Case SyntaxKind.EventBlock + Return DirectCast(declaration, EventBlockSyntax).EventStatement.Modifiers + Case SyntaxKind.EventStatement + Return DirectCast(declaration, EventStatementSyntax).Modifiers + Case SyntaxKind.ModifiedIdentifier + If IsChildOf(declaration, SyntaxKind.VariableDeclarator) Then + Return GetModifierTokens(declaration.Parent) + End If + Case SyntaxKind.LocalDeclarationStatement + Return DirectCast(declaration, LocalDeclarationStatementSyntax).Modifiers + Case SyntaxKind.VariableDeclarator + If IsChildOfVariableDeclaration(declaration) Then + Return GetModifierTokens(declaration.Parent) + End If + Case SyntaxKind.GetAccessorBlock, + SyntaxKind.SetAccessorBlock, + SyntaxKind.AddHandlerAccessorBlock, + SyntaxKind.RemoveHandlerAccessorBlock, + SyntaxKind.RaiseEventAccessorBlock + Return GetModifierTokens(DirectCast(declaration, AccessorBlockSyntax).AccessorStatement) + Case SyntaxKind.GetAccessorStatement, + SyntaxKind.SetAccessorStatement, + SyntaxKind.AddHandlerAccessorStatement, + SyntaxKind.RemoveHandlerAccessorStatement, + SyntaxKind.RaiseEventAccessorStatement + Return DirectCast(declaration, AccessorStatementSyntax).Modifiers + Case Else + Return Nothing + End Select + End Function + + Public Overrides Sub GetAccessibilityAndModifiers(modifierTokens As SyntaxTokenList, ByRef accessibility As Accessibility, ByRef modifiers As DeclarationModifiers, ByRef isDefault As Boolean) Implements ISyntaxFacts.GetAccessibilityAndModifiers + accessibility = Accessibility.NotApplicable + modifiers = DeclarationModifiers.None + isDefault = False + + For Each token In modifierTokens + Select Case token.Kind + Case SyntaxKind.DefaultKeyword + isDefault = True + Case SyntaxKind.PublicKeyword + accessibility = Accessibility.Public + Case SyntaxKind.PrivateKeyword + If accessibility = Accessibility.Protected Then + accessibility = Accessibility.ProtectedAndFriend + Else + accessibility = Accessibility.Private + End If + Case SyntaxKind.FriendKeyword + If accessibility = Accessibility.Protected Then + accessibility = Accessibility.ProtectedOrFriend + Else + accessibility = Accessibility.Friend + End If + Case SyntaxKind.ProtectedKeyword + If accessibility = Accessibility.Friend Then + accessibility = Accessibility.ProtectedOrFriend + ElseIf accessibility = Accessibility.Private Then + accessibility = Accessibility.ProtectedAndFriend + Else + accessibility = Accessibility.Protected + End If + Case SyntaxKind.MustInheritKeyword, SyntaxKind.MustOverrideKeyword + modifiers = modifiers Or DeclarationModifiers.Abstract + Case SyntaxKind.ShadowsKeyword + modifiers = modifiers Or DeclarationModifiers.[New] + Case SyntaxKind.OverridesKeyword + modifiers = modifiers Or DeclarationModifiers.Override + Case SyntaxKind.OverridableKeyword + modifiers = modifiers Or DeclarationModifiers.Virtual + Case SyntaxKind.SharedKeyword + modifiers = modifiers Or DeclarationModifiers.Static + Case SyntaxKind.AsyncKeyword + modifiers = modifiers Or DeclarationModifiers.Async + Case SyntaxKind.ConstKeyword + modifiers = modifiers Or DeclarationModifiers.Const + Case SyntaxKind.ReadOnlyKeyword + modifiers = modifiers Or DeclarationModifiers.ReadOnly + Case SyntaxKind.WriteOnlyKeyword + modifiers = modifiers Or DeclarationModifiers.WriteOnly + Case SyntaxKind.NotInheritableKeyword, SyntaxKind.NotOverridableKeyword + modifiers = modifiers Or DeclarationModifiers.Sealed + Case SyntaxKind.WithEventsKeyword + modifiers = modifiers Or DeclarationModifiers.WithEvents + Case SyntaxKind.PartialKeyword + modifiers = modifiers Or DeclarationModifiers.Partial + End Select + Next + End Sub + + Public Overrides Function GetDeclarationKind(declaration As SyntaxNode) As DeclarationKind Implements ISyntaxFacts.GetDeclarationKind + Select Case declaration.Kind + Case SyntaxKind.CompilationUnit + Return DeclarationKind.CompilationUnit + Case SyntaxKind.NamespaceBlock + Return DeclarationKind.Namespace + Case SyntaxKind.ImportsStatement + Return DeclarationKind.NamespaceImport + Case SyntaxKind.ClassBlock + Return DeclarationKind.Class + Case SyntaxKind.StructureBlock + Return DeclarationKind.Struct + Case SyntaxKind.InterfaceBlock + Return DeclarationKind.Interface + Case SyntaxKind.EnumBlock + Return DeclarationKind.Enum + Case SyntaxKind.EnumMemberDeclaration + Return DeclarationKind.EnumMember + Case SyntaxKind.DelegateFunctionStatement, + SyntaxKind.DelegateSubStatement + Return DeclarationKind.Delegate + Case SyntaxKind.FunctionBlock, + SyntaxKind.SubBlock + Return DeclarationKind.Method + Case SyntaxKind.FunctionStatement + If Not IsChildOf(declaration, SyntaxKind.FunctionBlock) Then + Return DeclarationKind.Method + End If + Case SyntaxKind.SubStatement + If Not IsChildOf(declaration, SyntaxKind.SubBlock) Then + Return DeclarationKind.Method + End If + Case SyntaxKind.ConstructorBlock + Return DeclarationKind.Constructor + Case SyntaxKind.PropertyBlock + If IsIndexer(declaration) Then + Return DeclarationKind.Indexer + Else + Return DeclarationKind.Property + End If + Case SyntaxKind.PropertyStatement + If Not IsChildOf(declaration, SyntaxKind.PropertyBlock) Then + If IsIndexer(declaration) Then + Return DeclarationKind.Indexer + Else + Return DeclarationKind.Property + End If + End If + Case SyntaxKind.OperatorBlock + Return DeclarationKind.Operator + Case SyntaxKind.OperatorStatement + If Not IsChildOf(declaration, SyntaxKind.OperatorBlock) Then + Return DeclarationKind.Operator + End If + Case SyntaxKind.EventBlock + Return DeclarationKind.CustomEvent + Case SyntaxKind.EventStatement + If Not IsChildOf(declaration, SyntaxKind.EventBlock) Then + Return DeclarationKind.Event + End If + Case SyntaxKind.Parameter + Return DeclarationKind.Parameter + Case SyntaxKind.FieldDeclaration + If GetDeclarationCount(declaration) = 1 Then + Return DeclarationKind.Field + End If + Case SyntaxKind.LocalDeclarationStatement + If GetDeclarationCount(declaration) = 1 Then + Return DeclarationKind.Variable + End If + Case SyntaxKind.ModifiedIdentifier + If IsChildOf(declaration, SyntaxKind.VariableDeclarator) Then + If IsChildOf(declaration.Parent, SyntaxKind.FieldDeclaration) And GetDeclarationCount(declaration.Parent.Parent) > 1 Then + Return DeclarationKind.Field + ElseIf IsChildOf(declaration.Parent, SyntaxKind.LocalDeclarationStatement) And GetDeclarationCount(declaration.Parent.Parent) > 1 Then + Return DeclarationKind.Variable + End If + End If + Case SyntaxKind.Attribute + Dim list = TryCast(declaration.Parent, AttributeListSyntax) + If list Is Nothing OrElse list.Attributes.Count > 1 Then + Return DeclarationKind.Attribute + End If + Case SyntaxKind.AttributeList + Dim list = DirectCast(declaration, AttributeListSyntax) + If list.Attributes.Count = 1 Then + Return DeclarationKind.Attribute + End If + Case SyntaxKind.GetAccessorBlock + Return DeclarationKind.GetAccessor + Case SyntaxKind.SetAccessorBlock + Return DeclarationKind.SetAccessor + Case SyntaxKind.AddHandlerAccessorBlock + Return DeclarationKind.AddAccessor + Case SyntaxKind.RemoveHandlerAccessorBlock + Return DeclarationKind.RemoveAccessor + Case SyntaxKind.RaiseEventAccessorBlock + Return DeclarationKind.RaiseAccessor + End Select + Return DeclarationKind.None + End Function + + Private Shared Function GetDeclarationCount(nodes As IReadOnlyList(Of SyntaxNode)) As Integer + Dim count As Integer = 0 + For i = 0 To nodes.Count - 1 + count = count + GetDeclarationCount(nodes(i)) + Next + Return count + End Function + + Friend Shared Function GetDeclarationCount(node As SyntaxNode) As Integer + Select Case node.Kind + Case SyntaxKind.FieldDeclaration + Return GetDeclarationCount(DirectCast(node, FieldDeclarationSyntax).Declarators) + Case SyntaxKind.LocalDeclarationStatement + Return GetDeclarationCount(DirectCast(node, LocalDeclarationStatementSyntax).Declarators) + Case SyntaxKind.VariableDeclarator + Return DirectCast(node, VariableDeclaratorSyntax).Names.Count + Case SyntaxKind.AttributesStatement + Return GetDeclarationCount(DirectCast(node, AttributesStatementSyntax).AttributeLists) + Case SyntaxKind.AttributeList + Return DirectCast(node, AttributeListSyntax).Attributes.Count + Case SyntaxKind.ImportsStatement + Return DirectCast(node, ImportsStatementSyntax).ImportsClauses.Count + End Select + Return 1 + End Function + + Private Shared Function IsIndexer(declaration As SyntaxNode) As Boolean + Select Case declaration.Kind + Case SyntaxKind.PropertyBlock + Dim p = DirectCast(declaration, PropertyBlockSyntax).PropertyStatement + Return p.ParameterList IsNot Nothing AndAlso p.ParameterList.Parameters.Count > 0 AndAlso p.Modifiers.Any(SyntaxKind.DefaultKeyword) + Case SyntaxKind.PropertyStatement + If Not IsChildOf(declaration, SyntaxKind.PropertyBlock) Then + Dim p = DirectCast(declaration, PropertyStatementSyntax) + Return p.ParameterList IsNot Nothing AndAlso p.ParameterList.Parameters.Count > 0 AndAlso p.Modifiers.Any(SyntaxKind.DefaultKeyword) + End If + End Select + Return False + 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 061a8351626..7968b1529fc 100644 --- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb +++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb @@ -1273,7 +1273,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration Dim modifiers As DeclarationModifiers Dim isDefault As Boolean - Me.GetAccessibilityAndModifiers(modifierList, access, modifiers, isDefault) + SyntaxFacts.GetAccessibilityAndModifiers(modifierList, access, modifiers, isDefault) Return isDefault End Function @@ -1283,7 +1283,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration Dim modifiers As DeclarationModifiers Dim currentIsDefault As Boolean - Me.GetAccessibilityAndModifiers(modifierList, access, modifiers, currentIsDefault) + SyntaxFacts.GetAccessibilityAndModifiers(modifierList, access, modifiers, currentIsDefault) If currentIsDefault <> isDefault Then Return GetModifierList(access, modifiers, kind, isDefault) @@ -1809,139 +1809,19 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration End Function Public Overrides Function GetDeclarationKind(declaration As SyntaxNode) As DeclarationKind - Select Case declaration.Kind - Case SyntaxKind.CompilationUnit - Return DeclarationKind.CompilationUnit - Case SyntaxKind.NamespaceBlock - Return DeclarationKind.Namespace - Case SyntaxKind.ImportsStatement - Return DeclarationKind.NamespaceImport - Case SyntaxKind.ClassBlock - Return DeclarationKind.Class - Case SyntaxKind.StructureBlock - Return DeclarationKind.Struct - Case SyntaxKind.InterfaceBlock - Return DeclarationKind.Interface - Case SyntaxKind.EnumBlock - Return DeclarationKind.Enum - Case SyntaxKind.EnumMemberDeclaration - Return DeclarationKind.EnumMember - Case SyntaxKind.DelegateFunctionStatement, - SyntaxKind.DelegateSubStatement - Return DeclarationKind.Delegate - Case SyntaxKind.FunctionBlock, - SyntaxKind.SubBlock - Return DeclarationKind.Method - Case SyntaxKind.FunctionStatement - If Not IsChildOf(declaration, SyntaxKind.FunctionBlock) Then - Return DeclarationKind.Method - End If - Case SyntaxKind.SubStatement - If Not IsChildOf(declaration, SyntaxKind.SubBlock) Then - Return DeclarationKind.Method - End If - Case SyntaxKind.ConstructorBlock - Return DeclarationKind.Constructor - Case SyntaxKind.PropertyBlock - If IsIndexer(declaration) Then - Return DeclarationKind.Indexer - Else - Return DeclarationKind.Property - End If - Case SyntaxKind.PropertyStatement - If Not IsChildOf(declaration, SyntaxKind.PropertyBlock) Then - If IsIndexer(declaration) Then - Return DeclarationKind.Indexer - Else - Return DeclarationKind.Property - End If - End If - Case SyntaxKind.OperatorBlock - Return DeclarationKind.Operator - Case SyntaxKind.OperatorStatement - If Not IsChildOf(declaration, SyntaxKind.OperatorBlock) Then - Return DeclarationKind.Operator - End If - Case SyntaxKind.EventBlock - Return DeclarationKind.CustomEvent - Case SyntaxKind.EventStatement - If Not IsChildOf(declaration, SyntaxKind.EventBlock) Then - Return DeclarationKind.Event - End If - Case SyntaxKind.Parameter - Return DeclarationKind.Parameter - Case SyntaxKind.FieldDeclaration - If GetDeclarationCount(declaration) = 1 Then - Return DeclarationKind.Field - End If - Case SyntaxKind.LocalDeclarationStatement - If GetDeclarationCount(declaration) = 1 Then - Return DeclarationKind.Variable - End If - Case SyntaxKind.ModifiedIdentifier - If IsChildOf(declaration, SyntaxKind.VariableDeclarator) Then - If IsChildOf(declaration.Parent, SyntaxKind.FieldDeclaration) And GetDeclarationCount(declaration.Parent.Parent) > 1 Then - Return DeclarationKind.Field - ElseIf IsChildOf(declaration.Parent, SyntaxKind.LocalDeclarationStatement) And GetDeclarationCount(declaration.Parent.Parent) > 1 Then - Return DeclarationKind.Variable - End If - End If - Case SyntaxKind.Attribute - Dim list = TryCast(declaration.Parent, AttributeListSyntax) - If list Is Nothing OrElse list.Attributes.Count > 1 Then - Return DeclarationKind.Attribute - End If - Case SyntaxKind.AttributeList - Dim list = DirectCast(declaration, AttributeListSyntax) - If list.Attributes.Count = 1 Then - Return DeclarationKind.Attribute - End If - Case SyntaxKind.GetAccessorBlock - Return DeclarationKind.GetAccessor - Case SyntaxKind.SetAccessorBlock - Return DeclarationKind.SetAccessor - Case SyntaxKind.AddHandlerAccessorBlock - Return DeclarationKind.AddAccessor - Case SyntaxKind.RemoveHandlerAccessorBlock - Return DeclarationKind.RemoveAccessor - Case SyntaxKind.RaiseEventAccessorBlock - Return DeclarationKind.RaiseAccessor - End Select - Return DeclarationKind.None - End Function - - Private Function GetDeclarationCount(nodes As IReadOnlyList(Of SyntaxNode)) As Integer - Dim count As Integer = 0 - For i = 0 To nodes.Count - 1 - count = count + GetDeclarationCount(nodes(i)) - Next - Return count + Return SyntaxFacts.GetDeclarationKind(declaration) End Function Private Function GetDeclarationCount(node As SyntaxNode) As Integer - Select Case node.Kind - Case SyntaxKind.FieldDeclaration - Return GetDeclarationCount(DirectCast(node, FieldDeclarationSyntax).Declarators) - Case SyntaxKind.LocalDeclarationStatement - Return GetDeclarationCount(DirectCast(node, LocalDeclarationStatementSyntax).Declarators) - Case SyntaxKind.VariableDeclarator - Return DirectCast(node, VariableDeclaratorSyntax).Names.Count - Case SyntaxKind.AttributesStatement - Return GetDeclarationCount(DirectCast(node, AttributesStatementSyntax).AttributeLists) - Case SyntaxKind.AttributeList - Return DirectCast(node, AttributeListSyntax).Attributes.Count - Case SyntaxKind.ImportsStatement - Return DirectCast(node, ImportsStatementSyntax).ImportsClauses.Count - End Select - Return 1 + Return VisualBasicSyntaxFacts.GetDeclarationCount(node) End Function Private Shared Function IsChildOf(node As SyntaxNode, kind As SyntaxKind) As Boolean - Return node.Parent IsNot Nothing AndAlso node.Parent.IsKind(kind) + Return VisualBasicSyntaxFacts.IsChildOf(node, kind) End Function Private Shared Function IsChildOfVariableDeclaration(node As SyntaxNode) As Boolean - Return IsChildOf(node, SyntaxKind.FieldDeclaration) OrElse IsChildOf(node, SyntaxKind.LocalDeclarationStatement) + Return VisualBasicSyntaxFacts.IsChildOfVariableDeclaration(node) End Function Private Function Isolate(declaration As SyntaxNode, editor As Func(Of SyntaxNode, SyntaxNode)) As SyntaxNode @@ -2011,20 +1891,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration End Select End Function - Private Shared Function IsIndexer(declaration As SyntaxNode) As Boolean - Select Case declaration.Kind - Case SyntaxKind.PropertyBlock - Dim p = DirectCast(declaration, PropertyBlockSyntax).PropertyStatement - Return p.ParameterList IsNot Nothing AndAlso p.ParameterList.Parameters.Count > 0 AndAlso p.Modifiers.Any(SyntaxKind.DefaultKeyword) - Case SyntaxKind.PropertyStatement - If Not IsChildOf(declaration, SyntaxKind.PropertyBlock) Then - Dim p = DirectCast(declaration, PropertyStatementSyntax) - Return p.ParameterList IsNot Nothing AndAlso p.ParameterList.Parameters.Count > 0 AndAlso p.Modifiers.Any(SyntaxKind.DefaultKeyword) - End If - End Select - Return False - End Function - Public Overrides Function GetName(declaration As SyntaxNode) As String Select Case declaration.Kind Case SyntaxKind.ClassBlock @@ -2473,11 +2339,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration End Function Public Overrides Function GetModifiers(declaration As SyntaxNode) As DeclarationModifiers - Dim tokens = GetModifierTokens(declaration) + Dim tokens = SyntaxFacts.GetModifierTokens(declaration) Dim acc As Accessibility Dim mods As DeclarationModifiers Dim isDefault As Boolean - GetAccessibilityAndModifiers(tokens, acc, mods, isDefault) + SyntaxFacts.GetAccessibilityAndModifiers(tokens, acc, mods, isDefault) Return mods End Function @@ -2486,12 +2352,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration End Function Private Function WithModifiersInternal(declaration As SyntaxNode, modifiers As DeclarationModifiers) As SyntaxNode - Dim tokens = GetModifierTokens(declaration) + Dim tokens = SyntaxFacts.GetModifierTokens(declaration) Dim acc As Accessibility Dim currentMods As DeclarationModifiers Dim isDefault As Boolean - GetAccessibilityAndModifiers(tokens, acc, currentMods, isDefault) + SyntaxFacts.GetAccessibilityAndModifiers(tokens, acc, currentMods, isDefault) If (currentMods <> modifiers) Then Dim newTokens = GetModifierList(acc, modifiers And GetAllowedModifiers(declaration.Kind), GetDeclarationKind(declaration), isDefault) @@ -2501,82 +2367,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration End If End Function - Private Function GetModifierTokens(declaration As SyntaxNode) As SyntaxTokenList - Select Case declaration.Kind - Case SyntaxKind.ClassBlock - Return DirectCast(declaration, ClassBlockSyntax).BlockStatement.Modifiers - Case SyntaxKind.ClassStatement - Return DirectCast(declaration, ClassStatementSyntax).Modifiers - Case SyntaxKind.StructureBlock - Return DirectCast(declaration, StructureBlockSyntax).BlockStatement.Modifiers - Case SyntaxKind.StructureStatement - Return DirectCast(declaration, StructureStatementSyntax).Modifiers - Case SyntaxKind.InterfaceBlock - Return DirectCast(declaration, InterfaceBlockSyntax).BlockStatement.Modifiers - Case SyntaxKind.InterfaceStatement - Return DirectCast(declaration, InterfaceStatementSyntax).Modifiers - Case SyntaxKind.EnumBlock - Return DirectCast(declaration, EnumBlockSyntax).EnumStatement.Modifiers - Case SyntaxKind.EnumStatement - Return DirectCast(declaration, EnumStatementSyntax).Modifiers - Case SyntaxKind.ModuleBlock - Return DirectCast(declaration, ModuleBlockSyntax).ModuleStatement.Modifiers - Case SyntaxKind.ModuleStatement - Return DirectCast(declaration, ModuleStatementSyntax).Modifiers - Case SyntaxKind.DelegateFunctionStatement, - SyntaxKind.DelegateSubStatement - Return DirectCast(declaration, DelegateStatementSyntax).Modifiers - Case SyntaxKind.FieldDeclaration - Return DirectCast(declaration, FieldDeclarationSyntax).Modifiers - Case SyntaxKind.FunctionBlock, - SyntaxKind.SubBlock - Return DirectCast(declaration, MethodBlockSyntax).BlockStatement.Modifiers - Case SyntaxKind.ConstructorBlock - Return DirectCast(declaration, ConstructorBlockSyntax).BlockStatement.Modifiers - Case SyntaxKind.FunctionStatement, - SyntaxKind.SubStatement - Return DirectCast(declaration, MethodStatementSyntax).Modifiers - Case SyntaxKind.SubNewStatement - Return DirectCast(declaration, SubNewStatementSyntax).Modifiers - Case SyntaxKind.PropertyBlock - Return DirectCast(declaration, PropertyBlockSyntax).PropertyStatement.Modifiers - Case SyntaxKind.PropertyStatement - Return DirectCast(declaration, PropertyStatementSyntax).Modifiers - Case SyntaxKind.OperatorBlock - Return DirectCast(declaration, OperatorBlockSyntax).BlockStatement.Modifiers - Case SyntaxKind.OperatorStatement - Return DirectCast(declaration, OperatorStatementSyntax).Modifiers - Case SyntaxKind.EventBlock - Return DirectCast(declaration, EventBlockSyntax).EventStatement.Modifiers - Case SyntaxKind.EventStatement - Return DirectCast(declaration, EventStatementSyntax).Modifiers - Case SyntaxKind.ModifiedIdentifier - If IsChildOf(declaration, SyntaxKind.VariableDeclarator) Then - Return GetModifierTokens(declaration.Parent) - End If - Case SyntaxKind.LocalDeclarationStatement - Return DirectCast(declaration, LocalDeclarationStatementSyntax).Modifiers - Case SyntaxKind.VariableDeclarator - If IsChildOfVariableDeclaration(declaration) Then - Return GetModifierTokens(declaration.Parent) - End If - Case SyntaxKind.GetAccessorBlock, - SyntaxKind.SetAccessorBlock, - SyntaxKind.AddHandlerAccessorBlock, - SyntaxKind.RemoveHandlerAccessorBlock, - SyntaxKind.RaiseEventAccessorBlock - Return GetModifierTokens(DirectCast(declaration, AccessorBlockSyntax).AccessorStatement) - Case SyntaxKind.GetAccessorStatement, - SyntaxKind.SetAccessorStatement, - SyntaxKind.AddHandlerAccessorStatement, - SyntaxKind.RemoveHandlerAccessorStatement, - SyntaxKind.RaiseEventAccessorStatement - Return DirectCast(declaration, AccessorStatementSyntax).Modifiers - Case Else - Return Nothing - End Select - End Function - Private Function WithModifierTokens(declaration As SyntaxNode, tokens As SyntaxTokenList) As SyntaxNode Select Case declaration.Kind Case SyntaxKind.ClassBlock @@ -2645,21 +2435,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration End Function Public Overrides Function GetAccessibility(declaration As SyntaxNode) As Accessibility - If Not CanHaveAccessibility(declaration) Then - Return Accessibility.NotApplicable - End If - - Dim tokens = GetModifierTokens(declaration) - Dim acc As Accessibility - Dim mods As DeclarationModifiers - Dim isDefault As Boolean - GetAccessibilityAndModifiers(tokens, acc, mods, isDefault) - Return acc + Return SyntaxFacts.GetAccessibility(declaration) End Function Public Overrides Function WithAccessibility(declaration As SyntaxNode, accessibility As Accessibility) As SyntaxNode - If Not CanHaveAccessibility(declaration) AndAlso - accessibility <> accessibility.NotApplicable Then + If Not SyntaxFacts.CanHaveAccessibility(declaration) AndAlso + accessibility <> Accessibility.NotApplicable Then Return declaration End If @@ -2667,15 +2448,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration End Function Private Function WithAccessibilityInternal(declaration As SyntaxNode, accessibility As Accessibility) As SyntaxNode - If Not CanHaveAccessibility(declaration) Then + If Not SyntaxFacts.CanHaveAccessibility(declaration) Then Return declaration End If - Dim tokens = GetModifierTokens(declaration) + Dim tokens = SyntaxFacts.GetModifierTokens(declaration) Dim currentAcc As Accessibility Dim mods As DeclarationModifiers Dim isDefault As Boolean - GetAccessibilityAndModifiers(tokens, currentAcc, mods, isDefault) + SyntaxFacts.GetAccessibilityAndModifiers(tokens, currentAcc, mods, isDefault) If currentAcc = accessibility Then Return declaration @@ -2692,63 +2473,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration Return WithModifierTokens(declaration, Merge(tokens, newTokens)) End Function - Friend Overrides Function CanHaveAccessibility(declaration As SyntaxNode) As Boolean - Select Case declaration.Kind - Case SyntaxKind.ClassBlock, - SyntaxKind.ClassStatement, - SyntaxKind.StructureBlock, - SyntaxKind.StructureStatement, - SyntaxKind.InterfaceBlock, - SyntaxKind.InterfaceStatement, - SyntaxKind.EnumBlock, - SyntaxKind.EnumStatement, - SyntaxKind.ModuleBlock, - SyntaxKind.ModuleStatement, - SyntaxKind.DelegateFunctionStatement, - SyntaxKind.DelegateSubStatement, - SyntaxKind.FieldDeclaration, - SyntaxKind.FunctionBlock, - SyntaxKind.SubBlock, - SyntaxKind.FunctionStatement, - SyntaxKind.SubStatement, - SyntaxKind.PropertyBlock, - SyntaxKind.PropertyStatement, - SyntaxKind.OperatorBlock, - SyntaxKind.OperatorStatement, - SyntaxKind.EventBlock, - SyntaxKind.EventStatement, - SyntaxKind.GetAccessorBlock, - SyntaxKind.GetAccessorStatement, - SyntaxKind.SetAccessorBlock, - SyntaxKind.SetAccessorStatement, - SyntaxKind.AddHandlerAccessorBlock, - SyntaxKind.AddHandlerAccessorStatement, - SyntaxKind.RemoveHandlerAccessorBlock, - SyntaxKind.RemoveHandlerAccessorStatement, - SyntaxKind.RaiseEventAccessorBlock, - SyntaxKind.RaiseEventAccessorStatement - Return True - - Case SyntaxKind.ConstructorBlock, - SyntaxKind.SubNewStatement - ' Shared constructor cannot have modifiers in VB. - Return Not declaration.GetModifiers().Any(SyntaxKind.SharedKeyword) - - Case SyntaxKind.ModifiedIdentifier - Return If(IsChildOf(declaration, SyntaxKind.VariableDeclarator), - CanHaveAccessibility(declaration.Parent), - False) - - Case SyntaxKind.VariableDeclarator - Return If(IsChildOfVariableDeclaration(declaration), - CanHaveAccessibility(declaration.Parent), - False) - - Case Else - Return False - End Select - End Function - Private Function GetModifierList(accessibility As Accessibility, modifiers As DeclarationModifiers, kind As DeclarationKind, Optional isDefault As Boolean = False) As SyntaxTokenList Dim _list = SyntaxFactory.TokenList() @@ -2763,19 +2487,19 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration End If Select Case (accessibility) - Case accessibility.Internal + Case Accessibility.Internal _list = _list.Add(SyntaxFactory.Token(SyntaxKind.FriendKeyword)) - Case accessibility.Public + Case Accessibility.Public _list = _list.Add(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) - Case accessibility.Private + Case Accessibility.Private _list = _list.Add(SyntaxFactory.Token(SyntaxKind.PrivateKeyword)) - Case accessibility.Protected + Case Accessibility.Protected _list = _list.Add(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword)) - Case accessibility.ProtectedOrInternal + Case Accessibility.ProtectedOrInternal _list = _list.Add(SyntaxFactory.Token(SyntaxKind.FriendKeyword)).Add(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword)) - Case accessibility.ProtectedAndInternal + Case Accessibility.ProtectedAndInternal _list = _list.Add(SyntaxFactory.Token(SyntaxKind.PrivateKeyword)).Add(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword)) - Case accessibility.NotApplicable + Case Accessibility.NotApplicable Case Else Throw New NotSupportedException(String.Format("Accessibility '{0}' not supported.", accessibility)) End Select @@ -2844,65 +2568,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration Return _list End Function - Private Sub GetAccessibilityAndModifiers(modifierTokens As SyntaxTokenList, ByRef accessibility As Accessibility, ByRef modifiers As DeclarationModifiers, ByRef isDefault As Boolean) - accessibility = accessibility.NotApplicable - modifiers = DeclarationModifiers.None - isDefault = False - - For Each token In modifierTokens - Select Case token.Kind - Case SyntaxKind.DefaultKeyword - isDefault = True - Case SyntaxKind.PublicKeyword - accessibility = accessibility.Public - Case SyntaxKind.PrivateKeyword - If accessibility = accessibility.Protected Then - accessibility = accessibility.ProtectedAndFriend - Else - accessibility = accessibility.Private - End If - Case SyntaxKind.FriendKeyword - If accessibility = accessibility.Protected Then - accessibility = accessibility.ProtectedOrFriend - Else - accessibility = accessibility.Friend - End If - Case SyntaxKind.ProtectedKeyword - If accessibility = accessibility.Friend Then - accessibility = accessibility.ProtectedOrFriend - ElseIf accessibility = accessibility.Private Then - accessibility = accessibility.ProtectedAndFriend - Else - accessibility = accessibility.Protected - End If - Case SyntaxKind.MustInheritKeyword, SyntaxKind.MustOverrideKeyword - modifiers = modifiers Or DeclarationModifiers.Abstract - Case SyntaxKind.ShadowsKeyword - modifiers = modifiers Or DeclarationModifiers.[New] - Case SyntaxKind.OverridesKeyword - modifiers = modifiers Or DeclarationModifiers.Override - Case SyntaxKind.OverridableKeyword - modifiers = modifiers Or DeclarationModifiers.Virtual - Case SyntaxKind.SharedKeyword - modifiers = modifiers Or DeclarationModifiers.Static - Case SyntaxKind.AsyncKeyword - modifiers = modifiers Or DeclarationModifiers.Async - Case SyntaxKind.ConstKeyword - modifiers = modifiers Or DeclarationModifiers.Const - Case SyntaxKind.ReadOnlyKeyword - modifiers = modifiers Or DeclarationModifiers.ReadOnly - Case SyntaxKind.WriteOnlyKeyword - modifiers = modifiers Or DeclarationModifiers.WriteOnly - Case SyntaxKind.NotInheritableKeyword, SyntaxKind.NotOverridableKeyword - modifiers = modifiers Or DeclarationModifiers.Sealed - Case SyntaxKind.WithEventsKeyword - modifiers = modifiers Or DeclarationModifiers.WithEvents - Case SyntaxKind.PartialKeyword - modifiers = modifiers Or DeclarationModifiers.Partial - End Select - Next - End Sub - Private Function GetTypeParameters(typeParameterNames As IEnumerable(Of String)) As TypeParameterListSyntax If typeParameterNames Is Nothing Then Return Nothing -- GitLab