private static Accessibility?GetPartialAccessModifier( SyntaxNodeAnalysisContext context, MemberDeclarationSyntax declaration) { var accessibility = Accessibility.NotApplicable; ISymbol symbol = context.SemanticModel.GetDeclaredSymbol(declaration, context.CancellationToken); if (symbol != null) { foreach (SyntaxReference syntaxReference in symbol.DeclaringSyntaxReferences) { if (syntaxReference.GetSyntax(context.CancellationToken) is MemberDeclarationSyntax declaration2) { Accessibility accessibility2 = SyntaxAccessibility.GetExplicitAccessibility(declaration2); if (accessibility2 != Accessibility.NotApplicable) { if (accessibility == Accessibility.NotApplicable || accessibility == accessibility2) { accessibility = accessibility2; } else { return(null); } } } } } return(accessibility); }
public static Task <Document> RefactorAsync( Document document, PropertyDeclarationSyntax propertyDeclaration, CancellationToken cancellationToken = default(CancellationToken)) { AccessorListSyntax accessorList = AccessorList(); if (propertyDeclaration.ExpressionBody != null) { accessorList = accessorList .AddAccessors(AutoGetAccessorDeclaration()); } else { AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { if (SyntaxAccessibility.GetExplicitAccessibility(getter) == Accessibility.Private) { getter = SyntaxAccessibility.WithExplicitAccessibility(getter, Accessibility.Protected); } accessorList = accessorList.AddAccessors(getter .WithBody(null) .WithSemicolonToken(SemicolonToken())); } AccessorDeclarationSyntax setter = propertyDeclaration.Setter(); if (setter != null) { if (SyntaxAccessibility.GetExplicitAccessibility(setter) == Accessibility.Private) { setter = SyntaxAccessibility.WithExplicitAccessibility(setter, Accessibility.Protected); } accessorList = accessorList.AddAccessors(setter .WithBody(null) .WithSemicolonToken(SemicolonToken())); } } PropertyDeclarationSyntax newNode = propertyDeclaration .WithExpressionBody(null) .WithSemicolonToken(default(SyntaxToken)) .WithAccessorList(accessorList) .InsertModifier(SyntaxKind.AbstractKeyword) .RemoveModifier(SyntaxKind.VirtualKeyword) .WithTriviaFrom(propertyDeclaration) .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(propertyDeclaration, newNode, cancellationToken)); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { Diagnostic diagnostic = context.Diagnostics[0]; if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.SynchronizeAccessibility)) { return; } SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false); if (!TryFindFirstAncestorOrSelf(root, context.Span, out MemberDeclarationSyntax memberDeclaration)) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); var symbol = (INamedTypeSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken); ImmutableArray <MemberDeclarationSyntax> memberDeclarations = ImmutableArray.CreateRange( symbol.DeclaringSyntaxReferences, f => (MemberDeclarationSyntax)f.GetSyntax(context.CancellationToken)); foreach (Accessibility accessibility in memberDeclarations .Select(f => SyntaxAccessibility.GetExplicitAccessibility(f)) .Where(f => f != Accessibility.NotApplicable)) { if (SyntaxAccessibility.IsValidAccessibility(memberDeclaration, accessibility)) { CodeAction codeAction = CodeAction.Create( $"Change accessibility to '{SyntaxFacts.GetText(accessibility)}'", cancellationToken => ChangeAccessibilityRefactoring.RefactorAsync(context.Solution(), memberDeclarations, accessibility, cancellationToken), GetEquivalenceKey(CompilerDiagnosticIdentifiers.PartialDeclarationsHaveConfictingAccessibilityModifiers, accessibility.ToString())); context.RegisterCodeFix(codeAction, diagnostic); } } }
public static void AnalyzeConstructorDeclaration(SyntaxNodeAnalysisContext context) { var constructorDeclaration = (ConstructorDeclarationSyntax)context.Node; if (!SyntaxAccessibility.GetExplicitAccessibility(constructorDeclaration).Is(Accessibility.Public, Accessibility.ProtectedOrInternal)) { return; } if (!constructorDeclaration.IsParentKind(SyntaxKind.ClassDeclaration)) { return; } var classDeclaration = (ClassDeclarationSyntax)constructorDeclaration.Parent; SyntaxTokenList modifiers = classDeclaration.Modifiers; bool isAbstract = modifiers.Contains(SyntaxKind.AbstractKeyword); if (!isAbstract && modifiers.Contains(SyntaxKind.PartialKeyword)) { INamedTypeSymbol classSymbol = context.SemanticModel.GetDeclaredSymbol(classDeclaration, context.CancellationToken); if (classSymbol != null) { isAbstract = classSymbol.IsAbstract; } } if (!isAbstract) { return; } context.ReportDiagnostic(DiagnosticDescriptors.AbstractTypeShouldNotHavePublicConstructors, constructorDeclaration.Identifier); }
public static AccessibilityFilter GetValidAccessibilityFilter( MemberDeclarationListSelection selectedMembers, SemanticModel semanticModel, CancellationToken cancellationToken = default(CancellationToken)) { if (selectedMembers.Count < 2) { return(AccessibilityFilter.None); } ImmutableArray <Accessibility> avaiableAccessibilities = AvailableAccessibilities; var all = AccessibilityFilter.None; AccessibilityFilter valid = AccessibilityFilter.Public | AccessibilityFilter.Internal | AccessibilityFilter.Protected | AccessibilityFilter.Private; foreach (MemberDeclarationSyntax member in selectedMembers) { Accessibility accessibility = SyntaxAccessibility.GetExplicitAccessibility(member); if (accessibility == Accessibility.NotApplicable) { accessibility = SyntaxAccessibility.GetDefaultExplicitAccessibility(member); if (accessibility == Accessibility.NotApplicable) { return(AccessibilityFilter.None); } } switch (accessibility) { case Accessibility.Private: case Accessibility.Protected: case Accessibility.ProtectedAndInternal: case Accessibility.ProtectedOrInternal: case Accessibility.Internal: case Accessibility.Public: { all |= accessibility.GetAccessibilityFilter(); break; } default: { Debug.Fail(accessibility.ToString()); return(AccessibilityFilter.None); } } ModifierListInfo modifiersInfo = SyntaxInfo.ModifierListInfo(member); if (modifiersInfo.Modifiers.ContainsAny( SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword)) { valid &= ~AccessibilityFilter.Private; } if (modifiersInfo.IsOverride && IsBaseDeclarationWithoutSource(member, semanticModel, cancellationToken)) { switch (accessibility) { case Accessibility.Private: case Accessibility.Protected: case Accessibility.Internal: case Accessibility.Public: { valid &= accessibility.GetAccessibilityFilter(); if (valid == AccessibilityFilter.None) { return(AccessibilityFilter.None); } avaiableAccessibilities = _accessibilityArrayMap[accessibility]; continue; } default: { return(AccessibilityFilter.None); } } } foreach (Accessibility accessibility2 in avaiableAccessibilities) { if (accessibility != accessibility2 && !SyntaxAccessibility.IsValidAccessibility(member, accessibility2, ignoreOverride: true)) { valid &= ~accessibility2.GetAccessibilityFilter(); if (valid == AccessibilityFilter.None) { return(AccessibilityFilter.None); } } } } switch (all) { case AccessibilityFilter.Private: case AccessibilityFilter.Protected: case AccessibilityFilter.Internal: case AccessibilityFilter.Public: { valid &= ~all; break; } } return(valid); }
public static Accessibilities GetValidAccessibilities(MemberDeclarationListSelection selectedMembers, bool allowOverride = false) { if (selectedMembers.Count < 2) { return(Accessibilities.None); } var all = Accessibilities.None; Accessibilities valid = Accessibilities.Public | Accessibilities.Internal | Accessibilities.Protected | Accessibilities.Private; foreach (MemberDeclarationSyntax member in selectedMembers) { Accessibility accessibility = SyntaxAccessibility.GetExplicitAccessibility(member); if (accessibility == Accessibility.NotApplicable) { accessibility = SyntaxAccessibility.GetDefaultExplicitAccessibility(member); if (accessibility == Accessibility.NotApplicable) { return(Accessibilities.None); } } Accessibilities accessibilities = accessibility.GetAccessibilities(); switch (accessibility) { case Accessibility.Private: case Accessibility.Protected: case Accessibility.ProtectedAndInternal: case Accessibility.ProtectedOrInternal: case Accessibility.Internal: case Accessibility.Public: { all |= accessibilities; break; } default: { Debug.Fail(accessibility.ToString()); return(Accessibilities.None); } } foreach (Accessibility accessibility2 in AvailableAccessibilities) { if (accessibility != accessibility2 && !SyntaxAccessibility.IsValidAccessibility(member, accessibility2, ignoreOverride: allowOverride)) { valid &= ~accessibility2.GetAccessibilities(); } } } switch (all) { case Accessibilities.Private: case Accessibilities.Protected: case Accessibilities.Internal: case Accessibilities.Public: { valid &= ~all; break; } } return(valid); }