ucn 5.5.1 → 5.5.2

package/languages/index.js

@@ -8,6 +8,11 @@ const path = require('path');
 const { UcnError } = require('../core/errors');
 const { createLanguageAdapter } = require('./adapter');
 
+// Modules read lazily (load cycles), each resolved once: a require() per
+// call in hot paths was measurable (fix #436).
+let lazyJavaUnicodeModuleCache = null;
+const lazyJavaUnicodeModule = () => lazyJavaUnicodeModuleCache || (lazyJavaUnicodeModuleCache = require('./java-unicode'));
+
 // Lazy-loaded tree-sitter
 let TreeSitter = null;
 
@@ -33,6 +38,9 @@ function protocolMembers(rules) {
             const named = rule.pattern ? rule.pattern.test(name) : rule.names.includes(name);
             if (!named) continue;
             if (rule.member && ctx.isMember === false) continue;
+            // A member type alias (fix #427: `typedef int& reference;`).
+            if (rule.typeMember && !ctx.isTypeMember) continue;
+            if (!rule.typeMember && ctx.isTypeMember) continue;
             // Owner kinds the runtime exempts from the protocol (fix #392:
             // Java enum constants serialize by name and ignore the callbacks).
             if (rule.exceptOwnerKinds && typeof ctx.ownerKinds === 'function' &&
@@ -96,6 +104,40 @@ const JAVA_LANG_NOT_SERIALIZABLE = ['Object', 'Runnable', 'AutoCloseable', 'Comp
 
 const STRUCTURAL_TRAITS = {
     typeSystem: 'structural',
+    // A write on the instance can replace an inherited method with a
+    // callable value, including a wrapper of the previous method.
+    instanceAttributesShadowMethods: true,
+    // An external type can supply an inherent method before a project
+    // trait implementation at the same receiver probe step.
+    inherentMethodsPrecedeTraitImpls: false,
+    // Field access follows proven dereference wrappers on a return value.
+    derefFieldAccess: false,
+    // Whether importing a module runs its top-level code when the importer
+    // loads (JS/TS/HTML scripts, Python): only then is an import cycle an
+    // import-time cycle (fix #433).
+    importsRunModules: true,
+    // The receiver keyword whose member lookup starts at the enclosing
+    // class's bases, skipping its own members (`super.m()`, Python
+    // `super().m()`, C# `base.M()`), or null (fix #428).
+    superReceiver: 'super',
+    // The methods whose own receiver constructs their class (fix #434):
+    // `new this(..)` in a static method, `new this.constructor(..)` in an
+    // instance method. `binding` is the parser's 'class' or 'instance'.
+    ownClassMethod: (method, binding) => binding === 'class' ? method.type === 'static' : method.type !== 'static',
+    // Whether files without module syntax share one global scope (classic
+    // scripts): their top-level declarations are globals (fix #434).
+    scriptsShareGlobalScope: true,
+    plainQueryTree: true,
+    physicalCallTokenSyntax: true,
+    scopeAlternativeBindings: false,
+    nameReferenceFamily: 'js',
+    staticValueImportSyntax: null,
+    implicitEnumCaseLabels: false,
+    valuePatternConstants: false,
+    moduleValueLookup: false,
+    typeArgumentValues: null,
+    separateStaticStorage: true,
+    valueScopes: null,
     // A type's identity is its declaring module (a source file or inline
     // module), not the directory (fix #384): two same-name types in two
     // modules of one directory are distinct (JS/TS, Python modules, Rust
@@ -112,6 +154,9 @@ const STRUCTURAL_TRAITS = {
     // 'namespace-usings' (C#: enclosing namespaces, then using directives,
     // global usings and project-file <Using> items), or null.
     typeNameScoping: null,
+    typeNameSourceCanonical: null,
+    typeNameOwnersAt: null,
+    implementationOwnerSyntax: null,
     // Types every file imports on demand without writing it (Java java.lang,
     // JLS 7.3): { module, names }. A project type of the same name in another
     // package is visible only through an import.
@@ -128,7 +173,23 @@ const STRUCTURAL_TRAITS = {
     // signature must not use `= value` syntax (Go/Java/Rust).
     hasDefaultParams: true,
     allMethodsVirtual: false,
+    // A class member fills the slot of every supertype declaring that member
+    // (an override of `A.m` in `D(A, B)` overrides `B.m` too), and a member a
+    // class inherits implements its own interfaces' members (TS `class Impl
+    // extends Base implements Bean`): plan's rename closure climbs from
+    // every slot holder (fix #426). memberHidingModifier: the modifier of a
+    // member that hides the inherited one instead (C# `new`).
+    memberFillsSupertypeSlots: true,
+    inheritedMemberFillsSlots: true,
+    memberHidingModifier: null,
+    virtualMemberModifiers: null,
     hasArityOverloads: false,
+    userDefinedConversions: null,
+    overloadPhases: null,
+    overloadFileSymbols: false,
+    inheritedOverloadSignatures: false,
+    // Interface instance members join lookup after the superclass chain.
+    interfaceMembersInMethodLookup: false,
     // Whether `from pkg import name` can bind a SUBMODULE file as a plain
     // name (fix #224). Python sets true: graph-build resolves the composed
     // dotted specifier and records it in moduleResolved, making the receiver
@@ -155,6 +216,31 @@ const STRUCTURAL_TRAITS = {
     // inside a class means this.execute(), and static imports bind foreign
     // class methods to bare names (fix #220).
     bareCallReachesMethods: false,
+    // A function declared in a function body is a binding of that body
+    // (JS/TS function scope, fix #423; Python defs, fix #402): a bare name
+    // outside the enclosing function never names it.
+    nestedItemsBlockScoped: true,
+    // Whether a declaration binds its name in its whole scope whatever its
+    // position (JS/TS: function declarations hoist, `let`/`const`/`class`
+    // names resolve statically; fix #423). Python binds names as statements
+    // run, so a module-level reference sees only earlier bindings.
+    staticModuleScope: true,
+    // Where a bare (receiver-less) name can denote a class or enum MEMBER
+    // value when bare names never reach methods (fix #420): 'declaration-body'
+    // (JS/TS: only inside the enum or namespace declaring it), 'class-body'
+    // (Python: directly in the class body, never in its methods), 'imports'
+    // (Rust: enum variants a `use` brings in), 'none' (Go struct fields, C).
+    // Imports in these languages never name a member either.
+    bareValueMemberScope: 'declaration-body',
+    // An enum member names a type of its own (TS literal enum member types:
+    // `kind: Kind.Text` in an annotation reads the member, fix #431).
+    enumMemberTypes: true,
+    // A type path can name a field (`T::f` for a static member): Rust sets
+    // false (fix #431).
+    typePathReachesFields: true,
+    // Classes whose synthesized initializer takes their fields as keyword
+    // parameters (Python dataclasses, NamedTuple, TypedDict), or null.
+    fieldInitializers: null,
     // 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).
@@ -165,6 +251,24 @@ const STRUCTURAL_TRAITS = {
     // Whether `Type(...)` constructs a class without a `new` token. Python
     // classes are ordinary callable objects; JS/TS classes require `new`.
     classesCallableWithoutNew: false,
+    hasConstructors: true,
+    fixedConstructorName: 'constructor',
+    constructorArgumentNodes: { delegation: { nodeType: 'call_expression', argsField: 'arguments' } },
+    functionalTypeConstruction: false,
+    constructorInheritance: { order: 'single', classNodes: ['class_declaration', 'class'], headerNode: 'class_heritage' },
+    implicitBaseConstruction: null,
+    // Whether a constructor delegation is spelled by a keyword (`this(..)`,
+    // `super(..)`, `base(..)`) rather than by the type's name (C++
+    // mem-initializers): such a site holds no token a type rename edits
+    // (fix #421).
+    keywordConstructorDelegation: false,
+    constructorUsesAreTypeReferences: false,
+    packExpansionArguments: false,
+    // Whether a call may pass more or fewer arguments than the callee
+    // declares without error (JavaScript): argument count then never decides
+    // which one callable runs. TypeScript reports the mismatch at compile time
+    // and Python raises at run time, so there it stays evidence (fix #421).
+    lenientCallArity: false,
     // Whether a decorator REPLACES the callable it decorates with its own
     // return value (Python/JS decorators, fix #364). What a decorated async
     // function's call returns is then decided by the decorator, not by the
@@ -212,6 +316,11 @@ const STRUCTURAL_TRAITS = {
     // `Func<int> f = Build`): plan renames it by the language's simple-name
     // lookup. Java spells method values apart (`Type::m`).
     methodGroupReferences: false,
+    methodGroupReceiver: null,
+    // AST terminal-name test for invocations wrapped in generic syntax.
+    isInvokedName: null,
+    accessorReferenceShape: null,
+    accessorTypeSyntax: null,
     // Whether a class may declare a field and a method of one name, so a
     // paren-less member access (`this.size`) names the field and a method
     // value is spelled apart (`obj::m`, `Type::m`) (fix #390: Java, Rust).
@@ -262,10 +371,42 @@ const STRUCTURAL_TRAITS = {
 };
 const NOMINAL_TRAITS = {
     typeSystem: 'nominal',
+    instanceAttributesShadowMethods: false,
+    inherentMethodsPrecedeTraitImpls: false,
+    derefFieldAccess: false,
+    importsRunModules: false,
+    superReceiver: null,
+    ownClassMethod: null,
+    scriptsShareGlobalScope: false,
+    hasConstructors: false,
+    fixedConstructorName: null,
+    constructorInheritance: null,
+    implicitBaseConstruction: null,
+    keywordConstructorDelegation: false,
+    constructorUsesAreTypeReferences: false,
+    packExpansionArguments: false,
+    // Whether a member may be defined outside its class body (C++
+    // `W::W(int) {}` in a source file, its class in a header): such a
+    // definition holds the body of one in-class declaration (fix #421).
+    outOfClassMemberDefinitions: false,
+    plainQueryTree: true,
+    physicalCallTokenSyntax: true,
+    scopeAlternativeBindings: false,
+    nameReferenceFamily: null,
+    staticValueImportSyntax: null,
+    implicitEnumCaseLabels: false,
+    valuePatternConstants: false,
+    moduleValueLookup: false,
+    typeArgumentValues: null,
+    separateStaticStorage: false,
+    valueScopes: null,
     moduleTypeIdentity: false,
     standardPathRoots: [],
     typeNameScoping: null,
+    typeNameSourceCanonical: null,
+    typeNameOwnersAt: null,
     implicitTypeImport: null,
+    implementationOwnerSyntax: null,
     methodCallInclusion: 'auto',
     packageScope: 'file',
     hasReceiverPackageCalls: false,
@@ -291,11 +432,25 @@ const NOMINAL_TRAITS = {
     // sets and Rust inherent methods bind statically — only interface/trait
     // receivers dispatch there, which is detected per-type, not per-language.
     allMethodsVirtual: false,
+    // See STRUCTURAL_TRAITS (fix #426): Go and Rust members never fill
+    // other supertypes' slots (structural satisfaction and trait impls have
+    // closures of their own); Java, C# and C++ override.
+    memberFillsSupertypeSlots: false,
+    inheritedMemberFillsSlots: false,
+    memberHidingModifier: null,
+    virtualMemberModifiers: null,
     // 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,
+    // User-defined conversions keep otherwise incompatible argument types
+    // possible; selecting an overload still needs a positive conversion proof.
+    userDefinedConversions: null,
+    overloadPhases: null,
+    overloadFileSymbols: false,
+    inheritedOverloadSignatures: false,
+    interfaceMembersInMethodLookup: 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).
@@ -324,6 +479,10 @@ const NOMINAL_TRAITS = {
     // cobra/grpc-go-measured). Java overrides true (implicit this-calls,
     // static imports).
     bareCallReachesMethods: false,
+    bareValueMemberScope: 'none',
+    enumMemberTypes: false,
+    typePathReachesFields: true,
+    fieldInitializers: null,
     // 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)()
@@ -346,6 +505,8 @@ const NOMINAL_TRAITS = {
     // methods — false. Per-language override, not preset-wide.
     memberAccessNeverMethod: false,
     classesCallableWithoutNew: false,
+    constructorArgumentNodes: {},
+    functionalTypeConstruction: false,
     decoratorsWrapCallables: false,
     callableDecorators: null,
     knownAsyncGlobals: null,
@@ -361,6 +522,11 @@ const NOMINAL_TRAITS = {
     docCrefReferences: false,
     // Simple-name method groups (fix #395, C#).
     methodGroupReferences: false,
+    methodGroupReceiver: null,
+    // AST terminal-name test for invocations wrapped in generic syntax.
+    isInvokedName: null,
+    accessorReferenceShape: null,
+    accessorTypeSyntax: null,
     // A static import of a type brings only the members the type itself
     // declares, never inherited ones (fix #392, C# `using static`). Java's
     // static imports reach inherited static members.
@@ -438,6 +604,7 @@ const LANGUAGES = {
             languageProtocolMember: JS_PROTOCOL_MEMBERS,
             storedPromises: true,
             knownAsyncGlobals: ['fetch'],
+            lenientCallArity: true,
             testFileCandidates: (base, ext) => [`${base}.test${ext}`, `${base}.spec${ext}`, `${base}.test.ts`, `${base}.test.js`, `${base}.spec.ts`, `${base}.spec.js`],
             testDirs: ['__tests__'],
         },
@@ -485,6 +652,21 @@ const LANGUAGES = {
         traits: {
             ...STRUCTURAL_TRAITS,
             selfParam: ['self', 'cls'],
+            // `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).
+            ownClassMethod: (method, binding, receiver) => method.paramsStructured?.[0]?.name === receiver &&
+                (binding === 'class'
+                    ? method.type === 'classmethod' || ['__init_subclass__', '__class_getitem__'].includes(method.name)
+                    : !['classmethod', 'staticmethod'].includes(method.type) && method.name !== '__new__'),
+            // An inherited member shadows other bases' members in the MRO,
+            // no interface contract: not modeled as slot evidence (fix #426).
+            inheritedMemberFillsSlots: false,
+            memberLookupOrder: 'c3',
+            fixedConstructorName: null,
+            nameReferenceFamily: 'python',
+            scriptsShareGlobalScope: false,
+            separateStaticStorage: false,
             // fix #224: `from pkg import name` may bind a SUBMODULE file, not
             // a symbol — graph-build resolves the composed dotted specifier
             // and query code treats such receivers as module receivers. JS
@@ -493,10 +675,24 @@ const LANGUAGES = {
             // `__x` (not a dunder) is name-mangled per class (fix #397).
             privateMemberName: name => /^__/.test(String(name)) && !/__$/.test(String(name)),
             classesCallableWithoutNew: true,
+            constructorInheritance: { order: 'c3', classNodes: ['class_definition'], headerField: 'superclasses', keywordNode: 'keyword_argument' },
+            constructorProtocol: { initializer: '__init__', allocator: '__new__', metaclass: 'metaclass', builtinRoot: 'object',
+                functionNode: 'function_definition', classNode: 'class_definition',
+                headerField: 'superclasses', keywordNode: 'keyword_argument' },
             // Call sites bind by parameter name (f(x=1)); signatures carry
             // keyword-only (`*`) and positional-only (`/`) markers (fix #281).
             keywordArguments: true,
             assignmentDeclaresLocal: true,
+            bareValueMemberScope: 'class-body',
+            enumMemberTypes: false,
+            // Classes whose initializer the standard library synthesizes from
+            // their own fields (fix #431): a keyword argument of their
+            // construction names a field. Resolved qualified names.
+            fieldInitializers: {
+                decorators: ['dataclasses.dataclass'],
+                bases: ['typing.NamedTuple', 'typing_extensions.NamedTuple',
+                    'typing.TypedDict', 'typing_extensions.TypedDict'],
+            },
             // Calling an async def creates a coroutine object in any scope:
             // audit-async checks such calls in sync functions too, and
             // follows a local assigned from the call to the uses that need
@@ -507,10 +703,12 @@ const LANGUAGES = {
             // f` / `except ImportError: def f`) is one item with an
             // alternative per runtime configuration (fix #398F).
             conditionalDefinitions: 'branch',
+            scopeAlternativeBindings: true,
             // A def inside a function body binds a local of that function: a
             // bare name outside it never names it (fix #402), unless the
             // function declares the name `global`.
             nestedItemsBlockScoped: true,
+            staticModuleScope: false,
             // Decorators with a known effect on what calling the decorated
             // function returns (fix #364), as resolved qualified names (a
             // trailing `()` marks a decorator factory call). Any other
@@ -568,6 +766,8 @@ const LANGUAGES = {
             ...NOMINAL_TRAITS,
             selfParam: null,
             packageScope: 'directory',
+            nameReferenceFamily: 'go',
+            closedQueryBodies: ['function_declaration', 'method_declaration', 'func_literal'],
             hasReceiverPackageCalls: true,
             exportVisibility: 'capitalization',
             hasDynamicImports: false,
@@ -581,6 +781,9 @@ const LANGUAGES = {
             },
             testFileCandidates: (base, ext) => [`${base}_test.go`],
             nameBoundTestFunctions: GO_EXAMPLE_NAMES,
+            // One package-level name declared in files of one package under
+            // different build constraints is one item (fix #425).
+            conditionalDefinitions: 'build-constraint',
         },
     },
     rust: {
@@ -592,18 +795,38 @@ const LANGUAGES = {
         traits: {
             ...NOMINAL_TRAITS,
             selfParam: ['self', '&self', '&mut self', 'mut self'],
+            inherentMethodsPrecedeTraitImpls: true,
+            derefFieldAccess: true,
+            nameReferenceFamily: 'rust',
+            // Members live in impl blocks, separate from the declaration
+            // of the type. Resolve the written self type in the impl scope.
+            implementationOwnerSyntax: { node: 'impl_item', field: 'type' },
+            staticEnumReferenceSyntax: true,
+            valuePatternConstants: true,
+            moduleValueLookup: true,
+            typeArgumentValues: 'generic-parameter',
+            // A struct's fields are reached through a value (`x.f`, struct
+            // expressions and patterns); a type path `T::f` names an
+            // associated item (fix #431).
+            typePathReachesFields: false,
             hasDynamicImports: false,
             moduleTypeIdentity: true,
             // Same-scope definitions of one name are configuration
             // alternatives selected by `#[cfg]` (fix #376).
             conditionalDefinitions: 'attribute',
             typeQualifiedCallStyle: 'path',
+            // A path segment's case tells a type from a module (CamelCase
+            // types, snake_case modules: the language's naming lints); C++
+            // namespaces are not case-coded, its qualifiers are resolved by
+            // name lookup (fix #427).
+            caseCodedPathQualifiers: true,
             standardPathRoots: ['std', 'core', 'alloc'],
             // Call records say whether their value is consumed where it is
             // produced (`valueConsumed`, `consumingMethod`; fix #371).
             callValueFacts: true,
             memberAccessNeverMethod: true,
             fieldsAndMethodsSeparate: true,
+            bareValueMemberScope: 'imports',
             genericBoundDispatchClosed: true,
             macroTemplateBodies: true,
             // Macro invocations are written `name!(...)` / `#[name]`: a
@@ -612,6 +835,12 @@ const LANGUAGES = {
             // A fn declared inside a fn body is an item of that block: a
             // bare path outside the block never names it (fix #377).
             nestedItemsBlockScoped: true,
+            // A name resolves through the scopes that bind it, innermost
+            // first: block items and `use` declarations, then the module's
+            // items and explicit `use` bindings, then its globs, with types,
+            // values and macros in separate namespaces (fix #422,
+            // core/rust-names.js).
+            itemScopeResolution: true,
             // Names every module sees without a `use` (the std prelude of
             // editions 2015-2024 and the primitive types): a name no `use`,
             // glob or item binds must be one of them, or come from a macro
@@ -636,11 +865,39 @@ const LANGUAGES = {
         treeSitterLang: 'java',
         module: () => require('./java'),
         treeSitterModule: () => require('tree-sitter-java'),
+        // tree-sitter-java misreads a type annotation before a variable
+        // arity parameter's `...` (`Object @Nullable ... args`, JLS 8.4.1).
+        parseRecovery: () => require('./java').recoverTypeAnnotatedVarargs,
         traits: {
             ...NOMINAL_TRAITS,
+            // A method overrides/implements every supertype's same-signature
+            // member, an inherited one included (JLS 8.4.8) (fix #426).
+            memberFillsSupertypeSlots: true,
+            inheritedMemberFillsSlots: true,
+            superReceiver: 'super',
+            hasConstructors: true,
+            implicitBaseConstruction: { classes: ['class_declaration'], headerField: 'superclass',
+                constructors: ['constructor_declaration'], delegationNodes: ['explicit_constructor_invocation'],
+                ownerScope: node => require('./java').implicitOwnerScope(node),
+                baseKinds: ['class'], separator: '.' },
+            keywordConstructorDelegation: true,
+            constructorArgumentNodes: {
+                delegation: { nodeType: 'explicit_constructor_invocation', argsField: 'arguments' },
+                enum: { nodeType: 'enum_constant', argsField: 'arguments' },
+            },
             fieldsAndMethodsSeparate: true,
+            nameReferenceFamily: 'java',
+            staticEnumReferenceSyntax: true,
+            closedQueryBodies: ['method_declaration', 'constructor_declaration',
+                'compact_constructor_declaration', 'lambda_expression'],
+            staticValueImportSyntax: tree => require('./java').staticValueImportSyntax(tree),
+            // Pattern variables are scoped by the pattern's flow (fix #420).
+            patternBindingReach: (binding, reference) => require('./java').patternBindingReach(binding, reference),
+            implicitEnumCaseLabels: true,
             standardPathRoots: ['java', 'javax'],
             typeNameScoping: 'package-on-demand',
+            typeNameSourceCanonical: (source, parseError, lines) => lazyJavaUnicodeModule().typeNameSourceCanonical(source, parseError, lines),
+            typeNameOwnersAt: (source, site) => lazyJavaUnicodeModule().typeNameOwnersAt(source, site),
             typeNamedSourceFile: true,
             // The public top-level types of java.lang (JDK 8-21, preview
             // included): a spec-level list, not project knowledge.
@@ -677,6 +934,10 @@ const LANGUAGES = {
             selfParam: ['this'],
             allMethodsVirtual: true,
             hasArityOverloads: true,
+            overloadPhases: 'strict-loose-variable',
+            overloadFileSymbols: true,
+            inheritedOverloadSignatures: true,
+            interfaceMembersInMethodLookup: true,
             universalSupertype: 'Object',
             universalSupertypeMembers: { toString: 0, equals: 1, hashCode: 0, clone: 0, finalize: 0 },
             // Serialization callbacks and fields the JVM uses reflectively.
@@ -718,6 +979,7 @@ const LANGUAGES = {
             ...NOMINAL_TRAITS,
             selfParam: null,
             packageScope: 'file',
+            nameReferenceFamily: 'c',
             hasDynamicImports: false,
             exportVisibility: 'linkage',
             // Same-signature definitions in one file are `#if` alternatives.
@@ -727,6 +989,7 @@ const LANGUAGES = {
             // spelled NAME( where #define NAME( is in effect is the macro
             // (fix #377).
             macroInvocationSyntax: 'call',
+            usageKindsOnly: true,
             typeQualifiedCallStyle: 'static',
             bareCallReachesMethods: false,
             methodCallReachesFunctions: true,
@@ -744,6 +1007,27 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-cpp'),
         traits: {
             ...NOMINAL_TRAITS,
+            // An override overrides every base's virtual of its signature; an
+            // inherited member never implements another base's pure virtual
+            // (fix #426).
+            memberFillsSupertypeSlots: true,
+            virtualMemberModifiers: ['virtual', 'override'],
+            hasConstructors: true,
+            implicitBaseConstruction: { classes: ['class_specifier', 'struct_specifier'], headerNode: 'base_class_clause',
+                constructors: ['function_definition', 'field_declaration', 'declaration'], defaultPotential: true,
+                constructorInfo: (...args) => require('./c-family').implicitConstructorInfo(...args),
+                ownerScope: node => require('./c-family').implicitOwnerScope(node),
+                baseKinds: ['class', 'struct'], separator: '::' },
+            functionalTypeConstruction: true,
+            outOfClassMemberDefinitions: true,
+            constructorArgumentNodes: { direct: { nodeType: 'init_declarator', argsField: 'value' },
+                delegation: { nodeType: 'field_initializer', argsNodeType: 'argument_list' } },
+            isInvokedName: (node, options) => require('./c-family').isInvokedName(node, options),
+            nameReferenceFamily: 'c',
+            typeArgumentValues: 'ordinary',
+            // A call's arguments may expand a parameter pack (`f(params...)`):
+            // the written count is not the argument count (fix #430).
+            packExpansionArguments: true,
             selfParam: ['this'],
             packageScope: 'file',
             hasDynamicImports: false,
@@ -754,12 +1038,22 @@ const LANGUAGES = {
             // spelled NAME( where #define NAME( is in effect is the macro
             // (fix #377).
             macroInvocationSyntax: 'call',
+            usageKindsOnly: true,
             typeQualifiedCallStyle: 'path',
             standardPathRoots: ['std'],
             hasArityOverloads: true,
+            userDefinedConversions: 'constructors-and-operators',
             // Range-for lowers onto member begin()/end() with no name token.
+            // The standard library's traits read member types by name
+            // (fix #427): std::iterator_traits (value_type, difference_type,
+            // pointer, reference, iterator_category, iterator_concept),
+            // std::pointer_traits (element_type), container adaptors
+            // (size_type, const_reference), transparent comparators.
             languageProtocolMember: protocolMembers([
                 { names: ['begin', 'end'], member: true },
+                { names: ['value_type', 'difference_type', 'pointer', 'reference', 'iterator_category',
+                    'iterator_concept', 'element_type', 'size_type', 'const_reference', 'is_transparent'],
+                member: true, typeMember: true },
             ]),
             // C++ instance dispatch is virtual only when the declaration
             // explicitly says virtual/override (unlike Java's implicit rule).
@@ -782,21 +1076,61 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-c-sharp'),
         traits: {
             ...NOMINAL_TRAITS,
+            // 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).
+            memberFillsSupertypeSlots: true,
+            inheritedMemberFillsSlots: true,
+            superReceiver: 'base',
+            memberHidingModifier: 'new',
+            virtualMemberModifiers: ['virtual', 'abstract', 'override'],
+            hasConstructors: true,
+            implicitBaseConstruction: { classes: ['class_declaration', 'record_declaration'], headerNode: 'base_list',
+                constructors: ['constructor_declaration'], delegationNodes: ['constructor_initializer'],
+                ownerScope: node => require('./csharp').implicitOwnerScope(node),
+                firstBaseOnly: true, referenceTypesOnly: true, baseKinds: ['class', 'record'], separator: '.' },
+            keywordConstructorDelegation: true,
+            // A use of a constructor is a use of its type (fix #430): a
+            // `: this(..)` initializer depends on the type as `: base(..)`
+            // depends on the base.
+            constructorUsesAreTypeReferences: true,
+            plainQueryTree: false,
+            isInvokedName: (node, options) => require('./csharp').isInvokedName(node, options),
+            nameReferenceFamily: 'csharp',
+            staticEnumReferenceSyntax: true,
+            enumReferenceContext: node => ({
+                scopes: require('./csharp-scope').usingScopesOf(node),
+                directives: require('./csharp').queryUsingDirectives(node.tree),
+            }),
+            closedQueryBodies: ['method_declaration', 'constructor_declaration', 'destructor_declaration',
+                'operator_declaration', 'conversion_operator_declaration', 'local_function_statement',
+                'accessor_declaration', 'lambda_expression', 'anonymous_method_expression'],
+            queryBodyViews: tree => require('./csharp').queryBodyViews(tree),
+            queryBodyTree: (...args) => require('./csharp').queryBodyTree(...args),
             standardPathRoots: ['System'],
             conditionalDefinitions: 'preprocessor',
             typeNameScoping: 'namespace-usings',
+            constructorArgumentNodes: { delegation: { nodeType: 'constructor_initializer', argsNodeType: 'argument_list' } },
             genericArityIsIdentity: true,
             typeArgumentsFromArgumentsOnly: true,
             selfParam: ['this', 'base'],
             packageScope: 'namespace',
             hasDynamicImports: false,
             hasArityOverloads: true,
+            userDefinedConversions: 'operators',
             bareCallReachesMethods: true,
+            // The type the compiler synthesizes for top-level statements: a
+            // local function there has no other class in lexical scope.
+            topLevelStatementsType: 'Program',
+            inheritedOverloadSignatures: true,
             typeQualifiedCallStyle: 'static',
             universalSupertype: 'Object',
             universalSupertypeMembers: { ToString: 0, Equals: 1, GetHashCode: 0, Finalize: 0 },
             docCrefReferences: true,
             methodGroupReferences: true,
+            methodGroupReceiver: node => require('./csharp').methodGroupReceiver(node),
+            accessorReferenceShape: (tree, usage) => require('./csharp').accessorReferenceShape(tree, usage),
+            accessorTypeSyntax: text => require('./csharp').accessorTypeSyntax(text),
             staticImportsDeclaredOnly: true,
             // Pattern-bound members the compiler lowers syntax onto
             // (foreach, await, deconstruction) - invoked with no name token.
@@ -844,6 +1178,22 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-html'),
         traits: {
             ...STRUCTURAL_TRAITS,
+            lenientCallArity: true,
+            // Embedded scripts supply their own parse trees.
+            physicalCallTokenSyntax: false,
+            // The script source with its rows and columns kept, parsed in its
+            // own language where an edit reads tokens (fix #419).
+            embeddedSyntax: { language: 'javascript', source: (content, parser) => {
+                const html = require('./html');
+                return html.buildVirtualJSContent(content, html.extractScriptBlocks(content, parser));
+            } },
+            constructorInheritance: { ...STRUCTURAL_TRAITS.constructorInheritance, syntaxLanguage: 'javascript',
+                source: (content, parser) => {
+                    const html = require('./html');
+                    return html.buildVirtualJSContent(content, html.extractScriptBlocks(content, parser));
+                } },
+            valueScopes: (content, parser) => require('./html')
+                .extractScriptBlocks(content, parser, { includeScopes: true }),
             selfParam: ['this'],
             storedPromises: true,
             knownAsyncGlobals: ['fetch'],
@@ -981,7 +1331,14 @@ function _installNodeFieldCaches(TS) {
             Object.defineProperty(base, NAMED_CHILDREN_LIST, {
                 configurable: true,
                 writable: true,
-                value() { return namedList(this); },
+                value(parent) {
+                    const children = namedList(this);
+                    // The traversal already knows this native child edge.
+                    // Keep leaf facts lazy: an empty list alone needs none.
+                    const facts = this[NODE_FACTS];
+                    if (parent !== undefined && facts !== undefined) facts.parent = parent;
+                    return children;
+                },
             });
             Object.defineProperty(base, 'namedChildren', {
                 configurable: true,
@@ -1145,9 +1502,13 @@ function getParser(language) {
     }
 
     parsers[language] = parser;
+    parserLanguages.set(parser, language);
     return parser;
 }
 
+// The language each cached parser reads, for grammar-gap recovery (fix #428).
+const parserLanguages = new WeakMap();
+
 /**
  * Detect language from file path
  * @param {string} filePath - File path
@@ -1241,10 +1602,32 @@ function getParseOptions(contentLength = 0) {
 let _lastParseParser = null;
 let _lastParseContent = null;
 let _lastParseTree = null;
+// The plain parse of the file an analysis reads (fix #436): a language may
+// parse other views of the source after it (recoveries, configurations),
+// and an index-time fact of the literal tree then needs no second parse.
+let _literalCapture = null;
+
+/** Remember the tree of the next plain parse of exactly (parser, content). */
+function captureLiteralParse(parser, content) {
+    _literalCapture = { parser, content, tree: null };
+}
+
+/** The tree captureLiteralParse remembered (null if none), ending the capture. */
+function takeLiteralParse() {
+    const capture = _literalCapture;
+    _literalCapture = null;
+    return capture?.tree || null;
+}
+
+function noteLiteralParse(parser, content, tree) {
+    if (_literalCapture && !_literalCapture.tree && tree && parser === _literalCapture.parser &&
+        content === _literalCapture.content) _literalCapture.tree = tree;
+}
 
 function safeParse(parser, content, oldTree = undefined, options = {}) {
     // Fast path: return cached tree if same parser and content (no oldTree override)
     if (!oldTree && parser === _lastParseParser && content === _lastParseContent && _lastParseTree) {
+        noteLiteralParse(parser, content, _lastParseTree);
         return _lastParseTree;
     }
 
@@ -1266,12 +1649,22 @@ function safeParse(parser, content, oldTree = undefined, options = {}) {
     let lastError;
     for (const bufferSize of bufferSizes) {
         try {
-            const tree = parser.parse(content, oldTree, { ...options, bufferSize });
+            let tree = parser.parse(content, oldTree, { ...options, bufferSize });
+            // A language whose grammar misses a construct of valid source
+            // recovers that construct by a reparse with the construct's
+            // inert tokens blanked (positions unchanged, fix #428).
+            const recovery = oldTree ? null : LANGUAGES[parserLanguages.get(parser)]?.parseRecovery;
+            if (recovery && tree?.rootNode?.hasError) {
+                const recovered = recovery()(tree, content,
+                    text => parser.parse(text, undefined, { ...options, bufferSize }));
+                if (recovered) tree = recovered;
+            }
             // Cache the result for same-(parser, content) reuse
             if (!oldTree) {
                 _lastParseParser = parser;
                 _lastParseContent = content;
                 _lastParseTree = tree;
+                noteLiteralParse(parser, content, tree);
             }
             return tree;
         } catch (e) {
@@ -1313,6 +1706,8 @@ module.exports = {
     PARSE_OPTIONS,
     getParseOptions,
     safeParse,
+    captureLiteralParse,
+    takeLiteralParse,
     langTraits,
     DEFAULT_BUFFER_SIZE,
     MAX_BUFFER_SIZE