internal static DeclarationModifiers CheckModifiers( DeclarationModifiers modifiers, DeclarationModifiers allowedModifiers, Location errorLocation, DiagnosticBag diagnostics, out bool modifierErrors) { modifierErrors = false; DeclarationModifiers errorModifiers = modifiers & ~allowedModifiers; DeclarationModifiers result = modifiers & allowedModifiers; while (errorModifiers != DeclarationModifiers.None) { DeclarationModifiers oneError = errorModifiers & ~(errorModifiers - 1); Debug.Assert(oneError != DeclarationModifiers.None); errorModifiers = errorModifiers & ~oneError; switch (oneError) { case DeclarationModifiers.Partial: diagnostics.Add(ErrorCode.ERR_PartialMethodOnlyMethods, errorLocation); break; default: diagnostics.Add(ErrorCode.ERR_BadMemberFlag, errorLocation, ConvertSingleModifierToSyntaxText(oneError)); break; } modifierErrors = true; } bool isMethod = (allowedModifiers & (DeclarationModifiers.Partial | DeclarationModifiers.Virtual)) == (DeclarationModifiers.Partial | DeclarationModifiers.Virtual); if (isMethod && ((result & (DeclarationModifiers.Partial | DeclarationModifiers.Private)) == (DeclarationModifiers.Partial | DeclarationModifiers.Private))) { diagnostics.Add(ErrorCode.ERR_PartialMethodInvalidModifier, errorLocation); } return result; }
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) }); }
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; }
public static CompletionItem Create( string displayText, TextSpan span, Glyph? glyph, DeclarationModifiers modifiers, int line, ISymbol symbol, SyntaxToken token, int descriptionPosition, CompletionItemRules rules) { var props = ImmutableDictionary<string, string>.Empty .Add("Line", line.ToString()) .Add("Modifiers", modifiers.ToString()) .Add("TokenSpanEnd", token.Span.End.ToString()); return SymbolCompletionItem.Create( displayText: displayText, span: span, symbol: symbol, glyph: glyph, descriptionPosition: descriptionPosition, properties: props, rules: rules); }
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; }
internal SourceMemberFieldSymbol( SourceMemberContainerTypeSymbol containingType, VariableDeclaratorSyntax declarator, DeclarationModifiers modifiers, bool modifierErrors, DiagnosticBag diagnostics) : base(containingType, declarator.Identifier.ValueText, declarator.GetReference(), declarator.Identifier.GetLocation()) { this.modifiers = modifiers; this.CheckAccessibility(diagnostics); var location = Location; if (modifierErrors) { // skip the following checks } else if (containingType.IsSealed && (DeclaredAccessibility == Accessibility.Protected || DeclaredAccessibility == Accessibility.ProtectedOrInternal)) { diagnostics.Add(AccessCheck.GetProtectedMemberInSealedTypeError(containingType), location, this); } else if (IsVolatile && IsReadOnly) { diagnostics.Add(ErrorCode.ERR_VolatileAndReadonly, location, this); } else if (containingType.IsStatic && !IsStatic) { diagnostics.Add(ErrorCode.ERR_InstanceMemberInStaticClass, location, this); } // TODO: Consider checking presence of core type System.Runtime.CompilerServices.IsVolatile // if there is a volatile modifier. Perhaps an appropriate error should be reported if the // type isn’t available. }
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 LocalFunctionSymbol( Binder binder, Symbol containingSymbol, LocalFunctionStatementSyntax syntax) { _syntax = syntax; _containingSymbol = containingSymbol; _declarationModifiers = DeclarationModifiers.Private | DeclarationModifiers.Static | syntax.Modifiers.ToDeclarationModifiers(); var diagnostics = DiagnosticBag.GetInstance(); if (_syntax.TypeParameterList != null) { binder = new WithMethodTypeParametersBinder(this, binder); _typeParameters = MakeTypeParameters(diagnostics); } else { _typeParameters = ImmutableArray<TypeParameterSymbol>.Empty; } if (IsExtensionMethod) { diagnostics.Add(ErrorCode.ERR_BadExtensionAgg, Locations[0]); } _binder = binder; _refKind = (syntax.ReturnType.Kind() == SyntaxKind.RefType) ? RefKind.Ref : RefKind.None; _diagnostics = diagnostics.ToReadOnlyAndFree(); }
public static SourcePropertyAccessorSymbol CreateAccessorSymbol( NamedTypeSymbol containingType, SourcePropertySymbol property, DeclarationModifiers propertyModifiers, string propertyName, ArrowExpressionClauseSyntax syntax, PropertySymbol explicitlyImplementedPropertyOpt, string aliasQualifierOpt, DiagnosticBag diagnostics) { string name; ImmutableArray<MethodSymbol> explicitInterfaceImplementations; GetNameAndExplicitInterfaceImplementations( explicitlyImplementedPropertyOpt, propertyName, property.IsCompilationOutputWinMdObj(), aliasQualifierOpt, isGetMethod: true, name: out name, explicitInterfaceImplementations: out explicitInterfaceImplementations); return new SourcePropertyAccessorSymbol( containingType, name, property, propertyModifiers, explicitInterfaceImplementations, syntax.Expression.GetLocation(), syntax, diagnostics); }
private ISymbol GenerateMember( ISymbol member, bool addUnsafe, CancellationToken cancellationToken) { var modifiers = new DeclarationModifiers(isOverride: true, isUnsafe: addUnsafe); var accessibility = member.ComputeResultantAccessibility(_state.ClassType); if (member.Kind == SymbolKind.Method) { return GenerateMethod((IMethodSymbol)member, modifiers, accessibility, cancellationToken); } else if (member.Kind == SymbolKind.Property) { return GenerateProperty((IPropertySymbol)member, modifiers, accessibility, cancellationToken); } else if (member.Kind == SymbolKind.Event) { var @event = (IEventSymbol)member; return CodeGenerationSymbolFactory.CreateEventSymbol( @event, accessibility: accessibility, modifiers: modifiers); } return null; }
protected CodeGenerationNamespaceOrTypeSymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility declaredAccessibility, DeclarationModifiers modifiers, string name) : base(containingType, attributes, declaredAccessibility, modifiers, name) { }
internal SourceMemberFieldSymbol( SourceMemberContainerTypeSymbol containingType, DeclarationModifiers modifiers, string name, SyntaxReference syntax, Location location) : base(containingType, name, syntax, location) { _modifiers = modifiers; }
/// <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; }
protected SourceDelegateMethodSymbol( SourceMemberContainerTypeSymbol delegateType, TypeSymbol returnType, DelegateDeclarationSyntax syntax, MethodKind methodKind, DeclarationModifiers declarationModifiers) : base(delegateType, syntax.GetReference(), bodySyntaxReferenceOpt: null, location: syntax.Identifier.GetLocation()) { _returnType = returnType; this.MakeFlags(methodKind, declarationModifiers, _returnType.SpecialType == SpecialType.System_Void, isExtensionMethod: false); }
protected CodeGenerationTypeSymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility declaredAccessibility, DeclarationModifiers modifiers, string name, SpecialType specialType) : base(containingType, attributes, declaredAccessibility, modifiers, name) { this.SpecialType = specialType; }
internal SourceFixedFieldSymbol( SourceMemberContainerTypeSymbol containingType, VariableDeclaratorSyntax declarator, DeclarationModifiers modifiers, bool modifierErrors, DiagnosticBag diagnostics) : base(containingType, declarator, modifiers, modifierErrors, diagnostics) { // Checked in parser: a fixed field declaration requires a length in square brackets Debug.Assert(this.IsFixed); }
internal GlobalExpressionVariable( SourceMemberContainerTypeSymbol containingType, DeclarationModifiers modifiers, TypeSyntax typeSyntax, string name, SyntaxReference syntax, Location location) : base(containingType, modifiers, name, syntax, location) { Debug.Assert(DeclaredAccessibility == Accessibility.Private); _typeSyntax = typeSyntax.GetReference(); }
private ISymbol GenerateProperty( Compilation compilation, IPropertySymbol property, Accessibility accessibility, DeclarationModifiers modifiers, bool generateAbstractly, bool useExplicitInterfaceSymbol, string memberName, CancellationToken cancellationToken) { var factory = this.Document.GetLanguageService<SyntaxGenerator>(); var comAliasNameAttribute = compilation.ComAliasNameAttributeType(); var getAccessor = property.GetMethod == null ? null : CodeGenerationSymbolFactory.CreateAccessorSymbol( property.GetMethod.RemoveInaccessibleAttributesAndAttributesOfType( accessibleWithin: this.State.ClassOrStructType, removeAttributeType: comAliasNameAttribute), attributes: null, accessibility: accessibility, explicitInterfaceSymbol: useExplicitInterfaceSymbol ? property.GetMethod : null, statements: GetGetAccessorStatements(compilation, property, generateAbstractly, cancellationToken)); var setAccessor = property.SetMethod == null ? null : CodeGenerationSymbolFactory.CreateAccessorSymbol( property.SetMethod.RemoveInaccessibleAttributesAndAttributesOfType( accessibleWithin: this.State.ClassOrStructType, removeAttributeType: comAliasNameAttribute), attributes: null, accessibility: accessibility, explicitInterfaceSymbol: useExplicitInterfaceSymbol ? property.SetMethod : null, statements: GetSetAccessorStatements(compilation, property, generateAbstractly, cancellationToken)); var syntaxFacts = Document.GetLanguageService<ISyntaxFactsService>(); var parameterNames = NameGenerator.EnsureUniqueness( property.Parameters.Select(p => p.Name).ToList(), isCaseSensitive: syntaxFacts.IsCaseSensitive); var updatedProperty = property.RenameParameters(parameterNames); updatedProperty = updatedProperty.RemoveAttributeFromParameters(comAliasNameAttribute); // TODO(cyrusn): Delegate through throughMember if it's non-null. return CodeGenerationSymbolFactory.CreatePropertySymbol( updatedProperty, accessibility: accessibility, modifiers: modifiers, explicitInterfaceSymbol: useExplicitInterfaceSymbol ? property : null, name: memberName, getMethod: getAccessor, setMethod: setAccessor); }
/// <summary> /// Creates a property symbol that can be used to describe a property declaration. /// </summary> public static IPropertySymbol CreatePropertySymbol(IList<AttributeData> attributes, Accessibility accessibility, DeclarationModifiers modifiers, ITypeSymbol type, IPropertySymbol explicitInterfaceSymbol, string name, IList<IParameterSymbol> parameters, IMethodSymbol getMethod, IMethodSymbol setMethod, bool isIndexer = false) { return CreatePropertySymbol( containingType: null, attributes: attributes, accessibility: accessibility, modifiers: modifiers, type: type, explicitInterfaceSymbol: explicitInterfaceSymbol, name: name, parameters: parameters, getMethod: getMethod, setMethod: setMethod, isIndexer: isIndexer); }
public SynthesizedFieldSymbolBase( NamedTypeSymbol containingType, string name, bool isPublic, bool isReadOnly, bool isStatic) { Debug.Assert(!string.IsNullOrEmpty(name)); this.containingType = containingType; this.name = name; this.modifiers = (isPublic ? DeclarationModifiers.Public : DeclarationModifiers.Private) | (isReadOnly ? DeclarationModifiers.ReadOnly : DeclarationModifiers.None) | (isStatic ? DeclarationModifiers.Static : DeclarationModifiers.None); }
private static string ConvertSingleModifierToSyntaxText(DeclarationModifiers modifier) { switch (modifier) { case DeclarationModifiers.Abstract: return SyntaxFacts.GetText(SyntaxKind.AbstractKeyword); case DeclarationModifiers.Sealed: return SyntaxFacts.GetText(SyntaxKind.SealedKeyword); case DeclarationModifiers.Static: return SyntaxFacts.GetText(SyntaxKind.StaticKeyword); case DeclarationModifiers.New: return SyntaxFacts.GetText(SyntaxKind.NewKeyword); case DeclarationModifiers.Public: return SyntaxFacts.GetText(SyntaxKind.PublicKeyword); case DeclarationModifiers.Protected: return SyntaxFacts.GetText(SyntaxKind.ProtectedKeyword); case DeclarationModifiers.Internal: return SyntaxFacts.GetText(SyntaxKind.InternalKeyword); case DeclarationModifiers.ProtectedInternal: return SyntaxFacts.GetText(SyntaxKind.ProtectedKeyword) + " " + SyntaxFacts.GetText(SyntaxKind.InternalKeyword); case DeclarationModifiers.Private: return SyntaxFacts.GetText(SyntaxKind.PrivateKeyword); case DeclarationModifiers.ReadOnly: return SyntaxFacts.GetText(SyntaxKind.ReadOnlyKeyword); case DeclarationModifiers.Const: return SyntaxFacts.GetText(SyntaxKind.ConstKeyword); case DeclarationModifiers.Volatile: return SyntaxFacts.GetText(SyntaxKind.VolatileKeyword); case DeclarationModifiers.Extern: return SyntaxFacts.GetText(SyntaxKind.ExternKeyword); case DeclarationModifiers.Partial: return SyntaxFacts.GetText(SyntaxKind.PartialKeyword); case DeclarationModifiers.Unsafe: return SyntaxFacts.GetText(SyntaxKind.UnsafeKeyword); case DeclarationModifiers.Fixed: return SyntaxFacts.GetText(SyntaxKind.FixedKeyword); case DeclarationModifiers.Virtual: return SyntaxFacts.GetText(SyntaxKind.VirtualKeyword); case DeclarationModifiers.Override: return SyntaxFacts.GetText(SyntaxKind.OverrideKeyword); case DeclarationModifiers.Replace: return SyntaxFacts.GetText(SyntaxKind.ReplaceKeyword); case DeclarationModifiers.Async: return SyntaxFacts.GetText(SyntaxKind.AsyncKeyword); default: throw ExceptionUtilities.UnexpectedValue(modifier); } }
public static SourcePropertyAccessorSymbol CreateAccessorSymbol( NamedTypeSymbol containingType, SourcePropertySymbol property, DeclarationModifiers propertyModifiers, string propertyName, AccessorDeclarationSyntax syntax, PropertySymbol explicitlyImplementedPropertyOpt, string aliasQualifierOpt, bool isAutoPropertyAccessor, DiagnosticBag diagnostics) { Debug.Assert(syntax.Kind == SyntaxKind.GetAccessorDeclaration || syntax.Kind == SyntaxKind.SetAccessorDeclaration); bool isGetMethod = (syntax.Kind == SyntaxKind.GetAccessorDeclaration); bool isWinMd = property.IsCompilationOutputWinMdObj(); string name; ImmutableArray<MethodSymbol> explicitInterfaceImplementations; if ((object)explicitlyImplementedPropertyOpt == null) { name = GetAccessorName(propertyName, isGetMethod, isWinMd); explicitInterfaceImplementations = ImmutableArray<MethodSymbol>.Empty; } else { MethodSymbol implementedAccessor = isGetMethod ? explicitlyImplementedPropertyOpt.GetMethod : explicitlyImplementedPropertyOpt.SetMethod; string accessorName = (object)implementedAccessor != null ? implementedAccessor.Name : GetAccessorName(explicitlyImplementedPropertyOpt.MetadataName, isGetMethod, isWinMd); //Not name - could be indexer placeholder name = ExplicitInterfaceHelpers.GetMemberName(accessorName, explicitlyImplementedPropertyOpt.ContainingType, aliasQualifierOpt); explicitInterfaceImplementations = (object)implementedAccessor == null ? ImmutableArray<MethodSymbol>.Empty : ImmutableArray.Create<MethodSymbol>(implementedAccessor); } var methodKind = isGetMethod ? MethodKind.PropertyGet : MethodKind.PropertySet; return new SourcePropertyAccessorSymbol( containingType, name, property, propertyModifiers, explicitInterfaceImplementations, syntax.Keyword.GetLocation(), syntax, methodKind, isAutoPropertyAccessor, diagnostics); }
internal static GlobalExpressionVariable Create( SourceMemberContainerTypeSymbol containingType, DeclarationModifiers modifiers, TypeSyntax typeSyntax, string name, SyntaxNode syntax, Location location, FieldSymbol containingFieldOpt, SyntaxNode nodeToBind) { Debug.Assert(nodeToBind.Kind() == SyntaxKind.VariableDeclarator || nodeToBind is ExpressionSyntax); var syntaxReference = syntax.GetReference(); return typeSyntax.IsVar ? new InferrableGlobalExpressionVariable(containingType, modifiers, typeSyntax, name, syntaxReference, location, containingFieldOpt, nodeToBind) : new GlobalExpressionVariable(containingType, modifiers, typeSyntax, name, syntaxReference, location); }
internal BackingField( SourceParameterSymbol parameterSymbol, DeclarationModifiers modifiers, bool modifierErrors, DiagnosticBag diagnostics) : base((SourceMemberContainerTypeSymbol)parameterSymbol.ContainingType) { this.parameterSymbol = parameterSymbol; this.modifiers = modifiers; this.CheckAccessibility(diagnostics); if (!modifierErrors) { this.ReportModifiersDiagnostics(diagnostics); } }
public MemberInsertionCompletionItem( CompletionListProvider provider, string displayText, TextSpan filterSpan, Func<CancellationToken, Task<ImmutableArray<SymbolDisplayPart>>> descriptionFactory, Glyph? glyph, DeclarationModifiers modifiers, int line, SymbolKey symbolId, SyntaxToken token) : base(provider, displayText, filterSpan, descriptionFactory, glyph) { this.Modifiers = modifiers; this.Line = line; this.SymbolId = symbolId; this.Token = token; }
public CodeGenerationConstructorSymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility accessibility, DeclarationModifiers modifiers, IList<IParameterSymbol> parameters) : base(containingType, attributes, accessibility, modifiers, returnType: null, explicitInterfaceSymbolOpt: null, name: string.Empty, typeParameters: SpecializedCollections.EmptyList<ITypeParameterSymbol>(), parameters: parameters, returnTypeAttributes: SpecializedCollections.EmptyList<AttributeData>()) { }
internal static DeclarationModifiers MakeAndCheckNontypeMemberModifiers( SyntaxTokenList modifiers, DeclarationModifiers defaultAccess, DeclarationModifiers allowedModifiers, Location errorLocation, DiagnosticBag diagnostics, out bool modifierErrors) { var result = modifiers.ToDeclarationModifiers(); result = CheckModifiers(result, allowedModifiers, errorLocation, diagnostics, out modifierErrors); if ((result & DeclarationModifiers.AccessibilityMask) == 0) { result |= defaultAccess; } return result; }
internal SourceMemberFieldSymbol( SourceMemberContainerTypeSymbol containingType, VariableDeclaratorSyntax declarator, DeclarationModifiers modifiers, bool modifierErrors, DiagnosticBag diagnostics) : base(containingType, declarator.Identifier.ValueText, declarator.GetReference(), declarator.Identifier.GetLocation()) { _modifiers = modifiers; _hasInitializer = declarator.Initializer != null; this.CheckAccessibility(diagnostics); if (!modifierErrors) { this.ReportModifiersDiagnostics(diagnostics); } }
protected override bool IsPartialMethodCompletionContext(SyntaxTree tree, int position, CancellationToken cancellationToken, out DeclarationModifiers modifiers, out SyntaxToken token) { var touchingToken = tree.FindTokenOnLeftOfPosition(position, cancellationToken); var targetToken = touchingToken.GetPreviousTokenIfTouchingWord(position); var text = tree.GetText(cancellationToken); token = targetToken; modifiers = default(DeclarationModifiers); if (targetToken.IsKind(SyntaxKind.VoidKeyword, SyntaxKind.PartialKeyword) || (targetToken.Kind() == SyntaxKind.IdentifierToken && targetToken.HasMatchingText(SyntaxKind.PartialKeyword))) { return !IsOnSameLine(touchingToken.GetNextToken(), touchingToken, text) && VerifyModifiers(tree, position, cancellationToken, out modifiers); } return false; }
// TODO: CLSCompliantAttribute internal SourceEventSymbol( SourceMemberContainerTypeSymbol containingType, CSharpSyntaxNode syntax, SyntaxTokenList modifiers, ExplicitInterfaceSpecifierSyntax interfaceSpecifierSyntaxOpt, SyntaxToken nameTokenSyntax, DiagnosticBag diagnostics) { _location = nameTokenSyntax.GetLocation(); this.containingType = containingType; _syntaxRef = syntax.GetReference(); var isExplicitInterfaceImplementation = interfaceSpecifierSyntaxOpt != null; bool modifierErrors; _modifiers = MakeModifiers(modifiers, isExplicitInterfaceImplementation, _location, diagnostics, out modifierErrors); this.CheckAccessibility(_location, diagnostics); }
public bool AppliesTo(SymbolKindOrTypeKind kind, DeclarationModifiers modifiers, Accessibility?accessibility) { if (!ApplicableSymbolKindList.Any(static (k, kind) => k.Equals(kind), kind))
private bool VerifyModifiers(SyntaxTree tree, int position, CancellationToken cancellationToken, out DeclarationModifiers modifiers) { var touchingToken = tree.FindTokenOnLeftOfPosition(position, cancellationToken); var token = touchingToken.GetPreviousToken(); var foundPartial = touchingToken.IsKindOrHasMatchingText(SyntaxKind.PartialKeyword); var foundAsync = false; while (IsOnSameLine(token, touchingToken, tree.GetText(cancellationToken))) { if (token.IsKind(SyntaxKind.ExternKeyword, SyntaxKind.PublicKeyword, SyntaxKind.ProtectedKeyword, SyntaxKind.InternalKeyword)) { modifiers = default; return(false); } if (token.IsKindOrHasMatchingText(SyntaxKind.AsyncKeyword)) { foundAsync = true; } foundPartial = foundPartial || token.IsKindOrHasMatchingText(SyntaxKind.PartialKeyword); token = token.GetPreviousToken(); } modifiers = new DeclarationModifiers(isAsync: foundAsync, isPartial: true); return(foundPartial); }
public ModifierKind(DeclarationModifiers modifier) { this.Modifier = modifier; }
private static async Task <Solution> PullMembersIntoClassAsync( Document document, PullMembersUpOptions result, Solution solution, CancellationToken cancellationToken ) { var solutionEditor = new SolutionEditor(solution); var codeGenerationService = document.Project.LanguageServices.GetRequiredService <ICodeGenerationService>(); var destinationSyntaxNode = await codeGenerationService .FindMostRelevantNameSpaceOrTypeDeclarationAsync( solution, result.Destination, options : null, cancellationToken ) .ConfigureAwait(false); var symbolToDeclarations = await InitializeSymbolToDeclarationsMapAsync( result, cancellationToken ) .ConfigureAwait(false); // Add members to destination var pullUpMembersSymbols = result.MemberAnalysisResults.SelectAsArray( memberResult => { if ( memberResult.MakeMemberDeclarationAbstract && !memberResult.Member.IsKind(SymbolKind.Field) ) { // Change the member to abstract if user choose to make them abstract return(MakeAbstractVersion(memberResult.Member)); } else { return(memberResult.Member); } } ); var options = new CodeGenerationOptions( reuseSyntax: true, generateMethodBodies: false, options: await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false) ); var newDestination = codeGenerationService.AddMembers( destinationSyntaxNode, pullUpMembersSymbols, options: options, cancellationToken: cancellationToken ); // Remove some original members since we are pulling members into class. // Note: If the user chooses to make the member abstract, then the original member will be changed to an override, // and it will pull an abstract declaration up to the destination. // But if the member is abstract itself, it will still be removed. foreach (var analysisResult in result.MemberAnalysisResults) { foreach (var syntax in symbolToDeclarations[analysisResult.Member]) { var originalMemberEditor = await solutionEditor .GetDocumentEditorAsync( solution.GetDocumentId(syntax.SyntaxTree), cancellationToken ) .ConfigureAwait(false); if ( !analysisResult.MakeMemberDeclarationAbstract || analysisResult.Member.IsAbstract ) { originalMemberEditor.RemoveNode( originalMemberEditor.Generator.GetDeclaration(syntax) ); } else { var declarationSyntax = originalMemberEditor.Generator.GetDeclaration( syntax ); originalMemberEditor.ReplaceNode( declarationSyntax, (node, generator) => generator.WithModifiers(node, DeclarationModifiers.Override) ); } } } // Change the destination to abstract class if needed. var destinationEditor = await solutionEditor .GetDocumentEditorAsync( solution.GetDocumentId(destinationSyntaxNode.SyntaxTree), cancellationToken ) .ConfigureAwait(false); if ( !result.Destination.IsAbstract && result.MemberAnalysisResults.Any( analysis => analysis.Member.IsAbstract || analysis.MakeMemberDeclarationAbstract ) ) { var modifiers = DeclarationModifiers.From(result.Destination).WithIsAbstract(true); newDestination = destinationEditor.Generator.WithModifiers( newDestination, modifiers ); } destinationEditor.ReplaceNode( destinationSyntaxNode, (syntaxNode, generator) => newDestination ); return(solutionEditor.GetChangedSolution()); }
private SourcePropertyAccessorSymbol( NamedTypeSymbol containingType, string name, SourcePropertySymbol property, DeclarationModifiers propertyModifiers, ImmutableArray <MethodSymbol> explicitInterfaceImplementations, Location location, AccessorDeclarationSyntax syntax, MethodKind methodKind, bool isAutoPropertyAccessor, DiagnosticBag diagnostics) : base(containingType, syntax.GetReference(), syntax.Body?.GetReference(), location) { _property = property; _explicitInterfaceImplementations = explicitInterfaceImplementations; _name = name; _isAutoPropertyAccessor = isAutoPropertyAccessor; bool modifierErrors; var declarationModifiers = this.MakeModifiers(syntax, location, diagnostics, out modifierErrors); // Include modifiers from the containing property. propertyModifiers &= ~DeclarationModifiers.AccessibilityMask; if ((declarationModifiers & DeclarationModifiers.Private) != 0) { // Private accessors cannot be virtual. propertyModifiers &= ~DeclarationModifiers.Virtual; } declarationModifiers |= propertyModifiers & ~DeclarationModifiers.Indexer; // ReturnsVoid property is overridden in this class so // returnsVoid argument to MakeFlags is ignored. this.MakeFlags(methodKind, declarationModifiers, returnsVoid: false, isExtensionMethod: false, isMetadataVirtualIgnoringModifiers: explicitInterfaceImplementations.Any()); var bodyOpt = syntax.Body; if (bodyOpt != null) { CheckModifiersForBody(location, diagnostics); } var info = ModifierUtils.CheckAccessibility(this.DeclarationModifiers); if (info != null) { diagnostics.Add(info, location); } if (!modifierErrors) { this.CheckModifiers(location, isAutoPropertyAccessor, diagnostics); } if (this.IsOverride) { MethodSymbol overriddenMethod = this.OverriddenMethod; if ((object)overriddenMethod != null) { // If this accessor is overriding a method from metadata, it is possible that // the name of the overridden method doesn't follow the C# get_X/set_X pattern. // We should copy the name so that the runtime will recognize this as an override. _name = overriddenMethod.Name; } } }
internal static void CheckUnsafeModifier(this Symbol symbol, DeclarationModifiers modifiers, BindingDiagnosticBag diagnostics) { symbol.CheckUnsafeModifier(modifiers, symbol.Locations[0], diagnostics); }
internal static DeclarationModifiers MakeModifiers(NamedTypeSymbol containingType, SyntaxToken firstIdentifier, SyntaxTokenList modifiers, BindingDiagnosticBag diagnostics, out bool modifierErrors) { DeclarationModifiers defaultAccess = (containingType.IsInterface) ? DeclarationModifiers.Public : DeclarationModifiers.Private; DeclarationModifiers allowedModifiers = DeclarationModifiers.AccessibilityMask | DeclarationModifiers.Const | DeclarationModifiers.New | DeclarationModifiers.ReadOnly | DeclarationModifiers.Static | DeclarationModifiers.Volatile | DeclarationModifiers.Fixed | DeclarationModifiers.Unsafe | DeclarationModifiers.Abstract; // filtered out later var errorLocation = new SourceLocation(firstIdentifier); DeclarationModifiers result = ModifierUtils.MakeAndCheckNontypeMemberModifiers( modifiers, defaultAccess, allowedModifiers, errorLocation, diagnostics, out modifierErrors); if ((result & DeclarationModifiers.Abstract) != 0) { diagnostics.Add(ErrorCode.ERR_AbstractField, errorLocation); result &= ~DeclarationModifiers.Abstract; } if ((result & DeclarationModifiers.Fixed) != 0) { if ((result & DeclarationModifiers.Static) != 0) { // The modifier 'static' is not valid for this item diagnostics.Add(ErrorCode.ERR_BadMemberFlag, errorLocation, SyntaxFacts.GetText(SyntaxKind.StaticKeyword)); } if ((result & DeclarationModifiers.ReadOnly) != 0) { // The modifier 'readonly' is not valid for this item diagnostics.Add(ErrorCode.ERR_BadMemberFlag, errorLocation, SyntaxFacts.GetText(SyntaxKind.ReadOnlyKeyword)); } if ((result & DeclarationModifiers.Const) != 0) { // The modifier 'const' is not valid for this item diagnostics.Add(ErrorCode.ERR_BadMemberFlag, errorLocation, SyntaxFacts.GetText(SyntaxKind.ConstKeyword)); } if ((result & DeclarationModifiers.Volatile) != 0) { // The modifier 'volatile' is not valid for this item diagnostics.Add(ErrorCode.ERR_BadMemberFlag, errorLocation, SyntaxFacts.GetText(SyntaxKind.VolatileKeyword)); } result &= ~(DeclarationModifiers.Static | DeclarationModifiers.ReadOnly | DeclarationModifiers.Const | DeclarationModifiers.Volatile); Debug.Assert((result & ~(DeclarationModifiers.AccessibilityMask | DeclarationModifiers.Fixed | DeclarationModifiers.Unsafe | DeclarationModifiers.New)) == 0); } if ((result & DeclarationModifiers.Const) != 0) { if ((result & DeclarationModifiers.Static) != 0) { // The constant '{0}' cannot be marked static diagnostics.Add(ErrorCode.ERR_StaticConstant, errorLocation, firstIdentifier.ValueText); } if ((result & DeclarationModifiers.ReadOnly) != 0) { // The modifier 'readonly' is not valid for this item diagnostics.Add(ErrorCode.ERR_BadMemberFlag, errorLocation, SyntaxFacts.GetText(SyntaxKind.ReadOnlyKeyword)); } if ((result & DeclarationModifiers.Volatile) != 0) { // The modifier 'volatile' is not valid for this item diagnostics.Add(ErrorCode.ERR_BadMemberFlag, errorLocation, SyntaxFacts.GetText(SyntaxKind.VolatileKeyword)); } if ((result & DeclarationModifiers.Unsafe) != 0) { // The modifier 'unsafe' is not valid for this item diagnostics.Add(ErrorCode.ERR_BadMemberFlag, errorLocation, SyntaxFacts.GetText(SyntaxKind.UnsafeKeyword)); } result |= DeclarationModifiers.Static; // "constants are considered static members" } else { // NOTE: always cascading on a const, so suppress. // NOTE: we're being a bit sneaky here - we're using the containingType rather than this symbol // to determine whether or not unsafe is allowed. Since this symbol and the containing type are // in the same compilation, it won't make a difference. We do, however, have to pass the error // location explicitly. containingType.CheckUnsafeModifier(result, errorLocation, diagnostics); } return(result); }
private void CheckModifiers(Location location, DiagnosticBag diagnostics) { const DeclarationModifiers partialMethodInvalidModifierMask = (DeclarationModifiers.AccessibilityMask & ~DeclarationModifiers.Private) | DeclarationModifiers.Virtual | DeclarationModifiers.Abstract | DeclarationModifiers.Override | DeclarationModifiers.New | DeclarationModifiers.Sealed | DeclarationModifiers.Extern; if (IsPartial && !ReturnsVoid) { diagnostics.Add(ErrorCode.ERR_PartialMethodMustReturnVoid, location); } else if (IsPartial && !ContainingType.IsInterface && (DeclarationModifiers & partialMethodInvalidModifierMask) != 0) { diagnostics.Add(ErrorCode.ERR_PartialMethodInvalidModifier, location); } else if (this.DeclaredAccessibility == Accessibility.Private && (IsVirtual || IsAbstract || IsOverride)) { diagnostics.Add(ErrorCode.ERR_VirtualPrivate, location, this); } else if (IsStatic && (IsOverride || IsVirtual || IsAbstract)) { // A static member '{0}' cannot be marked as override, virtual, or abstract diagnostics.Add(ErrorCode.ERR_StaticNotVirtual, location, this); } else if (IsOverride && (IsNew || IsVirtual)) { // A member '{0}' marked as override cannot be marked as new or virtual diagnostics.Add(ErrorCode.ERR_OverrideNotNew, location, this); } else if (IsSealed && !IsOverride) { // '{0}' cannot be sealed because it is not an override diagnostics.Add(ErrorCode.ERR_SealedNonOverride, location, this); } else if (!ContainingType.IsInterfaceType() && _lazyReturnType.IsStatic) { // '{0}': static types cannot be used as return types diagnostics.Add(ErrorCode.ERR_ReturnTypeIsStaticClass, location, _lazyReturnType); } else if (IsAbstract && IsExtern) { diagnostics.Add(ErrorCode.ERR_AbstractAndExtern, location, this); } else if (IsAbstract && IsSealed) { diagnostics.Add(ErrorCode.ERR_AbstractAndSealed, location, this); } else if (IsAbstract && IsVirtual) { diagnostics.Add(ErrorCode.ERR_AbstractNotVirtual, location, this); } else if (IsAbstract && !ContainingType.IsAbstract && ContainingType.TypeKind == TypeKind.Class) { // '{0}' is abstract but it is contained in non-abstract class '{1}' diagnostics.Add(ErrorCode.ERR_AbstractInConcreteClass, location, this, ContainingType); } else if (IsVirtual && ContainingType.IsSealed) { // '{0}' is a new virtual member in sealed class '{1}' diagnostics.Add(ErrorCode.ERR_NewVirtualInSealed, location, this, ContainingType); } else if (bodySyntaxReferenceOpt == null && IsAsync) { diagnostics.Add(ErrorCode.ERR_BadAsyncLacksBody, location); } else if (bodySyntaxReferenceOpt == null && !IsExtern && !IsAbstract && !IsPartial && !IsExpressionBodied) { diagnostics.Add(ErrorCode.ERR_ConcreteMissingBody, location, this); } else if (ContainingType.IsSealed && this.DeclaredAccessibility.HasProtected() && !this.IsOverride) { diagnostics.Add(AccessCheck.GetProtectedMemberInSealedTypeError(ContainingType), location, this); } else if (ContainingType.IsStatic && !IsStatic) { diagnostics.Add(ErrorCode.ERR_InstanceMemberInStaticClass, location, Name); } else if (_lazyIsVararg && (IsGenericMethod || ContainingType.IsGenericType || _lazyParameters.Length > 0 && _lazyParameters[_lazyParameters.Length - 1].IsParams)) { diagnostics.Add(ErrorCode.ERR_BadVarargs, location); } else if (_lazyIsVararg && IsAsync) { diagnostics.Add(ErrorCode.ERR_VarargsAsync, location); } }
public EnumBuilder SetDeclarationModifiers(DeclarationModifiers modifiers) { DeclarationModifiers = modifiers; return(this); }
private SourcePropertyAccessorSymbol( NamedTypeSymbol containingType, string name, SourcePropertySymbol property, DeclarationModifiers propertyModifiers, ImmutableArray <MethodSymbol> explicitInterfaceImplementations, Location location, AccessorDeclarationSyntax syntax, MethodKind methodKind, bool isAutoPropertyAccessor, bool isExplicitInterfaceImplementation, DiagnosticBag diagnostics) : base(containingType, syntax.GetReference(), location) { _property = property; _explicitInterfaceImplementations = explicitInterfaceImplementations; _name = name; _isAutoPropertyAccessor = isAutoPropertyAccessor; Debug.Assert(!_property.IsExpressionBodied, "Cannot have accessors in expression bodied lightweight properties"); var hasBody = syntax.Body != null; var hasExpressionBody = syntax.ExpressionBody != null; _isExpressionBodied = !hasBody && hasExpressionBody; bool modifierErrors; var declarationModifiers = this.MakeModifiers(syntax, isExplicitInterfaceImplementation, hasBody || hasExpressionBody, location, diagnostics, out modifierErrors); // Include some modifiers from the containing property, but not the accessibility modifiers. declarationModifiers |= GetAccessorModifiers(propertyModifiers) & ~DeclarationModifiers.AccessibilityMask; if ((declarationModifiers & DeclarationModifiers.Private) != 0) { // Private accessors cannot be virtual. declarationModifiers &= ~DeclarationModifiers.Virtual; } // ReturnsVoid property is overridden in this class so // returnsVoid argument to MakeFlags is ignored. this.MakeFlags(methodKind, declarationModifiers, returnsVoid: false, isExtensionMethod: false, isMetadataVirtualIgnoringModifiers: explicitInterfaceImplementations.Any()); CheckFeatureAvailabilityAndRuntimeSupport(syntax, location, hasBody: hasBody || hasExpressionBody || isAutoPropertyAccessor, diagnostics); if (hasBody || hasExpressionBody) { CheckModifiersForBody(syntax, location, diagnostics); } var info = ModifierUtils.CheckAccessibility(this.DeclarationModifiers, this, isExplicitInterfaceImplementation); if (info != null) { diagnostics.Add(info, location); } if (!modifierErrors) { this.CheckModifiers(location, hasBody || hasExpressionBody, isAutoPropertyAccessor, diagnostics); } if (this.IsOverride) { MethodSymbol overriddenMethod = this.OverriddenMethod; if ((object)overriddenMethod != null) { // If this accessor is overriding a method from metadata, it is possible that // the name of the overridden method doesn't follow the C# get_X/set_X pattern. // We should copy the name so that the runtime will recognize this as an override. _name = overriddenMethod.Name; } } CheckForBlockAndExpressionBody( syntax.Body, syntax.ExpressionBody, syntax, diagnostics); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { var model = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false); var gen = SyntaxGenerator.GetGenerator(context.Document); foreach (var dx in context.Diagnostics) { if (dx.Location.IsInSource) { var root = await dx.Location.SourceTree.GetRootAsync(context.CancellationToken).ConfigureAwait(false); var declarationNode = gen.GetDeclaration(root.FindToken(dx.Location.SourceSpan.Start).Parent); if (declarationNode != null) { var solution = context.Document.Project.Solution; var symbol = model.GetDeclaredSymbol(declarationNode, context.CancellationToken); if (symbol != null) { if (symbol is not INamedTypeSymbol) { if (symbol.IsOverride) { context.RegisterCodeFix(new ChangeModifierAction(MicrosoftCodeQualityAnalyzersResources.MakeMemberNotOverridable, "MakeMemberNotOverridable", solution, symbol, DeclarationModifiers.From(symbol) + DeclarationModifiers.Sealed), dx); } else if (symbol.IsVirtual) { context.RegisterCodeFix(new ChangeModifierAction(MicrosoftCodeQualityAnalyzersResources.MakeMemberNotOverridable, "MakeMemberNotOverridable", solution, symbol, DeclarationModifiers.From(symbol) - DeclarationModifiers.Virtual), dx); } else if (symbol.IsAbstract) { context.RegisterCodeFix(new ChangeModifierAction(MicrosoftCodeQualityAnalyzersResources.MakeMemberNotOverridable, "MakeMemberNotOverridable", solution, symbol, DeclarationModifiers.From(symbol) - DeclarationModifiers.Abstract), dx); } // trigger containing type code fixes below symbol = symbol.ContainingType; } // if the diagnostic identified a type then it is the containing type of the member if (symbol is INamedTypeSymbol type) { // cannot make abstract type sealed because they cannot be constructed if (!type.IsAbstract) { context.RegisterCodeFix(new ChangeModifierAction(MicrosoftCodeQualityAnalyzersResources.MakeDeclaringTypeSealed, "MakeDeclaringTypeSealed", solution, type, DeclarationModifiers.From(type) + DeclarationModifiers.Sealed), dx); } context.RegisterCodeFix(new ChangeAccessibilityAction(MicrosoftCodeQualityAnalyzersResources.MakeDeclaringTypeInternal, "MakeDeclaringTypeInternal", solution, type, Accessibility.Internal), dx); } } } } } }
private static DeclarationModifiers GetAccessorModifiers(DeclarationModifiers propertyModifiers) => propertyModifiers & ~(DeclarationModifiers.Indexer | DeclarationModifiers.ReadOnly);
public abstract bool TryDetermineModifiers(SyntaxToken startToken, SourceText text, int startLine, out Accessibility seenAccessibility, out DeclarationModifiers modifiers);
protected abstract bool IsPartialMethodCompletionContext(SyntaxTree tree, int position, CancellationToken cancellationToken, out DeclarationModifiers modifiers, out SyntaxToken token);
public LocalFunctionSymbol( Binder binder, Symbol containingSymbol, LocalFunctionStatementSyntax syntax) { _syntax = syntax; _containingSymbol = containingSymbol; _declarationDiagnostics = new DiagnosticBag(); _declarationModifiers = DeclarationModifiers.Private | DeclarationModifiers.Static | syntax.Modifiers.ToDeclarationModifiers(diagnostics: _declarationDiagnostics); this.CheckUnsafeModifier(_declarationModifiers, _declarationDiagnostics); ScopeBinder = binder; binder = binder.WithUnsafeRegionIfNecessary(syntax.Modifiers); if (_syntax.TypeParameterList != null) { binder = new WithMethodTypeParametersBinder(this, binder); _typeParameters = MakeTypeParameters(_declarationDiagnostics); } else { _typeParameters = ImmutableArray <SourceMethodTypeParameterSymbol> .Empty; ReportErrorIfHasConstraints(_syntax.ConstraintClauses, _declarationDiagnostics); } if (IsExtensionMethod) { _declarationDiagnostics.Add(ErrorCode.ERR_BadExtensionAgg, Locations[0]); } foreach (var param in syntax.ParameterList.Parameters) { ReportAttributesDisallowed(param.AttributeLists, _declarationDiagnostics); } if (syntax.ReturnType.Kind() == SyntaxKind.RefType) { var returnType = (RefTypeSyntax)syntax.ReturnType; if (returnType.ReadOnlyKeyword.Kind() == SyntaxKind.ReadOnlyKeyword) { _refKind = RefKind.RefReadOnly; } else { _refKind = RefKind.Ref; } } else { _refKind = RefKind.None; } _binder = binder; }
public LocalFunctionSymbol( Binder binder, Symbol containingSymbol, LocalFunctionStatementSyntax syntax) : base(syntax.GetReference()) { Debug.Assert(containingSymbol.DeclaringCompilation == binder.Compilation); _containingSymbol = containingSymbol; _declarationDiagnostics = new BindingDiagnosticBag(); _declarationModifiers = DeclarationModifiers.Private | syntax.Modifiers.ToDeclarationModifiers(diagnostics: _declarationDiagnostics.DiagnosticBag); if (SyntaxFacts.HasYieldOperations(syntax.Body)) { _lazyIteratorElementType = TypeWithAnnotations.Boxed.Sentinel; } this.CheckUnsafeModifier(_declarationModifiers, _declarationDiagnostics); ScopeBinder = binder; binder = binder.WithUnsafeRegionIfNecessary(syntax.Modifiers); if (syntax.TypeParameterList != null) { _typeParameters = MakeTypeParameters(_declarationDiagnostics); } else { _typeParameters = ImmutableArray <SourceMethodTypeParameterSymbol> .Empty; ReportErrorIfHasConstraints(syntax.ConstraintClauses, _declarationDiagnostics.DiagnosticBag); } if (IsExtensionMethod) { _declarationDiagnostics.Add(ErrorCode.ERR_BadExtensionAgg, Locations[0]); } foreach (var param in syntax.ParameterList.Parameters) { ReportAttributesDisallowed(param.AttributeLists, _declarationDiagnostics); } if (syntax.ReturnType.Kind() == SyntaxKind.RefType) { var returnType = (RefTypeSyntax)syntax.ReturnType; if (returnType.ReadOnlyKeyword.Kind() == SyntaxKind.ReadOnlyKeyword) { _refKind = RefKind.RefReadOnly; } else { _refKind = RefKind.Ref; } } else { _refKind = RefKind.None; } _binder = binder; }
protected SourceUserDefinedOperatorSymbolBase( MethodKind methodKind, string name, SourceMemberContainerTypeSymbol containingType, Location location, CSharpSyntaxNode syntax, DeclarationModifiers declarationModifiers, bool hasBody, bool isExpressionBodied, bool isIterator, DiagnosticBag diagnostics) : base(containingType, syntax.GetReference(), location, isIterator) { _name = name; _isExpressionBodied = isExpressionBodied; this.CheckUnsafeModifier(declarationModifiers, diagnostics); // We will bind the formal parameters and the return type lazily. For now, // assume that the return type is non-void; when we do the lazy initialization // of the parameters and return type we will update the flag if necessary. this.MakeFlags(methodKind, declarationModifiers, returnsVoid: false, isExtensionMethod: false); if (this.ContainingType.IsInterface && (methodKind == MethodKind.Conversion || name == WellKnownMemberNames.EqualityOperatorName || name == WellKnownMemberNames.InequalityOperatorName)) { // If we have a conversion or equality/inequality operator in an interface, we already have reported that fact as // an error. No need to cascade the error further. return; } if (this.ContainingType.IsStatic) { // Similarly if we're in a static class, though we have not reported it yet. // CS0715: '{0}': static classes cannot contain user-defined operators diagnostics.Add(ErrorCode.ERR_OperatorInStaticClass, location, this); return; } // SPEC: An operator declaration must include both a public and a // SPEC: static modifier if (this.DeclaredAccessibility != Accessibility.Public || !this.IsStatic) { // CS0558: User-defined operator '...' must be declared static and public diagnostics.Add(ErrorCode.ERR_OperatorsMustBeStatic, this.Locations[0], this); } // SPEC: Because an external operator provides no actual implementation, // SPEC: its operator body consists of a semicolon. For expression-bodied // SPEC: operators, the body is an expression. For all other operators, // SPEC: the operator body consists of a block... if (hasBody && IsExtern) { diagnostics.Add(ErrorCode.ERR_ExternHasBody, location, this); } else if (!hasBody && !IsExtern && !IsAbstract && !IsPartial) { // Do not report that the body is missing if the operator is marked as // partial or abstract; we will already have given an error for that so // there's no need to "cascade" the error. diagnostics.Add(ErrorCode.ERR_ConcreteMissingBody, location, this); } // SPEC: It is an error for the same modifier to appear multiple times in an // SPEC: operator declaration. var info = ModifierUtils.CheckAccessibility(this.DeclarationModifiers, this, isExplicitInterfaceImplementation: false); if (info != null) { diagnostics.Add(info, location); } }
private static DeclarationModifiers WithReadOnly(DeclarationModifiers modifiers) => (modifiers - DeclarationModifiers.Volatile) | DeclarationModifiers.ReadOnly;
private async Task VerifyModifiers(string markup, DeclarationModifiers modifiers) { var result = await GetResultsAsync(markup); Assert.Equal(modifiers, result.Modifiers); }
public override bool TryDetermineModifiers(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); bool isUnsafe = false; bool isSealed = false; bool isAbstract = false; 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.PrivateKeyword: if (seenAccessibility == Accessibility.NotApplicable) { seenAccessibility = Accessibility.Private; } // If we see private AND protected, filter for private protected else if (seenAccessibility == Accessibility.Protected) { seenAccessibility = Accessibility.ProtectedAndInternal; } break; case SyntaxKind.InternalKeyword: if (seenAccessibility == Accessibility.NotApplicable) { seenAccessibility = Accessibility.Internal; } // If we see internal AND protected, filter for protected internal else 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 else if (seenAccessibility == Accessibility.Internal) { seenAccessibility = Accessibility.ProtectedOrInternal; } // If we see private AND protected, filter for private protected else if (seenAccessibility == Accessibility.Private) { seenAccessibility = Accessibility.ProtectedAndInternal; } 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(isUnsafe: isUnsafe, isAbstract: isAbstract, isOverride: true, isSealed: isSealed); return(overrideToken.IsKind(SyntaxKind.OverrideKeyword) && IsOnStartLine(overrideToken.Parent.SpanStart, text, startLine)); }
protected override bool IsPartialMethodCompletionContext(SyntaxTree tree, int position, CancellationToken cancellationToken, out DeclarationModifiers modifiers, out SyntaxToken token) { var touchingToken = tree.FindTokenOnLeftOfPosition(position, cancellationToken); var targetToken = touchingToken.GetPreviousTokenIfTouchingWord(position); var text = tree.GetText(cancellationToken); token = targetToken; modifiers = default; if (targetToken.IsKind(SyntaxKind.VoidKeyword, SyntaxKind.PartialKeyword) || (targetToken.Kind() == SyntaxKind.IdentifierToken && targetToken.HasMatchingText(SyntaxKind.PartialKeyword))) { return(!IsOnSameLine(touchingToken.GetNextToken(), touchingToken, text) && VerifyModifiers(tree, position, cancellationToken, out modifiers)); } return(false); }
internal static void ReportUnsupportedModifiersForLanguageVersion(DeclarationModifiers modifiers, DeclarationModifiers unsupportedModifiers, Location errorLocation, BindingDiagnosticBag diagnostics, LanguageVersion availableVersion, LanguageVersion requiredVersion) { DeclarationModifiers errorModifiers = modifiers & unsupportedModifiers; var requiredVersionArgument = new CSharpRequiredLanguageVersion(requiredVersion); var availableVersionArgument = availableVersion.ToDisplayString(); while (errorModifiers != DeclarationModifiers.None) { DeclarationModifiers oneError = errorModifiers & ~(errorModifiers - 1); Debug.Assert(oneError != DeclarationModifiers.None); errorModifiers = errorModifiers & ~oneError; diagnostics.Add(ErrorCode.ERR_InvalidModifierForLanguageVersion, errorLocation, ConvertSingleModifierToSyntaxText(oneError), availableVersionArgument, requiredVersionArgument); } }
internal static DeclarationModifiers MakeModifiers(NamedTypeSymbol containingType, SyntaxToken firstIdentifier, SyntaxTokenList modifiers, bool isRefField, BindingDiagnosticBag diagnostics, out bool modifierErrors) { bool isInterface = containingType.IsInterface; DeclarationModifiers defaultAccess = isInterface ? DeclarationModifiers.Public : DeclarationModifiers.Private; DeclarationModifiers allowedModifiers = DeclarationModifiers.AccessibilityMask | DeclarationModifiers.Const | DeclarationModifiers.New | DeclarationModifiers.ReadOnly | DeclarationModifiers.Static | DeclarationModifiers.Volatile | DeclarationModifiers.Fixed | DeclarationModifiers.Unsafe | DeclarationModifiers.Abstract | DeclarationModifiers.Required; // Some of these are filtered out later, when illegal, for better error messages. var errorLocation = new SourceLocation(firstIdentifier); DeclarationModifiers result = ModifierUtils.MakeAndCheckNontypeMemberModifiers( isOrdinaryMethod: false, isForInterfaceMember: isInterface, modifiers, defaultAccess, allowedModifiers, errorLocation, diagnostics, out modifierErrors); if ((result & DeclarationModifiers.Abstract) != 0) { diagnostics.Add(ErrorCode.ERR_AbstractField, errorLocation); result &= ~DeclarationModifiers.Abstract; } if ((result & DeclarationModifiers.Fixed) != 0) { reportBadMemberFlagIfAny(result, DeclarationModifiers.Static, diagnostics, errorLocation); reportBadMemberFlagIfAny(result, DeclarationModifiers.ReadOnly, diagnostics, errorLocation); reportBadMemberFlagIfAny(result, DeclarationModifiers.Const, diagnostics, errorLocation); reportBadMemberFlagIfAny(result, DeclarationModifiers.Volatile, diagnostics, errorLocation); reportBadMemberFlagIfAny(result, DeclarationModifiers.Required, diagnostics, errorLocation); result &= ~(DeclarationModifiers.Static | DeclarationModifiers.ReadOnly | DeclarationModifiers.Const | DeclarationModifiers.Volatile | DeclarationModifiers.Required); Debug.Assert((result & ~(DeclarationModifiers.AccessibilityMask | DeclarationModifiers.Fixed | DeclarationModifiers.Unsafe | DeclarationModifiers.New)) == 0); } if ((result & DeclarationModifiers.Const) != 0) { if ((result & DeclarationModifiers.Static) != 0) { // The constant '{0}' cannot be marked static diagnostics.Add(ErrorCode.ERR_StaticConstant, errorLocation, firstIdentifier.ValueText); } reportBadMemberFlagIfAny(result, DeclarationModifiers.ReadOnly, diagnostics, errorLocation); reportBadMemberFlagIfAny(result, DeclarationModifiers.Volatile, diagnostics, errorLocation); reportBadMemberFlagIfAny(result, DeclarationModifiers.Unsafe, diagnostics, errorLocation); if (reportBadMemberFlagIfAny(result, DeclarationModifiers.Required, diagnostics, errorLocation)) { result &= ~DeclarationModifiers.Required; } result |= DeclarationModifiers.Static; // "constants are considered static members" } else { if ((result & DeclarationModifiers.Static) != 0 && (result & DeclarationModifiers.Required) != 0) { // The modifier 'required' is not valid for this item diagnostics.Add(ErrorCode.ERR_BadMemberFlag, errorLocation, SyntaxFacts.GetText(SyntaxKind.RequiredKeyword)); result &= ~DeclarationModifiers.Required; } // NOTE: always cascading on a const, so suppress. // NOTE: we're being a bit sneaky here - we're using the containingType rather than this symbol // to determine whether or not unsafe is allowed. Since this symbol and the containing type are // in the same compilation, it won't make a difference. We do, however, have to pass the error // location explicitly. containingType.CheckUnsafeModifier(result, errorLocation, diagnostics); } if (isRefField) { reportBadMemberFlagIfAny(result, DeclarationModifiers.Static, diagnostics, errorLocation); reportBadMemberFlagIfAny(result, DeclarationModifiers.Const, diagnostics, errorLocation); reportBadMemberFlagIfAny(result, DeclarationModifiers.Volatile, diagnostics, errorLocation); } return(result);
internal static void CheckFeatureAvailabilityForStaticAbstractMembersInInterfacesIfNeeded(DeclarationModifiers mods, bool isExplicitInterfaceImplementation, Location location, BindingDiagnosticBag diagnostics) { if (isExplicitInterfaceImplementation && (mods & DeclarationModifiers.Static) != 0) { Debug.Assert(location.SourceTree is not null); LanguageVersion availableVersion = ((CSharpParseOptions)location.SourceTree.Options).LanguageVersion; LanguageVersion requiredVersion = MessageID.IDS_FeatureStaticAbstractMembersInInterfaces.RequiredVersion(); if (availableVersion < requiredVersion) { ModifierUtils.ReportUnsupportedModifiersForLanguageVersion(mods, DeclarationModifiers.Static, location, diagnostics, availableVersion, requiredVersion); } } }
public ChangeModifierAction(string title, string equivalenceKey, Solution solution, ISymbol symbol, DeclarationModifiers newModifiers) : base(title, equivalenceKey, solution, symbol) { _newModifiers = newModifiers; }
internal static string ConvertSingleModifierToSyntaxText(DeclarationModifiers modifier) { switch (modifier) { case DeclarationModifiers.Abstract: return(SyntaxFacts.GetText(SyntaxKind.AbstractKeyword)); case DeclarationModifiers.Sealed: return(SyntaxFacts.GetText(SyntaxKind.SealedKeyword)); case DeclarationModifiers.Static: return(SyntaxFacts.GetText(SyntaxKind.StaticKeyword)); case DeclarationModifiers.New: return(SyntaxFacts.GetText(SyntaxKind.NewKeyword)); case DeclarationModifiers.Public: return(SyntaxFacts.GetText(SyntaxKind.PublicKeyword)); case DeclarationModifiers.Protected: return(SyntaxFacts.GetText(SyntaxKind.ProtectedKeyword)); case DeclarationModifiers.Internal: return(SyntaxFacts.GetText(SyntaxKind.InternalKeyword)); case DeclarationModifiers.ProtectedInternal: return(SyntaxFacts.GetText(SyntaxKind.ProtectedKeyword) + " " + SyntaxFacts.GetText(SyntaxKind.InternalKeyword)); case DeclarationModifiers.Private: return(SyntaxFacts.GetText(SyntaxKind.PrivateKeyword)); case DeclarationModifiers.PrivateProtected: return(SyntaxFacts.GetText(SyntaxKind.PrivateKeyword) + " " + SyntaxFacts.GetText(SyntaxKind.ProtectedKeyword)); case DeclarationModifiers.ReadOnly: return(SyntaxFacts.GetText(SyntaxKind.ReadOnlyKeyword)); case DeclarationModifiers.Const: return(SyntaxFacts.GetText(SyntaxKind.ConstKeyword)); case DeclarationModifiers.Volatile: return(SyntaxFacts.GetText(SyntaxKind.VolatileKeyword)); case DeclarationModifiers.Extern: return(SyntaxFacts.GetText(SyntaxKind.ExternKeyword)); case DeclarationModifiers.Partial: return(SyntaxFacts.GetText(SyntaxKind.PartialKeyword)); case DeclarationModifiers.Unsafe: return(SyntaxFacts.GetText(SyntaxKind.UnsafeKeyword)); case DeclarationModifiers.Fixed: return(SyntaxFacts.GetText(SyntaxKind.FixedKeyword)); case DeclarationModifiers.Virtual: return(SyntaxFacts.GetText(SyntaxKind.VirtualKeyword)); case DeclarationModifiers.Override: return(SyntaxFacts.GetText(SyntaxKind.OverrideKeyword)); case DeclarationModifiers.Async: return(SyntaxFacts.GetText(SyntaxKind.AsyncKeyword)); case DeclarationModifiers.Ref: return(SyntaxFacts.GetText(SyntaxKind.RefKeyword)); case DeclarationModifiers.Required: return(SyntaxFacts.GetText(SyntaxKind.RequiredKeyword)); default: throw ExceptionUtilities.UnexpectedValue(modifier); } }
/// <summary> /// Creates a field symbol that can be used to describe a field declaration. /// </summary> public static IFieldSymbol CreateFieldSymbol(IList <AttributeData> attributes, Accessibility accessibility, DeclarationModifiers modifiers, ITypeSymbol type, string name, bool hasConstantValue = false, object constantValue = null, SyntaxNode initializer = null) { var result = new CodeGenerationFieldSymbol(null, attributes, accessibility, modifiers, type, name, hasConstantValue, constantValue); CodeGenerationFieldInfo.Attach(result, modifiers.IsUnsafe, modifiers.IsWithEvents, initializer); return(result); }
internal static DeclarationModifiers CheckModifiers( bool isForTypeDeclaration, bool isForInterfaceMember, DeclarationModifiers modifiers, DeclarationModifiers allowedModifiers, Location errorLocation, BindingDiagnosticBag diagnostics, SyntaxTokenList?modifierTokens, out bool modifierErrors) { Debug.Assert(!isForTypeDeclaration || !isForInterfaceMember); modifierErrors = false; DeclarationModifiers reportStaticNotVirtualForModifiers = DeclarationModifiers.None; if (isForTypeDeclaration) { Debug.Assert((allowedModifiers & (DeclarationModifiers.Override | DeclarationModifiers.Virtual)) == 0); } else if ((modifiers & allowedModifiers & DeclarationModifiers.Static) != 0) { if (isForInterfaceMember) { reportStaticNotVirtualForModifiers = allowedModifiers & DeclarationModifiers.Override; } else { reportStaticNotVirtualForModifiers = allowedModifiers & (DeclarationModifiers.Abstract | DeclarationModifiers.Override | DeclarationModifiers.Virtual); } allowedModifiers &= ~reportStaticNotVirtualForModifiers; } DeclarationModifiers errorModifiers = modifiers & ~allowedModifiers; DeclarationModifiers result = modifiers & allowedModifiers; while (errorModifiers != DeclarationModifiers.None) { DeclarationModifiers oneError = errorModifiers & ~(errorModifiers - 1); Debug.Assert(oneError != DeclarationModifiers.None); errorModifiers = errorModifiers & ~oneError; switch (oneError) { case DeclarationModifiers.Partial: // Provide a specialized error message in the case of partial. ReportPartialError(errorLocation, diagnostics, modifierTokens); break; case DeclarationModifiers.Abstract: case DeclarationModifiers.Override: case DeclarationModifiers.Virtual: if ((reportStaticNotVirtualForModifiers & oneError) == 0) { goto default; } diagnostics.Add(ErrorCode.ERR_StaticNotVirtual, errorLocation, ModifierUtils.ConvertSingleModifierToSyntaxText(oneError)); break; default: diagnostics.Add(ErrorCode.ERR_BadMemberFlag, errorLocation, ConvertSingleModifierToSyntaxText(oneError)); break; } modifierErrors = true; } modifierErrors |= checkFeature(DeclarationModifiers.PrivateProtected, MessageID.IDS_FeaturePrivateProtected) | checkFeature(DeclarationModifiers.Required, MessageID.IDS_FeatureRequiredMembers); return(result); bool checkFeature(DeclarationModifiers modifier, MessageID featureID) => ((result & modifier) != 0) && !Binder.CheckFeatureAvailability(errorLocation.SourceTree, featureID, diagnostics, errorLocation); }
private CompletionItem CreateItem(IMethodSymbol method, int line, TextSpan lineSpan, TextSpan span, SemanticModel semanticModel, DeclarationModifiers modifiers, Document document, SyntaxToken token) { modifiers = new DeclarationModifiers(method.IsStatic, isUnsafe: method.IsUnsafe(), isPartial: true, isAsync: modifiers.IsAsync); var displayText = GetDisplayText(method, semanticModel, span.Start); return(MemberInsertionCompletionItem.Create( displayText, Glyph.MethodPrivate, modifiers, line, method, token, span.Start, rules: this.GetRules())); }
public static async Task <IPropertySymbol> OverridePropertyAsync( this SyntaxGenerator codeFactory, IPropertySymbol overriddenProperty, DeclarationModifiers modifiers, INamedTypeSymbol containingType, Document document, CancellationToken cancellationToken) { var getAccessibility = overriddenProperty.GetMethod.ComputeResultantAccessibility(containingType); var setAccessibility = overriddenProperty.SetMethod.ComputeResultantAccessibility(containingType); SyntaxNode getBody = null; SyntaxNode setBody = null; // Implement an abstract property by throwing not implemented in accessors. if (overriddenProperty.IsAbstract) { var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); getBody = codeFactory.CreateThrowNotImplementStatement(compilation); setBody = getBody; } else if (overriddenProperty.IsIndexer() && document.Project.Language == LanguageNames.CSharp) { // Indexer: return or set base[]. Only in C#, since VB must refer to these by name. getBody = codeFactory.ReturnStatement( codeFactory.ElementAccessExpression( codeFactory.BaseExpression(), codeFactory.CreateArguments(overriddenProperty.Parameters))); setBody = codeFactory.ExpressionStatement( codeFactory.AssignmentStatement( codeFactory.ElementAccessExpression( codeFactory.BaseExpression(), codeFactory.CreateArguments(overriddenProperty.Parameters)), codeFactory.IdentifierName("value"))); } else if (overriddenProperty.GetParameters().Any()) { // Call accessors directly if C# overriding VB if (document.Project.Language == LanguageNames.CSharp && (await SymbolFinder.FindSourceDefinitionAsync(overriddenProperty, document.Project.Solution, cancellationToken).ConfigureAwait(false)) .Language == LanguageNames.VisualBasic) { var getName = overriddenProperty.GetMethod != null ? overriddenProperty.GetMethod.Name : null; var setName = overriddenProperty.SetMethod != null ? overriddenProperty.SetMethod.Name : null; getBody = getName == null ? null : codeFactory.ReturnStatement( codeFactory.InvocationExpression( codeFactory.MemberAccessExpression( codeFactory.BaseExpression(), codeFactory.IdentifierName(getName)), codeFactory.CreateArguments(overriddenProperty.Parameters))); setBody = setName == null ? null : codeFactory.ExpressionStatement( codeFactory.InvocationExpression( codeFactory.MemberAccessExpression( codeFactory.BaseExpression(), codeFactory.IdentifierName(setName)), codeFactory.CreateArguments(overriddenProperty.SetMethod.GetParameters()))); } else { getBody = codeFactory.ReturnStatement( codeFactory.InvocationExpression( codeFactory.MemberAccessExpression( codeFactory.BaseExpression(), codeFactory.IdentifierName(overriddenProperty.Name)), codeFactory.CreateArguments(overriddenProperty.Parameters))); setBody = codeFactory.ExpressionStatement( codeFactory.AssignmentStatement( codeFactory.InvocationExpression( codeFactory.MemberAccessExpression( codeFactory.BaseExpression(), codeFactory.IdentifierName(overriddenProperty.Name)), codeFactory.CreateArguments(overriddenProperty.Parameters)), codeFactory.IdentifierName("value"))); } } else { // Regular property: return or set the base property getBody = codeFactory.ReturnStatement( codeFactory.MemberAccessExpression( codeFactory.BaseExpression(), codeFactory.IdentifierName(overriddenProperty.Name))); setBody = codeFactory.ExpressionStatement( codeFactory.AssignmentStatement( codeFactory.MemberAccessExpression( codeFactory.BaseExpression(), codeFactory.IdentifierName(overriddenProperty.Name)), codeFactory.IdentifierName("value"))); } // Only generate a getter if the base getter is accessible. IMethodSymbol accessorGet = null; if (overriddenProperty.GetMethod != null && overriddenProperty.GetMethod.IsAccessibleWithin(containingType)) { accessorGet = CodeGenerationSymbolFactory.CreateMethodSymbol( overriddenProperty.GetMethod, accessibility: getAccessibility, statements: new[] { getBody }, modifiers: modifiers); } // Only generate a setter if the base setter is accessible. IMethodSymbol accessorSet = null; if (overriddenProperty.SetMethod != null && overriddenProperty.SetMethod.IsAccessibleWithin(containingType) && overriddenProperty.SetMethod.DeclaredAccessibility != Accessibility.Private) { accessorSet = CodeGenerationSymbolFactory.CreateMethodSymbol( overriddenProperty.SetMethod, accessibility: setAccessibility, statements: new[] { setBody }, modifiers: modifiers); } return(CodeGenerationSymbolFactory.CreatePropertySymbol( overriddenProperty, accessibility: overriddenProperty.ComputeResultantAccessibility(containingType), modifiers: modifiers, name: overriddenProperty.Name, isIndexer: overriddenProperty.IsIndexer(), getMethod: accessorGet, setMethod: accessorSet)); }