feat(KindMatcher): Support supertypes

mohebifar · mohebifar · commit d17149232cc5 · 2025-03-13T13:08:03.000-07:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -33,7 +33,7 @@ ignore = { version = "0.4.22" }
 regex = { version = "1.10.4" }
 serde = { version = "1.0.200", features = ["derive"] }
 serde_yaml = "0.9.33"
-tree-sitter = { version = "0.24.4" }
+tree-sitter = { version = "0.25.3" }
 thiserror = "2.0.0"
 schemars = "0.8.17"
 anyhow = "1.0.82"
diff --git a/crates/core/src/matcher/kind.rs b/crates/core/src/matcher/kind.rs
@@ -24,16 +24,30 @@ pub enum KindMatcherError {
 
 #[derive(Clone)]
 pub struct KindMatcher<L: Language> {
-  kind: KindId,
+  subtypes: BitSet,
   lang: PhantomData<L>,
 }
 
 impl<L: Language> KindMatcher<L> {
   pub fn new(node_kind: &str, lang: L) -> Self {
-    Self {
-      kind: lang
+    let mut subtypes = BitSet::new();
+    let kind_id = lang
+      .get_ts_language()
+      .id_for_node_kind(node_kind, /*named*/ true);
+    if lang.get_ts_language().node_kind_is_supertype(kind_id) {
+      lang
         .get_ts_language()
-        .id_for_node_kind(node_kind, /*named*/ true),
+        .subtypes_for_supertype(kind_id)
+        .iter()
+        .for_each(|subtype| {
+          subtypes.insert((*subtype).into());
+        });
+    } else {
+      subtypes.insert(kind_id.into());
+    }
+
+    Self {
+      subtypes,
       lang: PhantomData,
     }
   }
@@ -48,15 +62,17 @@ impl<L: Language> KindMatcher<L> {
   }
 
   pub fn from_id(kind: KindId) -> Self {
+    let mut subtypes = BitSet::new();
+    subtypes.insert(kind.into());
     Self {
-      kind,
+      subtypes,
       lang: PhantomData,
     }
   }
 
   /// Whether the kind matcher contains undefined tree-sitter kind.
   pub fn is_invalid(&self) -> bool {
-    self.kind == TS_BUILTIN_SYM_END
+    self.subtypes.contains(TS_BUILTIN_SYM_END.into())
   }
 
   /// Construct a matcher that only matches ERROR
@@ -87,17 +103,15 @@ impl<L: Language> Matcher<L> for KindMatcher<L> {
     node: Node<'tree, D>,
     _env: &mut Cow<MetaVarEnv<'tree, D>>,
   ) -> Option<Node<'tree, D>> {
-    if node.kind_id() == self.kind {
+    if self.subtypes.contains(node.kind_id().into()) {
       Some(node)
     } else {
       None
     }
   }
 
   fn potential_kinds(&self) -> Option<BitSet> {
-    let mut set = BitSet::new();
-    set.insert(self.kind.into());
-    Some(set)
+    Some(self.subtypes.clone())
   }
 }
 
@@ -138,6 +152,20 @@ mod test {
     );
   }
 
+  #[test]
+  fn test_supertype_match() {
+    let supertype_kind = "declaration";
+    let cand = pattern_node("class A { a = 123 }");
+    let cand = cand.root();
+    let pattern = KindMatcher::new(supertype_kind, Tsx);
+    assert!(
+      pattern.find_node(cand.clone()).is_some(),
+      "goal: {}, candidate: {}",
+      supertype_kind,
+      cand.to_sexp(),
+    );
+  }
+
   #[test]
   fn test_kind_potential_kinds() {
     let kind = "field_definition";
diff --git a/crates/dynamic/src/lib.rs b/crates/dynamic/src/lib.rs
@@ -126,7 +126,7 @@ unsafe fn load_ts_language(
     .get(name.as_bytes())
     .map_err(DynamicLangError::ReadSymbol)?;
   let lang = func();
-  let version = lang.version();
+  let version = lang.abi_version();
   if !(MIN_COMPATIBLE_LANGUAGE_VERSION..=LANGUAGE_VERSION).contains(&version) {
     Err(DynamicLangError::IncompatibleVersion(version))
   } else {
diff --git a/crates/napi/src/doc.rs b/crates/napi/src/doc.rs
@@ -56,7 +56,7 @@ pub struct Wrapper {
 impl Content for Wrapper {
   type Underlying = u16;
   fn parse_tree_sitter(&self, parser: &mut Parser, tree: Option<&Tree>) -> Option<Tree> {
-    parser.parse_utf16(self.inner.as_slice(), tree)
+    parser.parse_utf16_le(self.inner.as_slice(), tree)
   }
   fn get_range(&self, range: Range<usize>) -> &[Self::Underlying] {
     // the range is in byte offset, but our underlying is u16

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ pub struct Wrapper {`
`56`	`56`	`impl Content for Wrapper {`
`57`	`57`	`type Underlying = u16;`
`58`	`58`	`fn parse_tree_sitter(&self, parser: &mut Parser, tree: Option<&Tree>) -> Option<Tree> {`
`59`		`- parser.parse_utf16(self.inner.as_slice(), tree)`
	`59`	`+ parser.parse_utf16_le(self.inner.as_slice(), tree)`
`60`	`60`	`}`
`61`	`61`	`fn get_range(&self, range: Range<usize>) -> &[Self::Underlying] {`
`62`	`62`	`// the range is in byte offset, but our underlying is u16`