Enum RewriteNode

pub enum RewriteNode {
    Trimmed {
        node: SyntaxNode,
        trim_left: bool,
        trim_right: bool,
    },
    Copied(SyntaxNode),
    Modified(ModifiedNode),
    Mapped {
        origin: TextSpan,
        node: Box<RewriteNode>,
    },
    Text(String),
    TextAndMapping(String, Vec<CodeMapping>),
}

Interface for modifying syntax nodes.

Variants

Trimmed

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

Fields

node: SyntaxNode

trim_left: bool

trim_right: bool

Copied(SyntaxNode)

Modified(ModifiedNode)

Mapped

Fields

origin: TextSpan

node: Box<RewriteNode>

Text(String)

TextAndMapping(String, Vec<CodeMapping>)

Implementations

impl RewriteNode

pub fn new_trimmed(syntax_node: SyntaxNode) -> Self

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

pub fn text(text: &str) -> Self

pub fn mapped_text( text: impl Into<String>, db: &dyn SyntaxGroup, origin: &impl TypedSyntaxNode, ) -> Self

pub fn empty() -> 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 $.

pub fn interspersed( children: impl IntoIterator<Item = RewriteNode>, separator: RewriteNode, ) -> RewriteNode

Creates a new Rewrite node by inserting a separator between each two given children.

pub fn mapped(self, db: &dyn SyntaxGroup, origin: &impl TypedSyntaxNode) -> Self

Creates a new rewrite node wrapped in a mapping to the original code.

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 Default for RewriteNode

fn default() -> Self

Returns the “default value” for a type.

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for RewriteNode

impl StructuralPartialEq for RewriteNode