private static async Task<Document> RemoveEmptyStatementAsync(Document document, SyntaxNode root, EmptyStatementSyntax node, CancellationToken cancellationToken)
{
SyntaxNode newRoot;
switch (node.Parent.Kind())
{
case SyntaxKind.Block:
case SyntaxKind.SwitchSection:
// empty statements in a block or switch section can be removed
return await RemoveSemicolonTextAsync(document, node.SemicolonToken, cancellationToken).ConfigureAwait(false);
case SyntaxKind.IfStatement:
case SyntaxKind.ElseClause:
case SyntaxKind.ForStatement:
case SyntaxKind.WhileStatement:
case SyntaxKind.DoStatement:
// these cases are always replaced with an empty block
newRoot = root.ReplaceNode(node, SyntaxFactory.Block().WithTriviaFrom(node));
return document.WithSyntaxRoot(newRoot);
case SyntaxKind.LabeledStatement:
// handle this case as a text manipulation for simplicity
return await RemoveSemicolonTextAsync(document, node.SemicolonToken, cancellationToken).ConfigureAwait(false);
default:
return document;
}
}
public override SyntaxNode VisitEmptyStatement(EmptyStatementSyntax node)
{
// Without this, the regions and comments get gobbled up when returning null for a SyntaxNode
// Turns out regions are comments are not nodes but trivia of the node, so when removing node, the triva also gets cleared.
return node.WithSemicolonToken(
SyntaxFactory.MissingToken(SyntaxKind.SemicolonToken)
.WithLeadingTrivia(node.SemicolonToken.LeadingTrivia)
.WithTrailingTrivia(node.SemicolonToken.TrailingTrivia));
}
public static EmptyStatementSyntax EmptyStatement()
{
var result = new EmptyStatementSyntax();
return result;
}
public virtual void VisitEmptyStatement(EmptyStatementSyntax node)
{
DefaultVisit(node);
}
private void EmptyStatement(EmptyStatementSyntax statement)
{
writer.WriteLine(';');
}
private BoundStatement BindEmptyStatement(EmptyStatementSyntax syntax)
{
return(new BoundNoOpStatement());
}
public static void Write(this EmptyStatementSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
}
public override void VisitEmptyStatement(EmptyStatementSyntax node)
{
CreateConnectedEndNode(node);
}
public virtual bool VisitEmptyStatementSyntax(
EmptyStatementSyntax emptyStatement,
VisitKind visitKind)
=> VisitStatementSyntax(emptyStatement, visitKind);
public override void VisitEmptyStatement(EmptyStatementSyntax node)
{
base.VisitEmptyStatement(node);
_counter++;
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitEmptyStatement(EmptyStatementSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitEmptyStatement(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitEmptyStatement(EmptyStatementSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitEmptyStatement(node);
}
public EmptyStatementSharpnode(EmptyStatementSyntax syntax) : base(syntax)
{
}
public override IEnumerable <IModel> VisitEmptyStatement(EmptyStatementSyntax node)
{
yield return(Create <EmptyStatement>(node));
}
// 空语句
public virtual void VisitEmptyStatementSyntax(EmptyStatementSyntax value)
{
DefaultVisit(value);
}
public override void VisitEmptyStatement(EmptyStatementSyntax node)
{
_currentBlock.Nodes.Add(node);
}
public override AccessorOrMutator VisitEmptyStatement(EmptyStatementSyntax node)
{
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <remarks>
/// Statements will cause an AST walker to be created, thus we don't need to go further deeper in the
/// tree by visiting the node.
/// </remarks>
public override void VisitEmptyStatement(EmptyStatementSyntax node)
{
this.VisitStatement(node);
}
public override SyntaxNode VisitEmptyStatement(EmptyStatementSyntax node)
{
return(null);
}
public override void VisitEmptyStatement(EmptyStatementSyntax node)
{
}
public override SyntaxNode VisitEmptyStatement(EmptyStatementSyntax node)
{
//Simply remove all Empty Statements
return(null);
}
public override void VisitEmptyStatement(EmptyStatementSyntax node)
{
cb.Append(";");
}
public override IEnumerable <Instruction> VisitEmptyStatement(EmptyStatementSyntax node)
{
return(Enumerable.Empty <Instruction>());
}
public override Evaluation VisitEmptyStatement(EmptyStatementSyntax node)
{
return(base.VisitEmptyStatement(node));
}
public override IStatement VisitEmptyStatement(EmptyStatementSyntax node)
{
return(CodeDummy.LabeledStatement);
}
public override void VisitEmptyStatement(EmptyStatementSyntax node)
{
}
public BoundNoOpStatement(EmptyStatementSyntax syntax)
: base(BoundNodeKind.NoOpStatement, syntax)
{
}
public override void VisitEmptyStatement(EmptyStatementSyntax node)
{
cb.Append(";");
}
public void VisitEmptyStatement(EmptyStatementSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
WriteLeadingTrivia(node);
_writer.WriteIndent();
_writer.EndStatement();
WriteTrailingTrivia(node);
}
public EmptyStatementTranslation(EmptyStatementSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
}
public override SyntaxNode VisitEmptyStatement(EmptyStatementSyntax node)
{
node = (EmptyStatementSyntax)base.VisitEmptyStatement(node);
Classes.Add(node);
return(node);
}
public override void VisitEmptyStatement(EmptyStatementSyntax node)
{
UpdateSyntaxNode(node);
}
// TODO: Better design, create ASTWalkerBase which inherits from CSharpSyntaxWalker.
// Make all ASTWalker(s) inherit from it and provide virtual methods for statements in order to provide only one
// method for statement visit.
// TODO: Evaluate the possibility to use BlockASTWalker.
#region CSharpSyntaxWalker overrides
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <remarks>
/// Statements will cause an AST walker to be created, thus we don't need to go further deeper in the
/// tree by visiting the node.
/// </remarks>
public override void VisitEmptyStatement(EmptyStatementSyntax node)
{
this.VisitStatement(node);
}
public override UstNode VisitEmptyStatement(EmptyStatementSyntax node)
{
var result = new EmptyStatement(node.GetTextSpan(), FileNode);
return(result);
}
public override IEnumerable <EditorNavigationTarget> VisitEmptyStatement(EmptyStatementSyntax node)
{
yield break;
}
public override SyntaxNode VisitEmptyStatement(EmptyStatementSyntax node)
{
// Construct an EmptyStatementSyntax with a missing semicolon
// This approach has the side effect of leaving a blank line wherever there was a redundant semicolon
return node.WithSemicolonToken(
SyntaxFactory.MissingToken(SyntaxKind.SemicolonToken)
.WithLeadingTrivia(node.SemicolonToken.LeadingTrivia)
.WithTrailingTrivia(node.SemicolonToken.TrailingTrivia));
}
public override void VisitEmptyStatement(EmptyStatementSyntax node)
{
base.VisitEmptyStatement(node);
_counter++;
}
private static async Task <Document> RemoveEmptyStatementAsync(Document document, SyntaxNode root, EmptyStatementSyntax node, CancellationToken cancellationToken)
{
SyntaxNode newRoot;
switch (node.Parent.Kind())
{
case SyntaxKind.Block:
case SyntaxKind.SwitchSection:
// empty statements in a block or switch section can be removed
return(await RemoveSemicolonTextAsync(document, node.SemicolonToken, cancellationToken).ConfigureAwait(false));
case SyntaxKind.IfStatement:
case SyntaxKind.ElseClause:
case SyntaxKind.ForStatement:
case SyntaxKind.WhileStatement:
case SyntaxKind.DoStatement:
// these cases are always replaced with an empty block
newRoot = root.ReplaceNode(node, SyntaxFactory.Block().WithTriviaFrom(node));
return(document.WithSyntaxRoot(newRoot));
case SyntaxKind.LabeledStatement:
// handle this case as a text manipulation for simplicity
return(await RemoveSemicolonTextAsync(document, node.SemicolonToken, cancellationToken).ConfigureAwait(false));
default:
return(document);
}
}
public virtual void VisitEmptyStatement(EmptyStatementSyntax node)
{
DefaultVisit(node);
}
public override void VisitEmptyStatement(EmptyStatementSyntax node)
{
CreateConnectedEndNode(node);
}
// // Summary: // Called when the visitor visits a EmptyStatementSyntax node. public virtual void VisitEmptyStatement(EmptyStatementSyntax node);
public override void VisitEmptyStatement(EmptyStatementSyntax node)
{
Emit <EmptyBlock, EmptyStatementSyntax>(node);
}
private BoundStatement BindEmptyStatement(EmptyStatementSyntax syntax)
{
return new BoundNoOpStatement();
}
public EmptyStatementTranslation(EmptyStatementSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
}
public override void VisitEmptyStatement(EmptyStatementSyntax node) => base.VisitEmptyStatement(node);
private static BoundStatement BindEmpty(EmptyStatementSyntax node)
{
return new BoundNoOpStatement(node, NoOpStatementFlavor.Default);
}
public BoundNoOpStatement(EmptyStatementSyntax syntax)
: base(BoundNodeKind.NoOpStatement, syntax)
{
}
