private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, Diagnostic diagnostic)
{
var token = root.FindToken(diagnostic.Location.SourceSpan.Start, findInsideTrivia: true);
var updatedDocument = document.WithSyntaxRoot(root.ReplaceToken(token, token.WithLeadingTrivia(token.LeadingTrivia.Add(SyntaxFactory.Space))));
return Task.FromResult(updatedDocument);
}
private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, SyntaxToken token)
{
SyntaxToken corrected = token.WithTrailingTrivia(token.TrailingTrivia.Insert(0, SyntaxFactory.Space));
Document updatedDocument = document.WithSyntaxRoot(root.ReplaceToken(token, corrected));
return Task.FromResult(updatedDocument);
}
private Task<Document> AppendAsyncSuffixToMethodNameAsync(Document document, SyntaxNode root, SyntaxToken methodNameToken
, CancellationToken cancellationToken)
{
string methodName = methodNameToken.Text;
string newMethodName = (methodName.EndsWith("async") ? methodName.Substring(0, methodName.Length - 5) : methodName)
+ "Async";
SyntaxNode newRoot = root.ReplaceToken(methodNameToken, SyntaxFactory.Identifier(newMethodName));
return Task.FromResult(document.WithSyntaxRoot(newRoot));
}
static Document PerformAction(Document document, SyntaxNode root, SyntaxToken token)
{
var node = token.Parent as LiteralExpressionSyntax;
var newRoot = root.ReplaceToken(
token,
SyntaxFactory.ParseToken(string.Format("&H{0:x}", token.Value))
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(node.GetTrailingTrivia())
);
return document.WithSyntaxRoot(newRoot);
}
private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, SyntaxToken keywordToken)
{
SyntaxToken hashToken = keywordToken.GetPreviousToken(includeDirectives: true);
if (!hashToken.IsKind(SyntaxKind.HashToken))
{
return Task.FromResult(document);
}
SyntaxToken corrected = hashToken.WithoutTrailingWhitespace().WithoutFormatting();
Document updatedDocument = document.WithSyntaxRoot(root.ReplaceToken(hashToken, corrected));
return Task.FromResult(updatedDocument);
}
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context)
{
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
var token = root.FindToken(diagnosticSpan.Start);
context.RegisterCodeFix(
CodeAction.Create(
Title,
c =>
{
var newRoot = root.ReplaceToken(token, SyntaxFactory.Token(SyntaxKind.None));
return Task.FromResult(context.Document.WithSyntaxRoot(newRoot));
}),
context.Diagnostics);
}
public static async Task<Solution> RenameSymbolAsync(Document document, SyntaxNode root, SyntaxToken declarationToken, string newName, CancellationToken cancellationToken)
{
var annotatedRoot = root.ReplaceToken(declarationToken, declarationToken.WithAdditionalAnnotations(RenameAnnotation.Create()));
var annotatedSolution = document.Project.Solution.WithDocumentSyntaxRoot(document.Id, annotatedRoot);
var annotatedDocument = annotatedSolution.GetDocument(document.Id);
annotatedRoot = await annotatedDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var annotatedToken = annotatedRoot.FindToken(declarationToken.SpanStart);
var semanticModel = await annotatedDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var symbol = semanticModel.GetDeclaredSymbol(annotatedToken.Parent, cancellationToken);
var newSolution = await Renamer.RenameSymbolAsync(annotatedSolution, symbol, newName, null, cancellationToken).ConfigureAwait(false);
// TODO: return annotatedSolution instead of newSolution if newSolution contains any new errors (for any project)
return newSolution;
}
private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, Diagnostic diagnostic)
{
var token = root.FindToken(diagnostic.Location.SourceSpan.Start, findInsideTrivia: true);
SyntaxToken updatedToken;
switch (token.Kind())
{
case SyntaxKind.XmlTextLiteralToken:
updatedToken = XmlSyntaxFactory.TextLiteral(" " + token.Text.TrimStart(' ')).WithTriviaFrom(token);
break;
default:
updatedToken = token.WithLeadingTrivia(token.LeadingTrivia.Add(SyntaxFactory.Space));
break;
}
Document updatedDocument = document.WithSyntaxRoot(root.ReplaceToken(token, updatedToken));
return Task.FromResult(updatedDocument);
}
protected override SyntaxNode InsertAttributeListIntoContainer(int index, SyntaxNode list, SyntaxNode container)
{
// If the attribute list is being inserted at the first index and the container is not the compilation unit, copy leading trivia
// to the list that is being inserted.
if (index == 0 && !(container is CompilationUnitSyntax))
{
var firstToken = container.GetFirstToken();
if (firstToken.HasLeadingTrivia)
{
var trivia = firstToken.LeadingTrivia;
container = container.ReplaceToken(firstToken, firstToken.WithLeadingTrivia(SyntaxTriviaList.Empty));
list = list.WithLeadingTrivia(trivia);
}
}
if (container is CompilationUnitSyntax)
{
var compilationUnit = (CompilationUnitSyntax)container;
var newAttributeLists = compilationUnit.AttributeLists.Insert(index, (AttributeListSyntax)list);
return compilationUnit.WithAttributeLists(newAttributeLists);
}
else if (container is EnumDeclarationSyntax)
{
var enumDeclaration = (EnumDeclarationSyntax)container;
var newAttributeLists = enumDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list);
return enumDeclaration.WithAttributeLists(newAttributeLists);
}
else if (container is ClassDeclarationSyntax)
{
var classDeclaration = (ClassDeclarationSyntax)container;
var newAttributeLists = classDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list);
return classDeclaration.WithAttributeLists(newAttributeLists);
}
else if (container is StructDeclarationSyntax)
{
var structDeclaration = (StructDeclarationSyntax)container;
var newAttributeLists = structDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list);
return structDeclaration.WithAttributeLists(newAttributeLists);
}
else if (container is InterfaceDeclarationSyntax)
{
var interfaceDeclaration = (InterfaceDeclarationSyntax)container;
var newAttributeLists = interfaceDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list);
return interfaceDeclaration.WithAttributeLists(newAttributeLists);
}
else if (container is MethodDeclarationSyntax)
{
var method = (MethodDeclarationSyntax)container;
var newAttributeLists = method.AttributeLists.Insert(index, (AttributeListSyntax)list);
return method.WithAttributeLists(newAttributeLists);
}
else if (container is OperatorDeclarationSyntax)
{
var operationDeclaration = (OperatorDeclarationSyntax)container;
var newAttributeLists = operationDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list);
return operationDeclaration.WithAttributeLists(newAttributeLists);
}
else if (container is ConversionOperatorDeclarationSyntax)
{
var conversion = (ConversionOperatorDeclarationSyntax)container;
var newAttributeLists = conversion.AttributeLists.Insert(index, (AttributeListSyntax)list);
return conversion.WithAttributeLists(newAttributeLists);
}
else if (container is ConstructorDeclarationSyntax)
{
var constructor = (ConstructorDeclarationSyntax)container;
var newAttributeLists = constructor.AttributeLists.Insert(index, (AttributeListSyntax)list);
return constructor.WithAttributeLists(newAttributeLists);
}
else if (container is DestructorDeclarationSyntax)
{
var destructor = (DestructorDeclarationSyntax)container;
var newAttributeLists = destructor.AttributeLists.Insert(index, (AttributeListSyntax)list);
return destructor.WithAttributeLists(newAttributeLists);
}
else if (container is PropertyDeclarationSyntax)
{
var property = (PropertyDeclarationSyntax)container;
var newAttributeLists = property.AttributeLists.Insert(index, (AttributeListSyntax)list);
return property.WithAttributeLists(newAttributeLists);
}
else if (container is EventDeclarationSyntax)
{
var eventDeclaration = (EventDeclarationSyntax)container;
var newAttributeLists = eventDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list);
return eventDeclaration.WithAttributeLists(newAttributeLists);
}
else if (container is IndexerDeclarationSyntax)
{
var indexer = (IndexerDeclarationSyntax)container;
var newAttributeLists = indexer.AttributeLists.Insert(index, (AttributeListSyntax)list);
return indexer.WithAttributeLists(newAttributeLists);
}
else if (container is FieldDeclarationSyntax)
{
var field = (FieldDeclarationSyntax)container;
var newAttributeLists = field.AttributeLists.Insert(index, (AttributeListSyntax)list);
return field.WithAttributeLists(newAttributeLists);
}
else if (container is EventFieldDeclarationSyntax)
{
var eventFieldDeclaration = (EventFieldDeclarationSyntax)container;
var newAttributeLists = eventFieldDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list);
return eventFieldDeclaration.WithAttributeLists(newAttributeLists);
}
else if (container is DelegateDeclarationSyntax)
{
var delegateDeclaration = (DelegateDeclarationSyntax)container;
var newAttributeLists = delegateDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list);
return delegateDeclaration.WithAttributeLists(newAttributeLists);
}
else if (container is EnumMemberDeclarationSyntax)
{
var member = (EnumMemberDeclarationSyntax)container;
var newAttributeLists = member.AttributeLists.Insert(index, (AttributeListSyntax)list);
return member.WithAttributeLists(newAttributeLists);
}
else if (container is ParameterSyntax)
{
var parameter = (ParameterSyntax)container;
var newAttributeLists = parameter.AttributeLists.Insert(index, (AttributeListSyntax)list);
return parameter.WithAttributeLists(newAttributeLists);
}
else if (container is VariableDeclaratorSyntax ||
container is VariableDeclarationSyntax)
{
return InsertAttributeListIntoContainer(index, list, container.Parent);
}
throw Exceptions.ThrowEUnexpected();
}
private static SyntaxNode RemoveAnnotationIfExists(SyntaxNode root, SyntaxAnnotation annotation)
{
var element = root.GetAnnotatedNodesAndTokens(annotation).FirstOrDefault();
if (element == default(SyntaxNodeOrToken))
{
return root;
}
if (element.IsNode)
{
var node = element.AsNode();
return root.ReplaceNode(
node,
node.WithoutAnnotations(annotation));
}
var token = element.AsToken();
return root.ReplaceToken(
token,
token.WithoutAnnotations(annotation));
}
private static SyntaxNode MoveMember(SyntaxNode syntaxRoot, MemberDeclarationSyntax member, MemberDeclarationSyntax targetMember, IndentationOptions indentationOptions)
{
var firstToken = syntaxRoot.GetFirstToken();
var fileHeader = GetFileHeader(firstToken.LeadingTrivia);
syntaxRoot = syntaxRoot.TrackNodes(member, targetMember, firstToken.Parent);
var memberToMove = syntaxRoot.GetCurrentNode(member);
var targetMemberTracked = syntaxRoot.GetCurrentNode(targetMember);
if (!memberToMove.HasLeadingTrivia)
{
var targetIndentationLevel = IndentationHelper.GetIndentationSteps(indentationOptions, targetMember);
var indentationString = IndentationHelper.GenerateIndentationString(indentationOptions, targetIndentationLevel);
memberToMove = memberToMove.WithLeadingTrivia(SyntaxFactory.Whitespace(indentationString));
}
if (!HasLeadingBlankLines(targetMember)
&& HasLeadingBlankLines(member))
{
memberToMove = memberToMove.WithTrailingTrivia(memberToMove.GetTrailingTrivia().Add(SyntaxFactory.CarriageReturnLineFeed));
memberToMove = memberToMove.WithLeadingTrivia(GetLeadingTriviaWithoutLeadingBlankLines(memberToMove));
}
syntaxRoot = syntaxRoot.InsertNodesBefore(targetMemberTracked, new[] { memberToMove });
var fieldToMoveTracked = syntaxRoot.GetCurrentNodes(member).Last();
syntaxRoot = syntaxRoot.RemoveNode(fieldToMoveTracked, SyntaxRemoveOptions.KeepNoTrivia);
if (fileHeader.Any())
{
var oldFirstToken = syntaxRoot.GetCurrentNode(firstToken.Parent).ChildTokens().First();
syntaxRoot = syntaxRoot.ReplaceToken(oldFirstToken, oldFirstToken.WithLeadingTrivia(StripFileHeader(oldFirstToken.LeadingTrivia)));
var newFirstToken = syntaxRoot.GetFirstToken();
syntaxRoot = syntaxRoot.ReplaceToken(newFirstToken, newFirstToken.WithLeadingTrivia(fileHeader.AddRange(newFirstToken.LeadingTrivia)));
}
return syntaxRoot;
}
private static SyntaxNode ReAddFileHeader(SyntaxNode syntaxRoot, ImmutableArray<SyntaxTrivia> fileHeader)
{
if (fileHeader.IsEmpty)
{
// Only re-add the file header if it was stripped.
return syntaxRoot;
}
var firstToken = syntaxRoot.GetFirstToken(includeZeroWidth: true);
var newLeadingTrivia = firstToken.LeadingTrivia.InsertRange(0, fileHeader);
return syntaxRoot.ReplaceToken(firstToken, firstToken.WithLeadingTrivia(newLeadingTrivia));
}
private static SyntaxNode ReAddFileHeader(SyntaxNode syntaxRoot, SyntaxNode newSyntaxRoot)
{
var oldFirstToken = syntaxRoot.GetFirstToken();
if (!oldFirstToken.HasLeadingTrivia)
{
return newSyntaxRoot;
}
var fileHeader = UsingsHelper.GetFileHeader(oldFirstToken.LeadingTrivia.ToList());
if (!fileHeader.Any())
{
return newSyntaxRoot;
}
var newFirstToken = newSyntaxRoot.GetFirstToken();
var newLeadingTrivia = newFirstToken.LeadingTrivia.InsertRange(0, fileHeader);
return newSyntaxRoot.ReplaceToken(newFirstToken, newFirstToken.WithLeadingTrivia(newLeadingTrivia));
}
private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, SyntaxToken token)
{
bool isAddingSpace = true;
switch (token.Kind())
{
case SyntaxKind.NewKeyword:
{
SyntaxToken nextToken = token.GetNextToken();
if (nextToken.IsKind(SyntaxKind.OpenBracketToken) || nextToken.IsKind(SyntaxKind.OpenParenToken))
{
isAddingSpace = false;
}
}
break;
case SyntaxKind.ReturnKeyword:
case SyntaxKind.ThrowKeyword:
{
SyntaxToken nextToken = token.GetNextToken();
if (nextToken.IsKind(SyntaxKind.SemicolonToken))
{
isAddingSpace = false;
}
}
break;
case SyntaxKind.CheckedKeyword:
case SyntaxKind.UncheckedKeyword:
isAddingSpace = token.GetNextToken().IsKind(SyntaxKind.OpenBraceToken);
break;
case SyntaxKind.DefaultKeyword:
case SyntaxKind.NameOfKeyword:
case SyntaxKind.SizeOfKeyword:
case SyntaxKind.TypeOfKeyword:
isAddingSpace = false;
break;
case SyntaxKind.IdentifierToken:
if (token.Text == "nameof")
{
// SA1000 would only have been reported for a nameof expression. No need to verify.
goto case SyntaxKind.NameOfKeyword;
}
return Task.FromResult(document);
default:
break;
}
if (isAddingSpace == token.HasTrailingTrivia)
{
return Task.FromResult(document);
}
if (isAddingSpace)
{
SyntaxTrivia whitespace = SyntaxFactory.Space;
SyntaxToken corrected = token.WithTrailingTrivia(token.TrailingTrivia.Insert(0, whitespace));
Document updatedDocument = document.WithSyntaxRoot(root.ReplaceToken(token, corrected));
return Task.FromResult(updatedDocument);
}
else
{
SyntaxToken corrected = token.WithoutTrailingWhitespace().WithoutFormatting();
Document updatedDocument = document.WithSyntaxRoot(root.ReplaceToken(token, corrected));
return Task.FromResult(updatedDocument);
}
}
