protected override ReadOnlyArray<ParameterSymbol> MakeParameters( Binder binder, DelegateDeclarationSyntax syntax, out bool isExtensionMethod, out bool isVararg, DiagnosticBag diagnostics, CancellationToken cancellationToken) { isExtensionMethod = false; isVararg = false; var delegateBinder = binder as DelegateBinder; var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(); int ordinal = 0; foreach (var p in delegateBinder.invoke.Parameters) { cancellationToken.ThrowIfCancellationRequested(); if (p.RefKind != RefKind.None) { parameters.Add(new SynthesizedParameterSymbol(this, p.Type, ordinal++, p.RefKind, p.Name)); } } parameters.Add(new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_IAsyncResult, diagnostics, syntax), ordinal++, RefKind.None, "result")); return parameters.ToReadOnlyAndFree(); }
internal DelegateConstructor( SourceNamedTypeSymbol delegateType, DelegateDeclarationSyntax syntax, Binder binder, CancellationToken cancellationToken) : base(delegateType, CommonMemberNames.InstanceConstructorName, syntax, MethodKind.Constructor, DeclarationModifiers.Public, binder, diagnostics: null, cancellationToken: cancellationToken) { }
protected override ReadOnlyArray<ParameterSymbol> MakeParameters(Binder binder, DelegateDeclarationSyntax syntax, out bool isExtensionMethod, out bool isVararg, DiagnosticBag diagnostics, CancellationToken cancellationToken) { isExtensionMethod = false; isVararg = false; return ReadOnlyArray<ParameterSymbol>.CreateFrom( new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_Object, diagnostics, syntax), 0, RefKind.None, "object"), new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_IntPtr, diagnostics, syntax), 1, RefKind.None, "method")); }
protected override ReadOnlyArray<ParameterSymbol> MakeParameters( Binder binder, DelegateDeclarationSyntax syntax, out bool isExtensionMethod, out bool isVararg, DiagnosticBag diagnostics, CancellationToken cancellationToken) { return MakeParameters(binder, syntax.ParameterList, out isExtensionMethod, out isVararg, diagnostics, cancellationToken); }
internal DelegateEndInvokeMethod( SourceNamedTypeSymbol delegateType, DelegateDeclarationSyntax syntax, DelegateBinder binder, DiagnosticBag diagnostics, CancellationToken cancellationToken) : base(delegateType, CommonMemberNames.DelegateEndInvokeName, syntax, MethodKind.Ordinary, DeclarationModifiers.Virtual | DeclarationModifiers.Public, binder, diagnostics, cancellationToken) { }
private void AddDelegateMembers( ArrayBuilder<Symbol> symbols, DelegateDeclarationSyntax syntax, BinderFactory binderFactory, DiagnosticBag diagnostics) { var bodyBinder = binderFactory.GetBinder(syntax.ParameterList); // A delegate has the following members: (see CLI spec 13.6) // (1) a method named Invoke with the specified signature var invoke = new DelegateInvokeMethodImplementation(this, syntax, bodyBinder, diagnostics); invoke.CheckMethodVarianceSafety(diagnostics); symbols.Add(invoke); // (2) a constructor with argument types (object, System.IntPtr) symbols.Add(new DelegateConstructor(this, syntax, bodyBinder)); var delegateBinder = new DelegateBinder(bodyBinder, this, invoke); // (3) BeginInvoke symbols.Add(new DelegateBeginInvokeMethod(this, syntax, delegateBinder, diagnostics)); // and (4) EndInvoke methods symbols.Add(new DelegateEndInvokeMethod(this, syntax, delegateBinder, diagnostics)); if (this.DeclaredAccessibility <= Accessibility.Private) { return; } if (!this.IsNoMoreVisibleThan(invoke.ReturnType)) { // Inconsistent accessibility: return type '{1}' is less accessible than delegate '{0}' diagnostics.Add(ErrorCode.ERR_BadVisDelegateReturn, Locations[0], this, invoke.ReturnType); } foreach (var parameter in invoke.Parameters) { if (!parameter.Type.IsAtLeastAsVisibleAs(this)) { // Inconsistent accessibility: parameter type '{1}' is less accessible than delegate '{0}' diagnostics.Add(ErrorCode.ERR_BadVisDelegateParam, Locations[0], this, parameter.Type); } } }
protected DelegateMethodSymbol( SourceNamedTypeSymbol containingType, DelegateDeclarationSyntax syntax, MethodKind methodKind, DeclarationModifiers declarationModifiers, Binder binder, DiagnosticBag diagnostics) : base(containingType, binder.GetSyntaxReference(syntax), blockSyntaxReference: null, location: binder.Location(syntax.Identifier)) { this.parameters = MakeParameters(binder, syntax, diagnostics); this.returnType = MakeReturnType(binder, syntax, diagnostics); this.flags = MakeFlags(methodKind, declarationModifiers, this.returnType.SpecialType == SpecialType.System_Void, isExtensionMethod: false); var info = ModifierUtils.CheckAccessibility(this.DeclarationModifiers); if (info != null) { diagnostics.Add(info, this.locations[0]); } }
protected override ReadOnlyArray<ParameterSymbol> MakeParameters( Binder binder, DelegateDeclarationSyntax syntax, out bool isExtensionMethod, out bool isVararg, DiagnosticBag diagnostics, CancellationToken cancellationToken) { isExtensionMethod = false; isVararg = false; var delegateBinder = binder as DelegateBinder; var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(); foreach (var p in delegateBinder.invoke.Parameters) { cancellationToken.ThrowIfCancellationRequested(); parameters.Add(new SynthesizedParameterSymbol(this, p.Type, p.Ordinal, p.RefKind, p.Name)); } parameters.Add(new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_AsyncCallback, diagnostics, syntax), delegateBinder.invoke.Parameters.Count, RefKind.None, "callback")); parameters.Add(new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_Object, diagnostics, syntax), delegateBinder.invoke.Parameters.Count + 1, RefKind.None, "object")); return parameters.ToReadOnlyAndFree(); }
protected DelegateMethodSymbol( SourceNamedTypeSymbol containingType, string name, DelegateDeclarationSyntax syntax, MethodKind methodKind, DeclarationModifiers declarationModifiers, Binder binder, DiagnosticBag diagnostics, CancellationToken cancellationToken) : base(containingType, name, binder.GetSyntaxReference(syntax), blockSyntax: null, location: binder.Location(syntax.Identifier)) { var location = this.locations[0]; bool isExtensionMethod; this.parameters = MakeParameters(binder, syntax, out isExtensionMethod, out this.isVararg, diagnostics, cancellationToken); this.returnType = MakeReturnType(binder, syntax, diagnostics); this.flags = MakeFlags(methodKind, declarationModifiers, IsVoidType(this.returnType), isExtensionMethod: isExtensionMethod); var info = ModifierUtils.CheckAccessibility(this.DeclarationModifiers); if (info != null) { diagnostics.Add(info, location); } }
private static async Task <Document> GetTransformedDocumentAsync(Document document, Diagnostic diagnostic, CancellationToken cancellationToken) { var documentRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); SyntaxNode syntax = documentRoot.FindNode(diagnostic.Location.SourceSpan); if (syntax == null) { return(document); } MethodDeclarationSyntax methodDeclarationSyntax = syntax.FirstAncestorOrSelf <MethodDeclarationSyntax>(); DelegateDeclarationSyntax delegateDeclarationSyntax = syntax.FirstAncestorOrSelf <DelegateDeclarationSyntax>(); if (methodDeclarationSyntax == null && delegateDeclarationSyntax == null) { return(document); } DocumentationCommentTriviaSyntax documentationComment = methodDeclarationSyntax?.GetDocumentationCommentTriviaSyntax() ?? delegateDeclarationSyntax?.GetDocumentationCommentTriviaSyntax(); if (documentationComment == null) { return(document); } SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); bool isTask; bool isAsynchronousTestMethod; if (methodDeclarationSyntax != null) { isTask = IsTaskReturningMethod(semanticModel, methodDeclarationSyntax, cancellationToken); isAsynchronousTestMethod = isTask && IsAsynchronousTestMethod(semanticModel, methodDeclarationSyntax, cancellationToken); } else { isTask = IsTaskReturningMethod(semanticModel, delegateDeclarationSyntax, cancellationToken); isAsynchronousTestMethod = false; } XmlNodeSyntax returnsElement = documentationComment.Content.GetFirstXmlElement(XmlCommentHelper.ReturnsXmlTag); if (returnsElement != null && !isTask) { // This code fix doesn't know how to do anything more than document Task-returning methods. return(document); } SyntaxList <XmlNodeSyntax> content = XmlSyntaxFactory.List(); if (isTask) { content = content.Add(XmlSyntaxFactory.Text("A ")); content = content.Add(XmlSyntaxFactory.SeeElement(SyntaxFactory.TypeCref(SyntaxFactory.ParseTypeName("global::System.Threading.Tasks.Task"))).WithAdditionalAnnotations(Simplifier.Annotation)); string operationKind = isAsynchronousTestMethod ? "unit test" : "operation"; content = content.Add(XmlSyntaxFactory.Text($" representing the asynchronous {operationKind}.")); // wrap the generated content in a <placeholder> element for review. content = XmlSyntaxFactory.List(XmlSyntaxFactory.PlaceholderElement(content)); } // Try to replace an existing <returns> element if the comment contains one. Otherwise, add it as a new element. SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); SyntaxNode newRoot; if (returnsElement != null) { XmlEmptyElementSyntax emptyElement = returnsElement as XmlEmptyElementSyntax; if (emptyElement != null) { XmlElementSyntax updatedReturns = XmlSyntaxFactory.Element(XmlCommentHelper.ReturnsXmlTag, content) .WithLeadingTrivia(returnsElement.GetLeadingTrivia()) .WithTrailingTrivia(returnsElement.GetTrailingTrivia()); newRoot = root.ReplaceNode(returnsElement, updatedReturns); } else { XmlElementSyntax updatedReturns = ((XmlElementSyntax)returnsElement).WithContent(content); newRoot = root.ReplaceNode(returnsElement, updatedReturns); } } else { string newLineText = document.Project.Solution.Workspace.Options.GetOption(FormattingOptions.NewLine, LanguageNames.CSharp); returnsElement = XmlSyntaxFactory.Element(XmlCommentHelper.ReturnsXmlTag, content); XmlNodeSyntax leadingNewLine = XmlSyntaxFactory.NewLine(newLineText); // HACK: The formatter isn't working when contents are added to an existing documentation comment, so we // manually apply the indentation from the last line of the existing comment to each new line of the // generated content. SyntaxTrivia exteriorTrivia = GetLastDocumentationCommentExteriorTrivia(documentationComment); if (!exteriorTrivia.Token.IsMissing) { leadingNewLine = leadingNewLine.ReplaceExteriorTrivia(exteriorTrivia); returnsElement = returnsElement.ReplaceExteriorTrivia(exteriorTrivia); } DocumentationCommentTriviaSyntax newDocumentationComment = documentationComment.WithContent( documentationComment.Content.InsertRange( documentationComment.Content.Count - 1, XmlSyntaxFactory.List(leadingNewLine, returnsElement))); newRoot = root.ReplaceNode(documentationComment, newDocumentationComment); } return(document.WithSyntaxRoot(newRoot)); }
private static void HandleDelegateDeclaration(SyntaxNodeAnalysisContext context) { DelegateDeclarationSyntax delegateDeclaration = (DelegateDeclarationSyntax)context.Node; HandleMemberDeclaration(context, delegateDeclaration, delegateDeclaration.TypeParameterList); }
internal DelegateInvokeMethodImplementation( SourceNamedTypeSymbol delegateType, DelegateDeclarationSyntax syntax, Binder binder, DiagnosticBag diagnostics) : base(delegateType, syntax, MethodKind.DelegateInvoke, DeclarationModifiers.Virtual | DeclarationModifiers.Public, binder, diagnostics) { }
/// <summary> /// Get summary. /// </summary> /// <param name="theSyntaxNode">The syntax node to add the summary.</param> /// <returns>The syntax list.</returns> private static DocumentationCommentTriviaSyntax GetSummary(DelegateDeclarationSyntax theSyntaxNode) { var summaryStart = XmlElementStartTag(XmlName(Identifier(Constants.Summary))) .WithLessThanToken(Token(SyntaxKind.LessThanToken)) .WithGreaterThanToken(Token(SyntaxKind.GreaterThanToken)).NormalizeWhitespace(); var summaryEnd = XmlElementEndTag(XmlName(Identifier(Constants.Summary))).NormalizeWhitespace() .WithLessThanSlashToken(Token(SyntaxKind.LessThanSlashToken)) .WithGreaterThanToken(Token(SyntaxKind.GreaterThanToken)); var summaryComment = " " + Convert.Method(theSyntaxNode.Identifier.ValueText); var summaryText = SingletonList <XmlNodeSyntax>( XmlText().NormalizeWhitespace() .WithTextTokens( TokenList( XmlTextNewLine(TriviaList(), Environment.NewLine, Environment.NewLine, TriviaList()).NormalizeWhitespace(), XmlTextLiteral( TriviaList(DocumentationCommentExterior("///")), summaryComment, summaryComment, TriviaList()).NormalizeWhitespace(), XmlTextNewLine(TriviaList(), Environment.NewLine, Environment.NewLine, TriviaList()).NormalizeWhitespace(), XmlTextLiteral( TriviaList(DocumentationCommentExterior("///")), " ", " ", TriviaList()))).NormalizeWhitespace()); var xmlComment = XmlText() .WithTextTokens( TokenList( XmlTextLiteral( TriviaList(DocumentationCommentExterior("///")), " ", " ", TriviaList()))).NormalizeWhitespace(); var newLine = XmlText().WithTextTokens(TokenList(XmlTextNewLine(TriviaList(), Environment.NewLine, Environment.NewLine, TriviaList()))).NormalizeWhitespace(); var summaryElement = XmlElement(summaryStart, summaryEnd).WithContent(summaryText); var list = List(new XmlNodeSyntax[] { xmlComment, summaryElement, newLine }); // Add parameter comments if (theSyntaxNode.ParameterList.Parameters.Any()) { foreach (var parameter in theSyntaxNode.ParameterList.Parameters) { list = list.AddRange( List( new XmlNodeSyntax[] { xmlComment, XmlElement( XmlElementStartTag(XmlName(Identifier("param"))) .WithAttributes( SingletonList <XmlAttributeSyntax>( XmlNameAttribute( XmlName(Identifier(TriviaList(Space), "name", TriviaList())), Token(SyntaxKind.DoubleQuoteToken), IdentifierName(parameter.Identifier.ValueText), Token(SyntaxKind.DoubleQuoteToken)))), XmlElementEndTag(XmlName(Identifier("param")))) .WithContent( SingletonList <XmlNodeSyntax>( XmlText() .WithTextTokens( TokenList( XmlTextLiteral( TriviaList(), Convert.Parameter(parameter.Identifier.ValueText, parameter.Type.ToString()), "comment", TriviaList()))))), newLine })); } } // Add returns comments var returntype = theSyntaxNode.ReturnType.ToString(); if (returntype != "void") { list = list.AddRange( List( new XmlNodeSyntax[] { xmlComment, XmlElement(XmlElementStartTag(XmlName(Identifier("returns"))), XmlElementEndTag(XmlName(Identifier("returns")))) .WithContent( SingletonList <XmlNodeSyntax>( XmlText().WithTextTokens(TokenList(XmlTextLiteral(TriviaList(), Convert.Returns(returntype), "comment", TriviaList()))))), newLine })); } // Add typeparams comments if (theSyntaxNode.TypeParameterList != null) { if (theSyntaxNode.TypeParameterList.Parameters.Any()) { foreach (var parameter in theSyntaxNode.TypeParameterList.Parameters) { list = list.AddRange( List( new XmlNodeSyntax[] { xmlComment, XmlElement( XmlElementStartTag(XmlName(Identifier("typeparam"))) .WithAttributes( SingletonList <XmlAttributeSyntax>( XmlNameAttribute( XmlName(Identifier(TriviaList(Space), "name", TriviaList())), Token(SyntaxKind.DoubleQuoteToken), IdentifierName(parameter.Identifier.ValueText), Token(SyntaxKind.DoubleQuoteToken)))), XmlElementEndTag(XmlName(Identifier("typeparam")))) .WithContent( SingletonList <XmlNodeSyntax>( XmlText() .WithTextTokens( TokenList( XmlTextLiteral( TriviaList(), string.Empty, "comment", TriviaList()))))), newLine })); } } } return(DocumentationCommentTrivia(SyntaxKind.SingleLineDocumentationCommentTrivia, list)); }
public override void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { throw new NotImplementedException(); }
public static void ComputeRefactorings(RefactoringContext context, DelegateDeclarationSyntax delegateDeclaration) { SyntaxToken identifier = delegateDeclaration.Identifier; ComputeRefactorings(context, delegateDeclaration, identifier); }
internal DelegateConstructor( SourceNamedTypeSymbol delegateType, DelegateDeclarationSyntax syntax, Binder binder) : base(delegateType, syntax, MethodKind.Constructor, DeclarationModifiers.Public, binder, diagnostics: null) { }
protected override ReadOnlyArray<ParameterSymbol> MakeParameters(Binder binder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics) { return ReadOnlyArray<ParameterSymbol>.CreateFrom( new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_Object, diagnostics, syntax), 0, RefKind.None, "object"), new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_IntPtr, diagnostics, syntax), 1, RefKind.None, "method")); }
internal DelegateEndInvokeMethod( SourceNamedTypeSymbol delegateType, DelegateDeclarationSyntax syntax, DelegateBinder binder, DiagnosticBag diagnostics) : base(delegateType, syntax, MethodKind.Ordinary, DeclarationModifiers.Virtual | DeclarationModifiers.Public, binder, diagnostics) { }
protected override ReadOnlyArray<ParameterSymbol> MakeParameters( Binder binder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics) { var delegateBinder = binder as DelegateBinder; var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(); int ordinal = 0; foreach (SourceParameterSymbol p in delegateBinder.invoke.Parameters) { if (p.RefKind != RefKind.None) { var synthesizedParam = new SourceClonedParameterSymbol(originalParam: p, newOwner: this, newOrdinal: ordinal++, suppressOptional: true); parameters.Add(synthesizedParam); } } parameters.Add(new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_IAsyncResult, diagnostics, syntax), ordinal++, RefKind.None, "result")); return parameters.ToReadOnlyAndFree(); }
protected override ReadOnlyArray<ParameterSymbol> MakeParameters( Binder binder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics) { var delegateBinder = binder as DelegateBinder; var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(); foreach (SourceParameterSymbol p in delegateBinder.invoke.Parameters) { var synthesizedParam = new SourceClonedParameterSymbol(originalParam: p, newOwner: this, newOrdinal: p.Ordinal, suppressOptional: true); parameters.Add(synthesizedParam); } int paramCount = delegateBinder.invoke.Parameters.Count; parameters.Add(new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_AsyncCallback, diagnostics, syntax), paramCount, RefKind.None, "callback")); parameters.Add(new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_Object, diagnostics, syntax), paramCount + 1, RefKind.None, "object")); return parameters.ToReadOnlyAndFree(); }
protected override TypeSymbol MakeReturnType(Binder bodyBinder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics) { TypeSymbol returnType = bodyBinder.BindType(syntax.ReturnType, diagnostics); if (returnType.IsRestrictedType()) { // Method or delegate cannot return type '{0}' diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, syntax.ReturnType.Location, returnType); } return returnType; }
protected override ReadOnlyArray<ParameterSymbol> MakeParameters( Binder binder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics) { SyntaxToken extensionMethodThis; SyntaxToken arglistToken; var parameters = ParameterHelpers.MakeParameters(binder, this, syntax.ParameterList, true, out extensionMethodThis, out arglistToken, diagnostics); if (arglistToken.Kind == SyntaxKind.ArgListKeyword) { // This is a parse-time error in the native compiler; it is a semantic analysis error in Roslyn. // error CS1669: __arglist is not valid in this context diagnostics.Add(ErrorCode.ERR_IllegalVarArgs, new SourceLocation(arglistToken)); } return parameters; }
public override void VisitDelegateDeclaration(DelegateDeclarationSyntax delegateDeclaration) { // stop visitor for going into delegates to improve performance }
protected override TypeSymbol MakeReturnType(Binder binder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics) { return binder.GetSpecialType(SpecialType.System_Void, diagnostics, syntax); }
internal static void AddDelegateMembers( SourceMemberContainerTypeSymbol delegateType, ArrayBuilder <Symbol> symbols, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics) { var compilation = delegateType.DeclaringCompilation; Binder binder = delegateType.GetBinder(syntax.ParameterList); RefKind refKind; TypeSyntax returnTypeSyntax = syntax.ReturnType.SkipRef(out refKind); var returnType = binder.BindType(returnTypeSyntax, diagnostics); // reuse types to avoid reporting duplicate errors if missing: var voidType = TypeWithAnnotations.Create(binder.GetSpecialType(SpecialType.System_Void, diagnostics, syntax)); // https://github.com/dotnet/roslyn/issues/30079: Should the 'object', IAsyncResult and AsyncCallback parameters be considered nullable or not nullable? var objectType = TypeWithAnnotations.Create(binder.GetSpecialType(SpecialType.System_Object, diagnostics, syntax)); var intPtrType = TypeWithAnnotations.Create(binder.GetSpecialType(SpecialType.System_IntPtr, diagnostics, syntax)); if (returnType.IsRestrictedType(ignoreSpanLikeTypes: true)) { // The return type of a method, delegate, or function pointer cannot be '{0}' diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType.Type); } // A delegate has the following members: (see CLI spec 13.6) // (1) a method named Invoke with the specified signature var invoke = new InvokeMethod(delegateType, refKind, returnType, syntax, binder, diagnostics); invoke.CheckDelegateVarianceSafety(diagnostics); symbols.Add(invoke); // (2) a constructor with argument types (object, System.IntPtr) symbols.Add(new Constructor(delegateType, voidType, objectType, intPtrType, syntax)); if (binder.Compilation.GetSpecialType(SpecialType.System_IAsyncResult).TypeKind != TypeKind.Error && binder.Compilation.GetSpecialType(SpecialType.System_AsyncCallback).TypeKind != TypeKind.Error && // WinRT delegates don't have Begin/EndInvoke methods !delegateType.IsCompilationOutputWinMdObj()) { var iAsyncResultType = TypeWithAnnotations.Create(binder.GetSpecialType(SpecialType.System_IAsyncResult, diagnostics, syntax)); var asyncCallbackType = TypeWithAnnotations.Create(binder.GetSpecialType(SpecialType.System_AsyncCallback, diagnostics, syntax)); // (3) BeginInvoke symbols.Add(new BeginInvokeMethod(invoke, iAsyncResultType, objectType, asyncCallbackType, syntax)); // and (4) EndInvoke methods symbols.Add(new EndInvokeMethod(invoke, iAsyncResultType, syntax)); } if (delegateType.DeclaredAccessibility <= Accessibility.Private) { return; } HashSet <DiagnosticInfo> useSiteDiagnostics = null; if (!delegateType.IsNoMoreVisibleThan(invoke.ReturnTypeWithAnnotations, ref useSiteDiagnostics)) { // Inconsistent accessibility: return type '{1}' is less accessible than delegate '{0}' diagnostics.Add(ErrorCode.ERR_BadVisDelegateReturn, delegateType.Locations[0], delegateType, invoke.ReturnType); } foreach (var parameter in invoke.Parameters) { if (!parameter.TypeWithAnnotations.IsAtLeastAsVisibleAs(delegateType, ref useSiteDiagnostics)) { // Inconsistent accessibility: parameter type '{1}' is less accessible than delegate '{0}' diagnostics.Add(ErrorCode.ERR_BadVisDelegateParam, delegateType.Locations[0], delegateType, parameter.Type); } } diagnostics.Add(delegateType.Locations[0], useSiteDiagnostics); }
protected abstract ReadOnlyArray<ParameterSymbol> MakeParameters(Binder binder, DelegateDeclarationSyntax syntax, out bool isExtensionMethod, out bool isVararg, DiagnosticBag diagnostics, CancellationToken cancellationToken);
public override void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { _parts.Add(new ExtensionScriptPart(_document, node, _sortWeight)); _sortWeight++; }
public override SyntaxToken VisitDelegateDeclaration([NotNull] DelegateDeclarationSyntax node) { return(node.Identifier); }
protected override TypeSymbol MakeReturnType(Binder bodyBinder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics) { return bodyBinder.BindType(syntax.ReturnType, diagnostics); }
public static bool IsPotentialCrossArch(DelegateDeclarationSyntax node) { return(node.Parent is NamespaceDeclarationSyntax); }
public override void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { base.VisitDelegateDeclaration(node); }
private void CreateDelegateDeclaration(Document document, FuncOrAction funcOrAction, IParameterSymbol parameterSymbol, out string newDelegateName, out DelegateDeclarationSyntax delegateDeclaration) { var syntaxGenerator = SyntaxGenerator.GetGenerator(document); var parameters = funcOrAction switch { FuncOrAction.Action action => action.Parameters, FuncOrAction.Func func => func.Parameters, _ => throw new System.NotImplementedException() }; newDelegateName = MakeFirstLetterUpperCase(parameterSymbol.Name); delegateDeclaration = (DelegateDeclarationSyntax)syntaxGenerator.DelegateDeclaration( newDelegateName, parameters .Select(p => syntaxGenerator.ParameterDeclaration( p.Name, syntaxGenerator.TypeExpression(p.Type))), accessibility: Accessibility.Public); if (funcOrAction is FuncOrAction.Func func1) { delegateDeclaration = delegateDeclaration .WithReturnType((TypeSyntax)syntaxGenerator.TypeExpression(func1.ReturnType)); } }
public static bool CanRefactor(DelegateDeclarationSyntax declaration, SemanticModel semanticModel, CancellationToken cancellationToken = default(CancellationToken)) { return(CanRefactor(declaration.Identifier, semanticModel, cancellationToken)); }
protected abstract TypeSymbol MakeReturnType(Binder binder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics);
private static async Task <Solution> GetTransformedSolutionAsync(Document document, Diagnostic diagnostic, CancellationToken cancellationToken) { var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); SyntaxNode node = root.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true); BaseTypeDeclarationSyntax baseTypeDeclarationSyntax = node as BaseTypeDeclarationSyntax; DelegateDeclarationSyntax delegateDeclarationSyntax = node as DelegateDeclarationSyntax; if (baseTypeDeclarationSyntax == null && delegateDeclarationSyntax == null) { return(document.Project.Solution); } DocumentId extractedDocumentId = DocumentId.CreateNewId(document.Project.Id); string extractedDocumentName = baseTypeDeclarationSyntax.Identifier.ValueText; if (baseTypeDeclarationSyntax != null) { TypeDeclarationSyntax typeDeclarationSyntax = baseTypeDeclarationSyntax as TypeDeclarationSyntax; if (typeDeclarationSyntax?.TypeParameterList?.Parameters.Count > 0) { extractedDocumentName += "`" + typeDeclarationSyntax.TypeParameterList.Parameters.Count; } } else { if (delegateDeclarationSyntax.TypeParameterList?.Parameters.Count > 0) { extractedDocumentName += "`" + delegateDeclarationSyntax.TypeParameterList.Parameters.Count; } } extractedDocumentName += ".cs"; List <SyntaxNode> nodesToRemoveFromExtracted = new List <SyntaxNode>(); SyntaxNode previous = node; for (SyntaxNode current = node.Parent; current != null; previous = current, current = current.Parent) { foreach (SyntaxNode child in current.ChildNodes()) { if (child == previous) { continue; } switch (child.Kind()) { case SyntaxKind.NamespaceDeclaration: case SyntaxKind.ClassDeclaration: case SyntaxKind.StructDeclaration: case SyntaxKind.InterfaceDeclaration: case SyntaxKind.EnumDeclaration: case SyntaxKind.DelegateDeclaration: nodesToRemoveFromExtracted.Add(child); break; default: break; } } } SyntaxNode extractedDocumentNode = root.RemoveNodes(nodesToRemoveFromExtracted, SyntaxRemoveOptions.KeepUnbalancedDirectives); Solution updatedSolution = document.Project.Solution.AddDocument(extractedDocumentId, extractedDocumentName, extractedDocumentNode, document.Folders); // Make sure to also add the file to linked projects foreach (var linkedDocumentId in document.GetLinkedDocumentIds()) { DocumentId linkedExtractedDocumentId = DocumentId.CreateNewId(linkedDocumentId.ProjectId); updatedSolution = updatedSolution.AddDocument(linkedExtractedDocumentId, extractedDocumentName, extractedDocumentNode, document.Folders); } // Remove the type from its original location updatedSolution = updatedSolution.WithDocumentSyntaxRoot(document.Id, root.RemoveNode(node, SyntaxRemoveOptions.KeepUnbalancedDirectives)); return(updatedSolution); }
protected abstract ReadOnlyArray<ParameterSymbol> MakeParameters(Binder binder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics);
private GenericInfo(DelegateDeclarationSyntax delegateDeclaration) : this(delegateDeclaration, delegateDeclaration.TypeParameterList, delegateDeclaration.ConstraintClauses) { }
public void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { if (node == null) throw new ArgumentNullException("node"); node.Validate(); WriteLeadingTrivia(node); _writer.WriteIndent(); WriteAttributes( node, _writer.Configuration.LineBreaksAndWrapping.Other.PlaceMethodAttributeOnSameLine ); var modifiers = GetGlobalMemberModifiers(node, node.Modifiers); if (modifiers != Modifiers.None) { _writer.WriteModifiers(modifiers); _writer.WriteSpace(); } _writer.WriteKeyword(PrinterKeyword.Delegate); _writer.WriteSpace(); node.ReturnType.Accept(this); _writer.WriteSpace(); _writer.WriteIdentifier(node.Identifier); if (node.TypeParameterList != null) node.TypeParameterList.Accept(this); node.ParameterList.Accept(this); if (node.ConstraintClauses.Count > 0) WriteConstraintClauses(node.ConstraintClauses); _writer.EndStatement(); WriteTrailingTrivia(node); }
public override void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { VisitAttributeLists(node.AttributeLists); Visit(node.ParameterList); //base.VisitDelegateDeclaration(node); }
public DelegateNode(DelegateDeclarationSyntax node) { this.node = node; }
private static bool IsTaskReturningMethod(SemanticModel semanticModel, DelegateDeclarationSyntax delegateDeclarationSyntax, CancellationToken cancellationToken) { return(IsTaskType(semanticModel, delegateDeclarationSyntax.ReturnType, cancellationToken)); }
public override void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { base.VisitDelegateDeclaration(node); Append(node); }
public override void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { }
private static bool IsNestedType(DelegateDeclarationSyntax delegateDeclaration) { return(delegateDeclaration?.Parent is BaseTypeDeclarationSyntax); }
/// <summary> /// Initializes a new instance of the <see cref="DelegateData"/> class. /// </summary> /// <param name="declaration"><see cref="DelegateDeclarationSyntax"/> this <see cref="DelegateData"/> represents.</param> /// <param name="compilation">Parent <see cref="ICompilationData"/> of this <see cref="DelegateData"/>.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="declaration"/> is <see langword="null"/>. -or- <paramref name="compilation"/> is <see langword="null"/> /// </exception> public DelegateData(DelegateDeclarationSyntax declaration, ICompilationData compilation) : base(declaration, compilation) { }
public override void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { Entities.NamedType.Create(cx, cx.GetModel(node).GetDeclaredSymbol(node)).ExtractRecursive(trapFile, parent); }
/// <summary> /// Get a source type symbol for the given declaration syntax. /// </summary> /// <returns>Null if there is no matching declaration.</returns> internal SourceNamedTypeSymbol GetSourceTypeMember(DelegateDeclarationSyntax syntax) { return(GetSourceTypeMember(syntax.Identifier.ValueText, syntax.Arity, syntax.Kind(), syntax)); }
// Returns the name of the declared API if the node is the type of node that should have an XML doc comment // otherwise returns null; public string GetAPIForNode(SyntaxNode node) { switch (node.Kind()) { case SyntaxKind.ConstructorDeclaration: { ConstructorDeclarationSyntax syntax = (ConstructorDeclarationSyntax)node; // assume only one field/identifier string text = syntax.Identifier.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.ConversionOperatorDeclaration: { ConversionOperatorDeclarationSyntax syntax = (ConversionOperatorDeclarationSyntax)node; // assume only one field/identifier string text = syntax.OperatorKeyword.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.DelegateDeclaration: { DelegateDeclarationSyntax syntax = (DelegateDeclarationSyntax)node; // assume only one field/identifier string text = syntax.Identifier.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.EnumDeclaration: { EnumDeclarationSyntax syntax = (EnumDeclarationSyntax)node; // assume only one field/identifier string text = syntax.Identifier.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.EventDeclaration: { /* EventDeclarationSyntax syntax = (EventDeclarationSyntax)node; * * string text = syntax.Identifier.Text; * // for now assume only one match * if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) * { * var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); * // but which one is the right one? * var symbol = symbols.Single(); * return symbol.GetDocumentationCommentId(); * }*/ return(null); } case SyntaxKind.FieldDeclaration: { FieldDeclarationSyntax syntax = (FieldDeclarationSyntax)node; // assume only one field/identifier string text = syntax.Declaration.Variables.First().Identifier.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.IndexerDeclaration: { IndexerDeclarationSyntax syntax = (IndexerDeclarationSyntax)node; string text = syntax.ThisKeyword.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.InterfaceDeclaration: { InterfaceDeclarationSyntax syntax = (InterfaceDeclarationSyntax)node; string text = syntax.Identifier.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.MethodDeclaration: { MethodDeclarationSyntax methodDeclarationSyntax = (MethodDeclarationSyntax)node; string text = methodDeclarationSyntax.Identifier.Text; var parameters = methodDeclarationSyntax.ParameterList.Parameters; if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // select the symbol whose declaring syntax reference matches the node's syntax reference. //var symbol = symbols.Where(s => s.DeclaringSyntaxReferences.Contains(node.GetReference())).Single(); foreach (var symbol in symbols) { var references = symbol.DeclaringSyntaxReferences; foreach (var reference in references) { SyntaxNode testNode = reference.GetSyntax(); if (testNode.Equals(node)) { Console.WriteLine("Matched nodes."); } } } // find the one that corresponds to this syntax node. //foreach (var symbol in symbols) //{ // IMethodSymbol methodsymbol = (IMethodSymbol)symbol; // symbol.DeclaringSyntaxReferences.Select(syntaxReference => syntaxReference == node.GetReference()); // //} return(symbols.First().GetDocumentationCommentId()); } return(null); } case SyntaxKind.NamespaceDeclaration: // doesn't work { NamespaceDeclarationSyntax syntax = (NamespaceDeclarationSyntax)node; NameSyntax nameSyntax = syntax.Name; string text = nameSyntax.ToFullString(); // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.OperatorDeclaration: { OperatorDeclarationSyntax syntax = (OperatorDeclarationSyntax)node; // this won't work, it needs to be figured out. string text = syntax.OperatorKeyword.Text + syntax.OperatorToken.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.PropertyDeclaration: { PropertyDeclarationSyntax syntax = (PropertyDeclarationSyntax)node; string text = syntax.Identifier.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.ClassDeclaration: { Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax classSyntax = (ClassDeclarationSyntax)node; string text = classSyntax.Identifier.Text; string valueText = classSyntax.Identifier.ValueText; // for now assume only one match var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } case SyntaxKind.StructDeclaration: { Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax structSyntax = (StructDeclarationSyntax)node; string text = structSyntax.Identifier.Text; string valueText = structSyntax.Identifier.ValueText; // for now assume only one match var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } default: return(null); } //var types = m_compilation.GlobalNamespace.GetTypeMembers(name); //m_compilation.GetTypeByMetadataName() //string docCommentId = classSymbol.GetDocumentationCommentId(); return(""); }
internal static bool IsInDelegateDeclaration(int position, DelegateDeclarationSyntax delegateDecl) { Debug.Assert(delegateDecl != null); return(IsBeforeToken(position, delegateDecl, delegateDecl.SemicolonToken)); }
/// <summary> /// Initializes a new instance of the <see cref="DelegateContext"/> class. /// </summary> /// <param name="containingTypeContext">The context for the type that contains this member. /// May be null if the delegate was not defined within a class/struct/interface.</param> /// <param name="delegateDeclaration">The delegate declaration.</param> /// <param name="semanticModel">The semantic model.</param> /// <exception cref="System.ArgumentNullException"> /// delegateDeclaration /// or /// semanticModel /// </exception> public DelegateContext(Maybe <ITypeDeclarationContext> containingTypeContext, DelegateDeclarationSyntax delegateDeclaration, SemanticModel semanticModel) { ContainingTypeContext = containingTypeContext; Declaration = delegateDeclaration ?? throw new ArgumentNullException(nameof(delegateDeclaration)); SemanticModel = semanticModel ?? throw new ArgumentNullException(nameof(semanticModel)); Symbol = semanticModel.GetDeclaredSymbol(delegateDeclaration); }
public override void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { ConditionalStore(GetDeclaredSymbol(node), IsRemovableType); base.VisitDelegateDeclaration(node); }
protected override TypeSymbol MakeReturnType(Binder binder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics) { return GetVoidType(binder, syntax, diagnostics); }
protected override TypeSymbol MakeReturnType(Binder bodyBinder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics) { var delegateBinder = bodyBinder as DelegateBinder; return delegateBinder.invoke.ReturnType; }
public override SyntaxNode VisitDelegateDeclaration(DelegateDeclarationSyntax node) { //Extend:Maybe add support depend on template, e.g. MS Ajax return(node); }
/// <summary> /// Creates a new <see cref="ModifierListInfo"/> with the specified modifiers updated. /// </summary> /// <param name="modifiers"></param> /// <returns></returns> public ModifierListInfo WithModifiers(SyntaxTokenList modifiers) { ThrowInvalidOperationIfNotInitialized(); switch (Parent.Kind()) { case SyntaxKind.ClassDeclaration: { var classDeclaration = (ClassDeclarationSyntax)Parent; ClassDeclarationSyntax newNode = classDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.ConstructorDeclaration: { var constructorDeclaration = (ConstructorDeclarationSyntax)Parent; ConstructorDeclarationSyntax newNode = constructorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.OperatorDeclaration: { var operatorDeclaration = (OperatorDeclarationSyntax)Parent; OperatorDeclarationSyntax newNode = operatorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.ConversionOperatorDeclaration: { var conversionOperatorDeclaration = (ConversionOperatorDeclarationSyntax)Parent; ConversionOperatorDeclarationSyntax newNode = conversionOperatorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.DelegateDeclaration: { var delegateDeclaration = (DelegateDeclarationSyntax)Parent; DelegateDeclarationSyntax newNode = delegateDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.DestructorDeclaration: { var destructorDeclaration = (DestructorDeclarationSyntax)Parent; DestructorDeclarationSyntax newNode = destructorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.EnumDeclaration: { var enumDeclaration = (EnumDeclarationSyntax)Parent; EnumDeclarationSyntax newNode = enumDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.EventDeclaration: { var eventDeclaration = (EventDeclarationSyntax)Parent; EventDeclarationSyntax newNode = eventDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.EventFieldDeclaration: { var eventFieldDeclaration = (EventFieldDeclarationSyntax)Parent; EventFieldDeclarationSyntax newNode = eventFieldDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.FieldDeclaration: { var fieldDeclaration = (FieldDeclarationSyntax)Parent; FieldDeclarationSyntax newNode = fieldDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.IndexerDeclaration: { var indexerDeclaration = (IndexerDeclarationSyntax)Parent; IndexerDeclarationSyntax newNode = indexerDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.InterfaceDeclaration: { var interfaceDeclaration = (InterfaceDeclarationSyntax)Parent; InterfaceDeclarationSyntax newNode = interfaceDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.MethodDeclaration: { var methodDeclaration = (MethodDeclarationSyntax)Parent; MethodDeclarationSyntax newNode = methodDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.PropertyDeclaration: { var propertyDeclaration = (PropertyDeclarationSyntax)Parent; PropertyDeclarationSyntax newNode = propertyDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.StructDeclaration: { var structDeclaration = (StructDeclarationSyntax)Parent; StructDeclarationSyntax newNode = structDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.IncompleteMember: { var incompleteMember = (IncompleteMemberSyntax)Parent; IncompleteMemberSyntax newNode = incompleteMember.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.GetAccessorDeclaration: case SyntaxKind.SetAccessorDeclaration: case SyntaxKind.AddAccessorDeclaration: case SyntaxKind.RemoveAccessorDeclaration: case SyntaxKind.UnknownAccessorDeclaration: { var accessorDeclaration = (AccessorDeclarationSyntax)Parent; AccessorDeclarationSyntax newNode = accessorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.LocalDeclarationStatement: { var localDeclarationStatement = (LocalDeclarationStatementSyntax)Parent; LocalDeclarationStatementSyntax newNode = localDeclarationStatement.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.LocalFunctionStatement: { var localFunctionStatement = (LocalFunctionStatementSyntax)Parent; LocalFunctionStatementSyntax newNode = localFunctionStatement.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.Parameter: { var parameter = (ParameterSyntax)Parent; ParameterSyntax newNode = parameter.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } } throw new InvalidOperationException(); }
public override void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { CheckXmlDocForErrors(node, semanticModel.GetDeclaredSymbol(node)); }