fix: try use new wasm lang

Author: HerringtonDarkholme

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "ast-grep-wasm"
-version = "0.26.3"
+version = "0.38.0"
 authors = ["HerringtonDarkholme <2883231+HerringtonDarkholme@users.noreply.github.com>"]
 edition = "2018"
 description = "Search and Rewrite code at large scale using precise AST pattern"
@@ -28,11 +28,9 @@ console_error_panic_hook = { version = "0.1.7", optional = true }
 
 once_cell = "1.19.0"
 wee_alloc = { version = "0.4.5" }
-ast-grep-core = { version = "0.36.3" }
-ast-grep-config = { version = "0.36.3" }
-ast-grep-language = { version = "0.36.3", default-features = false }
+ast-grep-core = { version = "0.38.1", default-features = false }
+ast-grep-config = { version = "0.38.1", default-features = false }
 web-tree-sitter-sg = "0.24.4"
-tree-sitter = { version = "0.24.5", package = "tree-sitter-facade-sg" }
 serde-wasm-bindgen = "0.6"
 serde_json = "1.0.116"
 

Cargo.toml

@@ -1,16 +1,15 @@
 use serde::{Deserialize, Serialize};
-use tree_sitter as ts;
-use crate::wasm_lang::WasmLang;
+use crate::wasm_lang::{WasmDoc, WasmLang};
 use ast_grep_core::{
-  Language, Pattern, Node, StrDoc,
-  matcher::PatternNode
+  matcher::PatternNode, AstGrep, Language, Node, Pattern
 };
 use wasm_bindgen::prelude::JsError;
+use web_tree_sitter_sg::{Point, TreeCursor};
 
 #[derive(Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct DumpNode {
-  id: usize,
+  id: u32,
   field: Option<String>,
   kind: String,
   start: Pos,
@@ -26,26 +25,25 @@ pub struct Pos {
   column: u32,
 }
 
-impl From<ts::Point> for Pos {
-  #[inline]
-  fn from(pt: ts::Point) -> Self {
-    Pos {
-      row: pt.row(),
-      column: pt.column(),
+impl From<Point> for Pos {
+  fn from(point: Point) -> Self {
+    Self {
+      row: point.row(),
+      column: point.column(),
     }
   }
 }
 
-pub fn dump_one_node(cursor: &mut ts::TreeCursor, target: &mut Vec<DumpNode>) {
-  let node = cursor.node();
+pub fn dump_one_node(cursor: &mut TreeCursor, target: &mut Vec<DumpNode>) {
+  let node = cursor.current_node();
   let kind = if node.is_missing() {
-    format!("MISSING {}", node.kind())
+    format!("MISSING {}", node.type_())
   } else {
-    node.kind().to_string()
+    format!("{}", node.type_())
   };
   let start = node.start_position().into();
   let end = node.end_position().into();
-  let field = cursor.field_name().map(|c| c.to_string());
+  let field = cursor.current_field_name().map(|c| format!("{}", c));
   let mut children = vec![];
   if cursor.goto_first_child() {
     dump_nodes(cursor, &mut children);
@@ -62,7 +60,7 @@ pub fn dump_one_node(cursor: &mut ts::TreeCursor, target: &mut Vec<DumpNode>) {
   })
 }
 
-fn dump_nodes(cursor: &mut ts::TreeCursor, target: &mut Vec<DumpNode>) {
+fn dump_nodes(cursor: &mut TreeCursor, target: &mut Vec<DumpNode>) {
   loop {
     dump_one_node(cursor, target);
     if !cursor.goto_next_sibling() {
@@ -74,7 +72,8 @@ fn dump_nodes(cursor: &mut ts::TreeCursor, target: &mut Vec<DumpNode>) {
 pub fn dump_pattern(query: String, selector: Option<String>) -> Result<PatternTree, JsError> {
   let lang = WasmLang::get_current();
   let processed = lang.pre_process_pattern(&query);
-  let root = lang.ast_grep(processed);
+  let doc = WasmDoc::try_new(processed.to_string(), lang)?;
+  let root = AstGrep::doc(doc);
   let pattern = if let Some(sel) = selector {
     Pattern::contextual(&query, &sel, lang)?
   } else {
@@ -85,12 +84,12 @@ pub fn dump_pattern(query: String, selector: Option<String>) -> Result<PatternTr
   Ok(ret)
 }
 
-fn dump_pattern_tree(node: Node<StrDoc<WasmLang>>, node_id: usize, pattern: &PatternNode) -> PatternTree {
+fn dump_pattern_tree(node: Node<WasmDoc>, node_id: usize, pattern: &PatternNode) -> PatternTree {
   if node.node_id() == node_id {
     return dump_pattern_impl(node, pattern)
   }
   let children: Vec<_> = node.children().map(|n| dump_pattern_tree(n, node_id, pattern)).collect();
-  let ts = node.get_ts_node();
+  let ts = node.get_inner_node().0;
   let text = if children.is_empty() {
     Some(node.text().into())
   } else {
@@ -112,9 +111,9 @@ fn dump_pattern_tree(node: Node<StrDoc<WasmLang>>, node_id: usize, pattern: &Pat
   }
 }
 
-fn dump_pattern_impl(node: Node<StrDoc<WasmLang>>, pattern: &PatternNode) -> PatternTree {
+fn dump_pattern_impl(node: Node<WasmDoc>, pattern: &PatternNode) -> PatternTree {
   use PatternNode as PN;
-  let ts = node.get_ts_node();
+  let ts = node.get_inner_node().0;
   let kind =  if ts.is_missing() {
     format!("MISSING {}", node.kind())
   } else {

src/dump_tree.rs

@@ -11,7 +11,7 @@ use ast_grep_core::{AstGrep, Node as SgNode};
 use serde_wasm_bindgen::from_value as from_js_val;
 use std::collections::HashMap;
 use std::error::Error;
-use tree_sitter as ts;
+use web_tree_sitter_sg::TreeSitter;
 use wasm_bindgen::prelude::*;
 
 type Node<'a> = SgNode<'a, WasmDoc>;
@@ -21,7 +21,7 @@ static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
 
 #[wasm_bindgen(js_name = initializeTreeSitter)]
 pub async fn initialize_tree_sitter() -> Result<(), JsError> {
-  ts::TreeSitter::init().await
+  TreeSitter::init().await
 }
 
 #[wasm_bindgen(js_name = setupParser)]
@@ -38,7 +38,7 @@ pub fn find_nodes(src: String, configs: Vec<JsValue>) -> Result<JsValue, JsError
     rules.push(finder);
   }
   let combined = CombinedScan::new(rules.iter().collect());
-  let doc = WasmDoc::new(src.clone(), lang);
+  let doc = WasmDoc::try_new(src.clone(), lang)?;
   let root = AstGrep::doc(doc);
   let ret: HashMap<_, _> = combined.scan(&root, false).matches.into_iter().map(|(rule, matches)| {
     let matches: Vec<_> = matches.into_iter().map(|m| {
@@ -59,7 +59,7 @@ pub fn fix_errors(src: String, configs: Vec<JsValue>) -> Result<String, JsError>
     rules.push(finder);
   }
   let combined = CombinedScan::new(rules.iter().collect());
-  let doc = WasmDoc::new(src.clone(), lang);
+  let doc = WasmDoc::try_new(src.clone(), lang)?;
   let root = AstGrep::doc(doc);
   let diffs = combined.scan(&root, true).diffs;
   if diffs.is_empty() {
@@ -85,7 +85,7 @@ pub fn fix_errors(src: String, configs: Vec<JsValue>) -> Result<String, JsError>
 }
 
 fn convert_to_debug_node(n: Node) -> DumpNode {
-  let mut cursor = n.get_ts_node().walk();
+  let mut cursor = n.get_inner_node().0.walk();
   let mut target = vec![];
   dump_one_node(&mut cursor, &mut target);
   target.pop().expect_throw("found empty node")
@@ -94,7 +94,7 @@ fn convert_to_debug_node(n: Node) -> DumpNode {
 #[wasm_bindgen(js_name = dumpASTNodes)]
 pub fn dump_ast_nodes(src: String) -> Result<JsValue, JsError> {
   let lang = WasmLang::get_current();
-  let doc = WasmDoc::new(src, lang);
+  let doc = WasmDoc::try_new(src, lang)?;
   let root = AstGrep::doc(doc);
   let debug_node = convert_to_debug_node(root.root());
   let ret = serde_wasm_bindgen::to_value(&debug_node)?;