internal static Task <Document> RemoveSingleLineDocumentationComment(
this Document document,
DocumentationCommentTriviaSyntax documentationComment,
CancellationToken cancellationToken = default)
{
SyntaxNode node = documentationComment.ParentTrivia.Token.Parent;
SyntaxNode newNode = SyntaxRefactorings.RemoveSingleLineDocumentationComment(node, documentationComment);
return(document.ReplaceNodeAsync(node, newNode, cancellationToken));
}
public static Task <Document> ChangeTypeAsync(
Document document,
TypeSyntax type,
ITypeSymbol typeSymbol,
CancellationToken cancellationToken = default)
{
TypeSyntax newType = SyntaxRefactorings.ChangeType(type, typeSymbol);
return(document.ReplaceNodeAsync(type, newType, cancellationToken));
}
/// <summary>
/// Creates a new document with trivia inside the specified span removed.
/// </summary>
/// <param name="document"></param>
/// <param name="span"></param>
/// <param name="cancellationToken"></param>
public static async Task <Document> RemoveTriviaAsync(
this Document document,
TextSpan span,
CancellationToken cancellationToken = default)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
SyntaxNode newRoot = SyntaxRefactorings.RemoveTrivia(root, span);
return(document.WithSyntaxRoot(newRoot));
}
internal static Task <Document> RemoveNodeAsync(
this Document document,
SyntaxNode node,
CancellationToken cancellationToken = default)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
return(document.RemoveNodeAsync(node, SyntaxRefactorings.GetRemoveOptions(node), cancellationToken));
}
/// <summary>
/// Creates a new document with comments of the specified kind removed.
/// </summary>
/// <param name="document"></param>
/// <param name="comments"></param>
/// <param name="cancellationToken"></param>
public static async Task <Document> RemoveCommentsAsync(
this Document document,
CommentFilter comments,
CancellationToken cancellationToken = default)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
SyntaxNode newRoot = SyntaxRefactorings.RemoveComments(root, comments)
.WithFormatterAnnotation();
return(document.WithSyntaxRoot(newRoot));
}
public static Task <Document> ChangeTypeAndAddAwaitAsync(
Document document,
VariableDeclarationSyntax variableDeclaration,
VariableDeclaratorSyntax variableDeclarator,
SyntaxNode containingDeclaration,
ITypeSymbol newTypeSymbol,
CancellationToken cancellationToken)
{
VariableDeclarationSyntax newVariableDeclaration = SyntaxRefactorings.ChangeTypeAndAddAwait(variableDeclaration, variableDeclarator, newTypeSymbol);
if (!SyntaxInfo.ModifierListInfo(containingDeclaration).IsAsync)
{
SyntaxNode newDeclaration = containingDeclaration
.ReplaceNode(variableDeclaration, newVariableDeclaration)
.InsertModifier(SyntaxKind.AsyncKeyword);
return(document.ReplaceNodeAsync(containingDeclaration, newDeclaration, cancellationToken));
}
return(document.ReplaceNodeAsync(variableDeclaration, newVariableDeclaration, cancellationToken));
}
/// <summary>
/// Create a new document with the specified member declaration removed.
/// </summary>
/// <param name="document"></param>
/// <param name="member"></param>
/// <param name="cancellationToken"></param>
internal static Task <Document> RemoveMemberAsync(
this Document document,
MemberDeclarationSyntax member,
CancellationToken cancellationToken = default)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
if (member == null)
{
throw new ArgumentNullException(nameof(member));
}
SyntaxNode parent = member.Parent;
switch (parent?.Kind())
{
case SyntaxKind.CompilationUnit:
{
var compilationUnit = (CompilationUnitSyntax)parent;
return(document.ReplaceNodeAsync(compilationUnit, SyntaxRefactorings.RemoveMember(compilationUnit, member), cancellationToken));
}
case SyntaxKind.NamespaceDeclaration:
{
var namespaceDeclaration = (NamespaceDeclarationSyntax)parent;
return(document.ReplaceNodeAsync(namespaceDeclaration, SyntaxRefactorings.RemoveMember(namespaceDeclaration, member), cancellationToken));
}
case SyntaxKind.ClassDeclaration:
{
var classDeclaration = (ClassDeclarationSyntax)parent;
return(document.ReplaceNodeAsync(classDeclaration, SyntaxRefactorings.RemoveMember(classDeclaration, member), cancellationToken));
}
case SyntaxKind.StructDeclaration:
{
var structDeclaration = (StructDeclarationSyntax)parent;
return(document.ReplaceNodeAsync(structDeclaration, SyntaxRefactorings.RemoveMember(structDeclaration, member), cancellationToken));
}
case SyntaxKind.InterfaceDeclaration:
{
var interfaceDeclaration = (InterfaceDeclarationSyntax)parent;
return(document.ReplaceNodeAsync(interfaceDeclaration, SyntaxRefactorings.RemoveMember(interfaceDeclaration, member), cancellationToken));
}
default:
{
Debug.Assert(parent == null, parent.Kind().ToString());
return(document.RemoveNodeAsync(member, SyntaxRefactorings.DefaultRemoveOptions, cancellationToken));
}
}
}
