graph-indexer 2.1.1 → 3.0.0

package/src/parse/lang/go.mjs

@@ -0,0 +1,194 @@
+/** Go extraction spec. Methods are qualified by their receiver type (Engine.Run). */
+
+const RECV_TYPE = `[(type_identifier) @owner (pointer_type (type_identifier) @owner) (generic_type type: (type_identifier) @owner) (pointer_type (generic_type type: (type_identifier) @owner))]`;
+// a whole (single) type; normalizeType reduces it to what member lookup needs (`[]*pkg.T` → T[])
+const TYPE_HEAD = `[(type_identifier) (pointer_type) (qualified_type) (generic_type) (slice_type) (array_type) (map_type) (channel_type)] @type`;
+
+const QUERY = `
+(function_declaration name: (identifier) @name result: ${TYPE_HEAD}) @def.function
+(function_declaration name: (identifier) @name result: (parameter_list . (parameter_declaration type: ${TYPE_HEAD}))) @def.function
+(function_declaration name: (identifier) @name) @def.function
+(method_declaration receiver: (parameter_list (parameter_declaration type: ${RECV_TYPE})) name: (field_identifier) @name result: ${TYPE_HEAD}) @def.method
+(method_declaration receiver: (parameter_list (parameter_declaration type: ${RECV_TYPE})) name: (field_identifier) @name result: (parameter_list . (parameter_declaration type: ${TYPE_HEAD}))) @def.method
+(method_declaration receiver: (parameter_list (parameter_declaration type: ${RECV_TYPE})) name: (field_identifier) @name) @def.method
+(type_spec name: (type_identifier) @name type: (struct_type)) @def.struct
+(type_spec name: (type_identifier) @name type: (interface_type)) @def.interface
+(type_spec name: (type_identifier) @name type: [(map_type) (slice_type) (array_type)] @type) @def.type
+(type_spec name: (type_identifier) @name type: [(type_identifier) (qualified_type) (function_type) (map_type) (slice_type) (array_type) (pointer_type) (generic_type) (channel_type)]) @def.type
+(type_alias name: (type_identifier) @name type: ${TYPE_HEAD}) @def.type
+(type_alias name: (type_identifier) @name) @def.type
+(method_elem name: (field_identifier) @name result: ${TYPE_HEAD}) @def.method
+(method_elem name: (field_identifier) @name result: (parameter_list . (parameter_declaration type: ${TYPE_HEAD}))) @def.method
+(method_elem name: (field_identifier) @name) @def.method
+(field_declaration name: (field_identifier) @name type: ${TYPE_HEAD}) @def.field
+(field_declaration name: (field_identifier) @name) @def.field
+(const_spec name: (identifier) @name) @def.constant
+(var_spec name: (identifier) @name) @def.variable
+
+(call_expression function: (identifier) @name) @ref.call
+(call_expression function: (selector_expression operand: (_) @recv field: (field_identifier) @name)) @ref.call
+(type_identifier) @name @ref.type
+(qualified_type package: (package_identifier) @recv name: (type_identifier) @name) @ref.type
+(composite_literal type: (type_identifier) @name) @ref.new
+(call_expression function: (parenthesized_expression (unary_expression operand: (identifier) @name))) @ref.type
+(call_expression function: (parenthesized_expression (unary_expression operand: (selector_expression operand: (identifier) @recv field: (field_identifier) @name)))) @ref.type
+(composite_literal type: (qualified_type package: (package_identifier) @recv name: (type_identifier) @name)) @ref.new
+(field_declaration_list (field_declaration !name type: [(type_identifier) @name (pointer_type (type_identifier) @name)])) @ref.inherit
+(field_declaration_list (field_declaration !name type: [(qualified_type package: (package_identifier) @recv name: (type_identifier) @name) (pointer_type (qualified_type package: (package_identifier) @recv name: (type_identifier) @name))])) @ref.inherit
+(interface_type (type_elem (type_identifier) @name)) @ref.inherit
+(argument_list (identifier) @name) @ref.value
+(argument_list (selector_expression operand: (identifier) @recv field: (field_identifier) @name)) @ref.value
+(keyed_element (literal_element) (literal_element (identifier) @name)) @ref.value
+(composite_literal type: [(map_type) (slice_type) (array_type)] body: (literal_value (keyed_element . (literal_element (identifier) @name)))) @ref.value
+(composite_literal type: [(type_identifier) (qualified_type) (generic_type)] body: (literal_value (keyed_element . (literal_element (identifier) @name)))) @recv @ref.read
+(selector_expression operand: (_) @recv field: (field_identifier) @name) @ref.read
+
+(func_literal) @scope
+(return_statement (expression_list . (_) @ret))
+(import_spec) @import
+
+(short_var_declaration left: (expression_list . (identifier) @bind.name) right: (expression_list . (composite_literal type: (type_identifier) @bind.new))) @bind
+(short_var_declaration left: (expression_list . (identifier) @bind.name) right: (expression_list . (unary_expression operand: (composite_literal type: (type_identifier) @bind.new)))) @bind
+(short_var_declaration left: (expression_list . (identifier) @bind.name) right: (expression_list . (_) @bind.expr)) @bind
+(var_spec name: (identifier) @bind.name value: (expression_list . (_) @bind.expr)) @bind
+(for_statement (range_clause left: (expression_list . (_) . (identifier) @bind.name) right: (_) @bind.elem)) @bind
+(var_spec name: (identifier) @bind.name type: ${TYPE_HEAD.replaceAll('@type', '@bind.type')}) @bind
+(parameter_declaration name: (identifier) @bind.name type: ${TYPE_HEAD.replaceAll('@type', '@bind.type')}) @bind
+`;
+
+const BUILTIN_CALLS = new Set(['make', 'new', 'len', 'cap', 'append', 'copy', 'delete', 'panic', 'recover', 'print',
+    'println', 'close', 'complex', 'real', 'imag', 'min', 'max', 'clear', 'string', 'int', 'int64', 'int32', 'uint',
+    'uint64', 'uint32', 'float64', 'float32', 'byte', 'rune', 'bool', 'error', 'uintptr']);
+const PRIMITIVES = new Set(['string', 'int', 'int8', 'int16', 'int32', 'int64', 'uint', 'uint8', 'uint16', 'uint32',
+    'uint64', 'uintptr', 'float32', 'float64', 'complex64', 'complex128', 'byte', 'rune', 'bool', 'error', 'any',
+    'interface', 'map', 'chan', 'func']);
+
+function splitTop(s) {
+    const out = [];
+    let depth = 0, cur = '';
+    for (const ch of s) {
+        if ('([{'.includes(ch)) depth++;
+        else if (')]}'.includes(ch)) depth--;
+        if (ch === ',' && depth === 0) { out.push(cur.trim()); cur = ''; } else cur += ch;
+    }
+    if (cur.trim()) out.push(cur.trim());
+    return out;
+}
+function closeParen(s, open) {
+    for (let i = open, depth = 0; i < s.length; i++) {
+        if (s[i] === '(') depth++;
+        else if (s[i] === ')' && --depth === 0) return i;
+    }
+    return -1;
+}
+const KEYWORD_TYPES = new Set(['chan', 'func', 'map', 'struct', 'interface']);
+/** The types of a parameter or result list, names dropped (`a, b string` is two strings). */
+function listTypes(text) {
+    const entries = splitTop(text);
+    const named = entries.some(e => { const m = /^([A-Za-z_]\w*)\s+\S/.exec(e); return m && !KEYWORD_TYPES.has(m[1]); });
+    if (!named) return entries;
+    const out = [];
+    let type = null;
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const m = /^[A-Za-z_]\w*\s+(.+)$/s.exec(entries[i]);
+        if (m) type = m[1];
+        out.unshift(type);
+    }
+    return out;
+}
+/** A type reduced to what tells two signatures apart without type checking: `*pkg.T` → T. */
+function typeHead(t) {
+    let s = (t ?? '').trim();
+    for (let prev; prev !== s;) { prev = s; s = s.replace(/^(?:\*|\.\.\.|\[\d*\]|<-\s*|chan\s+)/, '').trim(); }
+    if (/^map\s*\[/.test(s)) return 'map';
+    if (/^func\b/.test(s)) return 'func';
+    if (/^(struct|interface)\s*\{/.test(s)) return s.startsWith('struct') ? 'struct' : 'interface';
+    s = s.replace(/\[.*$/s, '');
+    return s.split('.').pop();
+}
+/**
+ * The shape of a method's signature, for telling whether a type's method satisfies an interface's:
+ * parameter and result types reduced to their heads (`ServeHTTP(http.ResponseWriter, *http.Request)
+ * error` → `ResponseWriter,Request->error`). Null when the signature cannot be read.
+ */
+function methodShape(sig, name) {
+    if (!sig) return null;
+    const m = new RegExp(`(?:^|[\\s)])${name}\\s*\\(`).exec(sig);
+    if (!m) return null;
+    const open = m.index + m[0].length - 1, close = closeParen(sig, open);
+    if (close < 0) return null;
+    const params = listTypes(sig.slice(open + 1, close));
+    let rest = sig.slice(close + 1).replace(/\{\s*$/, '').trim();
+    let results;
+    if (rest.startsWith('(')) {
+        const end = closeParen(rest, 0);
+        if (end < 0) return null;
+        results = listTypes(rest.slice(1, end));
+    } else results = rest ? [rest] : [];
+    return params.map(typeHead).join(',') + '->' + results.map(typeHead).join(',');
+}
+
+function parseImport(node) {
+    const pathNode = node.childForFieldName('path');
+    if (!pathNode) return [];
+    const source = pathNode.text.replace(/^["`]|["`]$/g, '');
+    const alias = node.childForFieldName('name')?.text;
+    // the package is named after the last path element, but not a major version: `…/caddy/v2` is
+    // package caddy, `gopkg.in/yaml.v3` package yaml
+    const parts = source.split('/');
+    const last = /^v\d+$/.test(parts[parts.length - 1]) && parts.length > 1 ? parts[parts.length - 2] : parts[parts.length - 1];
+    const local = alias && alias !== '_' && alias !== '.' ? alias : (alias === '.' ? null : last.replace(/\.v\d+$/, '').replace(/^go-|-go$/g, ''));
+    return [{ source, imported: '*', local, wildcard: alias === '.' }];
+}
+
+function isModuleLevel(node) {
+    // var_spec → var_declaration → source_file (or var_spec_list in between)
+    let p = node.parent;
+    if (p?.type === 'var_spec_list') p = p.parent;
+    return p?.type === 'var_declaration' ? p.parent?.type === 'source_file' : p?.type === 'const_declaration' ? p.parent?.type === 'source_file' : true;
+}
+
+function docOf(defNode) {
+    // type_spec lives inside a type_declaration; comments sit above the declaration
+    return null;
+}
+
+function fileInfo(root) {
+    const pkg = root.namedChildren.find(c => c.type === 'package_clause');
+    return { package: pkg?.namedChildren[0]?.text ?? null };
+}
+
+export const go = {
+    id: 'go',
+    grammar: 'go',
+    extensions: ['.go'],
+    family: 'go',
+    query: QUERY,
+    implicitThis: false,
+    selfNames: [],
+    externalReceivers: new Set(['fmt', 'os', 'strings', 'strconv', 'errors', 'io', 'bytes', 'sync', 'time', 'context',
+        'log', 'math', 'sort', 'regexp', 'filepath', 'reflect', 'atomic', 'bufio', 'unicode', 'utf8', 'json', 'xml',
+        'hex', 'base64', 'rand', 'runtime', 'testing', 'assert', 'require', 'ioutil', 'url', 'unsafe']),
+    builtinCalls: BUILTIN_CALLS,
+    testFile: /_test\.go$|(^|\/)testdata\//,
+    commentTypes: ['comment'],
+    docWrappers: new Set(['type_declaration', 'const_declaration', 'var_declaration']),
+    docOf,
+    parseImport,
+    isModuleLevel,
+    isExported: (node, name) => /^[A-Z]/.test(name),
+    visibility: (node, name) => (name && /^[a-z_]/.test(name) ? 'private' : null),
+    isPrimitiveType: (t) => PRIMITIVES.has(t),
+    // `(T, error)` results: the value is the first element
+    mapIterValues: true, // `for _, v := range m` binds values
+    packageValues: true, // a bare identifier that is not local is a package-level variable
+    qualifiedTypes: true, // types keep their package (`http.Request`)
+    methodShape, // interfaces are satisfied by name and signature
+    cleanType: (t) => t.replace(/^\(\s*(?:\w+\s+)?([^,()]+?)\s*,\s*(?:\w+\s+)?error\s*\)$/s, '$1'),
+    refineKind(kind, d, parent) {
+        if (d.node.type === 'method_elem') return 'method';
+        return kind;
+    },
+    fileInfo,
+    bodyField: 'body',
+};

package/src/parse/lang/jvm.mjs

@@ -0,0 +1,118 @@
+/** Java extraction spec (Kotlin/Scala live in their own modules). */
+
+const T = (cap) => `[(type_identifier) @${cap} (generic_type (type_identifier) @${cap}) (scoped_type_identifier (type_identifier) @${cap} .) (generic_type (scoped_type_identifier (type_identifier) @${cap} .))]`;
+
+const JAVA_QUERY = `
+(class_declaration name: (identifier) @name) @def.class
+(class_declaration name: (identifier) @name superclass: (superclass (_) @type)) @def.class
+(interface_declaration name: (identifier) @name) @def.interface
+(enum_declaration name: (identifier) @name) @def.enum
+(record_declaration name: (identifier) @name) @def.class
+(annotation_type_declaration name: (identifier) @name) @def.interface
+(method_declaration type: (_) @type name: (identifier) @name) @def.method
+(method_declaration name: (identifier) @name) @def.method
+(constructor_declaration name: (identifier) @name) @def.constructor
+(field_declaration type: (_) @type declarator: (variable_declarator name: (identifier) @name)) @def.field
+(field_declaration declarator: (variable_declarator name: (identifier) @name)) @def.field
+(enum_constant name: (identifier) @name body: (class_body)) @def.class
+(enum_constant name: (identifier) @name) @def.constant
+(object_creation_expression "new" @name (class_body)) @def.class
+
+(method_invocation !object name: (identifier) @name) @ref.call
+(method_invocation object: (_) @recv name: (identifier) @name) @ref.call
+(object_creation_expression type: ${T('name')}) @ref.new
+(superclass ${T('name')}) @ref.inherit
+(super_interfaces (type_list ${T('name')})) @ref.inherit
+(object_creation_expression type: ${T('name')} (class_body)) @ref.inherit
+(extends_interfaces (type_list ${T('name')})) @ref.inherit
+(type_identifier) @name @ref.type
+(marker_annotation name: (identifier) @name) @ref.decorator
+(annotation name: (identifier) @name) @ref.decorator
+(method_reference . (identifier) @recv (identifier) @name) @ref.value
+; a class named on the left of a static access: StringUtil.join(…), Token.TokenType.EOF, Foo::bar
+; (a constant in capitals is not a class; a name that is no type of the repository resolves to nothing)
+(method_invocation object: ((identifier) @name @ref.type (#match? @name "^[A-Z]\\w*[a-z]")))
+(field_access object: ((identifier) @name @ref.type (#match? @name "^[A-Z]\\w*[a-z]")))
+(method_reference . ((identifier) @name @ref.type (#match? @name "^[A-Z]\\w*[a-z]")))
+(argument_list (identifier) @name) @ref.value
+
+(lambda_expression) @scope
+(return_statement (_) @ret)
+(import_declaration) @import
+
+(local_variable_declaration type: (_) @bind.type declarator: (variable_declarator name: (identifier) @bind.name)) @bind
+(local_variable_declaration declarator: (variable_declarator name: (identifier) @bind.name value: (object_creation_expression type: ${T('bind.new')}))) @bind
+(local_variable_declaration declarator: (variable_declarator name: (identifier) @bind.name value: (_) @bind.expr)) @bind
+(formal_parameter type: (_) @bind.type name: (identifier) @bind.name) @bind
+(enhanced_for_statement type: (_) @bind.type name: (identifier) @bind.name value: (_) @bind.elem) @bind
+(field_declaration type: (_) @field.type declarator: (variable_declarator name: (identifier) @field.name)) @field
+`;
+
+const JAVA_BUILTIN_TYPES = new Set(['String', 'Object', 'Integer', 'Long', 'Double', 'Float', 'Boolean', 'Character',
+    'Byte', 'Short', 'Void', 'List', 'Map', 'Set', 'Collection', 'Optional', 'Stream', 'Iterable', 'Iterator',
+    'ArrayList', 'HashMap', 'HashSet', 'LinkedList', 'Arrays', 'Collections', 'Objects', 'Math', 'System',
+    'StringBuilder', 'Exception', 'RuntimeException', 'Throwable', 'Class', 'Thread', 'Override', 'Deprecated',
+    'SuppressWarnings', 'FunctionalInterface']);
+
+function javaImport(node) {
+    const text = node.text.replace(/^import\s+(static\s+)?/, '').replace(/;\s*$/, '').trim();
+    const isStatic = /^import\s+static/.test(node.text);
+    if (text.endsWith('.*')) return [{ source: text.slice(0, -2), imported: '*', local: null, wildcard: true, static: isStatic }];
+    const parts = text.split('.');
+    const name = parts.pop();
+    return [{ source: parts.join('.'), imported: name, local: name, static: isStatic }];
+}
+
+function modifiersText(node) {
+    const m = node.namedChildren.find(c => c.type === 'modifiers');
+    return m ? m.text : '';
+}
+
+function javaFileInfo(root) {
+    const pkg = root.namedChildren.find(c => c.type === 'package_declaration');
+    return { package: pkg ? pkg.text.replace(/^package\s+/, '').replace(/;\s*$/, '').trim() : null };
+}
+
+export const java = {
+    id: 'java',
+    distinctOverloads: true, // each overload is a method of its own: calls bind by argument count
+    localValues: true, // an argument named like a local or parameter is that variable
+    nestedTypes: true, // `Token.Comment` names the class Comment nested in Token
+    // an anonymous class (`new Transformer<>() {…}`) is `<anonymous>`, a subclass of what it instantiates
+    normalizeName: (name, d) => (d.node.type === 'object_creation_expression' ? '<anonymous>' : name),
+    // an enum constant with a body (`AfterBody { boolean process(…) {…} }`) is a subclass of its enum
+    refineKind: (kind, d) => (d.node.type === 'enum_constant' && d.node.childForFieldName('body') ? 'class' : kind),
+    implicitBases: (node) => (node.type === 'enum_constant' && node.childForFieldName('body') ? [node.parent?.parent?.childForFieldName('name')?.text].filter(Boolean) : []),
+    grammar: 'java',
+    extensions: ['.java'],
+    family: 'jvm',
+    query: JAVA_QUERY,
+    implicitThis: true,
+    selfNames: ['this'],
+    externalReceivers: new Set(['System', 'Math', 'Arrays', 'Collections', 'Objects', 'String', 'Integer', 'Long',
+        'Double', 'Boolean', 'Optional', 'Stream', 'Collectors', 'LoggerFactory', 'log', 'logger', 'LOG', 'LOGGER',
+        'Assertions', 'Assert', 'Mockito', 'assertThat']),
+    builtinCalls: new Set(['assertEquals', 'assertTrue', 'assertFalse', 'assertNotNull', 'assertNull', 'assertThat',
+        'when', 'verify', 'mock', 'any', 'eq', 'println', 'printf', 'format', 'valueOf', 'toString', 'equals',
+        'hashCode', 'getClass', 'super', 'this']),
+    testFile: /(^|\/)src\/test\/|Tests?\.java$|IT\.java$/,
+    commentTypes: ['block_comment', 'line_comment'],
+    parseImport: javaImport,
+    isExported: (node) => /\bpublic\b/.test(modifiersText(node)) || node.parent?.type === 'interface_body',
+    visibility: (node) => { const m = modifiersText(node); return /\bprivate\b/.test(m) ? 'private' : /\bprotected\b/.test(m) ? 'protected' : /\bpublic\b/.test(m) ? 'public' : null; },
+    isPrimitiveType: (t) => JAVA_BUILTIN_TYPES.has(t) || /^(int|long|double|float|boolean|char|byte|short|void)$/.test(t),
+    elementTypes: new Set(['List', 'ArrayList', 'LinkedList', 'Collection', 'Set', 'HashSet', 'TreeSet', 'LinkedHashSet', 'SortedSet', 'NavigableSet',
+        'Iterable', 'Iterator', 'Stream', 'Queue', 'Deque', 'ArrayDeque', 'PriorityQueue', 'Vector', 'CopyOnWriteArrayList', 'BlockingQueue']),
+    elementMethods: new Set(['get', 'getFirst', 'getLast', 'peek', 'poll', 'pop', 'element', 'first', 'last', 'next', 'remove', 'take']),
+    mapTypes: new Set(['Map', 'HashMap', 'TreeMap', 'LinkedHashMap', 'ConcurrentHashMap', 'SortedMap', 'NavigableMap', 'ConcurrentMap', 'EnumMap']),
+    mapMethods: new Set(['get', 'getOrDefault', 'remove', 'put', 'putIfAbsent', 'computeIfAbsent', 'compute', 'merge']),
+    mapValueMethods: new Set(['values']),
+    decoratorsOf(node) {
+        const m = node.namedChildren.find(c => c.type === 'modifiers');
+        if (!m) return [];
+        return m.namedChildren.filter(c => c.type === 'annotation' || c.type === 'marker_annotation')
+            .map(a => a.childForFieldName('name')?.text).filter(Boolean).slice(0, 8);
+    },
+    fileInfo: javaFileInfo,
+    bodyField: 'body',
+};

package/src/parse/lang/kotlin.mjs

@@ -0,0 +1,97 @@
+/** Kotlin extraction spec (fwcd/tree-sitter-kotlin; the grammar has no field names, so patterns are positional). */
+
+const QUERY = `
+[(lambda_literal) (anonymous_function)] @scope
+(class_declaration (type_identifier) @name) @def.class
+(object_declaration (type_identifier) @name) @def.object
+(function_declaration (simple_identifier) @name (user_type (type_identifier) @type)) @def.function
+(function_declaration (simple_identifier) @name) @def.function
+(class_body (property_declaration (variable_declaration (simple_identifier) @name (user_type (type_identifier) @type))) @def.property)
+(class_body (property_declaration (variable_declaration (simple_identifier) @name)) @def.property)
+(source_file (property_declaration (variable_declaration (simple_identifier) @name)) @def.variable)
+(class_parameter (binding_pattern_kind) (simple_identifier) @name (user_type (type_identifier) @type)) @def.property
+(class_parameter (binding_pattern_kind) (simple_identifier) @name) @def.property
+(type_alias (type_identifier) @name) @def.type
+(enum_entry (simple_identifier) @name) @def.constant
+
+(call_expression . (simple_identifier) @name) @ref.call
+(call_expression . (navigation_expression (_) @recv . (navigation_suffix (simple_identifier) @name))) @ref.call
+(delegation_specifier (constructor_invocation (user_type (type_identifier) @name))) @ref.inherit
+(delegation_specifier (user_type (type_identifier) @name)) @ref.inherit
+(user_type (type_identifier) @name) @ref.type
+(annotation (user_type (type_identifier) @name)) @ref.decorator
+(annotation (constructor_invocation (user_type (type_identifier) @name))) @ref.decorator
+(value_argument (simple_identifier) @name) @ref.value
+(callable_reference (simple_identifier) @name) @ref.value
+
+(import_header) @import
+
+(property_declaration (variable_declaration (simple_identifier) @bind.name (user_type (type_identifier) @bind.type))) @bind
+(property_declaration (variable_declaration (simple_identifier) @bind.name) (call_expression . (simple_identifier) @bind.call)) @bind
+(parameter (simple_identifier) @bind.name (user_type (type_identifier) @bind.type)) @bind
+(class_parameter (simple_identifier) @field.name (user_type (type_identifier) @field.type)) @field
+(class_body (property_declaration (variable_declaration (simple_identifier) @field.name (user_type (type_identifier) @field.type))) @field)
+(class_body (property_declaration (variable_declaration (simple_identifier) @field.name) (call_expression . (simple_identifier) @field.call)) @field)
+`;
+
+const PRIMITIVES = new Set(['String', 'Int', 'Long', 'Double', 'Float', 'Boolean', 'Char', 'Byte', 'Short', 'Unit',
+    'Any', 'Nothing', 'List', 'MutableList', 'Map', 'MutableMap', 'Set', 'MutableSet', 'Array', 'Pair', 'Triple',
+    'Flow', 'StateFlow', 'MutableStateFlow', 'LiveData', 'MutableLiveData', 'Sequence']);
+
+function parseImport(node) {
+    const text = node.text.split('\n')[0].replace(/^import\s+/, '').replace(/;\s*$/, '').trim();
+    const alias = /\s+as\s+(\w+)$/.exec(text);
+    const path = text.replace(/\s+as\s+\w+$/, '').trim();
+    if (path.endsWith('.*')) return [{ source: path.slice(0, -2), imported: '*', local: null, wildcard: true }];
+    const parts = path.split('.');
+    const name = parts.pop();
+    return [{ source: parts.join('.'), imported: name, local: alias ? alias[1] : name }];
+}
+
+function modifiers(node) { return node.namedChildren.find(c => c.type === 'modifiers')?.text ?? ''; }
+
+function fileInfo(root) {
+    const pkg = root.namedChildren.find(c => c.type === 'package_header');
+    return { package: pkg ? pkg.text.replace(/^package\s+/, '').trim() : null };
+}
+
+export const kotlin = {
+    id: 'kotlin',
+    grammar: 'kotlin',
+    extensions: ['.kt', '.kts'],
+    family: 'jvm',
+    query: QUERY,
+    implicitThis: true,
+    selfNames: ['this'],
+    externalReceivers: new Set(['Log', 'Timber', 'System', 'Math', 'println']),
+    builtinCalls: new Set(['println', 'print', 'listOf', 'mutableListOf', 'mapOf', 'mutableMapOf', 'setOf', 'mutableSetOf',
+        'arrayOf', 'emptyList', 'emptyMap', 'emptySet', 'require', 'requireNotNull', 'check', 'checkNotNull', 'error',
+        'lazy', 'let', 'also', 'apply', 'run', 'with', 'repeat', 'TODO', 'assert', 'assertEquals', 'assertTrue', 'launch',
+        'async', 'runBlocking', 'withContext', 'remember', 'mutableStateOf']),
+    testFile: /(^|\/)src\/(test|androidTest)\/|Test\.kt$/,
+    commentTypes: ['comment', 'multiline_comment', 'line_comment'],
+    parseImport,
+    isExported: (node) => !/\b(private|internal)\b/.test(modifiers(node)),
+    visibility: (node) => { const m = modifiers(node); return /\bprivate\b/.test(m) ? 'private' : /\bprotected\b/.test(m) ? 'protected' : null; },
+    isPrimitiveType: (t) => PRIMITIVES.has(t),
+    elementTypes: new Set(['List', 'MutableList', 'ArrayList', 'Set', 'MutableSet', 'HashSet', 'LinkedHashSet', 'Collection', 'MutableCollection', 'Iterable', 'Sequence', 'Array']),
+    elementMethods: new Set(['get', 'first', 'last', 'firstOrNull', 'lastOrNull', 'single', 'singleOrNull', 'elementAt', 'getOrNull', 'find', 'random', 'removeFirst', 'removeLast']),
+    mapTypes: new Set(['Map', 'MutableMap', 'HashMap', 'LinkedHashMap']),
+    mapMethods: new Set(['get', 'getValue', 'getOrDefault', 'getOrElse', 'getOrPut', 'remove']),
+    mapValueMethods: new Set(['values']),
+    refineKind(kind, d) {
+        if (d.node.type === 'class_declaration') {
+            const head = d.node.text.slice(0, d.node.text.indexOf(d.nameNode.text));
+            if (/\binterface\b/.test(head)) return 'interface';
+            if (/\benum\b/.test(head)) return 'enum';
+        }
+        return kind;
+    },
+    decoratorsOf(node) {
+        const m = node.namedChildren.find(c => c.type === 'modifiers');
+        return m ? m.namedChildren.filter(c => c.type === 'annotation').map(a => a.text.replace(/^@/, '').split('(')[0]).slice(0, 8) : [];
+    },
+    fileInfo,
+    bodyField: null,
+    signatureCleanup: (text) => text.replace(/\s*[{=].*$/s, ''),
+};

package/src/parse/lang/misc.mjs

@@ -0,0 +1,115 @@
+/** Scala and CSS extraction specs. */
+
+const SCALA_QUERY = `
+(class_definition name: (identifier) @name) @def.class
+(object_definition name: (identifier) @name) @def.object
+(trait_definition name: (identifier) @name) @def.trait
+(enum_definition name: (identifier) @name) @def.enum
+(function_definition name: (identifier) @name return_type: [(type_identifier) @type (generic_type type: (type_identifier) @type)]) @def.function
+(function_definition name: (identifier) @name) @def.function
+(function_declaration name: (identifier) @name) @def.function
+(val_definition pattern: (identifier) @name type: [(type_identifier) @type (generic_type type: (type_identifier) @type)]) @def.variable
+(val_definition pattern: (identifier) @name) @def.variable
+(var_definition pattern: (identifier) @name) @def.variable
+(type_definition name: (type_identifier) @name) @def.type
+
+(call_expression function: (identifier) @name) @ref.call
+(call_expression function: (field_expression value: (_) @recv field: (identifier) @name)) @ref.call
+(call_expression function: (generic_function function: (identifier) @name)) @ref.call
+(instance_expression (type_identifier) @name) @ref.new
+(instance_expression (generic_type type: (type_identifier) @name)) @ref.new
+(extends_clause type: (type_identifier) @name) @ref.inherit
+(extends_clause type: (generic_type type: (type_identifier) @name)) @ref.inherit
+(type_identifier) @name @ref.type
+(arguments (identifier) @name) @ref.value
+
+(import_declaration) @import
+
+(val_definition pattern: (identifier) @bind.name type: [(type_identifier) @bind.type (generic_type type: (type_identifier) @bind.type)]) @bind
+(val_definition pattern: (identifier) @bind.name value: (instance_expression (type_identifier) @bind.new)) @bind
+(val_definition pattern: (identifier) @bind.name value: (call_expression function: (identifier) @bind.call)) @bind
+(parameter name: (identifier) @bind.name type: [(type_identifier) @bind.type (generic_type type: (type_identifier) @bind.type)]) @bind
+(class_parameter name: (identifier) @field.name type: [(type_identifier) @field.type (generic_type type: (type_identifier) @field.type)]) @field
+`;
+
+function scalaImport(node) {
+    const text = node.text.replace(/^import\s+/, '').trim();
+    const brace = /^(.*)\.\{(.*)\}$/.exec(text);
+    if (brace) {
+        return brace[2].split(',').map(s => s.trim()).filter(Boolean).map(s => {
+            const [n, a] = s.split(/\s*(?:=>|as)\s*/);
+            return n === '_' || n === '*' ? { source: brace[1], imported: '*', local: null, wildcard: true } : { source: brace[1], imported: n, local: a || n };
+        });
+    }
+    if (/\.(_|\*)$/.test(text)) return [{ source: text.replace(/\.(_|\*)$/, ''), imported: '*', local: null, wildcard: true }];
+    const parts = text.split('.');
+    const name = parts.pop();
+    return [{ source: parts.join('.'), imported: name, local: name }];
+}
+
+export const scala = {
+    id: 'scala',
+    grammar: 'scala',
+    extensions: ['.scala', '.sc'],
+    family: 'jvm',
+    query: SCALA_QUERY,
+    implicitThis: true,
+    selfNames: ['this'],
+    externalReceivers: new Set(['System', 'Math', 'Future', 'Option', 'Some', 'Seq', 'List', 'Map', 'Set', 'Vector', 'Array', 'println']),
+    builtinCalls: new Set(['println', 'print', 'require', 'assert', 'Some', 'None', 'Seq', 'List', 'Map', 'Set', 'Vector', 'Array', 'Option', 'Future']),
+    testFile: /(^|\/)src\/test\/|(Spec|Test|Suite)\.scala$/,
+    commentTypes: ['comment', 'block_comment'],
+    parseImport: scalaImport,
+    isExported: (node) => !/^\s*(private|protected)\b/.test(node.text),
+    visibility: (node) => (/^\s*private\b/.test(node.text) ? 'private' : null),
+    isPrimitiveType: (t) => /^(Int|Long|Double|Float|Boolean|Char|Byte|Short|Unit|String|Any|AnyRef|Nothing|Option|List|Seq|Map|Set|Vector|Array|Future)$/.test(t),
+    transparentTypes: new Set(['Option', 'Some']),
+    elementTypes: new Set(['List', 'Seq', 'IndexedSeq', 'Vector', 'Set', 'Array', 'Iterable', 'Iterator', 'ArrayBuffer', 'ListBuffer']),
+    elementMethods: new Set(['head', 'last', 'apply', 'find', 'headOption', 'lastOption']),
+    mapTypes: new Set(['Map', 'HashMap', 'TreeMap', 'mutable.Map']),
+    mapMethods: new Set(['apply', 'get', 'getOrElse']),
+    mapValueMethods: new Set(['values']),
+    refineKind(kind, d, parent) {
+        if (kind === 'variable' && parent && ['class', 'object', 'trait'].includes(parent.kind)) return 'field';
+        return kind;
+    },
+    isModuleLevel: (node) => ['compilation_unit', 'template_body', 'package_clause'].includes(node.parent?.type ?? '') || node.parent?.parent?.type === 'package_clause',
+    fileInfo(root) {
+        const pkg = root.namedChildren.find(c => c.type === 'package_clause');
+        return { package: pkg ? pkg.text.replace(/^package\s+/, '').split(/\s|\{/)[0] : null };
+    },
+    bodyField: 'body',
+};
+
+// CSS: selectors, custom properties and keyframes are the addressable units.
+const CSS_QUERY = `
+(stylesheet (rule_set (selectors) @name) @def.selector)
+(keyframes_statement (keyframes_name) @name) @def.keyframes
+(stylesheet (declaration (property_name) @name) @def.variable (#match? @name "^--"))
+(rule_set (block (declaration (property_name) @name) @def.variable (#match? @name "^--")))
+(call_expression (function_name) @_f (arguments (plain_value) @name) (#eq? @_f "var")) @ref.value
+(import_statement) @import
+`;
+
+export const css = {
+    id: 'css',
+    grammar: 'css',
+    extensions: ['.css', '.scss', '.less'],
+    family: 'css',
+    query: CSS_QUERY,
+    implicitThis: false,
+    selfNames: [],
+    externalReceivers: new Set(),
+    builtinCalls: new Set(),
+    testFile: /$^/,
+    commentTypes: ['comment'],
+    parseImport(node) {
+        const m = /["']([^"']+)["']|url\(([^)]+)\)/.exec(node.text);
+        return m ? [{ source: (m[1] || m[2]).trim(), imported: '*', local: null }] : [];
+    },
+    isExported: () => true,
+    visibility: null,
+    isPrimitiveType: () => true,
+    normalizeName: (name) => name.replace(/\s+/g, ' ').trim().slice(0, 120),
+    bodyField: 'block',
+};