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 BoundNoOpStatement(EmptyStatementSyntax syntax) : base(BoundNodeKind.NoOpStatement, syntax) { }
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)); }
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); } }
// // 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 override void VisitEmptyStatement(EmptyStatementSyntax node) => base.VisitEmptyStatement(node);
private static BoundStatement BindEmpty(EmptyStatementSyntax node) { return new BoundNoOpStatement(node, NoOpStatementFlavor.Default); }