code-gauge 4.8.0 → 5.1.0

package/native/src/languages.rs

@@ -41,24 +41,24 @@ const GRAMMAR_COUNT: usize = GrammarId::Tsx as usize + 1;
 impl LanguageDefinition {
     pub fn grammar(&self) -> Language {
         match self.grammar_id {
-            GrammarId::C => tree_sitter_c::language(),
-            GrammarId::Cpp => tree_sitter_cpp::language(),
-            GrammarId::CSharp => tree_sitter_c_sharp::language(),
-            GrammarId::Go => tree_sitter_go::language(),
-            GrammarId::Java => tree_sitter_java::language(),
+            GrammarId::C => tree_sitter_c::LANGUAGE.into(),
+            GrammarId::Cpp => tree_sitter_cpp::LANGUAGE.into(),
+            GrammarId::CSharp => tree_sitter_c_sharp::LANGUAGE.into(),
+            GrammarId::Go => tree_sitter_go::LANGUAGE.into(),
+            GrammarId::Java => tree_sitter_java::LANGUAGE.into(),
             GrammarId::JavaScript => tree_sitter_javascript::LANGUAGE.into(),
             GrammarId::Kotlin => tree_sitter_kotlin::LANGUAGE.into(),
-            GrammarId::Python => tree_sitter_python::language(),
-            GrammarId::Ruby => tree_sitter_ruby::language(),
-            GrammarId::Rust => tree_sitter_rust::language(),
-            GrammarId::TypeScript => tree_sitter_typescript::language_typescript(),
-            GrammarId::Tsx => tree_sitter_typescript::language_tsx(),
+            GrammarId::Python => tree_sitter_python::LANGUAGE.into(),
+            GrammarId::Ruby => tree_sitter_ruby::LANGUAGE.into(),
+            GrammarId::Rust => tree_sitter_rust::LANGUAGE.into(),
+            GrammarId::TypeScript => tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into(),
+            GrammarId::Tsx => tree_sitter_typescript::LANGUAGE_TSX.into(),
         }
     }
 
     /// The grammar's node kind names, indexed by kind id.
-    pub fn kind_names(&self) -> &'static [&'static str] {
-        static KIND_NAMES: [OnceLock<Vec<&'static str>>; GRAMMAR_COUNT] =
+    pub fn kind_names(&self) -> &'static [String] {
+        static KIND_NAMES: [OnceLock<Vec<String>>; GRAMMAR_COUNT] =
             [const { OnceLock::new() }; GRAMMAR_COUNT];
         KIND_NAMES[self.grammar_id as usize].get_or_init(|| {
             let grammar = self.grammar();
@@ -68,6 +68,7 @@ impl LanguageDefinition {
                         .ok()
                         .and_then(|id| grammar.node_kind_for_id(id))
                         .unwrap_or_default()
+                        .to_string()
                 })
                 .collect()
         })
@@ -361,7 +362,6 @@ const PYTHON_NCSS_NODES: &[&str] = &[
     "for_statement",
     "while_statement",
     "except_clause",
-    "except_group_clause",
     "finally_clause",
     "with_statement",
     "match_statement",
@@ -595,6 +595,7 @@ const CSHARP_NCSS_NODES: &[&str] = &[
     "interface_declaration",
     "enum_declaration",
     "record_declaration",
+    "extension_declaration",
     "delegate_declaration",
     "field_declaration",
     "event_field_declaration",

package/native/src/measure.rs

@@ -16,7 +16,9 @@ use crate::tree_index::{NodeExt, TreeIndex};
 use crate::types::{
     CrossFileFileData, FunctionMetrics, HalsteadCounts, LineMetrics, NativeMetrics,
 };
-use crate::util::{all_children, is_js_whitespace, named_children, node_text, split_lines, Source};
+use crate::util::{
+    all_children, is_js_whitespace, is_token, named_children, node_text, split_lines, Source,
+};
 
 pub fn measure(
     code: &str,
@@ -274,11 +276,11 @@ fn collect_token_symbols(
     ) {
         return;
     }
-    if atomic_operand_node_types().contains(node.kind_name()) {
+    if is_atomic_operand(node) {
         symbols.push(hash_text(node.kind_name()));
         return;
     }
-    if node.child_count() != 0 {
+    if !is_token(node) {
         for child in all_children(node) {
             collect_token_symbols(child, code, symbols, id_index_by_name);
         }
@@ -584,8 +586,6 @@ const OPERAND_NODE_TYPES: &[&str] = &[
     "hex_floating_point_literal",
     "string",
     "string_literal",
-    // Go raw strings are leaves with no content child, unlike Rust/C++ `raw_string_literal`s.
-    "raw_string_literal",
     "verbatim_string_literal",
     "string_fragment",
     "multiline_string_fragment",
@@ -638,7 +638,7 @@ fn measure_halstead(root: Node<'_>, code: &Source<'_>) -> HalsteadCounts {
     let mut operands: FxHashMap<&str, u64> = FxHashMap::default();
 
     fn visit<'a>(
-        node: Node<'_>,
+        node: Node<'a>,
         code: &Source<'a>,
         operators: &mut FxHashMap<&'a str, u64>,
         operands: &mut FxHashMap<&'a str, u64>,
@@ -650,14 +650,14 @@ fn measure_halstead(root: Node<'_>, code: &Source<'_>) -> HalsteadCounts {
             return;
         }
 
-        if atomic_operand_node_types().contains(node.kind_name()) {
+        if is_atomic_operand(node) {
             *operands.entry(node_text(node, code)).or_insert(0) += 1;
             return;
         }
 
         // Operators are counted from leaf tokens only: keyword-named nodes always contain a
         // same-text anonymous keyword leaf, so counting the named node as well would double-count.
-        if node.child_count() == 0 {
+        if is_token(node) {
             let text = node_text(node, code);
             // Operands win over text matches so identifiers spelled like word operators stay operands;
             // C# `nameof(x)` is the one keyword operator the grammar parses as a plain callee.
@@ -694,6 +694,14 @@ fn measure_halstead(root: Node<'_>, code: &Source<'_>) -> HalsteadCounts {
     }
 }
 
+/// A literal counted as one operand without descending: ATOMIC_OPERAND_NODE_TYPES, or a Go raw
+/// string, which wraps its content like Go's interpreted strings (the Rust and C++
+/// `raw_string_literal`s count their content leaves instead).
+fn is_atomic_operand(node: Node<'_>) -> bool {
+    atomic_operand_node_types().contains(node.kind_name())
+        || (node.kind_name() == "raw_string_literal" && crate::tree_index::language_name() == "go")
+}
+
 /// tree-sitter-c-sharp parses `nameof(x)` as an invocation of an identifier named `nameof`.
 fn is_csharp_nameof_callee(node: Node<'_>, text: &str) -> bool {
     text == "nameof"

package/native/src/tree_index.rs

@@ -11,7 +11,7 @@ thread_local! {
     /// nodes; TreeIndex borrows the tree and clears the map on drop, so no entry outlives it.
     static PARENTS: RefCell<FxHashMap<usize, Node<'static>>> = RefCell::new(FxHashMap::default());
     /// Node kind names of the indexed tree's language, indexed by kind id.
-    static KIND_NAMES: Cell<&'static [&'static str]> = const { Cell::new(&[]) };
+    static KIND_NAMES: Cell<&'static [String]> = const { Cell::new(&[]) };
     /// Name of the indexed tree's language.
     static LANGUAGE_NAME: Cell<&'static str> = const { Cell::new("") };
 }
@@ -87,7 +87,7 @@ pub trait NodeExt<'t> {
     /// `Node::parent`, answered from the TreeIndex when one is installed.
     fn parent_node(self) -> Option<Node<'t>>;
     /// `Node::kind`, answered from the TreeIndex when one is installed.
-    fn kind_name(self) -> &'static str;
+    fn kind_name(self) -> &'t str;
 }
 
 impl<'t> NodeExt<'t> for Node<'t> {
@@ -109,11 +109,11 @@ impl<'t> NodeExt<'t> for Node<'t> {
             .or_else(|| self.parent())
     }
 
-    fn kind_name(self) -> &'static str {
+    fn kind_name(self) -> &'t str {
         KIND_NAMES
             .get()
             .get(usize::from(self.kind_id()))
-            .copied()
+            .map(String::as_str)
             .unwrap_or_else(|| self.kind())
     }
 }

package/native/src/util.rs

@@ -61,6 +61,13 @@ pub fn is_kotlin_keyword_literal(node: Node<'_>, code: &Source<'_>) -> bool {
         && matches!(node_text(node, code), "true" | "false" | "null")
 }
 
+/// Whether the node stands for one source token. C# spells a contextual keyword used as a name
+/// (`type`, `field`, `alias`) as an `identifier` or `implicit_parameter` wrapping the keyword token,
+/// which still names a variable like any other identifier.
+pub fn is_token(node: Node<'_>) -> bool {
+    node.child_count() == 0 || matches!(node.kind_name(), "identifier" | "implicit_parameter")
+}
+
 pub fn named_children<'t>(node: Node<'t>) -> Vec<Node<'t>> {
     let mut cursor = node.walk();
     node.named_children(&mut cursor).collect()
@@ -77,13 +84,13 @@ pub fn all_children<'t>(node: Node<'t>) -> Vec<Node<'t>> {
 /// them), which would desynchronize field-based extraction on malformed source.
 pub fn find_children_by_field_name<'t>(node: Node<'t>, field_name: &str) -> Vec<Node<'t>> {
     let mut children = Vec::new();
-    let mut preceding_structural_field: Option<&'static str> = None;
+    let mut preceding_structural_field = None;
     for index in 0..node.child_count() {
         if let Some(child) = node.child(index) {
             let field = if child.is_extra() {
                 preceding_structural_field
             } else {
-                let field = node.field_name_for_child(index as u32);
+                let field = node.field_name_for_child(index);
                 preceding_structural_field = field;
                 field
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-gauge",
-  "version": "4.8.0",
+  "version": "5.1.0",
   "description": "Measure code metrics with tree-sitter.",
   "keywords": [
     "cli",
@@ -62,6 +62,7 @@
     "verify-full": "bun wb verify --full"
   },
   "dependencies": {
+    "@willbooster/shared-lib": "10.18.0",
     "commander": "15.0.0"
   },
   "devDependencies": {
@@ -94,12 +95,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "optionalDependencies": {
-    "code-gauge-linux-x64-gnu": "4.8.0",
-    "code-gauge-linux-arm64-gnu": "4.8.0",
-    "code-gauge-linux-x64-musl": "4.8.0",
-    "code-gauge-linux-arm64-musl": "4.8.0",
-    "code-gauge-darwin-x64": "4.8.0",
-    "code-gauge-darwin-arm64": "4.8.0",
-    "code-gauge-win32-x64-msvc": "4.8.0"
+    "code-gauge-linux-x64-gnu": "5.1.0",
+    "code-gauge-linux-arm64-gnu": "5.1.0",
+    "code-gauge-linux-x64-musl": "5.1.0",
+    "code-gauge-linux-arm64-musl": "5.1.0",
+    "code-gauge-darwin-x64": "5.1.0",
+    "code-gauge-darwin-arm64": "5.1.0",
+    "code-gauge-win32-x64-msvc": "5.1.0"
   }
 }