ucn 5.5.3 → 5.6.0

package/languages/index.js

@@ -104,6 +104,14 @@ const JAVA_LANG_NOT_SERIALIZABLE = ['Object', 'Runnable', 'AutoCloseable', 'Comp
 
 const STRUCTURAL_TRAITS = {
     typeSystem: 'structural',
+    // How a callable's return contract can come from its body instead of its
+    // header. 'unannotated': a callable with no return annotation takes the
+    // type its body returns; 'placeholder': a written placeholder type is
+    // deduced from the body; 'opaque': a declared opaque type still exposes
+    // properties of the concrete value. Empty: the header is the contract.
+    inferredReturnForms: ['unannotated'],
+    // Callable kinds a body statement alone selects, with no header change.
+    callableKindFromBody: [],
     // A write on the instance can replace an inherited method with a
     // callable value, including a wrapper of the previous method.
     instanceAttributesShadowMethods: true,
@@ -154,6 +162,10 @@ const STRUCTURAL_TRAITS = {
     // 'namespace-usings' (C#: enclosing namespaces, then using directives,
     // global usings and project-file <Using> items), or null.
     typeNameScoping: null,
+    // The platform's generic types a language writes with a syntax of its
+    // own: { nullable, tuple }, each the type's qualified name (C#:
+    // `System.Nullable<T>` is `T?`). Two spellings of one type.
+    platformTypeForms: null,
     typeNameSourceCanonical: null,
     typeNameOwnersAt: null,
     implementationOwnerSyntax: null,
@@ -256,6 +268,9 @@ const STRUCTURAL_TRAITS = {
     constructorArgumentNodes: { delegation: { nodeType: 'call_expression', argsField: 'arguments' } },
     functionalTypeConstruction: false,
     constructorInheritance: { order: 'single', classNodes: ['class_declaration', 'class'], headerNode: 'class_heritage' },
+    // Methods whose result a context-manager statement binds (`with X() as
+    // v` binds `X().__enter__()`), or null when the language has none.
+    contextEnterMethods: null,
     implicitBaseConstruction: null,
     // Whether a constructor delegation is spelled by a keyword (`this(..)`,
     // `super(..)`, `base(..)`) rather than by the type's name (C++
@@ -303,6 +318,123 @@ const STRUCTURAL_TRAITS = {
     // text dependencies; no other language checks a test function's name
     // against a declaration.
     nameBoundTestFunctions: null,
+    // Methods a type declares to satisfy a standard-library contract it
+    // never names (interfaces satisfied implicitly): name -> parameter
+    // count. A zero textual use of one is not evidence that it is unused.
+    implicitStandardContracts: null,
+    // Is this project type a contract a value can satisfy WITHOUT naming it
+    // (assigned, passed or returned as the type with no implements clause)?
+    // null: types are satisfied by declaration only, or the language has
+    // its own model (Go's method sets). A type that satisfies such a
+    // contract by its member names keeps the members the contract requires.
+    structuralContract: null,
+    // Can another file import ANY module-level name of a module, declared
+    // or merely imported there, with no export syntax (Python)? Removing
+    // such a name, an import included, takes it from its importers.
+    moduleNamesImportable: false,
+    // Is a directory importable as a package without its package file
+    // (Python namespace packages)? Then deleting that file takes away the
+    // names it declared, not the package.
+    packageFileOptional: false,
+    // Module-level names that let a module supply names it does not write
+    // (Python: a module `__getattr__`, a rewritten package `__path__`). A
+    // package that declares one cannot be shown to lack a submodule.
+    moduleSupplyHooks: [],
+    // Is a member's type whatever the class's methods assign to it (Python
+    // instance attributes)? Then an assignment to a receiver member in any
+    // method is part of the class's contract.
+    memberTypesFromAssignments: false,
+    // Does an async function's anonymous future expose properties of its
+    // body to callers (Rust auto traits: Send, Sync)?
+    asyncReturnIsOpaque: false,
+    // Modifiers that let the compiler run a callable and hand callers its
+    // VALUE (C++ constexpr/consteval, Rust `const fn`): the body is then
+    // part of what a caller relies on. null: no such callables.
+    compileTimeCallableMarkers: null,
+    // Callable names the language supplies with no import and no
+    // declaration (builtins, globals): a bare call of one always means
+    // something. null: every callable name is declared or imported.
+    ambientCallables: null,
+    // Builtins among `ambientCallables` that never return (Python `exit`),
+    // and global objects whose every member returns (`console`).
+    ambientNeverCallables: null,
+    ambientReturningNamespaces: null,
+    // How a declaration says "a call of this never returns" (`never`,
+    // `NoReturn`): a type checker ends the caller's path at a call of one,
+    // and only at a declared one. []: the language has no such type; null:
+    // no return contract is read from a body in this language.
+    neverReturnTypes: null,
+    // Can a type checker decide a condition from the names in it (Python:
+    // `sys.version_info`, `sys.platform`, `TYPE_CHECKING`, constants its
+    // configuration defines)? Then a condition that guards part of what a
+    // body returns is part of it; elsewhere only a condition that names
+    // nothing (`while (true)`) is decided.
+    namedConditionsDecidable: false,
+    // Do files without module syntax share one global scope (classic
+    // JavaScript scripts)? Then a top-level name of one is visible in all.
+    scriptGlobalScope: false,
+    // Are the members of a class compared and enumerated by SHAPE
+    // (TypeScript)? Then the trait answers whether anything with the
+    // class's members is a value of it: `(classNode, ignoredLines) =>
+    // boolean`, true unless the class itself declares a private or
+    // protected instance member (members starting on `ignoredLines` left
+    // out). null: a class is its declaration, and its members are reached
+    // by name only.
+    classComparedByShape: null,
+    // How a class member takes part in the class's type: `(classNode,
+    // name, line) => { role: 'instance' | 'optional' | 'static', hidden }
+    // | null`; hidden: private, protected or `#`.
+    classMemberRole: null,
+    // Members of an object literal declared as a type, read from syntax:
+    // `(root, line) => { names, open } | null` (languages/javascript.js).
+    typedLiteralMembers: null,
+    // The interface whose members every object has (`Object`): a project
+    // that declares one adds members to every literal.
+    universalObjectInterface: null,
+    // Has the language's checker been told not to report a break, as its
+    // own scanner reads comments (`// @ts-ignore` above the line the break
+    // is reported on, `# type: ignore` on a line of the reported range, a
+    // rule turned off for the file)? `(site) => boolean` with site
+    // { lines, root, line, kind: 'arity' | 'import-name' | 'import-module'
+    // | 'undefined-name' | 'literal', name, most, memo }. A break at such a
+    // site is one the toolchain will not show: check lists it and does not
+    // block on it.
+    checkSuppressedAt: null,
+    // The tests a file declares, as its runner collects them:
+    // `(fileEntry, helpers) => { units, inheriting }` where a unit is
+    // { kind: 'test' | 'suite', name, suite: [names], line, endLine } plus
+    // what a selector needs (core/test-units.js). Null: the language's
+    // tests are not read, and nothing is said about them.
+    testUnits: null,
+    // (fileEntry, helpers) => boolean: does this file hold code the runner
+    // asks at run time that may leave tests out (a conftest hook, a TestMain).
+    testGate: null,
+    // `(fileEntry, projectDeclaresType) => { marked, bases }` or null: can
+    // a file hold test code, from the index alone (no tree)? Asked before
+    // a file whose name is no test file's is read for the tests in it.
+    testCodeGate: null,
+    // Which family of runners executes the language's tests; the family's
+    // manifests are the evidence a runner is named on. Null: none modeled.
+    testRunnerFamily: null,
+    // Modules whose import in a test file names its runner: `() => Map` of
+    // module name to runner id; null where an import says nothing of it.
+    testRunnerModules: null,
+    // What a module of the language exports under a name, as far as
+    // declaring tests goes: `(fileEntry, helpers, name) => binding | null`.
+    // A test file that takes its runner through a project module is read
+    // through it. Null: imports are not followed.
+    testExport: null,
+    // How the language's runners name a test file. A test-path file that
+    // declares no test and is not named like one is support code.
+    testFileNames: [],
+    // Is the import of `module` written on a line one the project's judge
+    // resolves (an import statement), not a call it never looks into?
+    // `(root, line, module) => boolean`; null: every import of the language
+    // is a statement.
+    checkedImportAt: null,
+    // Does a virtual member change what a type IS to existing code (C++: a
+    // class with one is no aggregate, so `T t{1, 2}` stops compiling)?
+    virtualMemberChangesShape: false,
     // Whether a top-level type is declared in a source file named after it
     // (fix #386): javac requires `public class Widget` in Widget.java, so a
     // type rename renames that file too.
@@ -350,7 +482,15 @@ const STRUCTURAL_TRAITS = {
     // class literals. `hintPattern` locates vocabulary spellings whose
     // enclosing call nodes are inspected (the AST decides); `namespaceLookups` are module-namespace lookups by
     // name (eval, globals()[k]). `family` groups languages sharing one
-    // runtime. null = no runtime reflection.
+    // runtime. `unnamed` are reflective calls that carry no member name and
+    // `codeExecution` calls and constructions that run code built at
+    // runtime: both are counted per file with the rest of the vocabulary
+    // (fileEntry.reflectionUses / evalUses, what `repo` and the completeness
+    // footer disclose) and never matched against names. Such a rule is
+    // `{ callee }` (the callee as written; `qualified` when it has a
+    // receiver), `{ package }` (a call qualified by a local name the file's
+    // imports bind to that module) or `{ construct }` (the constructed
+    // class). null = no runtime reflection.
     reflectionApi: null,
     // Members every class inherits from the implicit root supertype, keyed by
     // name with their parameter count (Java Object.toString/equals/...,
@@ -371,6 +511,9 @@ const STRUCTURAL_TRAITS = {
 };
 const NOMINAL_TRAITS = {
     typeSystem: 'nominal',
+    // See STRUCTURAL_TRAITS: a declared return type is the whole contract.
+    inferredReturnForms: [],
+    callableKindFromBody: [],
     instanceAttributesShadowMethods: false,
     inherentMethodsPrecedeTraitImpls: false,
     derefFieldAccess: false,
@@ -381,6 +524,7 @@ const NOMINAL_TRAITS = {
     hasConstructors: false,
     fixedConstructorName: null,
     constructorInheritance: null,
+    contextEnterMethods: null,
     implicitBaseConstruction: null,
     keywordConstructorDelegation: false,
     constructorUsesAreTypeReferences: false,
@@ -403,6 +547,7 @@ const NOMINAL_TRAITS = {
     moduleTypeIdentity: false,
     standardPathRoots: [],
     typeNameScoping: null,
+    platformTypeForms: null,
     typeNameSourceCanonical: null,
     typeNameOwnersAt: null,
     implicitTypeImport: null,
@@ -516,6 +661,123 @@ const NOMINAL_TRAITS = {
     // Test functions the toolchain binds to a declared identifier by NAME
     // (fix #383); see GO_EXAMPLE_NAMES. null: no such convention.
     nameBoundTestFunctions: null,
+    // Methods a type declares to satisfy a standard-library contract it
+    // never names (interfaces satisfied implicitly): name -> parameter
+    // count. A zero textual use of one is not evidence that it is unused.
+    implicitStandardContracts: null,
+    // Is this project type a contract a value can satisfy WITHOUT naming it
+    // (assigned, passed or returned as the type with no implements clause)?
+    // null: types are satisfied by declaration only, or the language has
+    // its own model (Go's method sets). A type that satisfies such a
+    // contract by its member names keeps the members the contract requires.
+    structuralContract: null,
+    // Can another file import ANY module-level name of a module, declared
+    // or merely imported there, with no export syntax (Python)? Removing
+    // such a name, an import included, takes it from its importers.
+    moduleNamesImportable: false,
+    // Is a directory importable as a package without its package file
+    // (Python namespace packages)? Then deleting that file takes away the
+    // names it declared, not the package.
+    packageFileOptional: false,
+    // Module-level names that let a module supply names it does not write
+    // (Python: a module `__getattr__`, a rewritten package `__path__`). A
+    // package that declares one cannot be shown to lack a submodule.
+    moduleSupplyHooks: [],
+    // Is a member's type whatever the class's methods assign to it (Python
+    // instance attributes)? Then an assignment to a receiver member in any
+    // method is part of the class's contract.
+    memberTypesFromAssignments: false,
+    // Does an async function's anonymous future expose properties of its
+    // body to callers (Rust auto traits: Send, Sync)?
+    asyncReturnIsOpaque: false,
+    // Modifiers that let the compiler run a callable and hand callers its
+    // VALUE (C++ constexpr/consteval, Rust `const fn`): the body is then
+    // part of what a caller relies on. null: no such callables.
+    compileTimeCallableMarkers: null,
+    // Callable names the language supplies with no import and no
+    // declaration (builtins, globals): a bare call of one always means
+    // something. null: every callable name is declared or imported.
+    ambientCallables: null,
+    // Builtins among `ambientCallables` that never return (Python `exit`),
+    // and global objects whose every member returns (`console`).
+    ambientNeverCallables: null,
+    ambientReturningNamespaces: null,
+    // How a declaration says "a call of this never returns" (`never`,
+    // `NoReturn`): a type checker ends the caller's path at a call of one,
+    // and only at a declared one. []: the language has no such type; null:
+    // no return contract is read from a body in this language.
+    neverReturnTypes: null,
+    // Can a type checker decide a condition from the names in it (Python:
+    // `sys.version_info`, `sys.platform`, `TYPE_CHECKING`, constants its
+    // configuration defines)? Then a condition that guards part of what a
+    // body returns is part of it; elsewhere only a condition that names
+    // nothing (`while (true)`) is decided.
+    namedConditionsDecidable: false,
+    // Do files without module syntax share one global scope (classic
+    // JavaScript scripts)? Then a top-level name of one is visible in all.
+    scriptGlobalScope: false,
+    // Are the members of a class compared and enumerated by SHAPE
+    // (TypeScript)? Then the trait answers whether anything with the
+    // class's members is a value of it: `(classNode, ignoredLines) =>
+    // boolean`, true unless the class itself declares a private or
+    // protected instance member (members starting on `ignoredLines` left
+    // out). null: a class is its declaration, and its members are reached
+    // by name only.
+    classComparedByShape: null,
+    // How a class member takes part in the class's type: `(classNode,
+    // name, line) => { role: 'instance' | 'optional' | 'static', hidden }
+    // | null`; hidden: private, protected or `#`.
+    classMemberRole: null,
+    // Members of an object literal declared as a type, read from syntax:
+    // `(root, line) => { names, open } | null` (languages/javascript.js).
+    typedLiteralMembers: null,
+    // The interface whose members every object has (`Object`): a project
+    // that declares one adds members to every literal.
+    universalObjectInterface: null,
+    // Has the language's checker been told not to report a break, as its
+    // own scanner reads comments (`// @ts-ignore` above the line the break
+    // is reported on, `# type: ignore` on a line of the reported range, a
+    // rule turned off for the file)? `(site) => boolean` with site
+    // { lines, root, line, kind: 'arity' | 'import-name' | 'import-module'
+    // | 'undefined-name' | 'literal', name, most, memo }. A break at such a
+    // site is one the toolchain will not show: check lists it and does not
+    // block on it.
+    checkSuppressedAt: null,
+    // The tests a file declares, as its runner collects them:
+    // `(fileEntry, helpers) => { units, inheriting }` where a unit is
+    // { kind: 'test' | 'suite', name, suite: [names], line, endLine } plus
+    // what a selector needs (core/test-units.js). Null: the language's
+    // tests are not read, and nothing is said about them.
+    testUnits: null,
+    // (fileEntry, helpers) => boolean: does this file hold code the runner
+    // asks at run time that may leave tests out (a conftest hook, a TestMain).
+    testGate: null,
+    // `(fileEntry, projectDeclaresType) => { marked, bases }` or null: can
+    // a file hold test code, from the index alone (no tree)? Asked before
+    // a file whose name is no test file's is read for the tests in it.
+    testCodeGate: null,
+    // Which family of runners executes the language's tests; the family's
+    // manifests are the evidence a runner is named on. Null: none modeled.
+    testRunnerFamily: null,
+    // Modules whose import in a test file names its runner: `() => Map` of
+    // module name to runner id; null where an import says nothing of it.
+    testRunnerModules: null,
+    // What a module of the language exports under a name, as far as
+    // declaring tests goes: `(fileEntry, helpers, name) => binding | null`.
+    // A test file that takes its runner through a project module is read
+    // through it. Null: imports are not followed.
+    testExport: null,
+    // How the language's runners name a test file. A test-path file that
+    // declares no test and is not named like one is support code.
+    testFileNames: [],
+    // Is the import of `module` written on a line one the project's judge
+    // resolves (an import statement), not a call it never looks into?
+    // `(root, line, module) => boolean`; null: every import of the language
+    // is a statement.
+    checkedImportAt: null,
+    // Does a virtual member change what a type IS to existing code (C++: a
+    // class with one is no aggregate, so `T t{1, 2}` stops compiling)?
+    virtualMemberChangesShape: false,
     // A top-level type lives in a file named after it (fix #386, Java).
     typeNamedSourceFile: false,
     // Compiler-resolved doc references (fix #390, C# crefs).
@@ -543,6 +805,21 @@ const NOMINAL_TRAITS = {
  * lower-case letter is a suffix, not a member. Renaming the identifier or
  * member without the example fails vet ("refers to unknown field or method").
  */
+// Go satisfies interfaces implicitly, so no `implements` edge exists for
+// compiler/stdlib callbacks. A zero textual usage for one of these exact
+// method shapes is not evidence of deadness (sort.Interface, http.Handler,
+// io.Reader, encoding marshalers, database/sql contracts, errors helpers).
+const GO_STANDARD_CONTRACT_METHODS = new Map([
+    ['Len', 0], ['Less', 2], ['Swap', 2], ['ServeHTTP', 2],
+    ['Error', 0], ['String', 0], ['Read', 1], ['Write', 1], ['Close', 0],
+    ['Seek', 2], ['ReadAt', 2], ['WriteAt', 2], ['ReadByte', 0],
+    ['WriteByte', 1], ['ReadRune', 0], ['UnreadByte', 0], ['UnreadRune', 0],
+    ['MarshalJSON', 0], ['UnmarshalJSON', 1], ['MarshalText', 0],
+    ['UnmarshalText', 1], ['MarshalBinary', 0], ['UnmarshalBinary', 1],
+    ['Scan', 1], ['Value', 0], ['LogValue', 0], ['Unwrap', 0],
+    ['Is', 1], ['As', 1],
+]);
+
 const GO_EXAMPLE_NAMES = {
     kind: 'go-example',
     prefix: 'Example',
@@ -581,14 +858,57 @@ const JS_PROTOCOL_MEMBERS = protocolMembers([
     { pattern: /^\[Symbol\.[A-Za-z]+\]$/, member: true },
 ]);
 const JS_REFLECTION_API = {
-    hintPattern: /\bReflect\s*\.\s*(?:get|set|has|deleteProperty)\b|\beval\s*\(/,
+    hintPattern: /\b(?:Reflect|eval|Function)\b/,
     functions: [{ callee: /^(?:globalThis\.)?Reflect\.(?:get|set|has|deleteProperty)$/,
         nameArg: 1, receiverArg: 0, qualified: true }],
     computedMembers: true,
     namespaceLookups: { calls: /^eval$/ },
+    // Every other operation of the Reflect namespace (apply, construct,
+    // ownKeys, defineProperty, a decorator's Reflect.metadata).
+    unnamed: [{ callee: /^(?:globalThis\.)?Reflect\.\w+$/, qualified: true }],
+    // `eval` reached through the global object, and `new Function(code)`.
+    codeExecution: [
+        { callee: /^(?:globalThis|window|self)\.eval$/, qualified: true },
+        { construct: /^Function$/ },
+    ],
     family: 'javascript',
 };
 
+// Python's builtin callables: names a bare call can mean with nothing
+// declared or imported.
+const PY_AMBIENT_CALLABLES = new Set([
+    'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes',
+    'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict',
+    'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset',
+    'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance',
+    'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next',
+    'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed',
+    'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type',
+    'vars', 'zip', '__import__',
+]);
+// Global functions of the JavaScript runtimes (ECMAScript, Node, browsers).
+const JS_AMBIENT_CALLABLES = new Set([
+    'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'encodeURI', 'encodeURIComponent', 'decodeURI',
+    'decodeURIComponent', 'escape', 'unescape', 'eval', 'require', 'fetch', 'setTimeout', 'setInterval',
+    'setImmediate', 'clearTimeout', 'clearInterval', 'clearImmediate', 'queueMicrotask', 'structuredClone',
+    'requestAnimationFrame', 'cancelAnimationFrame', 'requestIdleCallback', 'alert', 'confirm', 'prompt',
+    'atob', 'btoa', 'postMessage', 'importScripts', 'close', 'open', 'print', 'stop', 'focus', 'blur',
+    'scroll', 'scrollTo', 'scrollBy', 'getComputedStyle', 'matchMedia', 'reportError', 'describe', 'it',
+    'test', 'expect', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll',
+]);
+
+// Global objects of the JavaScript runtimes whose members all return.
+const JS_RETURNING_NAMESPACES = new Set(['console', 'Math', 'JSON', 'Object', 'Array', 'Reflect', 'Number', 'String']);
+
+// A TypeScript interface or object type is satisfied by shape: any class or
+// object with its members is one.
+const TS_STRUCTURAL_CONTRACT = typeDef => typeDef.type === 'interface' || typeDef.type === 'type';
+// A Python class that lists Protocol among its bases is a protocol class:
+// type checkers accept any object with its members (PEP 544). A class that
+// only inherits from a protocol is an implementation, not a protocol. The
+// parser records the fact (`protocolClass`), import aliases resolved.
+const PY_STRUCTURAL_CONTRACT = typeDef => typeDef.protocolClass === true;
+
 // Language configurations
 const LANGUAGES = {
     javascript: {
@@ -599,9 +919,20 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-javascript'),
         traits: {
             ...STRUCTURAL_TRAITS,
+            testUnits: (fileEntry, helpers) => require('./javascript').testUnits(fileEntry, helpers),
+            testRunnerModules: () => require('./javascript').TEST_RUNNER_MODULES,
+            testExport: (fileEntry, helpers, name) => require('./javascript').testExport(fileEntry, helpers, name),
+            testRunnerFamily: 'javascript',
+            testFileNames: [/\.(test|spec)\.[cm]?[jt]sx?$/, /(^|\/)(test|spec)\.[cm]?[jt]sx?$/, /[-_]test\.[cm]?[jt]sx?$/, /(^|\/)test-[^/]*\.[cm]?[jt]sx?$/],
             selfParam: ['this'],
             reflectionApi: JS_REFLECTION_API,
             languageProtocolMember: JS_PROTOCOL_MEMBERS,
+            structuralContract: TS_STRUCTURAL_CONTRACT,
+            ambientCallables: JS_AMBIENT_CALLABLES,
+            ambientReturningNamespaces: JS_RETURNING_NAMESPACES,
+            neverReturnTypes: [],
+            checkedImportAt: (root, line, module) => require('./javascript').checkedImportAt(root, line, false, module),
+            scriptGlobalScope: true,
             storedPromises: true,
             knownAsyncGlobals: ['fetch'],
             lenientCallArity: true,
@@ -617,9 +948,25 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-typescript').typescript,
         traits: {
             ...STRUCTURAL_TRAITS,
+            testUnits: (fileEntry, helpers) => require('./javascript').testUnits(fileEntry, helpers),
+            testRunnerModules: () => require('./javascript').TEST_RUNNER_MODULES,
+            testExport: (fileEntry, helpers, name) => require('./javascript').testExport(fileEntry, helpers, name),
+            testRunnerFamily: 'javascript',
+            testFileNames: [/\.(test|spec)\.[cm]?[jt]sx?$/, /(^|\/)(test|spec)\.[cm]?[jt]sx?$/, /[-_]test\.[cm]?[jt]sx?$/, /(^|\/)test-[^/]*\.[cm]?[jt]sx?$/],
             selfParam: ['this'],
             reflectionApi: JS_REFLECTION_API,
             languageProtocolMember: JS_PROTOCOL_MEMBERS,
+            classComparedByShape: (classNode, ignoredLines) => !require('./javascript').classHasNominalMember(classNode, ignoredLines),
+            classMemberRole: (classNode, name, line) => require('./javascript').classMemberRole(classNode, name, line),
+            typedLiteralMembers: (root, line) => require('./javascript').typedLiteralMembers(root, line),
+            universalObjectInterface: 'Object',
+            checkSuppressedAt: site => require('./javascript').checkSuppressedAt(site),
+            checkedImportAt: (root, line, module) => require('./javascript').checkedImportAt(root, line, true, module),
+            structuralContract: TS_STRUCTURAL_CONTRACT,
+            ambientCallables: JS_AMBIENT_CALLABLES,
+            ambientReturningNamespaces: JS_RETURNING_NAMESPACES,
+            neverReturnTypes: ['never'],
+            scriptGlobalScope: true,
             storedPromises: true,
             knownAsyncGlobals: ['fetch'],
             testFileCandidates: (base, ext) => [`${base}.test${ext}`, `${base}.spec${ext}`, `${base}.test.ts`, `${base}.test.js`, `${base}.spec.ts`, `${base}.spec.js`],
@@ -634,9 +981,25 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-typescript').tsx,
         traits: {
             ...STRUCTURAL_TRAITS,
+            testUnits: (fileEntry, helpers) => require('./javascript').testUnits(fileEntry, helpers),
+            testRunnerModules: () => require('./javascript').TEST_RUNNER_MODULES,
+            testExport: (fileEntry, helpers, name) => require('./javascript').testExport(fileEntry, helpers, name),
+            testRunnerFamily: 'javascript',
+            testFileNames: [/\.(test|spec)\.[cm]?[jt]sx?$/, /(^|\/)(test|spec)\.[cm]?[jt]sx?$/, /[-_]test\.[cm]?[jt]sx?$/, /(^|\/)test-[^/]*\.[cm]?[jt]sx?$/],
             selfParam: ['this'],
             reflectionApi: JS_REFLECTION_API,
             languageProtocolMember: JS_PROTOCOL_MEMBERS,
+            classComparedByShape: (classNode, ignoredLines) => !require('./javascript').classHasNominalMember(classNode, ignoredLines),
+            classMemberRole: (classNode, name, line) => require('./javascript').classMemberRole(classNode, name, line),
+            typedLiteralMembers: (root, line) => require('./javascript').typedLiteralMembers(root, line),
+            universalObjectInterface: 'Object',
+            checkSuppressedAt: site => require('./javascript').checkSuppressedAt(site),
+            checkedImportAt: (root, line, module) => require('./javascript').checkedImportAt(root, line, true, module),
+            structuralContract: TS_STRUCTURAL_CONTRACT,
+            ambientCallables: JS_AMBIENT_CALLABLES,
+            ambientReturningNamespaces: JS_RETURNING_NAMESPACES,
+            neverReturnTypes: ['never'],
+            scriptGlobalScope: true,
             storedPromises: true,
             knownAsyncGlobals: ['fetch'],
             testFileCandidates: (base, ext) => [`${base}.test${ext}`, `${base}.spec${ext}`, `${base}.test.ts`, `${base}.test.js`, `${base}.spec.ts`, `${base}.spec.js`],
@@ -651,7 +1014,23 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-python'),
         traits: {
             ...STRUCTURAL_TRAITS,
+            testUnits: (fileEntry, helpers) => require('./python').testUnits(fileEntry, helpers),
+            testRunnerFamily: 'python',
+            testFileNames: [/^test_[^/]*\.py$/, /_test\.py$/],
+            // `yield` in the body makes the callable a generator.
+            callableKindFromBody: ['generator'],
             selfParam: ['self', 'cls'],
+            structuralContract: PY_STRUCTURAL_CONTRACT,
+            moduleNamesImportable: true,
+            moduleSupplyHooks: ['__getattr__', '__path__'],
+            packageFileOptional: true,
+            memberTypesFromAssignments: true,
+            ambientCallables: PY_AMBIENT_CALLABLES,
+            ambientNeverCallables: new Set(['exit', 'quit']),
+            neverReturnTypes: ['NoReturn', 'Never'],
+            namedConditionsDecidable: true,
+            checkSuppressedAt: site => require('./python').checkSuppressedAt(site),
+            checkedImportAt: (root, line, module) => require('./python').checkedImportAt(root, line, module),
             // `cls(..)` in a classmethod (or an implicit one), `type(self)(..)`
             // and `self.__class__(..)` in an instance method construct the
             // method's class through its first parameter (fix #434).
@@ -677,8 +1056,10 @@ const LANGUAGES = {
             classesCallableWithoutNew: true,
             constructorInheritance: { order: 'c3', classNodes: ['class_definition'], headerField: 'superclasses', keywordNode: 'keyword_argument' },
             constructorProtocol: { initializer: '__init__', allocator: '__new__', metaclass: 'metaclass', builtinRoot: 'object',
+                metaclassMethods: ['__call__', '__new__', '__init__'], identityMembers: ['__class__', '__getattribute__', '__getattr__'], identityOverrides: ['__getattribute__', '__setattr__', '__delattr__'],
                 functionNode: 'function_definition', classNode: 'class_definition',
                 headerField: 'superclasses', keywordNode: 'keyword_argument' },
+            contextEnterMethods: ['__enter__', '__aenter__'],
             // Call sites bind by parameter name (f(x=1)); signatures carry
             // keyword-only (`*`) and positional-only (`/`) markers (fix #281).
             keywordArguments: true,
@@ -748,9 +1129,12 @@ const LANGUAGES = {
                     owners: ['Enum', 'IntEnum', 'StrEnum', 'Flag', 'IntFlag', 'ReprEnum'] },
             ]),
             reflectionApi: {
-                hintPattern: /\b(?:getattr|setattr|hasattr|delattr|eval)\s*\(|\b(?:globals|vars)\s*\(\s*\)\s*\[/,
+                hintPattern: /\b(?:getattr|setattr|hasattr|delattr|eval|exec|globals|vars)\b/,
                 functions: [{ callee: /^(?:getattr|setattr|hasattr|delattr)$/, nameArg: 1, receiverArg: 0 }],
                 namespaceLookups: { calls: /^eval$/, subscriptOf: /^(?:globals|vars)\(\)$/ },
+                // `exec(code)` runs statements; it names nothing a lookup
+                // could be matched against.
+                codeExecution: [{ callee: /^exec$/ }],
             },
             testFileCandidates: (base, ext) => [`test_${base}.py`, `${base}_test.py`],
             testDirs: ['tests'],
@@ -764,6 +1148,10 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-go'),
         traits: {
             ...NOMINAL_TRAITS,
+            testUnits: (fileEntry, helpers) => require('./go').testUnits(fileEntry, helpers),
+            testGate: (fileEntry, helpers) => require('./go').testGate(fileEntry, helpers),
+            testRunnerFamily: 'go',
+            testFileNames: [/_test\.go$/],
             selfParam: null,
             packageScope: 'directory',
             nameReferenceFamily: 'go',
@@ -778,9 +1166,13 @@ const LANGUAGES = {
                 members: [{ member: /^(?:MethodByName|FieldByName)$/, nameArg: 0 }],
                 membersOnly: true,
                 formatCalls: { 'fmt.Sprintf': 'percent' },
+                // Every function of the reflect package, under whatever
+                // name the file imports it.
+                unnamed: [{ package: 'reflect' }],
             },
             testFileCandidates: (base, ext) => [`${base}_test.go`],
             nameBoundTestFunctions: GO_EXAMPLE_NAMES,
+            implicitStandardContracts: GO_STANDARD_CONTRACT_METHODS,
             // One package-level name declared in files of one package under
             // different build constraints is one item (fix #425).
             conditionalDefinitions: 'build-constraint',
@@ -794,6 +1186,15 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-rust'),
         traits: {
             ...NOMINAL_TRAITS,
+            testUnits: (fileEntry, helpers) => require('./rust').testUnits(fileEntry, helpers),
+            testRunnerFamily: 'rust',
+            testFileNames: [/(^|\/)tests\/[^/]+\.rs$/],
+            // `-> impl Trait` hides the type but leaks the value's auto traits.
+            inferredReturnForms: ['opaque', 'evaluated'],
+            // `async fn` returns an anonymous future whose auto traits
+            // (Send, Sync) come from what the body holds across an await.
+            asyncReturnIsOpaque: true,
+            compileTimeCallableMarkers: ['const'],
             selfParam: ['self', '&self', '&mut self', 'mut self'],
             inherentMethodsPrecedeTraitImpls: true,
             derefFieldAccess: true,
@@ -870,6 +1271,10 @@ const LANGUAGES = {
         parseRecovery: () => require('./java').recoverTypeAnnotatedVarargs,
         traits: {
             ...NOMINAL_TRAITS,
+            testUnits: (fileEntry, helpers) => require('./java').testUnits(fileEntry, helpers),
+            testCodeGate: (fileEntry, projectDeclaresType) => require('./java').testCodeGate(fileEntry, projectDeclaresType),
+            testRunnerFamily: 'java',
+            testFileNames: [/^Test[^/]*\.java$/, /Tests?\.java$/, /TestCase\.java$/, /IT\.java$/],
             // A method overrides/implements every supertype's same-signature
             // member, an inherited one included (JLS 8.4.8) (fix #426).
             memberFillsSupertypeSlots: true,
@@ -958,12 +1363,14 @@ const LANGUAGES = {
                 possibleViaExternal: { except: JAVA_LANG_NOT_SERIALIZABLE, shape: javaSerializationShape } },
             ]),
             reflectionApi: {
-                hintPattern: /\b(?:getMethod|getDeclaredMethod|getField|getDeclaredField)\b/,
+                hintPattern: /\b(?:getMethod|getDeclaredMethod|getField|getDeclaredField|forName)\b/,
                 members: [{ member: /^(?:getMethod|getDeclaredMethod|getField|getDeclaredField)$/, nameArg: 0 }],
                 membersOnly: true,
                 formatCalls: { 'String.format': 'percent' },
                 selfTypeCalls: ['getClass'],
                 typeLiteralNodes: ['class_literal'],
+                // A class loaded by its name.
+                unnamed: [{ callee: /^(?:java\.lang\.)?Class\.forName$/, qualified: true }],
             },
             bareCallReachesMethods: true,
             testFileCandidates: (base, ext) => [`${base}Test.java`, `${base}Tests.java`, `${base}TestCase.java`],
@@ -1007,6 +1414,12 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-cpp'),
         traits: {
             ...NOMINAL_TRAITS,
+            // `auto` / `decltype(auto)` return types are deduced from the body.
+            // 'instantiated': a template's body is checked against each
+            // caller's arguments.
+            inferredReturnForms: ['placeholder', 'instantiated', 'evaluated'],
+            virtualMemberChangesShape: true,
+            compileTimeCallableMarkers: ['constexpr', 'consteval'],
             // An override overrides every base's virtual of its signature; an
             // inherited member never implements another base's pure virtual
             // (fix #426).
@@ -1076,6 +1489,10 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-c-sharp'),
         traits: {
             ...NOMINAL_TRAITS,
+            testUnits: (fileEntry, helpers) => require('./csharp').testUnits(fileEntry, helpers),
+            testCodeGate: (fileEntry, projectDeclaresType) => require('./csharp').testCodeGate(fileEntry, projectDeclaresType),
+            testRunnerFamily: 'dotnet',
+            testFileNames: [/Tests?\.cs$/],
             // Interface mapping takes inherited members (C# spec 18.6.5); a
             // `new` member hides the inherited one, starting a slot of its
             // own (fix #426).
@@ -1110,6 +1527,7 @@ const LANGUAGES = {
             standardPathRoots: ['System'],
             conditionalDefinitions: 'preprocessor',
             typeNameScoping: 'namespace-usings',
+            platformTypeForms: { nullable: 'System.Nullable', tuple: 'System.ValueTuple' },
             constructorArgumentNodes: { delegation: { nodeType: 'constructor_initializer', argsNodeType: 'argument_list' } },
             genericArityIsIdentity: true,
             typeArgumentsFromArgumentsOnly: true,