code-gauge 4.1.2 → 4.2.0

package/native/src/functions.rs

@@ -6,12 +6,20 @@ use crate::util::{all_children, find_children_by_field_name, named_children, nod
 /// C++ `function_definition` also covers pure-virtual/`= default`/`= delete` members; those have no
 /// `body` and are signatures, not implementations, matching how TypeScript method signatures are
 /// excluded. Java `method_declaration` is NOT here: PMD reports abstract/interface methods as
-/// methods (NCSS 1), so bodyless Java methods stay in the function list.
+/// methods (NCSS 1), so bodyless Java methods stay in the function list (as do C#'s and Kotlin's).
+/// C# auto-property accessors (`{ get; set; }`) and Kotlin visibility-only accessors (`private
+/// set`) hold no code, so they need a body too; a C# property or indexer is a function only in its
+/// expression-bodied form (`int X => ...`), otherwise its accessors are the functions.
 const BODY_REQUIRED_FUNCTION_TYPES: &[&str] = &[
     "function_definition",
     "constructor_declaration",
     "compact_constructor_declaration",
     "function_signature_item",
+    "accessor_declaration",
+    "getter",
+    "setter",
+    "property_declaration",
+    "indexer_declaration",
 ];
 
 pub fn is_implemented_function(node: Node<'_>) -> bool {
@@ -21,6 +29,19 @@ pub fn is_implemented_function(node: Node<'_>) -> bool {
         return true;
     }
 
+    if node.kind() == "property_declaration" || node.kind() == "indexer_declaration" {
+        return node
+            .child_by_field_name("value")
+            .is_some_and(|value| value.kind() == "arrow_expression_clause");
+    }
+
+    // The Kotlin grammar has no fields; an implemented accessor holds a `function_body` child.
+    if node.kind() == "getter" || node.kind() == "setter" {
+        return named_children(node)
+            .iter()
+            .any(|child| child.kind() == "function_body");
+    }
+
     // C++ constructor/destructor function-try-blocks carry their `try_statement` outside the
     // `body` field; they are implementations, unlike `= 0`/`= default`/`= delete` members.
     named_children(node)
@@ -39,10 +60,28 @@ pub fn count_parameters(node: Node<'_>, code: &Source<'_>) -> usize {
         return 0;
     };
 
-    // A Java bare lambda parameter (`x -> x + 1`) puts a lone identifier in the `parameters` field.
-    if parameters_node.kind() == "identifier" {
+    // A Java bare lambda parameter (`x -> x + 1`) puts a lone identifier in the `parameters` field;
+    // a C# one (`x => x + 1`) is an `implicit_parameter` leaf.
+    if parameters_node.kind() == "identifier" || parameters_node.kind() == "implicit_parameter" {
+        return 1;
+    }
+    // Kotlin default values (`x: Int = 0`) are siblings of their `parameter`, not children.
+    if parameters_node.kind() == "function_value_parameters" {
+        return named_children(parameters_node)
+            .iter()
+            .filter(|child| child.kind() == "parameter")
+            .count();
+    }
+    // A Kotlin setter declares its single parameter directly (`set(value) { ... }`).
+    if parameters_node.kind() == "setter" {
         return 1;
     }
+    // A C# `params` array is spelled out as `type`/`name` fields of the parameter list itself.
+    let csharp_params_array_ids: HashSet<usize> = ["type", "name"]
+        .iter()
+        .flat_map(|field| find_children_by_field_name(parameters_node, field))
+        .map(|child| child.id())
+        .collect();
 
     // Ruby block-locals after `;` (`{ |x; memo| ... }`) occupy `locals` fields and receive no arguments.
     let block_local_ids: HashSet<usize> = find_children_by_field_name(parameters_node, "locals")
@@ -54,7 +93,9 @@ pub fn count_parameters(node: Node<'_>, code: &Source<'_>) -> usize {
     // C/C++ `f(void)` declares none, and a Ruby block parameter (`&blk`) binds the block, which
     // call sites pass outside the argument list.
     for child in named_children(parameters_node) {
-        if child.kind() == "comment"
+        if crate::ncss::COMMENT_NODE_TYPES.contains(&child.kind())
+            || child.kind() == "attribute_list"
+            || csharp_params_array_ids.contains(&child.id())
             || child.kind() == "self_parameter"
             || child.kind() == "receiver_parameter"
             || child.kind() == "block_parameter"
@@ -78,7 +119,7 @@ pub fn count_parameters(node: Node<'_>, code: &Source<'_>) -> usize {
         .iter()
         .filter(|child| !child.is_named() && node_text(**child, code) == "...")
         .count();
-    count + anonymous_variadic_count
+    count + anonymous_variadic_count + usize::from(!csharp_params_array_ids.is_empty())
 }
 
 /// C/C++ `int f(void)` has a `parameter_declaration` whose type is a bare `void` with no declarator.
@@ -95,6 +136,15 @@ fn find_parameters_node(node: Node<'_>) -> Option<Node<'_>> {
         return Some(direct);
     }
 
+    // A C# indexer accessor (`this[int i] { get { ... } }`) takes the indexer's parameters.
+    if node.kind() == "accessor_declaration" {
+        return node
+            .parent()
+            .and_then(|list| list.parent())
+            .filter(|owner| owner.kind() == "indexer_declaration")
+            .and_then(|owner| owner.child_by_field_name("parameters"));
+    }
+
     // A Java compact constructor implicitly takes the record's components, declared on the
     // `record_declaration` two levels up (via `class_body`).
     if node.kind() == "compact_constructor_declaration" {
@@ -113,9 +163,24 @@ fn find_parameters_node(node: Node<'_>) -> Option<Node<'_>> {
         declarator = next_declarator(current);
     }
 
-    named_children(node)
-        .into_iter()
-        .find(|child| child.kind() == "formal_parameters" || child.kind() == "parameter_list")
+    // A Kotlin setter's parameter (`set(value)`) sits directly under the setter node.
+    if node.kind() == "setter"
+        && named_children(node)
+            .iter()
+            .any(|child| child.kind() == "parameter_with_optional_type")
+    {
+        return Some(node);
+    }
+
+    named_children(node).into_iter().find(|child| {
+        matches!(
+            child.kind(),
+            "formal_parameters"
+                | "parameter_list"
+                | "function_value_parameters"
+                | "lambda_parameters"
+        )
+    })
 }
 
 pub fn collect_nodes<'t>(root: Node<'t>, node_types: &HashSet<&'static str>) -> Vec<Node<'t>> {
@@ -143,6 +208,10 @@ pub fn find_function_name(node: Node<'_>, code: &Source<'_>) -> Option<String> {
         return Some(wrapped_name);
     }
 
+    if let Some(member_name) = find_member_function_name(node, code) {
+        return Some(member_name);
+    }
+
     if let Some(name_node) = node.child_by_field_name("name") {
         return Some(node_text(name_node, code).to_string());
     }
@@ -183,6 +252,18 @@ pub fn find_function_name(node: Node<'_>, code: &Source<'_>) -> Option<String> {
     if node.kind() == "lambda" && parent.kind() == "assignment" {
         return find_ruby_assignment_name(parent, code);
     }
+
+    // A Kotlin lambda or anonymous function initializing a property (`val f = { ... }`, also through
+    // a label or annotation prefix) takes the property name.
+    if node.kind() == "lambda_literal" || node.kind() == "anonymous_function" {
+        let mut holder = parent;
+        while holder.kind() == "prefix_expression" {
+            holder = holder.parent()?;
+        }
+        if holder.kind() == "property_declaration" {
+            return find_kotlin_property_name(holder, code);
+        }
+    }
     if (node.kind() == "block" || node.kind() == "do_block") && is_ruby_lambda_call(parent, code) {
         return match parent.parent() {
             Some(grandparent) if grandparent.kind() == "assignment" => {
@@ -197,6 +278,111 @@ pub fn find_function_name(node: Node<'_>, code: &Source<'_>) -> Option<String> {
         .map(|name| node_text(name, code).to_string())
 }
 
+/// Names of C# and Kotlin members whose grammars carry no usable `name` field: accessors are
+/// named after their property (`Count.get`; an expression-bodied property is its own getter),
+/// Kotlin functions by their identifier child, Kotlin secondary constructors and C# destructors
+/// after their class, and C# operators like C++ ones.
+fn find_member_function_name(node: Node<'_>, code: &Source<'_>) -> Option<String> {
+    match node.kind() {
+        "accessor_declaration" => {
+            let keyword = node_text(node.child_by_field_name("name")?, code);
+            let owner = node.parent()?.parent()?;
+            Some(format!("{}.{keyword}", csharp_property_name(owner, code)?))
+        }
+        "property_declaration" | "indexer_declaration" => {
+            Some(format!("{}.get", csharp_property_name(node, code)?))
+        }
+        "getter" | "setter" => {
+            let keyword = if node.kind() == "getter" {
+                "get"
+            } else {
+                "set"
+            };
+            Some(format!(
+                "{}.{keyword}",
+                find_kotlin_accessor_owner_name(node, code)?
+            ))
+        }
+        "function_declaration" if node.child_by_field_name("name").is_none() => {
+            first_named_child_of_kind(node, "simple_identifier")
+                .map(|name| node_text(name, code).to_string())
+        }
+        "secondary_constructor" => {
+            let mut ancestor = node.parent();
+            while let Some(current) = ancestor {
+                if current.kind() == "class_declaration" || current.kind() == "object_declaration" {
+                    return first_named_child_of_kind(current, "type_identifier")
+                        .map(|name| node_text(name, code).to_string());
+                }
+                ancestor = current.parent();
+            }
+            None
+        }
+        "destructor_declaration" => Some(format!(
+            "~{}",
+            node_text(node.child_by_field_name("name")?, code)
+        )),
+        "operator_declaration" => Some(format!(
+            "operator {}",
+            node_text(node.child_by_field_name("operator")?, code)
+        )),
+        "conversion_operator_declaration" => Some(format!(
+            "operator {}",
+            node_text(node.child_by_field_name("type")?, code)
+        )),
+        _ => None,
+    }
+}
+
+/// A C# property or indexer (`this`) name.
+fn csharp_property_name(owner: Node<'_>, code: &Source<'_>) -> Option<String> {
+    match owner.kind() {
+        "indexer_declaration" => Some("this".to_string()),
+        _ => Some(node_text(owner.child_by_field_name("name")?, code).to_string()),
+    }
+}
+
+/// The property a Kotlin accessor belongs to: its parent when the accessor follows the initializer
+/// on the same line, otherwise (accessor on its own line) the grammar emits it as a class-body
+/// sibling after the property, any preceding accessor, and any comments between them.
+fn find_kotlin_accessor_owner_name(accessor: Node<'_>, code: &Source<'_>) -> Option<String> {
+    if let Some(name) = accessor
+        .parent()
+        .and_then(|parent| find_kotlin_property_name(parent, code))
+    {
+        return Some(name);
+    }
+    let mut sibling = accessor.prev_named_sibling();
+    while let Some(current) = sibling {
+        if current.kind() == "property_declaration" {
+            return find_kotlin_property_name(current, code);
+        }
+        if !matches!(current.kind(), "getter" | "setter")
+            && !crate::ncss::COMMENT_NODE_TYPES.contains(&current.kind())
+        {
+            return None;
+        }
+        sibling = current.prev_named_sibling();
+    }
+    None
+}
+
+/// The declared name of a Kotlin `property_declaration` (`val name: T`), if it declares one.
+fn find_kotlin_property_name(property: Node<'_>, code: &Source<'_>) -> Option<String> {
+    if property.kind() != "property_declaration" {
+        return None;
+    }
+    let declaration = first_named_child_of_kind(property, "variable_declaration")?;
+    first_named_child_of_kind(declaration, "simple_identifier")
+        .map(|name| node_text(name, code).to_string())
+}
+
+fn first_named_child_of_kind<'t>(node: Node<'t>, kind: &str) -> Option<Node<'t>> {
+    named_children(node)
+        .into_iter()
+        .find(|child| child.kind() == kind)
+}
+
 fn find_ruby_assignment_name(assignment: Node<'_>, code: &Source<'_>) -> Option<String> {
     let left_node = assignment.child_by_field_name("left")?;
     if left_node.kind() == "identifier" || left_node.kind() == "constant" {

package/native/src/languages.rs

@@ -16,9 +16,11 @@ pub struct LanguageDefinition {
 enum GrammarId {
     C,
     Cpp,
+    CSharp,
     Go,
     Java,
     JavaScript,
+    Kotlin,
     Python,
     Ruby,
     Rust,
@@ -31,9 +33,11 @@ impl LanguageDefinition {
         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::JavaScript => tree_sitter_javascript::language(),
+            GrammarId::Kotlin => tree_sitter_kotlin::language(),
             GrammarId::Python => tree_sitter_python::language(),
             GrammarId::Ruby => tree_sitter_ruby::language(),
             GrammarId::Rust => tree_sitter_rust::language(),
@@ -527,6 +531,124 @@ const CPP_NCSS_NODES: &[&str] = &[
     "co_yield_statement",
 ];
 
+// C# members mirror Java's: every member kind with a body is a function, and accessors
+// (`get { ... }`) are functions of their own so property logic is measured per accessor; an
+// expression-bodied property or indexer (`int X => ...`) is its own getter (see functions.rs).
+const CSHARP_FUNCTION_NODES: &[&str] = &[
+    "method_declaration",
+    "constructor_declaration",
+    "destructor_declaration",
+    "operator_declaration",
+    "conversion_operator_declaration",
+    "accessor_declaration",
+    "property_declaration",
+    "indexer_declaration",
+    "local_function_statement",
+    "lambda_expression",
+    "anonymous_method_expression",
+];
+const CSHARP_DECISION_NODES: &[&str] = &[
+    "if_statement",
+    "for_statement",
+    "foreach_statement",
+    "while_statement",
+    "do_statement",
+    "catch_clause",
+    "switch_section",
+    "switch_expression_arm",
+    "conditional_expression",
+];
+const CSHARP_NCSS_NODES: &[&str] = &[
+    "extern_alias_directive",
+    "using_directive",
+    "namespace_declaration",
+    "file_scoped_namespace_declaration",
+    "class_declaration",
+    "struct_declaration",
+    "interface_declaration",
+    "enum_declaration",
+    "record_declaration",
+    "delegate_declaration",
+    "field_declaration",
+    "event_field_declaration",
+    "event_declaration",
+    "property_declaration",
+    "indexer_declaration",
+    "method_declaration",
+    "constructor_declaration",
+    "destructor_declaration",
+    "operator_declaration",
+    "conversion_operator_declaration",
+    "accessor_declaration",
+    // An expression body (`=> expr`) stands for the single statement a block body would hold.
+    "arrow_expression_clause",
+    "local_function_statement",
+    "local_declaration_statement",
+    "expression_statement",
+    "if_statement",
+    "while_statement",
+    "do_statement",
+    "for_statement",
+    "foreach_statement",
+    "switch_statement",
+    "switch_expression",
+    "switch_section",
+    "switch_expression_arm",
+    "break_statement",
+    "continue_statement",
+    "return_statement",
+    "throw_statement",
+    "yield_statement",
+    "goto_statement",
+    "labeled_statement",
+    "lock_statement",
+    "using_statement",
+    "fixed_statement",
+    "checked_statement",
+    "unsafe_statement",
+    "catch_clause",
+    "finally_clause",
+];
+
+// Kotlin's grammar wraps neither statements nor members, so bodies are counted positionally like
+// Ruby's (see KOTLIN_NCSS_CONTAINERS); only clauses hanging off non-container parents are listed.
+const KOTLIN_FUNCTION_NODES: &[&str] = &[
+    "function_declaration",
+    "secondary_constructor",
+    "getter",
+    "setter",
+    "anonymous_function",
+    "lambda_literal",
+];
+const KOTLIN_DECISION_NODES: &[&str] = &[
+    "if_expression",
+    "for_statement",
+    "while_statement",
+    "do_while_statement",
+    "catch_block",
+    "when_entry",
+];
+// Accessors count like C# accessor declarations; a visibility-only `private set` is skipped in
+// ncss.rs because it declares nothing.
+const KOTLIN_NCSS_NODES: &[&str] = &[
+    "when_entry",
+    "catch_block",
+    "finally_block",
+    "getter",
+    "setter",
+];
+// `control_structure_body` holds a braceless branch/loop body (`if (x) foo()`), which counts like
+// the single statement of a braced one; `function_body` holds an expression body (`fun f() = x`).
+const KOTLIN_NCSS_CONTAINERS: &[&str] = &[
+    "source_file",
+    "import_list",
+    "statements",
+    "class_body",
+    "enum_class_body",
+    "control_structure_body",
+    "function_body",
+];
+
 pub const LANGUAGES: &[LanguageDefinition] = &[
     LanguageDefinition {
         name: "javascript",
@@ -638,6 +760,26 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         ncss_node_types: CPP_NCSS_NODES,
         ncss_container_node_types: &[],
     },
+    LanguageDefinition {
+        name: "csharp",
+        aliases: &["cs", "c#"],
+        grammar_id: GrammarId::CSharp,
+        function_node_types: CSHARP_FUNCTION_NODES,
+        decision_node_types: CSHARP_DECISION_NODES,
+        nesting_node_types: CSHARP_DECISION_NODES,
+        ncss_node_types: CSHARP_NCSS_NODES,
+        ncss_container_node_types: &[],
+    },
+    LanguageDefinition {
+        name: "kotlin",
+        aliases: &["kt", "kts"],
+        grammar_id: GrammarId::Kotlin,
+        function_node_types: KOTLIN_FUNCTION_NODES,
+        decision_node_types: KOTLIN_DECISION_NODES,
+        nesting_node_types: KOTLIN_DECISION_NODES,
+        ncss_node_types: KOTLIN_NCSS_NODES,
+        ncss_container_node_types: KOTLIN_NCSS_CONTAINERS,
+    },
 ];
 
 pub fn find_language(name: &str) -> Option<&'static LanguageDefinition> {

package/native/src/measure.rs

@@ -16,7 +16,10 @@ use crate::languages::LanguageDefinition;
 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_identifier_leaf, is_js_whitespace, named_children, node_text, split_lines,
+    Source,
+};
 
 pub fn measure(
     code: &str,
@@ -115,6 +118,9 @@ pub fn collect_cross_file_data(
 /// Name-carrying leaf types anonymized by tokenize_function so consistent renames still match.
 const IDENTIFIER_LEAF_NODE_TYPES: &[&str] = &[
     "identifier",
+    "simple_identifier",
+    "interpolated_identifier",
+    "implicit_parameter",
     "property_identifier",
     "field_identifier",
     "type_identifier",
@@ -152,14 +158,17 @@ fn collect_token_symbols(
     symbols: &mut Vec<i32>,
     id_index_by_name: &mut HashMap<String, usize>,
 ) {
-    if matches!(node.kind(), "comment" | "line_comment" | "block_comment") {
+    if matches!(
+        node.kind(),
+        "comment" | "line_comment" | "block_comment" | "multiline_comment"
+    ) {
         return;
     }
     if atomic_operand_node_types().contains(node.kind()) {
         symbols.push(hash_text(node.kind()));
         return;
     }
-    if node.child_count() > 0 {
+    if !is_identifier_leaf(node) {
         for child in all_children(node) {
             collect_token_symbols(child, code, symbols, id_index_by_name);
         }
@@ -279,7 +288,10 @@ fn collect_comment_spans(root: Node<'_>) -> Vec<CommentSpan> {
     let mut spans = Vec::new();
 
     fn visit(node: Node<'_>, spans: &mut Vec<CommentSpan>) {
-        if matches!(node.kind(), "comment" | "line_comment" | "block_comment") {
+        if matches!(
+            node.kind(),
+            "comment" | "line_comment" | "block_comment" | "multiline_comment"
+        ) {
             for row in node.start_position().row..=node.end_position().row {
                 // Node columns are UTF-16 code units x 2 (the tree is parsed from UTF-16);
                 // halving matches the code-unit columns the line scan below counts.
@@ -392,6 +404,18 @@ const OPERATOR_TEXTS: &[&str] = &[
     "&^",
     "&^=",
     "&.",
+    // Kotlin elvis, not-null assertion, negated containment/type checks, safe cast, and labeled
+    // jumps (single tokens in the grammar: `break@`, `continue@`, `return@`).
+    "?:",
+    "!!",
+    "!in",
+    "!is",
+    "as?",
+    "break@",
+    "continue@",
+    "return@",
+    // C# `default(T)`/`default`; the same token labels switch sections, which do not count.
+    "default",
     // Member access/qualification are classical Halstead operators; `->` also captures
     // Python/Rust return-type arrows, consistent with the counted `=>`.
     ".",
@@ -435,6 +459,9 @@ const OPERATOR_TEXTS: &[&str] = &[
 
 const OPERAND_NODE_TYPES: &[&str] = &[
     "identifier",
+    "simple_identifier",
+    "interpolated_identifier",
+    "implicit_parameter",
     "property_identifier",
     "field_identifier",
     "type_identifier",
@@ -445,9 +472,13 @@ const OPERAND_NODE_TYPES: &[&str] = &[
     "simple_symbol",
     "self",
     "this",
+    "this_expression",
     "super",
-    // C/C++/Rust built-in types are leaves of their own node type, unlike Go's `type_identifier`.
+    "super_expression",
+    "base",
+    // C/C++/Rust/C# built-in types are leaves of their own node type, unlike Go's `type_identifier`.
     "primitive_type",
+    "predefined_type",
     "boolean_type",
     "void_type",
     "auto",
@@ -456,6 +487,9 @@ const OPERAND_NODE_TYPES: &[&str] = &[
     "float",
     "integer_literal",
     "float_literal",
+    "real_literal",
+    "hex_literal",
+    "bin_literal",
     "int_literal",
     "rune_literal",
     "imaginary_literal",
@@ -470,16 +504,18 @@ const OPERAND_NODE_TYPES: &[&str] = &[
     "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",
     "string_content",
+    "string_literal_content",
     "raw_string_content",
     "template_string",
-    "character_literal",
     "char_literal",
     "character",
     "true",
     "false",
+    "boolean_literal",
     "null",
     "null_literal",
     "undefined",
@@ -488,8 +524,13 @@ const OPERAND_NODE_TYPES: &[&str] = &[
 ];
 
 /// Non-leaf literals counted as one Halstead operand without descending; see metrics.ts.
+/// `character_literal` is a leaf in Java and Kotlin but wraps a content node in C#; Kotlin's
+/// suffixed numbers (`1L`, `1u`) wrap the bare literal, so `1` and `1L` stay distinct.
 const ATOMIC_OPERAND_NODE_TYPES: &[&str] = &[
     "interpreted_string_literal",
+    "character_literal",
+    "long_literal",
+    "unsigned_literal",
     "regex",
     "user_defined_literal",
     "integral_type",
@@ -523,7 +564,10 @@ fn measure_halstead(root: Node<'_>, code: &Source<'_>) -> HalsteadCounts {
         operators: &mut HashMap<String, u64>,
         operands: &mut HashMap<String, u64>,
     ) {
-        if matches!(node.kind(), "comment" | "line_comment" | "block_comment") {
+        if matches!(
+            node.kind(),
+            "comment" | "line_comment" | "block_comment" | "multiline_comment"
+        ) {
             return;
         }
 
@@ -536,10 +580,13 @@ fn measure_halstead(root: Node<'_>, code: &Source<'_>) -> HalsteadCounts {
 
         // 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_identifier_leaf(node) {
             let text = node_text(node, code);
-            // Operands win over text matches so identifiers spelled like word operators stay operands.
-            if operand_node_types().contains(node.kind()) {
+            // 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.
+            if is_csharp_nameof_callee(node, text) {
+                *operators.entry(text.to_string()).or_insert(0) += 1;
+            } else if operand_node_types().contains(node.kind()) {
                 *operands.entry(text.to_string()).or_insert(0) += 1;
             } else if (operator_texts().contains(text) || operator_texts().contains(node.kind()))
                 && is_countable_contextual_token(node, text)
@@ -565,6 +612,18 @@ fn measure_halstead(root: Node<'_>, code: &Source<'_>) -> HalsteadCounts {
     }
 }
 
+/// 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"
+        && node.kind() == "identifier"
+        && node.parent().is_some_and(|parent| {
+            parent.kind() == "invocation_expression"
+                && parent
+                    .child_by_field_name("function")
+                    .is_some_and(|callee| callee.id() == node.id())
+        })
+}
+
 /// Ternary/conditional and Rust try parents make `?` an operator; TS optional markers do not.
 const QUESTION_OPERATOR_PARENT_TYPES: &[&str] = &[
     "ternary_expression",
@@ -573,6 +632,8 @@ const QUESTION_OPERATOR_PARENT_TYPES: &[&str] = &[
     "try_expression",
     // TypeScript conditional types (`T extends U ? X : Y`) select like a ternary.
     "conditional_type",
+    // C# null-conditional access (`a?.b`).
+    "conditional_access_expression",
 ];
 
 fn is_countable_contextual_token(node: Node<'_>, text: &str) -> bool {
@@ -582,6 +643,11 @@ fn is_countable_contextual_token(node: Node<'_>, text: &str) -> bool {
         return parent_type == Some("binary_operator")
             || parent_type == Some("augmented_assignment");
     }
+    if text == "default" {
+        return node
+            .parent()
+            .is_some_and(|parent| parent.kind() == "default_expression");
+    }
     if text != "?" {
         return true;
     }