Enum cairo_lang_semantic::patcher::RewriteNode

pub enum RewriteNode {
    Trimmed {
        node: SyntaxNode,
        trim_left: bool,
        trim_right: bool,
    },
    Copied(SyntaxNode),
    Modified(ModifiedNode),
    Text(String),
}

Interface for modifying syntax nodes.

Variants

Trimmed

Fields

node: SyntaxNode

trim_left: bool

trim_right: bool

A rewrite node that represents a trimmed copy of a syntax node: one with the leading and trailing trivia excluded.

Copied(SyntaxNode)

Modified(ModifiedNode)

Text(String)

Implementations

impl RewriteNode

pub fn new_trimmed(syntax_node: SyntaxNode) -> Self

pub fn new_modified(children: Vec<RewriteNode>) -> Self

pub fn from_ast<T: TypedSyntaxNode>(node: &T) -> Self

Creates a rewrite node from an AST object.

pub fn modify(&mut self, db: &dyn SyntaxGroup) -> &mut ModifiedNode

Prepares a node for modification.

pub fn modify_child( &mut self, db: &dyn SyntaxGroup, index: usize ) -> &mut RewriteNode

Prepares a node for modification and returns a specific child.

pub fn set_str(&mut self, s: String)

Replaces this node with text.

pub fn interpolate_patched( code: &str, patches: UnorderedHashMap<String, RewriteNode> ) -> RewriteNode

Creates a new Rewrite node by interpolating a string with patches. Each substring of the form $<name>$ is replaced with syntax nodes from patches. A $$ substring is replaced with $.

Trait Implementations

impl Clone for RewriteNode

fn clone(&self) -> RewriteNode

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RewriteNode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<SyntaxNode> for RewriteNode

fn from(node: SyntaxNode) -> Self

Converts to this type from the input type.

impl PartialEq for RewriteNode

fn eq(&self, other: &RewriteNode) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for RewriteNode

impl StructuralEq for RewriteNode

impl StructuralPartialEq for RewriteNode