Struct AstRoot 

pub struct AstRoot<D>
where
    D: Doc,
{ /* private fields */ }

Root of an AST tree that owns the source code and parsed tree structure.

Root acts as the entry point for all AST operations. It manages the document (source code + parsed tree) and provides methods to get the root node and perform tree-wide operations like replacements.

Generic Parameters

• D: Doc - The document type that holds source code and language information

Example

let mut ast = Language::Tsx.ast_grep("let x = 42;");
let root_node = ast.root();

// Perform tree-wide replacements
ast.replace("let $VAR = $VALUE", "const $VAR = $VALUE");
println!("{}", ast.generate());

Implementations

impl<D> Root<D>

where D: Doc,

pub const fn doc(doc: D) -> Root<D>

pub fn lang(&self) -> &<D as Doc>::Lang

pub fn root(&self) -> Node<'_, D>

The root node represents the entire source

pub fn edit( &mut self, edit: &Edit<<D as Doc>::Source>, ) -> Result<&mut Root<D>, String>

pub fn replace<M, R>(&mut self, pattern: M, replacer: R) -> Result<bool, String>

where M: Matcher, R: Replacer<D>,

pub fn adopt<'r>(&'r self, inner: <D as Doc>::Node<'r>) -> Node<'r, D>

Adopt the tree_sitter as the descendant of the root and return the wrapped sg Node. It assumes inner is under the root and will panic at dev build if wrong node is used.

impl<L> Root<StrDoc<L>>

where L: LanguageExt,

pub fn new<S>(src: S, lang: L) -> Root<StrDoc<L>>

where S: AsRef<str>,

pub fn source(&self) -> &str

pub fn generate(self) -> String

impl<L> Root<StrDoc<L>>

where L: LanguageExt,

pub fn str(src: &str, lang: L) -> Root<StrDoc<L>>

pub fn try_new(src: &str, lang: L) -> Result<Root<StrDoc<L>>, String>

pub fn get_text(&self) -> &str

pub fn get_injections<F>(&self, get_lang: F) -> Vec<Root<StrDoc<L>>>

where F: Fn(&str) -> Option<L>,

Trait Implementations

impl<D> Clone for Root<D>

where D: Clone + Doc,

fn clone(&self) -> Root<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D> Debug for Root<D>

where D: Debug + Doc,

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

Formats the value using the given formatter.

impl<D> Replacer<D> for Root<D>

where D: Doc,

fn generate_replacement( &self, nm: &NodeMatch<'_, D>, ) -> Vec<<<D as Doc>::Source as Content>::Underlying>

Generate replacement content for a matched node.

fn get_replaced_range( &self, nm: &NodeMatch<'_, D>, matcher: impl Matcher, ) -> Range<usize>

Determine the exact range of source code to replace.