protected override IndentationResult?GetDesiredIndentationWorker(
Indenter indenter,
SyntaxToken?tokenOpt,
SyntaxTrivia?triviaOpt
) =>
TryGetDesiredIndentation(indenter, triviaOpt)
?? TryGetDesiredIndentation(indenter, tokenOpt);
public IEnumerable <SyntaxNode> Nodes(ISet <int> references, SyntaxTrivia?previous)
{
SyntaxNode first = null;
SyntaxNode second = null;
if (references.Contains(this.number))
{
first = SyntaxFactory.LabeledStatement(Label(this.number), SyntaxFactory.EmptyStatement());
second = this.node;
}
else
{
first = this.node;
}
if (previous.HasValue)
{
first = first.WithLeadingTrivia(previous.Value);
}
yield return(first);
if (second != null)
{
yield return(second);
}
}
internal static SyntaxTrivia EndOfLine(string text, bool elastic = false)
{
SyntaxTrivia?trivia = null;
// use predefined trivia
switch (text)
{
case "\r":
trivia = elastic ? ElasticCarriageReturn : CarriageReturn;
break;
case "\n":
trivia = elastic ? ElasticLineFeed : LineFeed;
break;
case "\r\n":
trivia = elastic ? ElasticCarriageReturnLineFeed : CarriageReturnLineFeed;
break;
}
// note: predefined trivia might not yet be defined during initialization
if (trivia != null)
{
return(trivia);
}
trivia = SyntaxTrivia.Create(SyntaxKind.EndOfLineTrivia, text);
if (!elastic)
{
return(trivia);
}
return(trivia.WithAnnotationsGreen(new[] { SyntaxAnnotation.ElasticAnnotation }));
}
private static IndentationResult?TryGetDesiredIndentation(Indenter indenter, SyntaxTrivia?triviaOpt)
{
// If we have a // comment, and it's the only thing on the line, then if we hit enter, we should align to
// that. This helps for cases like:
//
// int goo; // this comment
// // continues
// // onwards
//
// The user will have to manually indent `// continues`, but we'll respect that indentation from that point on.
if (triviaOpt == null)
{
return(null);
}
var trivia = triviaOpt.Value;
if (!trivia.IsSingleOrMultiLineComment() && !trivia.IsDocComment())
{
return(null);
}
var line = indenter.Text.Lines.GetLineFromPosition(trivia.FullSpan.Start);
if (line.GetFirstNonWhitespacePosition() != trivia.FullSpan.Start)
{
return(null);
}
// Previous line just contained this single line comment. Align us with it.
return(new IndentationResult(trivia.FullSpan.Start, 0));
}
public static SyntaxTrivia DetermineEndOfLine(SyntaxToken token, SyntaxTrivia?defaultValue = null)
{
SyntaxTrivia trivia = FindEndOfLine(token);
return((trivia.IsEndOfLineTrivia())
? trivia
: defaultValue ?? CSharpFactory.NewLine());
}
public static Document RewriteDocument(Document document, SyntaxNode root,
SyntaxNode targetNode, SyntaxTrivia?replacementTrivia = null)
{
replacementTrivia = replacementTrivia ?? SyntaxFactory.ElasticMarker;
var rewritten = new CommentRemovalRewriter(replacementTrivia.Value).Visit(targetNode);
return(document.WithSyntaxRoot(root.ReplaceNode(targetNode, rewritten)));
}
internal static SyntaxTrivia GetBestNewLineTrivia(SyntaxTriviaList list, SyntaxTrivia?defaultNewLineTrivia = null)
{
SyntaxTrivia trivia;
if (TryGetExistingNewLine(list, out trivia))
{
return(trivia);
}
return(defaultNewLineTrivia ?? SyntaxFactory.CarriageReturnLineFeed);
}
/// <summary>
/// Look at the context of the node to determine the best possible new line trivia. It will prefer
/// existing new lines over creating a new one to help ensure the same new lines are preserved
/// throughout the file.
/// </summary>
internal static SyntaxTrivia GetBestNewLineTrivia(SyntaxNode node, SyntaxTrivia?defaultNewLineTrivia = null)
{
SyntaxTrivia trivia;
if (TryGetExistingNewLine(node.GetLeadingTrivia(), out trivia) ||
TryGetExistingNewLine(node.GetTrailingTrivia(), out trivia))
{
return(trivia);
}
return(defaultNewLineTrivia ?? SyntaxFactory.CarriageReturnLineFeed);
}
private void AddEndOfLine(SyntaxTrivia?eolTrivia)
{
if (!eolTrivia.HasValue)
{
return;
}
if (_residualTrivia.Count == 0 || !IsEndOfLine(_residualTrivia[_residualTrivia.Count - 1]))
{
_residualTrivia.Add(eolTrivia.Value);
}
}
internal static SyntaxTrivia GetBestNewLineTrivia(SyntaxToken token, SyntaxTrivia?defaultNewLineTrivia = null)
{
SyntaxTrivia trivia;
if (TryGetExistingNewLine(token.LeadingTrivia, out trivia) ||
TryGetExistingNewLine(token.TrailingTrivia, out trivia))
{
return(trivia);
}
return(defaultNewLineTrivia ?? SyntaxFactory.CarriageReturnLineFeed);
}
/// <inheritdoc />
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
SyntaxTrivia?v = (SyntaxTrivia?)value;
if (value == null || !v.HasValue)
{
return(null);
}
var s = v.Value;
return(s.Kind().ToString());
}
public static SyntaxTriviaList ToSyntaxTriviaList(this IEnumerable <SyntaxTrivia> sequence)
{
SyntaxTrivia?first = sequence.FirstOrNullable();
if (first == null)
{
return(default(SyntaxTriviaList));
}
else
{
return(((Syntax.InternalSyntax.InternalSyntaxNode)first.Value.UnderlyingNode).Language.SyntaxFactory.TriviaList(sequence));
}
}
public override void VisitSyntaxTrivia(SyntaxTrivia node)
{
// check if offset is inside the node's span
if (CheckNodeContainsOffset(node))
{
// the node span contains the offset
// check the predicate
if (this.predicate(node))
{
// store the potential result
this.Result = node;
}
}
}
public static SyntaxTrivia DetermineEndOfLine(SyntaxNodeOrToken nodeOrToken, SyntaxTrivia?defaultValue = null)
{
if (nodeOrToken.IsNode)
{
return(DetermineEndOfLine(nodeOrToken.AsNode(), defaultValue));
}
else if (nodeOrToken.IsToken)
{
return(DetermineEndOfLine(nodeOrToken.AsToken(), defaultValue));
}
else
{
throw new ArgumentException("", nameof(nodeOrToken));
}
}
public static void CollectCommentBlockSpans(
SyntaxTriviaList triviaList, ArrayBuilder <BlockSpan> spans)
{
if (triviaList.Count > 0)
{
SyntaxTrivia?startComment = null;
SyntaxTrivia?endComment = null;
Action completeSingleLineCommentGroup = () =>
{
if (startComment != null)
{
var singleLineCommentGroupRegion = CreateCommentBlockSpan(startComment.Value, endComment.Value);
spans.Add(singleLineCommentGroupRegion);
startComment = null;
endComment = null;
}
};
// Iterate through trivia and collect the following:
// 1. Groups of contiguous single-line comments that are only separated by whitespace
// 2. Multi-line comments
foreach (var trivia in triviaList)
{
if (trivia.IsSingleLineComment())
{
startComment = startComment ?? trivia;
endComment = trivia;
}
else if (trivia.IsMultiLineComment())
{
completeSingleLineCommentGroup();
var multilineCommentRegion = CreateCommentBlockSpan(trivia, trivia);
spans.Add(multilineCommentRegion);
}
else if (!trivia.MatchesKind(SyntaxKind.WhitespaceTrivia,
SyntaxKind.EndOfLineTrivia,
SyntaxKind.EndOfFileToken))
{
completeSingleLineCommentGroup();
}
}
completeSingleLineCommentGroup();
}
}
public IEnumerable <SyntaxNode> Statements()
{
SyntaxTrivia?previous = null;
foreach (Line line in this.statements)
{
SyntaxTrivia?next = line.Comment;
if (next == null)
{
foreach (SyntaxNode node in line.Nodes(this.references, previous))
{
yield return(node);
}
}
previous = next;
}
}
protected SyntaxNode GenerateAttribute(SyntaxNode syntaxNode, string name, SyntaxTrivia?leadingWhitespaceTrivia, SyntaxNode[] arguments)
{
return(GenerateAttribute(syntaxNode, name, leadingWhitespaceTrivia, arguments, null));
}
private static T WithLeadingWhitespaceTrivia <T>(this T syntaxNode, SyntaxTrivia?leadingWhitespaceTrivia)
where T : SyntaxNode
{
return(leadingWhitespaceTrivia.HasValue ? syntaxNode.WithLeadingTrivia(leadingWhitespaceTrivia.Value) : syntaxNode.WithoutLeadingTrivia());
}
private static T WithLeadingTrivia <T>(this T attributeList, SyntaxList <T> attributeLists, SyntaxTriviaList leadingTrivia, SyntaxTrivia?leadingWhitespaceTrivia)
where T : SyntaxNode
{
return(attributeLists.Count == 0 ? attributeList.WithLeadingTrivia(leadingTrivia) : attributeList.WithLeadingWhitespaceTrivia(leadingWhitespaceTrivia));
}
private static T WithLeadingWhitespaceTrivia <T, TAttributeList>(this T syntaxNode, SyntaxList <TAttributeList> attributeLists, SyntaxTrivia?leadingWhitespaceTrivia)
where T : SyntaxNode
where TAttributeList : SyntaxNode
{
return(attributeLists.Count > 0 ? syntaxNode : syntaxNode.WithLeadingWhitespaceTrivia(leadingWhitespaceTrivia));
}
protected SyntaxNode GenerateAttribute(SyntaxNode syntaxNode, string name, SyntaxTrivia?leadingWhitespaceTrivia, SyntaxAnnotation argumentListAnnotation)
{
SyntaxNode[] arguments = argumentListAnnotation == null ? null : Array.Empty <SyntaxNode>();
return(GenerateAttribute(syntaxNode, name, leadingWhitespaceTrivia, arguments, argumentListAnnotation));
}
public Line(int number, SyntaxNode node, SyntaxTrivia?comment)
{
this.number = number;
this.node = node;
this.comment = comment;
}
private void HandleDocumentedNode(SyntaxNodeAnalysisContext context)
{
DocumentationCommentTriviaSyntax documentationComment = context.Node.GetDocumentationCommentTriviaSyntax();
if (documentationComment != null)
{
// The element already has a documentation comment.
return;
}
SyntaxTrivia?firstComment = null;
SyntaxTrivia?lastComment = null;
bool isAtEndOfLine = false;
var leadingTrivia = context.Node.GetLeadingTrivia();
for (int i = leadingTrivia.Count - 1; i >= 0; i--)
{
switch (leadingTrivia[i].Kind())
{
case SyntaxKind.WhitespaceTrivia:
// Ignore indentation and/or trailing whitespace
continue;
case SyntaxKind.EndOfLineTrivia:
if (isAtEndOfLine)
{
// Multiple newlines
break;
}
isAtEndOfLine = true;
continue;
case SyntaxKind.SingleLineCommentTrivia:
firstComment = leadingTrivia[i];
lastComment = lastComment ?? firstComment;
isAtEndOfLine = false;
continue;
case SyntaxKind.MultiLineCommentTrivia:
if (lastComment != null)
{
// Have a multiline comment preceding a single line comment. Only consider the latter for this
// refactoring.
break;
}
firstComment = leadingTrivia[i];
lastComment = firstComment;
break;
}
// Reaching here means we don't want to continue the loop
break;
}
if (firstComment is null)
{
return;
}
var location = Location.Create(context.Node.SyntaxTree, TextSpan.FromBounds(firstComment.Value.SpanStart, lastComment.Value.Span.End));
context.ReportDiagnostic(Diagnostic.Create(Descriptor, location));
}
protected abstract SyntaxNode GenerateAttribute(SyntaxNode syntaxNode, string name, SyntaxTrivia?leadingWhitespaceTrivia, SyntaxNode[] arguments, SyntaxAnnotation argumentListAnnotation);
public static SyntaxTrivia DetermineEndOfLine(SyntaxNode node, SyntaxTrivia?defaultValue = null)
{
return(DetermineEndOfLine(node.GetFirstToken(), defaultValue));
}
protected abstract IndentationResult?GetDesiredIndentationWorker(
Indenter indenter, SyntaxToken?token, SyntaxTrivia?trivia);
public MethodTransformerResult Transform(IMethodOrAccessorTransformationResult transformResult,
ITypeTransformationMetadata typeMetadata, INamespaceTransformationMetadata namespaceMetadata)
{
var methodResult = transformResult.AnalyzationResult;
if (!methodResult.Missing || !methodResult.Conversion.HasFlag(MethodConversion.ToAsync) || methodResult.Symbol.IsObsolete())
{
return(MethodTransformerResult.Skip);
}
var methodNode = transformResult.Transformed;
var baseMethod = methodResult.RelatedMethods
.Where(o =>
(methodResult.BaseOverriddenMethod != null && o.Symbol.Equals(methodResult.BaseOverriddenMethod)) ||
methodResult.ImplementedInterfaces.Any(i => o.Symbol.Equals(i)))
.FirstOrDefault(o => o.AsyncCounterpartSymbol?.IsObsolete() == true);
if (baseMethod == null)
{
return(MethodTransformerResult.Skip);
}
namespaceMetadata.AddUsing("System");
AttributeListSyntax obsoleteAttribute = null;
var syntaxReference = baseMethod.AsyncCounterpartSymbol.DeclaringSyntaxReferences.SingleOrDefault();
SyntaxTrivia?documentationTrivia = null;
if (syntaxReference != null)
{
var baseMethodNode = syntaxReference.GetSyntax() as MethodDeclarationSyntax;
obsoleteAttribute = baseMethodNode?.AttributeLists.FirstOrDefault(o => o.Attributes.Count == 1 && o.Attributes.First().Name.ToString() == "Obsolete");
obsoleteAttribute = (AttributeListSyntax)_directiveRemover.VisitAttributeList(obsoleteAttribute);
documentationTrivia = obsoleteAttribute.GetLeadingTrivia()
.Select(o => o.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia) ? o : (SyntaxTrivia?)null)
.FirstOrDefault(o => o.HasValue);
}
if (obsoleteAttribute == null)
{
obsoleteAttribute = AttributeList(SingletonSeparatedList(Attribute(IdentifierName("Obsolete"))))
.WithOpenBracketToken(Token(TriviaList(transformResult.LeadingWhitespaceTrivia), SyntaxKind.OpenBracketToken, TriviaList()))
.WithCloseBracketToken(Token(TriviaList(), SyntaxKind.CloseBracketToken, TriviaList(transformResult.EndOfLineTrivia)));
}
var inheritDocTrivia = Trivia(GetInheritdoc(transformResult.EndOfLineTrivia.ToFullString()));
if (documentationTrivia.HasValue)
{
obsoleteAttribute = obsoleteAttribute.WithLeadingTrivia(obsoleteAttribute.GetLeadingTrivia()
.Replace(documentationTrivia.Value, inheritDocTrivia));
}
else
{
// Append <inheritdoc />
var leadingTrivia = obsoleteAttribute.GetLeadingTrivia();
var trivias = new List <SyntaxTrivia>();
if (leadingTrivia.Count == 0 || !leadingTrivia.Last().IsKind(SyntaxKind.WhitespaceTrivia))
{
trivias.Add(transformResult.LeadingWhitespaceTrivia);
}
trivias.Add(inheritDocTrivia);
trivias.Add(transformResult.LeadingWhitespaceTrivia);
obsoleteAttribute = obsoleteAttribute.WithLeadingTrivia(leadingTrivia.AddRange(trivias));
}
methodNode = methodNode
.WithLeadingTrivia(TriviaList(transformResult.LeadingWhitespaceTrivia))
.WithAttributeLists(methodNode.AttributeLists.Add(obsoleteAttribute));
return(MethodTransformerResult.Update(methodNode));
}
public static SyntaxNode CsGenerateAttribute(this SyntaxNode syntaxNode, string name, SyntaxTrivia?leadingWhitespaceTrivia, SyntaxNode[] arguments, SyntaxAnnotation argumentListAnnotation)
{
var leadingTrivia = syntaxNode.GetLeadingTrivia();
var attribute = CsGetAttributeSyntax(name, arguments, argumentListAnnotation);
var attributeList = SyntaxFactory.AttributeList(SyntaxFactory.SeparatedList(new AttributeSyntax[] { attribute }))
.NormalizeWhitespace()
.WithTrailingTrivia(SyntaxFactory.EndOfLine(Environment.NewLine));
if (syntaxNode is PropertyDeclarationSyntax propertySyntax)
{
return(propertySyntax.WithLeadingWhitespaceTrivia(propertySyntax.AttributeLists, leadingWhitespaceTrivia)
.AddAttributeLists(attributeList.WithLeadingTrivia(propertySyntax.AttributeLists, leadingTrivia, leadingWhitespaceTrivia)));
}
else if (syntaxNode is ClassDeclarationSyntax classSyntax)
{
return(classSyntax.WithLeadingWhitespaceTrivia(classSyntax.AttributeLists, leadingWhitespaceTrivia)
.AddAttributeLists(attributeList.WithLeadingTrivia(classSyntax.AttributeLists, leadingTrivia, leadingWhitespaceTrivia)));
}
else if (syntaxNode is MethodDeclarationSyntax methodSyntax)
{
return(methodSyntax.WithLeadingWhitespaceTrivia(methodSyntax.AttributeLists, leadingWhitespaceTrivia)
.AddAttributeLists(attributeList.WithLeadingTrivia(methodSyntax.AttributeLists, leadingTrivia, leadingWhitespaceTrivia)));
}
else
{
Debug.Fail("Only property or class syntax node supported.");
return(null);
}
}
public static T AppendTrivia <T>(this T node, SyntaxTrivia?trivia)
where T : SyntaxNode =>
trivia is null ? node : node.WithLeadingTrivia(node.GetLeadingTrivia().Add(trivia.Value));
protected override SyntaxNode GenerateAttribute(SyntaxNode syntaxNode, string name, SyntaxTrivia?leadingWhitespaceTrivia, SyntaxNode[] arguments, SyntaxAnnotation argumentListAnnotation)
{
return(syntaxNode.CsGenerateAttribute(name, leadingWhitespaceTrivia, arguments, argumentListAnnotation));
}