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));
}
