void ValidateClassType(Assembly assembly, string fullName, Accessibility access, bool final) { // Check that the type exists in the assembly. Type t = assembly.GetType(fullName); Assert.IsNotNull(t); // Check that it is a class Assert.IsTrue(t.IsClass); // Check that the full name is correct Assert.AreEqual(t.FullName, fullName); // Check that the type is final (sealed) Assert.AreEqual(t.IsSealed, final); // Check that it has the correct accessibility switch(access) { case Accessibility.Public: Assert.IsTrue(t.IsPublic); break; case Accessibility.Internal: Assert.IsTrue(t.IsNotPublic); break; case Accessibility.Private: case Accessibility.Protected: Assert.Fail("Invalid accessibility for class types"); break; } }
public void SetGenerateTypeOptions( Accessibility accessibility = Accessibility.NotApplicable, TypeKind typeKind = TypeKind.Class, string typeName = null, Project project = null, bool isNewFile = false, string newFileName = null, IList<string> folders = null, string fullFilePath = null, Document existingDocument = null, bool areFoldersValidIdentifiers = true, string defaultNamespace = null, bool isCancelled = false) { Accessibility = accessibility; TypeKind = typeKind; TypeName = typeName; Project = project; IsNewFile = isNewFile; NewFileName = newFileName; Folders = folders; FullFilePath = fullFilePath; ExistingDocument = existingDocument; AreFoldersValidIdentifiers = areFoldersValidIdentifiers; DefaultNamespace = defaultNamespace; IsCancelled = isCancelled; }
public GenerateTypeOptionsResult( Accessibility accessibility, TypeKind typeKind, string typeName, Project project, bool isNewFile, string newFileName, IList<string> folders, string fullFilePath, Document existingDocument, bool areFoldersValidIdentifiers, bool isCancelled = false) { this.Accessibility = accessibility; this.TypeKind = typeKind; this.TypeName = typeName; this.Project = project; this.IsNewFile = isNewFile; this.NewFileName = newFileName; this.Folders = folders; this.FullFilePath = fullFilePath; this.ExistingDocument = existingDocument; this.AreFoldersValidIdentifiers = areFoldersValidIdentifiers; this.IsCancelled = isCancelled; }
public ValuedDeclaration(QualifiedMemberName qualifiedName, string parentScope, string asTypeName, Accessibility accessibility, DeclarationType declarationType, string value, ParserRuleContext context, Selection selection, bool isBuiltIn = false) :base(qualifiedName, parentScope, asTypeName, true, false, accessibility, declarationType, context, selection, isBuiltIn) { _value = value; }
private IMethodSymbol GenerateSetAccessor( Compilation compilation, IPropertySymbol property, Accessibility accessibility, bool generateAbstractly, bool useExplicitInterfaceSymbol, INamedTypeSymbol[] attributesToRemove, CancellationToken cancellationToken) { if (property.SetMethod == null) { return null; } var setMethod = property.SetMethod.RemoveInaccessibleAttributesAndAttributesOfTypes( this.State.ClassOrStructType, attributesToRemove); return CodeGenerationSymbolFactory.CreateAccessorSymbol( setMethod, attributes: null, accessibility: accessibility, explicitInterfaceSymbol: useExplicitInterfaceSymbol ? property.SetMethod : null, statements: GetSetAccessorStatements(compilation, property, generateAbstractly, cancellationToken)); }
public void Declare(Accessibility accessibility, String name, Exp value = null) { if (dict.ContainsKey(name)) validations.GenericWarning("variable '" + name + "' is already declared", Void.Instance); dict.Add(name, new EnvItem(accessibility, value)); }
public DefaultResolvedAccessor(Accessibility accessibility, DomRegion region = default(DomRegion), IList<IAttribute> attributes = null, IList<IAttribute> returnTypeAttributes = null) { this.accessibility = accessibility; this.region = region; this.attributes = attributes ?? EmptyList<IAttribute>.Instance; this.returnTypeAttributes = returnTypeAttributes ?? EmptyList<IAttribute>.Instance; }
public PrinterConfig(string semiColonSeparatedIncludeRegexes, string semiColonSeparatedExcludeRegexes, Accessibility minAccessibility = Accessibility.Public) { var splitters = new[] { ";" }; m_IncludeSignatureRegexes = semiColonSeparatedIncludeRegexes.Split(splitters, StringSplitOptions.RemoveEmptyEntries); m_ExcludeSignatureRegexes = semiColonSeparatedExcludeRegexes.Split(splitters, StringSplitOptions.RemoveEmptyEntries); m_MinAccessibility = minAccessibility; }
public CodeGenerationMethodSymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility declaredAccessibility, DeclarationModifiers modifiers, ITypeSymbol returnType, bool returnsByRef, IMethodSymbol explicitInterfaceSymbolOpt, string name, IList<ITypeParameterSymbol> typeParameters, IList<IParameterSymbol> parameters, IList<AttributeData> returnTypeAttributes, MethodKind methodKind = MethodKind.Ordinary) : base(containingType, attributes, declaredAccessibility, modifiers, name, returnTypeAttributes) { _returnType = returnType; _returnsByRef = returnsByRef; _typeParameters = typeParameters.AsImmutableOrEmpty(); _parameters = parameters.AsImmutableOrEmpty(); _explicitInterfaceImplementations = explicitInterfaceSymbolOpt == null ? ImmutableArray.Create<IMethodSymbol>() : ImmutableArray.Create(explicitInterfaceSymbolOpt); this.OriginalDefinition = this; _methodKind = methodKind; }
public static Accessibility Minimum(Accessibility accessibility1, Accessibility accessibility2) { if (accessibility1 == Accessibility.Private || accessibility2 == Accessibility.Private) { return Accessibility.Private; } if (accessibility1 == Accessibility.ProtectedAndInternal || accessibility2 == Accessibility.ProtectedAndInternal) { return Accessibility.ProtectedAndInternal; } if (accessibility1 == Accessibility.Protected || accessibility2 == Accessibility.Protected) { return Accessibility.Protected; } if (accessibility1 == Accessibility.Internal || accessibility2 == Accessibility.Internal) { return Accessibility.Internal; } if (accessibility1 == Accessibility.ProtectedOrInternal || accessibility2 == Accessibility.ProtectedOrInternal) { return Accessibility.ProtectedOrInternal; } return Accessibility.Public; }
public CodeGenerationNamedTypeSymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility declaredAccessibility, DeclarationModifiers modifiers, TypeKind typeKind, string name, IList<ITypeParameterSymbol> typeParameters, INamedTypeSymbol baseType, IList<INamedTypeSymbol> interfaces, SpecialType specialType, IList<ISymbol> members, IList<CodeGenerationAbstractNamedTypeSymbol> typeMembers, INamedTypeSymbol enumUnderlyingType) : base(containingType, attributes, declaredAccessibility, modifiers, name, specialType, typeMembers) { _typeKind = typeKind; _typeParameters = typeParameters ?? SpecializedCollections.EmptyList<ITypeParameterSymbol>(); _baseType = baseType; _interfaces = interfaces ?? SpecializedCollections.EmptyList<INamedTypeSymbol>(); _members = members ?? SpecializedCollections.EmptyList<ISymbol>(); _enumUnderlyingType = enumUnderlyingType; this.OriginalDefinition = this; }
private ISymbol GenerateMethod( Compilation compilation, IMethodSymbol method, Accessibility accessibility, DeclarationModifiers modifiers, bool generateAbstractly, bool useExplicitInterfaceSymbol, string memberName, CancellationToken cancellationToken) { var syntaxFacts = this.Document.GetLanguageService<ISyntaxFactsService>(); var updatedMethod = method.EnsureNonConflictingNames( this.State.ClassOrStructType, syntaxFacts, cancellationToken); updatedMethod = updatedMethod.RemoveInaccessibleAttributesAndAttributesOfTypes( this.State.ClassOrStructType, AttributesToRemove(compilation)); return CodeGenerationSymbolFactory.CreateMethodSymbol( updatedMethod, accessibility: accessibility, modifiers: modifiers, explicitInterfaceSymbol: useExplicitInterfaceSymbol ? updatedMethod : null, name: memberName, statements: generateAbstractly ? null : new[] { CreateStatement(compilation, updatedMethod, cancellationToken) }); }
static void AdjustAccessibility (SyntaxTokenList modifiers, ref Accessibility acc, ref bool isStatic, ref bool result) { isStatic = modifiers.Any (mod => mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.StaticKeyword); if (modifiers.Any (mod => mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.ProtectedKeyword) && modifiers.Any (mod => mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.InternalKeyword)) { acc = Accessibility.ProtectedOrInternal; result = true; return; } foreach (var mod in modifiers) { if (mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.PublicKeyword) { acc = Accessibility.Public; result = true; return; } if (mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.PrivateKeyword) { acc = Accessibility.Private; result = true; return; } if (mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.ProtectedKeyword) { acc = Accessibility.Protected; result = true; return; } if (mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.InternalKeyword) { acc = Accessibility.Internal; result = true; return; } } }
static bool GetAccessibility (SyntaxNode element, out Accessibility acc, out bool isStatic) { isStatic = false; if (element.Parent is TypeDeclarationSyntax && element.Parent is InterfaceDeclarationSyntax) { acc = Accessibility.Public; return true; } bool result = false; acc = Accessibility.Private; if (element is TypeDeclarationSyntax && !(element.Parent is TypeDeclarationSyntax)) acc = Accessibility.Internal; if (element is VariableDeclaratorSyntax) element = element.Parent.Parent; if (element is TypeDeclarationSyntax) AdjustAccessibility (((TypeDeclarationSyntax)element).Modifiers, ref acc, ref isStatic, ref result); if (element is BaseFieldDeclarationSyntax) AdjustAccessibility (((BaseFieldDeclarationSyntax)element).Modifiers, ref acc, ref isStatic, ref result); if (element is BasePropertyDeclarationSyntax) AdjustAccessibility (((BasePropertyDeclarationSyntax)element).Modifiers, ref acc, ref isStatic, ref result); if (element is BaseMethodDeclarationSyntax) AdjustAccessibility (((BaseMethodDeclarationSyntax)element).Modifiers, ref acc, ref isStatic, ref result); return result; }
static bool TryDetermineOverridableMembers(SemanticModel semanticModel, SyntaxToken startToken, Accessibility seenAccessibility, out ISet<ISymbol> overridableMembers, CancellationToken cancellationToken) { var result = new HashSet<ISymbol>(); var containingType = semanticModel.GetEnclosingSymbol<INamedTypeSymbol>(startToken.SpanStart, cancellationToken); if (containingType != null && !containingType.IsScriptClass && !containingType.IsImplicitClass) { if (containingType.TypeKind == TypeKind.Class || containingType.TypeKind == TypeKind.Struct) { var baseTypes = containingType.GetBaseTypes().Reverse(); foreach (var type in baseTypes) { cancellationToken.ThrowIfCancellationRequested(); // Prefer overrides in derived classes RemoveOverriddenMembers(result, type, cancellationToken); // Retain overridable methods AddProtocolMembers(semanticModel, result, containingType, type, cancellationToken); } // Don't suggest already overridden members RemoveOverriddenMembers(result, containingType, cancellationToken); } } // Filter based on accessibility if (seenAccessibility != Accessibility.NotApplicable) { result.RemoveWhere(m => m.DeclaredAccessibility != seenAccessibility); } overridableMembers = result; return overridableMembers.Count > 0; }
internal static IPropertySymbol CreatePropertySymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility accessibility, DeclarationModifiers modifiers, ITypeSymbol type, IPropertySymbol explicitInterfaceSymbol, string name, IList<IParameterSymbol> parameters, IMethodSymbol getMethod, IMethodSymbol setMethod, bool isIndexer = false, SyntaxNode initializer = null) { var result = new CodeGenerationPropertySymbol( containingType, attributes, accessibility, modifiers, type, explicitInterfaceSymbol, name, isIndexer, parameters, getMethod, setMethod); CodeGenerationPropertyInfo.Attach(result, modifiers.IsNew, modifiers.IsUnsafe, initializer); return result; }
// Constructor public Symbol(string name, ScopeType scope) { Name = name; Scope = scope; Frequency = 0; ConstAllowed = true; Accessibility= Accessibility.Default; }
protected Declaration(IEnumerable<DeclarationSyntax> syntax, Package containingPackage, Namespace containingNamespace, Accessibility declaredAccessibility, string name) : base(syntax, declaredAccessibility, name) { Requires.NotNull(containingPackage, nameof(containingPackage)); ContainingPackage = containingPackage; ContainingNamespace = containingNamespace; }
public DestructorSyntax(Accessibility access, IEnumerable<ParameterSyntax> parameters, IEnumerable<StatementSyntax> body) { Requires.EnumDefined(access, nameof(access)); Access = access; Parameters = parameters.ToList(); Body = body.ToList(); }
/// <summary> /// Creates a method declaration. /// </summary> public abstract SyntaxNode MethodDeclaration( string name, IEnumerable<SyntaxNode> parameters = null, IEnumerable<string> typeParameters = null, SyntaxNode returnType = null, Accessibility accessibility = Accessibility.NotApplicable, SymbolModifiers modifiers = default(SymbolModifiers), IEnumerable<SyntaxNode> statements = null);
int GetAccessSortValue (Accessibility mods) { if ((mods & Accessibility.Private) != 0) return 0; if ((mods & Accessibility.Internal) != 0) return 1; if ((mods & Accessibility.Protected) != 0) return 2; if ((mods & Accessibility.Public) != 0) return 3; return 4; }
// Copy constructor public Symbol(Symbol other) { Name = other.Name; Scope = other.Scope; Frequency = other.Frequency; Rank = other.Rank; Accessibility = other.Accessibility; ConstAllowed = false; }
protected CodeGenerationNamespaceOrTypeSymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, string name) : base(containingType, attributes, declaredAccessibility, modifiers, name) { }
public MethodSyntax(Accessibility access, SyntaxToken name, IEnumerable<ParameterSyntax> parameters, IEnumerable<StatementSyntax> body) : base(name) { Requires.EnumDefined(access, nameof(access)); Access = access; Parameters = parameters.ToList(); Body = body.ToList(); }
public void NamespaceOnlyExcludedWhenContentsAreExcluded(Accessibility typeAccessibility, string namespaceExclusionRegex, int expectedMembers) { var type = new ApiNodeBuilder(SymbolKind.NamedType, typeAccessibility); var namespaceNode = new ApiNodeBuilder(SymbolKind.Namespace, signature: "Api.Tests").WithMembers(type); var assemblyNode = new ApiNodeBuilder(SymbolKind.Assembly).WithMembers(namespaceNode).Build(); var filtered = GetFiltered(new PrinterConfig("", namespaceExclusionRegex), assemblyNode); Assert.That(filtered.Members.Count<IApiNode>(), Is.EqualTo(expectedMembers)); }
protected bool IsMemberExcluded(string identifier, Accessibility accessibility) { var isExcluded = ParserOptions.SharpDoxConfig.ExcludedIdentifiers.Contains(identifier); isExcluded = accessibility == Accessibility.Private && ParserOptions.SharpDoxConfig.ExcludePrivate || isExcluded; isExcluded = accessibility == Accessibility.Protected && ParserOptions.SharpDoxConfig.ExcludeProtected || isExcluded; isExcluded = accessibility == Accessibility.Internal && ParserOptions.SharpDoxConfig.ExcludeInternal || isExcluded; return isExcluded && !ParserOptions.IgnoreExcludes; }
protected Symbol(IEnumerable<SyntaxNode> syntax, Accessibility declaredAccessibility, string name) { Requires.NotNull(name, nameof(name)); this.syntax = syntax.ToList().AsReadOnly(); Requires.That(this.syntax.All(s => s != null), nameof(syntax), "Syntax nodes must not be null"); Name = name; DeclaredAccessibility = declaredAccessibility; }
public SynthesizedPropertySymbol(NamedTypeSymbol containing, string name, bool isStatic, TypeSymbol type, Accessibility accessibility, MethodSymbol getter, MethodSymbol setter) { _containing = containing; _name = name; _accessibility = accessibility; _setMethod = setter; _getMethod = getter; _type = type; _isStatic = isStatic; }
public SynthesizedFieldSymbol( NamedTypeSymbol containing, TypeSymbol type, string name, Accessibility accessibility, ConstantValue constant) :this(containing, type, name, accessibility, true) { _const = constant; }
/// <summary> /// Creates an event symbol that can be used to describe an event declaration. /// </summary> public static IEventSymbol CreateEventSymbol( IList<AttributeData> attributes, Accessibility accessibility, DeclarationModifiers modifiers, ITypeSymbol type, IEventSymbol explicitInterfaceSymbol, string name, IMethodSymbol addMethod = null, IMethodSymbol removeMethod = null, IMethodSymbol raiseMethod = null) { var result = new CodeGenerationEventSymbol(null, attributes, accessibility, modifiers, type, explicitInterfaceSymbol, name, addMethod, removeMethod, raiseMethod); CodeGenerationEventInfo.Attach(result, modifiers.IsUnsafe); return result; }
public SecureEnclaveValet(string identifier, bool isSharedAccessGroupIdentifier, Accessibility accessibility) : base(identifier, isSharedAccessGroupIdentifier, accessibility) { }
public SynchronizableValet(string identifier, Accessibility accessibility) : this(identifier, false, accessibility) { }
public SourceFieldSymbol(SourceTypeSymbol type, string name, Location location, Accessibility accessibility, PHPDocBlock phpdoc, KindEnum kind, BoundExpression initializer = null) { Contract.ThrowIfNull(type); Contract.ThrowIfNull(name); _containingType = type; _fieldName = name; _fieldKind = kind; _accessibility = accessibility; _phpDoc = phpdoc; _initializer = initializer; _location = location; }
static bool TryDetermineOverridableProtocolMembers(SemanticModel semanticModel, SyntaxToken startToken, Accessibility seenAccessibility, out ISet <ISymbol> overridableMembers, CancellationToken cancellationToken) { var result = new HashSet <ISymbol>(); var containingType = semanticModel.GetEnclosingSymbol <INamedTypeSymbol>(startToken.SpanStart, cancellationToken); if (containingType != null && !containingType.IsScriptClass && !containingType.IsImplicitClass) { if (containingType.TypeKind == TypeKind.Class || containingType.TypeKind == TypeKind.Struct) { var baseTypes = containingType.GetBaseTypes().Reverse().Concat(containingType.AllInterfaces); foreach (var type in baseTypes) { cancellationToken.ThrowIfCancellationRequested(); // Prefer overrides in derived classes RemoveOverriddenMembers(result, type, cancellationToken); // Retain overridable methods AddProtocolMembers(semanticModel, result, containingType, type, cancellationToken); } // Don't suggest already overridden members RemoveOverriddenMembers(result, containingType, cancellationToken); } } // Filter based on accessibility if (seenAccessibility != Accessibility.NotApplicable) { result.RemoveWhere(m => m.DeclaredAccessibility != seenAccessibility); } // Filter members that are already overriden - they're already part of 'override completion' ISet <ISymbol> realOverridableMembers; if (OverrideContextHandler.TryDetermineOverridableMembers(semanticModel, startToken, seenAccessibility, out realOverridableMembers, cancellationToken)) { result.RemoveWhere(m => realOverridableMembers.Any(m2 => IsEqualMember(m, m2))); } overridableMembers = result; return(overridableMembers.Count > 0); }
private static NamedTypeSymbol ValidateBuilderType(SyntheticBoundNodeFactory F, object builderAttributeArgument, Accessibility desiredAccessibility, bool isGeneric) { var builderType = builderAttributeArgument as NamedTypeSymbol; if ((object)builderType != null && !builderType.IsErrorType() && builderType.SpecialType != SpecialType.System_Void && builderType.DeclaredAccessibility == desiredAccessibility) { bool isArityOk = isGeneric ? builderType.IsUnboundGenericType && builderType.ContainingType?.IsGenericType != true && builderType.Arity == 1 : !builderType.IsGenericType; if (isArityOk) { return(builderType); } } F.Diagnostics.Add(ErrorCode.ERR_BadAsyncReturn, F.Syntax.Location); return(null); }
public abstract bool TryDetermineModifiers(SyntaxToken startToken, SourceText text, int startLine, out Accessibility seenAccessibility, out DeclarationModifiers modifiers);
public ScopedWhereUsedAnalyzer(MethodDefinition method, Func <TypeDefinition, IEnumerable <T> > typeAnalysisFunction) : this(method.DeclaringType, typeAnalysisFunction) { this.memberAccessibility = GetMethodAccessibility(method); }
protected override Task <Document> ReplaceModifierRefactoring(Document document, SyntaxNode node, Accessibility fromAccessibility, Accessibility toAccessibility) { return(Refactorings.ReplaceModifierRefactoring.RefactorAsync(document, node, fromAccessibility, toAccessibility)); }
internal static XElement CreateXElement(this Accessibility accessibility) { return(new XElement("AccessibilityKind", accessibility)); }
protected override IEnumerable <CompletionData> CreateCompletionData(CompletionEngine engine, SemanticModel semanticModel, int position, ITypeSymbol returnType, Accessibility seenAccessibility, SyntaxToken startToken, SyntaxToken tokenBeforeReturnType, bool afterKeyword, CancellationToken cancellationToken) { var result = new List <CompletionData> (); ISet <ISymbol> overridableMembers; if (!TryDetermineOverridableProtocolMembers(semanticModel, tokenBeforeReturnType, seenAccessibility, out overridableMembers, cancellationToken)) { return(result); } if (returnType != null) { overridableMembers = FilterOverrides(overridableMembers, returnType); } var curType = semanticModel.GetEnclosingSymbol <INamedTypeSymbol> (startToken.SpanStart, cancellationToken); var declarationBegin = afterKeyword ? startToken.SpanStart : position - 1; foreach (var m in overridableMembers) { var data = new ProtocolCompletionData(this, factory, declarationBegin, curType, m, afterKeyword); result.Add(data); } return(result); }
internal static bool MatchesSymbol(this Accessibility accessibility, ISymbol symbol) { return(GetAccessibility(symbol) == accessibility); }
public SecureEnclaveValet(string identifier, Accessibility accessibility) : this(identifier, false, accessibility) { }
public static AccessibilityFilter GetValidAccessibilityFilter( MemberDeclarationListSelection selectedMembers, SemanticModel semanticModel, CancellationToken cancellationToken = default) { if (selectedMembers.Count < 2) { return(AccessibilityFilter.None); } ImmutableArray <Accessibility> availableAccessibilities = AvailableAccessibilities; var isAllExplicit = true; 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) { isAllExplicit = false; 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); } availableAccessibilities = _accessibilityArrayMap[accessibility]; continue; } default: { return(AccessibilityFilter.None); } } } foreach (Accessibility accessibility2 in availableAccessibilities) { if (accessibility != accessibility2 && !SyntaxAccessibility.IsValidAccessibility(member, accessibility2, ignoreOverride: true)) { valid &= ~accessibility2.GetAccessibilityFilter(); if (valid == AccessibilityFilter.None) { return(AccessibilityFilter.None); } } } } if (isAllExplicit) { switch (all) { case AccessibilityFilter.Private: case AccessibilityFilter.Protected: case AccessibilityFilter.Internal: case AccessibilityFilter.Public: { valid &= ~all; break; } } } return(valid); }
public Valet(string identifier, Accessibility accessibility) : this(identifier, false, accessibility) { }
internal bool AppliesTo(SymbolKind symbolKind, Accessibility accessibility) => this.AppliesTo(new SymbolKindOrTypeKind(symbolKind), new DeclarationModifiers(), accessibility);
protected override Task <Document> AddModifierRefactoring(Document document, SyntaxNode node, Accessibility accessibility) { return(Refactorings.AddModifierRefactoring.RefactorAsync(document, node, accessibility)); }
public static SyntaxNode AutoPropertyDeclaration(this SyntaxGenerator generator, string propertyName, SyntaxNode type, Accessibility accessibility, DeclarationModifiers modifiers = default(DeclarationModifiers)) { var getAccessorDeclaration = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); var setAccessorDeclaration = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); var propertyDeclaraton = ((PropertyDeclarationSyntax)generator.PropertyDeclaration(propertyName, type, Accessibility.Public)) .WithAccessorList(SyntaxFactory.AccessorList()) .AddAccessorListAccessors(getAccessorDeclaration, setAccessorDeclaration); return(propertyDeclaraton); }
public static string GetStockIcon(this EntityDeclaration element, bool showAccessibility = true) { Accessibility acc = Accessibility.Public; if (element is Accessor) { if (showAccessibility) { if (!GetAccessibility(element, out acc)) { GetAccessibility(element.Parent as EntityDeclaration, out acc); } } return(methodIconTable [(int)(acc)]); } if (showAccessibility) { GetAccessibility(element, out acc); } if (element is TypeDeclaration) { var type = element as TypeDeclaration; switch (type.ClassType) { case ClassType.Class: return(typeIconTable [0, (int)(acc)]); case ClassType.Struct: return(typeIconTable [3, (int)(acc)]); case ClassType.Interface: return(typeIconTable [2, (int)(acc)]); case ClassType.Enum: return(typeIconTable [1, (int)(acc)]); default: throw new ArgumentOutOfRangeException(); } } if (element is DelegateDeclaration) { return(typeIconTable [4, (int)(acc)]); } // member accessibility GetAccessibility(element, out acc); if (element is MethodDeclaration) { var method = element as MethodDeclaration; if (method.IsExtensionMethod) { return(extensionMethodIconTable [(int)(acc)]); } return(methodIconTable [(int)(acc)]); } if (element is OperatorDeclaration || element is ConstructorDeclaration || element is DestructorDeclaration || element is Accessor) { return(methodIconTable [(int)(acc)]); } if (element is PropertyDeclaration) { return(propertyIconTable [(int)(acc)]); } if (element is EventDeclaration || element is CustomEventDeclaration) { return(eventIconTable [(int)(acc)]); } if (element.Parent is TypeDeclaration && ((TypeDeclaration)element.Parent).ClassType == ClassType.Enum) { acc = Accessibility.Public; } return(fieldIconTable [(int)(acc)]); }
public SynchronizableValet(string identifier, bool isSharedAccessGroupIdentifier, Accessibility accessibility) { Handle = isSharedAccessGroupIdentifier ? InitWithSharedAccessGroupIdentifier(identifier, accessibility) : InitWithIdentifier(identifier, accessibility); }
internal static bool TryDetermineOverridableMembers(SemanticModel semanticModel, SyntaxToken startToken, Accessibility seenAccessibility, out ISet <ISymbol> overridableMembers, CancellationToken cancellationToken) { var result = new HashSet <ISymbol>(); var containingType = semanticModel.GetEnclosingSymbol <INamedTypeSymbol>(startToken.SpanStart, cancellationToken); if (containingType != null && !containingType.IsScriptClass && !containingType.IsImplicitClass) { if (containingType.TypeKind == TypeKind.Class || containingType.TypeKind == TypeKind.Struct) { var baseTypes = containingType.GetBaseTypes().Reverse(); foreach (var type in baseTypes) { cancellationToken.ThrowIfCancellationRequested(); // Prefer overrides in derived classes RemoveOverriddenMembers(result, type, cancellationToken); // Retain overridable methods AddOverridableMembers(result, containingType, type, cancellationToken); } // Don't suggest already overridden members RemoveOverriddenMembers(result, containingType, cancellationToken); } } // Filter based on accessibility if (seenAccessibility != Accessibility.NotApplicable) { result.RemoveWhere(m => m.DeclaredAccessibility != seenAccessibility); } overridableMembers = result; return(overridableMembers.Count > 0); }
public static void Start() { var accessibility = new Accessibility(); accessibility.MyProperty = "MyProperty"; }
public void OnTouchExplorationStateChanged(bool enabled) { Accessibility.SetAccessibility(enabled); }
static bool TryDetermineModifiers(ref SyntaxToken startToken, SourceText text, int startLine, out Accessibility seenAccessibility /*, out DeclarationModifiers modifiers*/) { var token = startToken; //modifiers = new DeclarationModifiers(); seenAccessibility = Accessibility.NotApplicable; var overrideToken = default(SyntaxToken); while (IsOnStartLine(token.SpanStart, text, startLine) && !token.IsKind(SyntaxKind.None)) { switch (token.Kind()) { //case SyntaxKind.UnsafeKeyword: // isUnsafe = true; //break; case SyntaxKind.OverrideKeyword: overrideToken = token; break; //case SyntaxKind.SealedKeyword: // isSealed = true; //break; //case SyntaxKind.AbstractKeyword: // isAbstract = true; //break; case SyntaxKind.ExternKeyword: break; // Filter on the most recently typed accessibility; keep the first one we see case SyntaxKind.PublicKeyword: if (seenAccessibility == Accessibility.NotApplicable) { seenAccessibility = Accessibility.Public; } break; case SyntaxKind.InternalKeyword: if (seenAccessibility == Accessibility.NotApplicable) { seenAccessibility = Accessibility.Internal; } // If we see internal AND protected, filter for protected internal if (seenAccessibility == Accessibility.Protected) { seenAccessibility = Accessibility.ProtectedOrInternal; } break; case SyntaxKind.ProtectedKeyword: if (seenAccessibility == Accessibility.NotApplicable) { seenAccessibility = Accessibility.Protected; } // If we see protected AND internal, filter for protected internal if (seenAccessibility == Accessibility.Internal) { seenAccessibility = Accessibility.ProtectedOrInternal; } break; default: // Anything else and we bail. return(false); } var previousToken = token.GetPreviousToken(); // We want only want to consume modifiers if (previousToken.IsKind(SyntaxKind.None) || !IsOnStartLine(previousToken.SpanStart, text, startLine)) { break; } token = previousToken; } startToken = token; /* modifiers = new DeclarationModifiers () * .WithIsUnsafe (isUnsafe) * .WithIsAbstract (isAbstract) * .WithIsOverride (true) * .WithIsSealed (isSealed);*/ return(overrideToken.IsKind(SyntaxKind.OverrideKeyword) && IsOnStartLine(overrideToken.Parent.SpanStart, text, startLine)); }