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