ucn 5.4.1 → 5.5.0

package/core/index-ir.js

@@ -9,15 +9,32 @@
  */
 
 function createImportBindings(imports) {
-    return imports.flatMap(item => (item.names || [])
+    return imports.flatMap(item => {
+        const names = item.names || [];
+        let renames;
+        if (item.renames?.length) {
+            const sourceNames = new Set(names);
+            renames = new Map();
+            // Reverse once so each per-name stack pops in source order.
+            for (let i = item.renames.length - 1; i >= 0; i--) {
+                const rename = item.renames[i];
+                const spelling = sourceNames.has(rename.original) ? rename.original : rename.local;
+                if (!renames.has(spelling)) renames.set(spelling, []);
+                renames.get(spelling).push(rename);
+            }
+        }
+        return names
         .filter(name => name && name !== '*' && name !== '_' && name !== '.')
         .map(name => {
             // A rename may be recorded under its original name (Python
             // `from m import a as b` lists 'a') or under its local alias
             // (Rust `use m::a as b` lists 'b', fix #357); both yield the
             // binding {name: original, alias: local}.
-            const rename = (item.renames || []).find(candidate =>
-                candidate.original === name || candidate.local === name);
+            // Each rename belongs to one import specifier. Reusing it for
+            // every repeated source name loses the unaliased binding in
+            // `import { A, A as B }`. A local spelling is used only when
+            // this record does not also list the original spelling (Rust).
+            const rename = renames?.get(name)?.pop();
             return {
                 name: rename ? rename.original : name,
                 module: item.module,
@@ -27,8 +44,26 @@ function createImportBindings(imports) {
                 ...(item.defaultLike && { defaultLike: true }),
                 ...(item.deferred && { deferred: true }),
                 ...(item.dynamic && { dynamic: true }),
+                ...(item.namespace && { namespace: item.namespace }),
             };
-        }));
+        });
+    });
+}
+
+/** Names a C# slot-typed `new(..)` record depends on: the call or type it
+ * is an argument of, the receiver member of that call, or the member it is
+ * assigned to (fix #400). Null when the file has none. */
+function targetTypedKeysOf(calls) {
+    let keys = null;
+    for (const call of calls || []) {
+        const slot = call?.targetSlot;
+        if (!slot) continue;
+        if (!keys) keys = new Set();
+        for (const key of [slot.ownerName, slot.receiverName, slot.member]) if (key) keys.add(key);
+        // A generic receiver's written type (fix #401) is its own key.
+        if (slot.receiverTypeText) keys.add(`~${slot.receiverTypeText}`);
+    }
+    return keys ? [...keys].sort() : null;
 }
 
 function createFileEntryFromIR({
@@ -63,6 +98,14 @@ function createFileEntryFromIR({
             ...(item.line != null && { line: item.line }),
             ...(item.deferred && { deferred: true }),
             ...(item.deferredReason && { deferredReason: item.deferredReason }),
+            // C# using directives (fix #395): the namespace the directive
+            // sits in (its name resolves from there), `using static`, and
+            // `global using`.
+            ...(item.namespace && { namespace: item.namespace }),
+            ...(item.static && { static: true }),
+            ...(item.global && { global: true }),
+            // Go (fix #400): the import writes no local name.
+            ...(item.implicitName && { implicitName: true }),
         })),
         globalImports: imports.filter(item => item.global).map(item => item.module),
         importNames: imports.flatMap(item => item.names || []),
@@ -73,10 +116,45 @@ function createFileEntryFromIR({
         bindings: [],
         dynamicImports: ir.dynamicImports || 0,
         ...(ir.diagnostics?.parseRecovery && { parseRecovery: true }),
+        ...(ir.diagnostics?.parseErrorRegions?.length > 0 && {
+            parseErrorRegions: ir.diagnostics.parseErrorRegions,
+        }),
         ...(ir.importAliases && { importAliases: ir.importAliases }),
         ...(ir.moduleAssignedNames?.length > 0 && {
             moduleAssignedNames: ir.moduleAssignedNames,
         }),
+        ...(ir.asyncClosureNames?.length > 0 && {
+            asyncClosureNames: ir.asyncClosureNames,
+        }),
+        ...(Array.isArray(ir.openCalls) && { openCalls: ir.openCalls }),
+        ...(ir.typeConversions?.length > 0 && {
+            typeConversions: ir.typeConversions,
+        }),
+        ...(ir.reflectionSites?.length > 0 && {
+            reflectionSites: ir.reflectionSites,
+        }),
+        ...(ir.macroScopeMarkers?.length > 0 && {
+            macroScopeMarkers: ir.macroScopeMarkers,
+        }),
+        ...(ir.cppUsings?.length > 0 && {
+            cppUsings: ir.cppUsings,
+        }),
+        ...(ir.languageFeatures?.length > 0 && {
+            languageFeatures: ir.languageFeatures,
+        }),
+        ...(Array.isArray(ir.conditionalViews) && { conditionalViews: ir.conditionalViews }),
+        // C# target-typed `new(..)` records whose type a call or member
+        // decides (fix #400): the names a query matches before reading them.
+        ...(targetTypedKeysOf(ir.calls) && { targetTypedKeys: targetTypedKeysOf(ir.calls) }),
+        ...(ir.packageName && { packageName: ir.packageName }),
+        ...(ir.packageVars?.length > 0 && { packageVars: ir.packageVars }),
+        ...(ir.buildConstraint && { buildConstraint: ir.buildConstraint }),
+        ...(ir.moduleValueAliases?.length > 0 && { moduleValueAliases: ir.moduleValueAliases }),
+        ...(ir.moduleConstructedValues?.length > 0 && { moduleConstructedValues: ir.moduleConstructedValues }),
+        ...(ir.configurationItems?.length > 0 && { configurationItems: ir.configurationItems }),
+        ...(Array.isArray(ir.recoveryBlanks) && { recoveryBlanks: ir.recoveryBlanks }),
+        ...(Array.isArray(ir.recoveryCandidates) && { recoveryCandidates: ir.recoveryCandidates }),
+        ...(Array.isArray(ir.externalMacroNames) && { externalMacroNames: ir.externalMacroNames }),
         ...(isBundled && { isBundled: true }),
         ...(isGenerated && { isGenerated: true }),
     };
@@ -85,20 +163,25 @@ function createFileEntryFromIR({
 const OPTIONAL_SYMBOL_FIELDS = Object.freeze([
     'returnedFunctionResult', 'isFunctionVariable', 'paramTypes', 'isAsync',
     'isGenerator', 'generics', 'ownerGenerics', 'genericBounds', 'extends', 'implements', 'indent', 'isNested',
-    'enclosingType', 'isMethod', 'receiver', 'memberType', 'fieldType',
-    'aliasOf', 'aliasMembers', 'aliasTypeText', 'aliasTypeParameters', 'aliasTypeDefaults', 'derefTarget', 'decorators', 'decoratorsWithArgs',
+    'enclosingType', 'isMethod', 'receiver', 'memberType', 'fieldType', 'embedded',
+    'aliasOf', 'aliasQualifier', 'aliasMembers', 'aliasTypeText', 'aliasTypeParameters', 'aliasTypeDefaults', 'derefTarget', 'decorators', 'decoratorsWithArgs',
     'annotationsWithArgs', 'attributesWithArgs', 'nameLine', 'traitImpl',
-    'traitName', 'isSignature', 'memberAssigned', 'assignedReceiver', 'bodyScopedName',
-    'registryMember', 'registryContainer', 'namespace',
-    'isExtensionMethod', 'extensionReceiver', 'explicitInterface',
+    'traitName', 'isSignature', 'memberAssigned', 'assignedReceiver', 'assignedObject', 'selfNamed', 'bodyScopedName',
+    'registryMember', 'registryContainer', 'registryContainerType', 'objectLiteralLine', 'namespace',
+    'isExtensionMethod', 'extensionReceiver', 'explicitInterface', 'primaryParams',
     'lexicalScopeStartLine', 'lexicalScopeEndLine',
-    'returnTypeQualifier', 'macroNeverReturns', 'callbackParamTypes', 'iteratorItemType',
+    'returnTypeQualifier', 'returnTypeResolved', 'supertraits', 'ownerGenericBounds', 'ownerSelfArgs', 'implSelfRef', 'implSelfQualifier', 'blanketSelfBounds', 'selfParamKind', 'macroNeverReturns', 'callbackParamTypes', 'iteratorItemType', 'futureReturn',
     'returnedConcreteType', 'returnedConstructors', 'templateDependent',
     'returnedCallStart', 'returnedCallEnd',
-    'returnedReceiverPath',
+    'returnedReceiverPath', 'valueType', 'valueDerefVia',
     'isSpecialization',
     'linkage', 'functionLike', 'callableAlias', 'exportedAlias',
     'aliasOwner', 'aliasMember', 'callableTarget', 'macroParamEffects',
+    'namespaceScope', 'ppParams', 'ppVariadic', 'ppBody', 'ppConditional', 'languageBranch', 'macroExpansion', 'macroScope', 'accessAfterMacro', 'ppBranch',
+    'generatedByMacro',
+    'typeArity', 'ownerTypeArity',
+    'annotationType', 'valueShape', 'friendOf', 'templateParams', 'delegateParams',
+        'typedefName',
 ]);
 
 function materializeSymbol(fileEntry, item) {