ucn 3.8.26 → 4.0.0

package/languages/go.js

@@ -10,7 +10,8 @@ const {
     traverseTreeCached,
     nodeToLocation,
     parseStructuredParams,
-    extractGoDocstring
+    extractGoDocstring,
+    visitNameNodes,
 } = require('./utils');
 const { PARSE_OPTIONS, safeParse } = require('./index');
 
@@ -181,6 +182,28 @@ function _processClass(node, types, processedRanges, lines) {
                     ...(embeddedBases.length > 0 && { extends: embeddedBases.join(', ') })
                 });
             }
+        } else if (spec.type === 'type_alias') {
+            // `type A = B` — A IS B (compiler identity, methods carry over;
+            // unlike `type A B` defined types, which get NO methods from B).
+            // Record the aliased base so callers can treat A-qualified
+            // receivers as B (fix #208).
+            const nameNode = spec.childForFieldName('name');
+            const typeNode = spec.childForFieldName('type');
+            if (nameNode && typeNode) {
+                const aliasOf = typeNode.type === 'type_identifier' ? typeNode.text
+                    : typeNode.type === 'qualified_type' ? typeNode.childForFieldName('name')?.text
+                    : null;
+                const { startLine, endLine } = nodeToLocation(node, lines);
+                types.push({
+                    name: nameNode.text,
+                    startLine,
+                    endLine,
+                    type: 'type',
+                    members: [],
+                    modifiers: /^[A-Z]/.test(nameNode.text) ? ['export'] : [],
+                    ...(aliasOf && { aliasOf }),
+                });
+            }
         }
     }
     return true;
@@ -555,6 +578,63 @@ const GO_BUILTINS = new Set([
     'println', 'real', 'recover'
 ]);
 
+/**
+ * Variable receiving this call's result (fix #207 return-type flow):
+ *   bb := balancer.Get(n)  → { assignedTo: 'bb' }
+ *   x, err := pkg.Make()   → { assignedTo: 'x', assignedTuple: true }
+ *                            (tuple unpack — the flow map pairs the first
+ *                             return element with the first variable)
+ *   y = q()                → { assignedTo: 'y' } (plain `=` only — `+=` etc.
+ *                            don't bind the call's type to the variable)
+ *   a, b := g(), h()       → parallel assignment: each call pairs with its
+ *                            own LHS position, single-value semantics
+ * Identifier targets only; blank (`_`) targets return undefined.
+ */
+function goAssignmentTargetOf(callNode) {
+    let n = callNode;
+    let p = n.parent;
+    let rhsIndex = 0;
+    let rhsCount = 1;
+    if (p && p.type === 'expression_list') {
+        rhsCount = p.namedChildCount;
+        for (let i = 0; i < p.namedChildCount; i++) {
+            if (p.namedChild(i).id === n.id) { rhsIndex = i; break; }
+        }
+        n = p; p = n.parent;
+    }
+    if (!p || (p.type !== 'short_var_declaration' && p.type !== 'assignment_statement')) return undefined;
+    if (p.type === 'assignment_statement') {
+        const op = p.childForFieldName('operator');
+        if (op && op.text !== '=') return undefined;
+    }
+    const right = p.childForFieldName('right');
+    if (!right || right.id !== n.id) return undefined;
+    const left = p.childForFieldName('left');
+    if (!left) return undefined;
+    const names = left.type === 'expression_list'
+        ? Array.from({ length: left.namedChildCount }, (_, i) => left.namedChild(i))
+        : [left];
+    if (rhsCount > 1) {
+        const target = names[rhsIndex];
+        return target?.type === 'identifier' && target.text !== '_'
+            ? { assignedTo: target.text } : undefined;
+    }
+    const target = names[0];
+    if (target?.type !== 'identifier' || target.text === '_') return undefined;
+    if (names.length > 1) {
+        // All LHS names (fix #220): an EXTERNAL producer decides every tuple
+        // element's type, not just the first — `tmpFile, err := os.CreateTemp`
+        // marks err external-flow too. The TYPED flow keeps pairing only
+        // element 0 with the producer's return tuple (#207).
+        const rest = names.slice(1)
+            .filter(t => t.type === 'identifier' && t.text !== '_')
+            .map(t => t.text);
+        return { assignedTo: target.text, assignedTuple: true,
+            ...(rest.length > 0 && { assignedTupleRest: rest }) };
+    }
+    return { assignedTo: target.text };
+}
+
 function findCallsInCode(code, parser, options = {}) {
     const tree = parseTree(parser, code);
     const calls = [];
@@ -736,6 +816,104 @@ function findCallsInCode(code, parser, options = {}) {
         return undefined;
     };
 
+    // fix #203 (Go): is a bare-identifier function REFERENCE shadowed by an
+    // enclosing func-literal/function parameter, method receiver, range/init
+    // binding, or a := / var local declared before use? grpc-go-measured:
+    // `&clusterInfo{unsubscribe: unsubscribe}` inside `func(ref int32,
+    // unsubscribe func())` references the parameter, never a same-name
+    // package symbol. The enclosing INDEXED symbol's params are checked at
+    // query time in findCallers — func-literal params and block locals are
+    // only visible here. (Rust/Java need no equivalent: their parsers emit
+    // no bare-identifier callback references — Rust only obj.method field
+    // expressions, Java only :: method references.)
+    const _paramListDeclares = (paramsNode, name) => {
+        if (!paramsNode) return false;
+        for (let i = 0; i < paramsNode.namedChildCount; i++) {
+            const pd = paramsNode.namedChild(i);
+            if (pd.type !== 'parameter_declaration' && pd.type !== 'variadic_parameter_declaration') continue;
+            // Go allows several names per declaration: `a, b int`
+            for (let j = 0; j < pd.namedChildCount; j++) {
+                const c = pd.namedChild(j);
+                if (c.type === 'identifier' && c.text === name) return true;
+            }
+        }
+        return false;
+    };
+    const _declaresLocal = (stmt, name, refNode) => {
+        if (!stmt) return false;
+        // The declaration CONTAINING the reference is not a shadow: in
+        // `unsubscribe := unsubscribe` the RHS names the OUTER binding —
+        // Go's := declares the LHS only after the statement.
+        if (stmt.startIndex <= refNode.startIndex && stmt.endIndex >= refNode.endIndex) return false;
+        if (stmt.type === 'short_var_declaration') {
+            const left = stmt.childForFieldName('left');
+            if (left) {
+                for (let i = 0; i < left.namedChildCount; i++) {
+                    const id = left.namedChild(i);
+                    if (id.type === 'identifier' && id.text === name) return true;
+                }
+            }
+        } else if (stmt.type === 'var_declaration') {
+            for (let i = 0; i < stmt.namedChildCount; i++) {
+                const spec = stmt.namedChild(i);
+                if (spec.type !== 'var_spec') continue;
+                for (let j = 0; j < spec.namedChildCount; j++) {
+                    const id = spec.namedChild(j);
+                    if (id.type === 'identifier' && id.text === name) return true;
+                }
+            }
+        }
+        return false;
+    };
+    const isShadowedByLocal = (refNode, name) => {
+        for (let p = refNode.parent; p; p = p.parent) {
+            if (p.type === 'block') {
+                for (let i = 0; i < p.namedChildCount; i++) {
+                    const stmt = p.namedChild(i);
+                    if (stmt.startIndex >= refNode.startIndex) break; // declaration-before-use
+                    if (_declaresLocal(stmt, name, refNode)) return true;
+                }
+            } else if (p.type === 'for_statement') {
+                for (let i = 0; i < p.namedChildCount; i++) {
+                    const c = p.namedChild(i);
+                    if (c.type === 'range_clause') {
+                        const left = c.childForFieldName('left');
+                        if (left) {
+                            for (let j = 0; j < left.namedChildCount; j++) {
+                                const id = left.namedChild(j);
+                                if (id.type === 'identifier' && id.text === name) return true;
+                            }
+                        }
+                    } else if (c.type === 'for_clause') {
+                        if (_declaresLocal(c.childForFieldName('initializer'), name, refNode)) return true;
+                    }
+                }
+            } else if (p.type === 'if_statement' || p.type === 'expression_switch_statement' ||
+                p.type === 'type_switch_statement') {
+                if (_declaresLocal(p.childForFieldName('initializer'), name, refNode)) return true;
+                // if/switch initializers are plain named children in some
+                // grammar versions; type switches bind `v := x.(type)`
+                for (let i = 0; i < p.namedChildCount; i++) {
+                    const c = p.namedChild(i);
+                    if (c.type === 'short_var_declaration' && _declaresLocal(c, name, refNode)) return true;
+                    if (p.type === 'type_switch_statement' && c.type === 'expression_list' &&
+                        c.nextSibling?.type === ':=') {
+                        for (let j = 0; j < c.namedChildCount; j++) {
+                            const id = c.namedChild(j);
+                            if (id.type === 'identifier' && id.text === name) return true;
+                        }
+                    }
+                }
+            } else if (p.type === 'func_literal' || p.type === 'function_declaration' ||
+                p.type === 'method_declaration') {
+                if (_paramListDeclares(p.childForFieldName('parameters'), name)) return true;
+                if (p.type === 'method_declaration' &&
+                    _paramListDeclares(p.childForFieldName('receiver'), name)) return true;
+            }
+        }
+        return false;
+    };
+
     traverseTree(tree.rootNode, (node) => {
         // Track function entry
         if (isFunctionNode(node)) {
@@ -795,6 +973,23 @@ function findCallsInCode(code, parser, options = {}) {
                                 if (callName && /^New[A-Z]/.test(callName)) {
                                     typeName = callName.slice(3);
                                     if (!typeName || !/^[A-Z]/.test(typeName)) typeName = null;
+                                } else if (callFuncNode.type === 'identifier' &&
+                                    callFuncNode.text === 'new') {
+                                    // buf := new(bytes.Buffer) — the builtin
+                                    // allocator returns *T (fix #220,
+                                    // cobra-measured: buf.String() is
+                                    // bytes.Buffer's, never a project method).
+                                    // The argument parses as an expression:
+                                    // identifier or selector_expression.
+                                    const args = val.childForFieldName('arguments');
+                                    const argNode = args && args.namedChild(0);
+                                    if (argNode) {
+                                        typeName = argNode.type === 'identifier'
+                                            ? argNode.text
+                                            : argNode.type === 'selector_expression'
+                                                ? argNode.childForFieldName('field')?.text || null
+                                                : extractTypeName(argNode);
+                                    }
                                 }
                             }
                         }
@@ -804,6 +999,34 @@ function findCallsInCode(code, parser, options = {}) {
             }
         }
 
+        // Explicitly typed var declarations: `var buf bytes.Buffer`,
+        // `var sb strings.Builder` (fix #220, cobra-measured — sb.String()
+        // on an untyped receiver fell to single-owner confirmation). Same
+        // semantics as parameter annotations: the declared type is the
+        // receiver's compile-time type.
+        if (node.type === 'var_declaration' && functionStack.length > 0) {
+            const scopeKey = functionStack[functionStack.length - 1].startLine;
+            const varTypeMap = scopeTypes.get(scopeKey);
+            if (varTypeMap) {
+                const recordSpec = (spec) => {
+                    if (spec.type !== 'var_spec') return;
+                    const typeName = extractTypeName(spec.childForFieldName('type'));
+                    if (!typeName) return;
+                    for (let j = 0; j < spec.namedChildCount; j++) {
+                        const id = spec.namedChild(j);
+                        if (id.type === 'identifier') varTypeMap.set(id.text, typeName);
+                    }
+                };
+                for (let i = 0; i < node.namedChildCount; i++) {
+                    const c = node.namedChild(i);
+                    if (c.type === 'var_spec') recordSpec(c);
+                    else if (c.type === 'var_spec_list') {
+                        for (let j = 0; j < c.namedChildCount; j++) recordSpec(c.namedChild(j));
+                    }
+                }
+            }
+        }
+
         // Track local closures: atoi := func(...) { ... } or var handler = func(...) { ... }
         if (node.type === 'short_var_declaration' || node.type === 'var_declaration') {
             // Check if a subtree contains a func_literal
@@ -861,6 +1084,26 @@ function findCallsInCode(code, parser, options = {}) {
             const enclosingFunction = getCurrentEnclosingFunction();
             let uncertain = false;
 
+            // Call-site arg count for arity pruning. Slice-spread (`xs...`)
+            // makes the count open-ended — flag it so pruning skips the site.
+            const argsNode = node.childForFieldName('arguments');
+            let argCount = 0;
+            let argSpread = false;
+            if (argsNode) {
+                for (let i = 0; i < argsNode.namedChildCount; i++) {
+                    if (argsNode.namedChild(i).type === 'comment') continue;
+                    argCount++;
+                }
+                for (let i = 0; i < argsNode.childCount; i++) {
+                    if (argsNode.child(i).type === '...') { argSpread = true; break; }
+                }
+            }
+
+            // Assignment target for return-type flow (fix #207):
+            // bb := balancer.Get(n) lets findCallers type bb from Get's
+            // declared return type at query time.
+            const assigned = goAssignmentTargetOf(node);
+
             if (funcNode.type === 'identifier') {
                 const callName = funcNode.text;
                 // Skip Go built-in function calls
@@ -877,6 +1120,11 @@ function findCallsInCode(code, parser, options = {}) {
                     name: callName,
                     line: node.startPosition.row + 1,
                     isMethod: false,
+                    argCount,
+                    ...(argSpread && { argSpread: true }),
+                    ...(assigned && { assignedTo: assigned.assignedTo }),
+                    ...(assigned?.assignedTuple && { assignedTuple: true }),
+                        ...(assigned?.assignedTupleRest && { assignedTupleRest: assigned.assignedTupleRest }),
                     enclosingFunction,
                     uncertain,
                     ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
@@ -892,13 +1140,67 @@ function findCallsInCode(code, parser, options = {}) {
                     // If receiver is a known import alias, this is a package call, not a method call
                     const isPkgCall = receiver && importAliases.has(receiver);
                     const receiverType = (!isPkgCall && receiver) ? getReceiverType(receiver) : undefined;
+                    // fix #202: one-hop declared-field receivers — h.inner.Run().
+                    // receiverRoot/Field/RootType let findCallers hop to the
+                    // field's declared struct-field type cross-file.
+                    let receiverRoot, receiverFieldName, receiverRootType;
+                    if (!receiver && operandNode?.type === 'selector_expression') {
+                        const rootNode = operandNode.childForFieldName('operand');
+                        const fldNode = operandNode.childForFieldName('field');
+                        if (rootNode?.type === 'identifier' && fldNode &&
+                            !importAliases.has(rootNode.text)) {
+                            receiverRoot = rootNode.text;
+                            receiverFieldName = fldNode.text;
+                            receiverRootType = getReceiverType(rootNode.text);
+                        }
+                    }
+                    // Chained receiver (fix #220, cobra-measured): the receiver
+                    // IS a call — rootCmd.Flags().String(...) — record the
+                    // producer so findCallers can type the receiver from its
+                    // declared return (*pflag.FlagSet → external → routed).
+                    // Package-qualified producers (os.CreateTemp().Name())
+                    // carry the qualifier for strict import-package resolution.
+                    let receiverCall, receiverCallIsMethod, receiverCallReceiver;
+                    if (!receiver && !receiverFieldName && operandNode?.type === 'call_expression') {
+                        const prodFunc = operandNode.childForFieldName('function');
+                        if (prodFunc?.type === 'identifier') {
+                            receiverCall = prodFunc.text;
+                        } else if (prodFunc?.type === 'selector_expression') {
+                            const pf = prodFunc.childForFieldName('field');
+                            const po = prodFunc.childForFieldName('operand');
+                            if (pf) {
+                                receiverCall = pf.text;
+                                if (po?.type === 'identifier' && importAliases.has(po.text)) {
+                                    receiverCallReceiver = po.text;
+                                } else {
+                                    receiverCallIsMethod = true;
+                                }
+                            }
+                        }
+                    }
                     const firstArg = getFirstStringArg(node);
                     calls.push({
                         name: fieldNode.text,
-                        line: node.startPosition.row + 1,
+                        // Name-node line convention (#201/RUST-2, fix #223):
+                        // a method call on a multi-line receiver —
+                        // (&pkg.Name{...}).String() — reports the FIELD's own
+                        // line, not the chain-start line. The account's ground
+                        // set and the oracles key by the name's line; Go was
+                        // the only parser still using the call node's start.
+                        line: fieldNode.startPosition.row + 1,
                         isMethod: !isPkgCall,
                         receiver,
                         ...(receiverType && { receiverType }),
+                        ...(receiverFieldName && { receiverRoot, receiverField: receiverFieldName }),
+                        ...(receiverFieldName && receiverRootType && { receiverRootType }),
+                        ...(receiverCall && { receiverCall }),
+                        ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
+                        ...(receiverCallReceiver && { receiverCallReceiver }),
+                        argCount,
+                        ...(argSpread && { argSpread: true }),
+                        ...(assigned && { assignedTo: assigned.assignedTo }),
+                        ...(assigned?.assignedTuple && { assignedTuple: true }),
+                        ...(assigned?.assignedTupleRest && { assignedTupleRest: assigned.assignedTupleRest }),
                         enclosingFunction,
                         uncertain,
                         ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
@@ -926,13 +1228,18 @@ function findCallsInCode(code, parser, options = {}) {
             const typeNode = node.childForFieldName('type');
             if (typeNode) {
                 let typeName = null;
+                let typeQualifier = null;
                 if (typeNode.type === 'type_identifier') {
                     // Foo{...}
                     typeName = typeNode.text;
                 } else if (typeNode.type === 'qualified_type') {
-                    // pkg.Foo{...}
+                    // pkg.Foo{...} — keep the package qualifier as receiver: a
+                    // package-qualified type can never resolve to a same-file
+                    // binding (Go cannot self-import), so resolution must not
+                    // claim local same-name symbols for it.
                     const tn = typeNode.childForFieldName('name');
                     if (tn) typeName = tn.text;
+                    typeQualifier = typeNode.childForFieldName('package')?.text || null;
                 }
                 // Skip anonymous types (slice_type, map_type, array_type, struct_type, etc.)
                 if (typeName) {
@@ -942,6 +1249,7 @@ function findCallsInCode(code, parser, options = {}) {
                         line: node.startPosition.row + 1,
                         isMethod: false,
                         isConstructor: true,
+                        ...(typeQualifier && { receiver: typeQualifier }),
                         enclosingFunction,
                         uncertain: false
                     });
@@ -988,7 +1296,8 @@ function findCallsInCode(code, parser, options = {}) {
                     isFunctionReference: true,
                     isPotentialCallback: true,
                     enclosingFunction,
-                    uncertain: false
+                    uncertain: false,
+                    ...(isShadowedByLocal(node, name) && { localShadow: true }),
                 });
             }
         }
@@ -1039,7 +1348,8 @@ function findCallsInCode(code, parser, options = {}) {
                                 isFunctionReference: true,
                                 isPotentialCallback: true,
                                 enclosingFunction,
-                                uncertain: false
+                                uncertain: false,
+                                ...(isShadowedByLocal(rhs, name) && { localShadow: true }),
                             });
                         }
                     }
@@ -1097,6 +1407,7 @@ function findCallsInCode(code, parser, options = {}) {
                             uncertain: false,
                             ...(compositeType && { compositeType }),
                             ...(fieldName && { fieldName }),
+                            ...(isShadowedByLocal(valueNode, name) && { localShadow: true }),
                         });
                     }
                 }
@@ -1329,7 +1640,7 @@ function findUsagesInCode(code, name, parser) {
     const tree = parseTree(parser, code);
     const usages = [];
 
-    traverseTreeCached(tree.rootNode, (node) => {
+    visitNameNodes(tree, code, name, (node) => {
         // Look for identifier, field_identifier (method names in selector expressions),
         // and type_identifier (type references in params, return types, composite literals, etc.)
         const isIdentifier = node.type === 'identifier' || node.type === 'field_identifier' || node.type === 'type_identifier';

package/languages/index.js

@@ -21,6 +21,25 @@ const STRUCTURAL_TRAITS = {
     exportVisibility: 'keyword',
     hasDynamicImports: true,
     testDirs: [],
+    allMethodsVirtual: false,
+    hasArityOverloads: false,
+    // Class members are public unless marked otherwise (#name, _name,
+    // `private`). An exported class therefore exposes its non-private methods
+    // as public API — deadcode treats them as exported (fix #211). Languages
+    // with explicit member visibility (Rust `pub`, Java `public` — already
+    // captured as modifiers) or capitalization rules (Go) set false: there
+    // the member's own marker decides.
+    implicitlyPublicMembers: true,
+    // A bare (receiver-less) name can never denote a METHOD here — JS/Python
+    // methods are reached through their receiver; only a rebound alias could,
+    // which is separate name-level evidence. Java sets true: `execute()`
+    // inside a class means this.execute(), and static imports bind foreign
+    // class methods to bare names (fix #220).
+    bareCallReachesMethods: false,
+    // A method-shaped call CAN reach a standalone function here: attribute
+    // assignment rebinds functions onto objects (obj.print = print), so the
+    // #218b gate routes such calls visible instead of excluding (fix #220).
+    methodCallReachesFunctions: true,
 };
 const NOMINAL_TRAITS = {
     typeSystem: 'nominal',
@@ -30,6 +49,58 @@ const NOMINAL_TRAITS = {
     exportVisibility: 'keyword',
     hasDynamicImports: true,
     testDirs: [],
+    // Whether ANY instance method call can dynamically dispatch to a subtype
+    // override (Java: all instance methods are virtual). Go struct method
+    // sets and Rust inherent methods bind statically — only interface/trait
+    // receivers dispatch there, which is detected per-type, not per-language.
+    allMethodsVirtual: false,
+    // Whether one class can define several same-name methods differing only
+    // in parameters (Java overloading). Drives the overload discipline in
+    // the caller contract: a pinned overload is only confirmed when the call
+    // site provably binds it.
+    hasArityOverloads: false,
+    // What a TYPE-QUALIFIED method call looks like, so a receiver that merely
+    // shares the target type's NAME isn't mistaken for the type itself:
+    //   'static'      — Type.method() static form, any arity (Java).
+    //   'method-expr' — Go method expressions T.M(recv, ...): the receiver
+    //                   instance is the FIRST argument, so a zero-arg call on
+    //                   a type-named receiver must be a variable (grpc-go
+    //                   names builder structs and Builder locals both `bb`).
+    //   'path'        — Rust Type::method (isPathCall); a DOT-call receiver
+    //                   matching a type name is a variable, never the type.
+    typeQualifiedCallStyle: 'static',
+    implicitlyPublicMembers: false,
+    // The implicit root supertype every class extends without declaring it
+    // (Java `Object`). A receiver declared with this type can hold ANY project
+    // instance, so it is dispatch-capable toward every override — but the
+    // edge is invisible to declared-ancestry walks (fix #212). Routing only,
+    // never exclusion evidence. Go/Rust: null — Go's interface{}/any cannot
+    // receive method calls without an assertion, Rust has no universal
+    // supertype. Structural languages: null — any/object/unknown receivers
+    // are already refused as exclusion evidence by the trust gate.
+    universalSupertype: null,
+    // A bare (receiver-less) call or reference can never denote a METHOD:
+    // Go method values/expressions require an explicit receiver or type
+    // qualifier (m.Helper(), T.Helper); Rust requires self./Type:: and `use`
+    // cannot import associated functions. A bare MarkFlagDirname(...) inside
+    // Command.MarkFlagDirname denotes the package FUNCTION (fix #220,
+    // cobra/grpc-go-measured). Java overrides true (implicit this-calls,
+    // static imports).
+    bareCallReachesMethods: false,
+    // Whether a method-shaped call (x.f()) can reach a standalone FUNCTION:
+    // Go func-typed fields are name-callable (s.Run() may invoke a stored
+    // function), so exclusion needs !bindingId there; Rust requires (s.f)()
+    // parens and Java requires .apply() — a dot-call provably never binds a
+    // free function (fix #220, ripgrep-measured).
+    methodCallReachesFunctions: false,
+    // Whether a paren-less member access (x.name) can denote a METHOD. Rust
+    // sets true for the inverse — `x.name` is ALWAYS a field there (method
+    // values are path-only: Type::method), so a member-access reference
+    // against a method target is excluded (fix #220, ripgrep-measured:
+    // `self.paths.has_implicit_path` is the bool FIELD, not the method).
+    // Go method values (obj.Method) and Java `::` references DO denote
+    // methods — false. Per-language override, not preset-wide.
+    memberAccessNeverMethod: false,
 };
 
 // Language configurations
@@ -99,6 +170,8 @@ const LANGUAGES = {
             hasReceiverPackageCalls: true,
             exportVisibility: 'capitalization',
             hasDynamicImports: false,
+            typeQualifiedCallStyle: 'method-expr',
+            methodCallReachesFunctions: true,
             testFileCandidates: (base, ext) => [`${base}_test.go`],
         },
     },
@@ -112,6 +185,8 @@ const LANGUAGES = {
             ...NOMINAL_TRAITS,
             selfParam: ['self', '&self', '&mut self', 'mut self'],
             hasDynamicImports: false,
+            typeQualifiedCallStyle: 'path',
+            memberAccessNeverMethod: true,
             testFileCandidates: (base, ext) => [`${base}_test.rs`],
             testDirs: ['tests'],
         },
@@ -125,6 +200,10 @@ const LANGUAGES = {
         traits: {
             ...NOMINAL_TRAITS,
             selfParam: ['this'],
+            allMethodsVirtual: true,
+            hasArityOverloads: true,
+            universalSupertype: 'Object',
+            bareCallReachesMethods: true,
             testFileCandidates: (base, ext) => [`${base}Test.java`, `${base}Tests.java`, `${base}TestCase.java`],
         },
     },