code-gauge 3.0.0 → 4.0.0

package/native/src/languages.rs

@@ -0,0 +1,647 @@
+use tree_sitter::Language;
+
+/// Per-language node-type configuration mirroring src/languages.ts.
+pub struct LanguageDefinition {
+    pub name: &'static str,
+    pub aliases: &'static [&'static str],
+    grammar_id: GrammarId,
+    pub function_node_types: &'static [&'static str],
+    pub decision_node_types: &'static [&'static str],
+    pub nesting_node_types: &'static [&'static str],
+    pub ncss_node_types: &'static [&'static str],
+    pub ncss_container_node_types: &'static [&'static str],
+}
+
+#[derive(Clone, Copy)]
+enum GrammarId {
+    C,
+    Cpp,
+    Go,
+    Java,
+    JavaScript,
+    Python,
+    Ruby,
+    Rust,
+    TypeScript,
+    Tsx,
+}
+
+impl LanguageDefinition {
+    pub fn grammar(&self) -> Language {
+        match self.grammar_id {
+            GrammarId::C => tree_sitter_c::language(),
+            GrammarId::Cpp => tree_sitter_cpp::language(),
+            GrammarId::Go => tree_sitter_go::language(),
+            GrammarId::Java => tree_sitter_java::language(),
+            GrammarId::JavaScript => tree_sitter_javascript::language(),
+            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(),
+        }
+    }
+}
+
+const COMMON_FUNCTION_NODES: &[&str] = &[
+    "function",
+    "function_declaration",
+    "function_definition",
+    "function_expression",
+    "function_item",
+    "function_signature_item",
+    "function_declarator",
+    "func_literal",
+    "method_declaration",
+    "method_definition",
+    "method_spec",
+    "arrow_function",
+    "generator_function",
+    "generator_function_declaration",
+    "lambda",
+    "lambda_expression",
+    "closure_expression",
+];
+
+const COMMON_DECISION_NODES: &[&str] = &[
+    "if_statement",
+    "elif_clause",
+    "else_if_clause",
+    "for_statement",
+    "for_in_statement",
+    "while_statement",
+    "do_statement",
+    "catch_clause",
+    "except_clause",
+    "case_clause",
+    "switch_case",
+    "match_arm",
+    "conditional_expression",
+    "ternary_expression",
+    "if_expression",
+    "while_expression",
+    "for_expression",
+    "loop_expression",
+];
+
+const GO_DECISION_NODES: &[&str] = &[
+    "if_statement",
+    "elif_clause",
+    "else_if_clause",
+    "for_statement",
+    "for_in_statement",
+    "while_statement",
+    "do_statement",
+    "catch_clause",
+    "except_clause",
+    "case_clause",
+    "switch_case",
+    "match_arm",
+    "conditional_expression",
+    "ternary_expression",
+    "if_expression",
+    "while_expression",
+    "for_expression",
+    "loop_expression",
+    "expression_case",
+    "type_case",
+    "communication_case",
+];
+
+// Default switch branches add no decision, but their contents are nested inside the switch like
+// any other arm, so they appear in the nesting sets only.
+const COMMON_NESTING_NODES: &[&str] = &[
+    "if_statement",
+    "elif_clause",
+    "else_if_clause",
+    "for_statement",
+    "for_in_statement",
+    "while_statement",
+    "do_statement",
+    "catch_clause",
+    "except_clause",
+    "case_clause",
+    "switch_case",
+    "match_arm",
+    "conditional_expression",
+    "ternary_expression",
+    "if_expression",
+    "while_expression",
+    "for_expression",
+    "loop_expression",
+    "switch_default",
+];
+const GO_NESTING_NODES: &[&str] = &[
+    "if_statement",
+    "elif_clause",
+    "else_if_clause",
+    "for_statement",
+    "for_in_statement",
+    "while_statement",
+    "do_statement",
+    "catch_clause",
+    "except_clause",
+    "case_clause",
+    "switch_case",
+    "match_arm",
+    "conditional_expression",
+    "ternary_expression",
+    "if_expression",
+    "while_expression",
+    "for_expression",
+    "loop_expression",
+    "expression_case",
+    "type_case",
+    "communication_case",
+    "default_case",
+];
+
+const JAVA_FUNCTION_NODES: &[&str] = &[
+    "function",
+    "function_declaration",
+    "function_definition",
+    "function_expression",
+    "function_item",
+    "function_signature_item",
+    "function_declarator",
+    "func_literal",
+    "method_declaration",
+    "method_definition",
+    "method_spec",
+    "arrow_function",
+    "generator_function",
+    "generator_function_declaration",
+    "lambda",
+    "lambda_expression",
+    "closure_expression",
+    "constructor_declaration",
+    "compact_constructor_declaration",
+];
+
+const JAVA_DECISION_NODES: &[&str] = &[
+    "if_statement",
+    "elif_clause",
+    "else_if_clause",
+    "for_statement",
+    "for_in_statement",
+    "while_statement",
+    "do_statement",
+    "catch_clause",
+    "except_clause",
+    "case_clause",
+    "switch_case",
+    "match_arm",
+    "conditional_expression",
+    "ternary_expression",
+    "if_expression",
+    "while_expression",
+    "for_expression",
+    "loop_expression",
+    "enhanced_for_statement",
+    "switch_block_statement_group",
+    "switch_rule",
+];
+
+const RUBY_FUNCTION_NODES: &[&str] = &["method", "singleton_method", "lambda", "block", "do_block"];
+const RUBY_DECISION_NODES: &[&str] = &[
+    "if",
+    "elsif",
+    "unless",
+    "while",
+    "until",
+    "for",
+    "when",
+    "in_clause",
+    "rescue",
+    "conditional",
+    "if_modifier",
+    "unless_modifier",
+    "while_modifier",
+    "until_modifier",
+    "rescue_modifier",
+];
+
+const C_FUNCTION_NODES: &[&str] = &["function_definition", "lambda_expression"];
+const C_DECISION_NODES: &[&str] = &[
+    "if_statement",
+    "elif_clause",
+    "else_if_clause",
+    "for_statement",
+    "for_in_statement",
+    "while_statement",
+    "do_statement",
+    "catch_clause",
+    "except_clause",
+    "case_clause",
+    "switch_case",
+    "match_arm",
+    "conditional_expression",
+    "ternary_expression",
+    "if_expression",
+    "while_expression",
+    "for_expression",
+    "loop_expression",
+    "case_statement",
+];
+const CPP_DECISION_NODES: &[&str] = &[
+    "if_statement",
+    "elif_clause",
+    "else_if_clause",
+    "for_statement",
+    "for_in_statement",
+    "while_statement",
+    "do_statement",
+    "catch_clause",
+    "except_clause",
+    "case_clause",
+    "switch_case",
+    "match_arm",
+    "conditional_expression",
+    "ternary_expression",
+    "if_expression",
+    "while_expression",
+    "for_expression",
+    "loop_expression",
+    "case_statement",
+    "for_range_loop",
+];
+
+// NCSS node sets: every listed type counts as one non-commenting source statement. The Java set is
+// calibrated against PMD's NcssCount rule; see src/languages.ts.
+const JS_NCSS_NODES: &[&str] = &[
+    "import_statement",
+    "export_statement",
+    "lexical_declaration",
+    "variable_declaration",
+    "function_declaration",
+    "function_signature",
+    "generator_function_declaration",
+    "class_declaration",
+    "abstract_class_declaration",
+    "module",
+    "method_definition",
+    "abstract_method_signature",
+    "class_static_block",
+    "field_definition",
+    "public_field_definition",
+    "type_alias_declaration",
+    "interface_declaration",
+    "enum_declaration",
+    "expression_statement",
+    "if_statement",
+    "else_clause",
+    "switch_statement",
+    "switch_case",
+    "switch_default",
+    "for_statement",
+    "for_in_statement",
+    "while_statement",
+    "do_statement",
+    "catch_clause",
+    "finally_clause",
+    "labeled_statement",
+    "return_statement",
+    "break_statement",
+    "continue_statement",
+    "throw_statement",
+    "debugger_statement",
+    "with_statement",
+];
+
+const PYTHON_NCSS_NODES: &[&str] = &[
+    "import_statement",
+    "import_from_statement",
+    "future_import_statement",
+    "print_statement",
+    "exec_statement",
+    "assert_statement",
+    "expression_statement",
+    "return_statement",
+    "delete_statement",
+    "raise_statement",
+    "pass_statement",
+    "break_statement",
+    "continue_statement",
+    "global_statement",
+    "nonlocal_statement",
+    "if_statement",
+    "elif_clause",
+    "else_clause",
+    "for_statement",
+    "while_statement",
+    "except_clause",
+    "except_group_clause",
+    "finally_clause",
+    "with_statement",
+    "match_statement",
+    "case_clause",
+    "function_definition",
+    "class_definition",
+    "type_alias_statement",
+];
+
+const GO_NCSS_NODES: &[&str] = &[
+    "package_clause",
+    "import_spec",
+    "type_spec",
+    "type_alias",
+    "const_spec",
+    "var_spec",
+    "function_declaration",
+    "method_declaration",
+    // Struct fields and interface members count contextually (see ncss.rs): only inside a named
+    // `type T struct/interface { ... }`, not in inline anonymous types, which are part of one
+    // declaration.
+    "short_var_declaration",
+    "expression_statement",
+    "send_statement",
+    "inc_statement",
+    "dec_statement",
+    "assignment_statement",
+    "if_statement",
+    "for_statement",
+    "expression_switch_statement",
+    "type_switch_statement",
+    "select_statement",
+    "expression_case",
+    "type_case",
+    "communication_case",
+    "default_case",
+    "return_statement",
+    "break_statement",
+    "continue_statement",
+    "goto_statement",
+    "fallthrough_statement",
+    "defer_statement",
+    "go_statement",
+    "labeled_statement",
+];
+
+const RUST_NCSS_NODES: &[&str] = &[
+    "use_declaration",
+    "extern_crate_declaration",
+    "foreign_mod_item",
+    "mod_item",
+    "const_item",
+    "static_item",
+    "struct_item",
+    "enum_item",
+    "union_item",
+    "trait_item",
+    "impl_item",
+    "function_item",
+    "function_signature_item",
+    "type_item",
+    "associated_type",
+    "macro_definition",
+    "field_declaration",
+    "let_declaration",
+    "expression_statement",
+    "else_clause",
+    "match_arm",
+];
+// `else_clause` is a container so `else if` chains count the nested if_expression; a plain
+// `else { ... }` is unaffected because its only child is a `block`, itself a container.
+const RUST_NCSS_CONTAINERS: &[&str] = &["block", "else_clause"];
+
+const JAVA_NCSS_NODES: &[&str] = &[
+    "package_declaration",
+    "import_declaration",
+    "module_declaration",
+    "requires_module_directive",
+    "exports_module_directive",
+    "opens_module_directive",
+    "uses_module_directive",
+    "provides_module_directive",
+    "class_declaration",
+    "interface_declaration",
+    "enum_declaration",
+    "annotation_type_declaration",
+    "annotation_type_element_declaration",
+    "record_declaration",
+    "field_declaration",
+    "constant_declaration",
+    "method_declaration",
+    "constructor_declaration",
+    "compact_constructor_declaration",
+    "static_initializer",
+    "explicit_constructor_invocation",
+    "local_variable_declaration",
+    "expression_statement",
+    "if_statement",
+    "while_statement",
+    "do_statement",
+    "for_statement",
+    "enhanced_for_statement",
+    "switch_statement",
+    "switch_expression",
+    "switch_label",
+    "break_statement",
+    "continue_statement",
+    "return_statement",
+    "throw_statement",
+    "assert_statement",
+    "synchronized_statement",
+    "labeled_statement",
+    "yield_statement",
+    "resource",
+    "catch_clause",
+    "finally_clause",
+];
+
+// Ruby statements have no wrapper node types, so bodies are counted positionally (see
+// ncss_container_node_types); only clause nodes hanging off non-container parents need listing.
+const RUBY_NCSS_NODES: &[&str] = &["elsif", "else", "when", "in_clause", "rescue", "ensure"];
+const RUBY_NCSS_CONTAINERS: &[&str] = &[
+    "program",
+    "body_statement",
+    "then",
+    "else",
+    "do",
+    "block_body",
+    "begin",
+    "ensure",
+];
+
+const C_NCSS_NODES: &[&str] = &[
+    "preproc_include",
+    "preproc_def",
+    "preproc_function_def",
+    "declaration",
+    "type_definition",
+    "field_declaration",
+    "function_definition",
+    // Counted only when they carry a body (see BODYLESS_NCSS_SPECIFIER_TYPES in ncss.rs).
+    "struct_specifier",
+    "enum_specifier",
+    "union_specifier",
+    "expression_statement",
+    "if_statement",
+    "else_clause",
+    "switch_statement",
+    "case_statement",
+    "for_statement",
+    "while_statement",
+    "do_statement",
+    "return_statement",
+    "break_statement",
+    "continue_statement",
+    "goto_statement",
+    "labeled_statement",
+];
+const CPP_NCSS_NODES: &[&str] = &[
+    "preproc_include",
+    "preproc_def",
+    "preproc_function_def",
+    "declaration",
+    "type_definition",
+    "field_declaration",
+    "function_definition",
+    "struct_specifier",
+    "enum_specifier",
+    "union_specifier",
+    "expression_statement",
+    "if_statement",
+    "else_clause",
+    "switch_statement",
+    "case_statement",
+    "for_statement",
+    "while_statement",
+    "do_statement",
+    "return_statement",
+    "break_statement",
+    "continue_statement",
+    "goto_statement",
+    "labeled_statement",
+    "class_specifier",
+    "namespace_definition",
+    "using_declaration",
+    "alias_declaration",
+    "namespace_alias_definition",
+    "concept_definition",
+    "static_assert_declaration",
+    "for_range_loop",
+    "catch_clause",
+    "throw_statement",
+    "co_return_statement",
+    "co_yield_statement",
+];
+
+pub const LANGUAGES: &[LanguageDefinition] = &[
+    LanguageDefinition {
+        name: "javascript",
+        aliases: &["js", "mjs", "cjs"],
+        grammar_id: GrammarId::JavaScript,
+        function_node_types: COMMON_FUNCTION_NODES,
+        decision_node_types: COMMON_DECISION_NODES,
+        nesting_node_types: COMMON_NESTING_NODES,
+        ncss_node_types: JS_NCSS_NODES,
+        ncss_container_node_types: &[],
+    },
+    LanguageDefinition {
+        name: "jsx",
+        aliases: &[],
+        grammar_id: GrammarId::JavaScript,
+        function_node_types: COMMON_FUNCTION_NODES,
+        decision_node_types: COMMON_DECISION_NODES,
+        nesting_node_types: COMMON_NESTING_NODES,
+        ncss_node_types: JS_NCSS_NODES,
+        ncss_container_node_types: &[],
+    },
+    LanguageDefinition {
+        name: "typescript",
+        aliases: &["ts"],
+        grammar_id: GrammarId::TypeScript,
+        function_node_types: COMMON_FUNCTION_NODES,
+        decision_node_types: COMMON_DECISION_NODES,
+        nesting_node_types: COMMON_NESTING_NODES,
+        ncss_node_types: JS_NCSS_NODES,
+        ncss_container_node_types: &[],
+    },
+    LanguageDefinition {
+        name: "tsx",
+        aliases: &[],
+        grammar_id: GrammarId::Tsx,
+        function_node_types: COMMON_FUNCTION_NODES,
+        decision_node_types: COMMON_DECISION_NODES,
+        nesting_node_types: COMMON_NESTING_NODES,
+        ncss_node_types: JS_NCSS_NODES,
+        ncss_container_node_types: &[],
+    },
+    LanguageDefinition {
+        name: "python",
+        aliases: &["py"],
+        grammar_id: GrammarId::Python,
+        function_node_types: COMMON_FUNCTION_NODES,
+        decision_node_types: COMMON_DECISION_NODES,
+        nesting_node_types: COMMON_NESTING_NODES,
+        ncss_node_types: PYTHON_NCSS_NODES,
+        ncss_container_node_types: &[],
+    },
+    LanguageDefinition {
+        name: "go",
+        aliases: &[],
+        grammar_id: GrammarId::Go,
+        function_node_types: COMMON_FUNCTION_NODES,
+        decision_node_types: GO_DECISION_NODES,
+        nesting_node_types: GO_NESTING_NODES,
+        ncss_node_types: GO_NCSS_NODES,
+        ncss_container_node_types: &[],
+    },
+    LanguageDefinition {
+        name: "rust",
+        aliases: &["rs"],
+        grammar_id: GrammarId::Rust,
+        function_node_types: COMMON_FUNCTION_NODES,
+        decision_node_types: COMMON_DECISION_NODES,
+        nesting_node_types: COMMON_NESTING_NODES,
+        ncss_node_types: RUST_NCSS_NODES,
+        ncss_container_node_types: RUST_NCSS_CONTAINERS,
+    },
+    LanguageDefinition {
+        name: "java",
+        aliases: &[],
+        grammar_id: GrammarId::Java,
+        function_node_types: JAVA_FUNCTION_NODES,
+        decision_node_types: JAVA_DECISION_NODES,
+        nesting_node_types: JAVA_DECISION_NODES,
+        ncss_node_types: JAVA_NCSS_NODES,
+        ncss_container_node_types: &[],
+    },
+    LanguageDefinition {
+        name: "ruby",
+        aliases: &["rb"],
+        grammar_id: GrammarId::Ruby,
+        function_node_types: RUBY_FUNCTION_NODES,
+        decision_node_types: RUBY_DECISION_NODES,
+        nesting_node_types: RUBY_DECISION_NODES,
+        ncss_node_types: RUBY_NCSS_NODES,
+        ncss_container_node_types: RUBY_NCSS_CONTAINERS,
+    },
+    LanguageDefinition {
+        name: "c",
+        aliases: &[],
+        grammar_id: GrammarId::C,
+        function_node_types: C_FUNCTION_NODES,
+        decision_node_types: C_DECISION_NODES,
+        nesting_node_types: C_DECISION_NODES,
+        ncss_node_types: C_NCSS_NODES,
+        ncss_container_node_types: &[],
+    },
+    LanguageDefinition {
+        name: "cpp",
+        aliases: &["c++", "cxx"],
+        grammar_id: GrammarId::Cpp,
+        function_node_types: C_FUNCTION_NODES,
+        decision_node_types: CPP_DECISION_NODES,
+        nesting_node_types: CPP_DECISION_NODES,
+        ncss_node_types: CPP_NCSS_NODES,
+        ncss_container_node_types: &[],
+    },
+];
+
+pub fn find_language(name: &str) -> Option<&'static LanguageDefinition> {
+    LANGUAGES
+        .iter()
+        .find(|language| language.name == name || language.aliases.contains(&name))
+}