tsc-ts 0.0.9 → 0.1.0

package/src/compiler/transformers/declarations.ts

@@ -44,7 +44,6 @@ import {
   GetAccessorDeclaration,
   HeritageClause,
   Identifier,
-  ImportAttributes,
   ImportClause,
   ImportDeclaration,
   ImportEqualsDeclaration,
@@ -102,6 +101,7 @@ import {
   isDeclarationNode,
 } from '../ast.js';
 import {
+  getHeritageClauseElementName,
   isAmbientModule,
   isAnyImportOrReExport,
   isFunctionLike,
@@ -183,6 +183,8 @@ export class DeclarationTransformer extends Transformer {
   private readonly expandoHosts: Map<Node, Node | undefined>;
   /** The namespace members for the assigned properties of each function, by statement. */
   private readonly expandoMembers: Map<Node, Node[]>;
+  /** Assigned properties of hosts that weren't visible when found, by host; written if the host becomes visible. */
+  private readonly deferredExpandoAssignments: Map<Node, BinaryExpression[]>;
   /** The `export =` for a CommonJS `module.exports = …`. */
   private cjsExportAssignment: Node | undefined;
   /** The exports for CommonJS `exports.x = …` assignments. */
@@ -221,6 +223,7 @@ export class DeclarationTransformer extends Transformer {
     this.lateStatementReplacements = new Map<Node, Node | undefined>();
     this.expandoHosts = new Map<Node, Node | undefined>();
     this.expandoMembers = new Map<Node, Node[]>();
+    this.deferredExpandoAssignments = new Map<Node, BinaryExpression[]>();
     this.cjsExportAssignment = undefined;
     this.cjsExportMembers = [];
     this.cjsExportAssignmentName = undefined;
@@ -293,6 +296,7 @@ export class DeclarationTransformer extends Transformer {
     this.lateStatementReplacements = new Map<Node, Node | undefined>();
     this.expandoHosts.clear();
     this.expandoMembers.clear();
+    this.deferredExpandoAssignments.clear();
     this.witnessedCjsExports.clear();
     this.cjsExportAssignment = undefined;
     this.cjsExportAssignmentName = undefined;
@@ -672,6 +676,19 @@ export class DeclarationTransformer extends Transformer {
       case SyntaxKind.TypeQuery:
         this.checkEntityNameVisibility((input as TypeQueryNode).exprName, this.enclosingDeclaration);
         return this.visitEachChild(input);
+      case SyntaxKind.QualifiedName: {
+        // `typeof this.#x`: the private member isn't in the declaration output.
+        const right = (input as QualifiedName).right;
+        if (right.kind === SyntaxKind.PrivateIdentifier)
+          this.tracker.addDiagnostic(
+            createDiagnosticForNode(
+              input,
+              Diagnostics.Declaration_emit_elides_private_members_but_0_refers_to_a_private_member_Write_an_explicit_type_here,
+              [getText(right)],
+            ),
+          );
+        return this.visitEachChild(input);
+      }
       case SyntaxKind.TupleType: {
         const result = this.visitEachChild(input);
         if (isOriginalNodeSingleLine(this.context, input)) this.context.addEmitFlags(result, EmitFlags.SingleLine);
@@ -774,10 +791,13 @@ export class DeclarationTransformer extends Transformer {
     const types = clause.types.nodes;
     const retained: Node[] = [];
     for (const type of types) {
-      const expression = (type as ExpressionWithTypeArguments).expression;
+      const name = getHeritageClauseElementName(type);
       if (
-        isEntityNameExpression(expression, false) ||
-        (clause.token === SyntaxKind.ExtendsKeyword && expression.kind === SyntaxKind.NullKeyword)
+        name.kind === SyntaxKind.QualifiedName ||
+        isEntityNameExpression(name, false) ||
+        (clause.token === SyntaxKind.ExtendsKeyword &&
+          type.kind === SyntaxKind.ExpressionWithTypeArguments &&
+          name.kind === SyntaxKind.NullKeyword)
       )
         retained.push(type);
     }
@@ -861,12 +881,14 @@ export class DeclarationTransformer extends Transformer {
       isVariableDeclarationInitializedToRequire(input)
     )
       return this.transformCjsRequireVariableDeclaration(input);
-    if (input.name instanceof BindingPattern) return this.recreateBindingPattern(input.name);
+    // A binding pattern with initializers becomes a declaration per name; without them it stays.
+    if (input.name instanceof BindingPattern && hasAnyBindingInitializers(input.name))
+      return this.recreateBindingPattern(input.name);
     // Variable types don't enter new diagnostic contexts.
     this.suppressNewDiagnosticContexts = true;
     return this.factory.updateVariableDeclaration(
       input,
-      input.name,
+      this.visitBindingName(input.name),
       undefined,
       this.ensureType(input, false),
       this.ensureNoInitializer(input),
@@ -1038,9 +1060,16 @@ export class DeclarationTransformer extends Transformer {
   private omitPrivateMethodType(input: Node): Node | undefined {
     const symbol = getSymbol(input);
     if (symbol !== undefined && declarationCount(symbol) > 0 && symbol.declaration !== input) return undefined;
-    const result = this.factory.created(
-      new PropertyDeclaration(this.ensureModifiers(input), getName(input)!, undefined, undefined, undefined),
-    );
+    // A method signature becomes a property signature, a method a property declaration.
+    let result: Node;
+    if (input.kind === SyntaxKind.MethodSignature)
+      result = this.factory.created(
+        new PropertySignatureDeclaration(this.ensureModifiers(input), getName(input)!, undefined, undefined, undefined),
+      );
+    else
+      result = this.factory.created(
+        new PropertyDeclaration(this.ensureModifiers(input), getName(input)!, undefined, undefined, undefined),
+      );
     this.context.assignCommentRange(result, input);
     return result;
   }
@@ -1091,7 +1120,7 @@ export class DeclarationTransformer extends Transformer {
         input.isTypeOnly,
         input.exportClause,
         this.rewriteModuleSpecifier(input, input.moduleSpecifier),
-        this.tryGetResolutionModeOverride(input.attributes),
+        input.attributes,
       );
     }
     if (input instanceof ExportAssignment)
@@ -1119,9 +1148,14 @@ export class DeclarationTransformer extends Transformer {
       (input.parent.kind === SyntaxKind.SourceFile || input.parent.kind === SyntaxKind.ModuleBlock)
     ) {
       const result = this.factory.created(new ExportAssignment(undefined, isExportEquals, undefined, expression));
+      this.context.assignSourceMapRange(result, input);
       this.context.assignCommentRange(result, input);
       return result;
     }
+    // Types the default export can't name are reported for it, as class and function declarations too.
+    const tracker = this.tracker;
+    tracker.diagnosticContext = new DiagnosticContext(DiagnosticContextKind.DefaultExport, input, undefined);
+    tracker.pushErrorFallbackNode(assignment);
     const unwrapped = skipOuterExpressions(expression);
     const name = this.getNameOfExportedExpression(unwrapped, isExportEquals);
     // Class and function expressions become declarations.
@@ -1129,17 +1163,16 @@ export class DeclarationTransformer extends Transformer {
       const declaration =
         unwrapped instanceof ClassExpression
           ? this.transformClassExpressionToDeclaration(unwrapped, name, this.declareModifiers())
-          : this.transformFunctionLikeToDeclaration(unwrapped, name, this.declareModifiers());
+          : this.transformFunctionLikeToDeclaration(unwrapped, name, this.declareModifiers(), getType(assignment));
+      tracker.popErrorFallbackNode();
       this.context.assignCommentRange(declaration, input);
       const exportAssignment = this.factory.created(new ExportAssignment(undefined, isExportEquals, undefined, name));
+      this.context.assignSourceMapRange(exportAssignment, input);
       this.context.addEmitFlags(exportAssignment, EmitFlags.NoComments);
       return this.factory.createSyntaxList([exportAssignment, declaration]);
     }
     // Other expressions are written as a `_default` variable with the expression's type.
-    const tracker = this.tracker;
-    tracker.diagnosticContext = new DiagnosticContext(DiagnosticContextKind.DefaultExport, input, undefined);
     this.cjsExportAssignmentName = name;
-    tracker.pushErrorFallbackNode(assignment);
     let initializer: Node | undefined = undefined;
     if (isPrimitiveLiteralValue(skipParenthesesOnly(expression), true))
       initializer = this.resolver.createLiteralConstValue(this.context, this.parseNode(assignment), tracker);
@@ -1148,6 +1181,7 @@ export class DeclarationTransformer extends Transformer {
     tracker.popErrorFallbackNode();
     const statement = this.createConstStatement(declaration);
     const exportAssignment = this.factory.created(new ExportAssignment(undefined, isExportEquals, undefined, name));
+    this.context.assignSourceMapRange(exportAssignment, input);
     this.context.assignCommentRange(statement, input);
     return this.factory.createSyntaxList([statement, exportAssignment]);
   }
@@ -1159,8 +1193,24 @@ export class DeclarationTransformer extends Transformer {
     );
   }
 
-  private transformFunctionLikeToDeclaration(fn: Node, name: Identifier, modifiers: ModifierList): Node {
-    const fullSignature = getFullSignature(fn);
+  private transformFunctionLikeToDeclaration(
+    fn: Node,
+    name: Identifier,
+    modifiers: ModifierList,
+    fullSignatureType: Node | undefined,
+  ): Node {
+    // A JSDoc signature, of the function or of the assignment, is reused as the type of a `const`.
+    const fullSignature = getFullSignature(fn) ?? fullSignatureType;
+    if (fullSignature !== undefined)
+      return this.factory.createVariableStatement(
+        modifiers,
+        this.factory.createVariableDeclarationList(
+          this.factory.createNodeList([
+            this.factory.createVariableDeclaration(name, undefined, this.visitNode(fullSignature), undefined),
+          ]),
+          NodeFlags.Const,
+        ),
+      );
     return this.factory.created(
       new FunctionDeclaration(
         modifiers,
@@ -1169,7 +1219,7 @@ export class DeclarationTransformer extends Transformer {
         this.ensureTypeParams(fn, getTypeParameters(fn)),
         this.updateParamList(fn, getParameters(fn)!),
         this.ensureType(fn, false),
-        fullSignature === undefined ? undefined : this.visitNode(fullSignature),
+        undefined,
         undefined,
       ),
     );
@@ -1236,11 +1286,6 @@ export class DeclarationTransformer extends Transformer {
     return input;
   }
 
-  private tryGetResolutionModeOverride(node: ImportAttributes | undefined): ImportAttributes | undefined {
-    if (node === undefined) return undefined;
-    return this.resolver.getResolutionModeOverride(node) !== undefined ? node : undefined;
-  }
-
   /** The replacement statements for a direct child of a source file or module block. */
   private transformTopLevelDeclaration(input: Node): Node | undefined {
     if (input === undefined) return undefined;
@@ -1280,7 +1325,8 @@ export class DeclarationTransformer extends Transformer {
     if (isDeclaration(input) && this.isDeclarationAndNotVisible(input)) return undefined;
     if (isFunctionLike(input) && this.resolver.isImplementationOfOverload(input)) return undefined;
     const original = this.context.mostOriginal(input);
-    if (this.expandoHosts.has(original)) return this.createFullExpandoBlock(original);
+    if (this.expandoHosts.has(original) || this.deferredExpandoAssignments.has(original))
+      return this.createFullExpandoBlock(original);
     const previousEnclosingDeclaration = this.enclosingDeclaration;
     if (isEnclosingDeclaration(input)) this.enclosingDeclaration = input;
     const oldContext = tracker.diagnosticContext;
@@ -1349,7 +1395,8 @@ export class DeclarationTransformer extends Transformer {
       this.ensureModifiers(input),
       input.name,
       this.visitNodes(input.typeParameters),
-      this.visitNode(input.type)!,
+      // stripInternal can elide an `@internal` type on the right; it falls back to `any`, as index signatures do.
+      this.visitNode(input.type) ?? this.keyword(SyntaxKind.AnyKeyword),
     );
   }
 
@@ -1384,6 +1431,7 @@ export class DeclarationTransformer extends Transformer {
     const saveNeedsDeclare = this.needsDeclare;
     this.needsDeclare = false;
     const body = input.body;
+    const attributes = this.visitNode(input.attributes) as TypeLiteralNode | undefined;
     let keyword = input.keyword;
     if (keyword !== SyntaxKind.GlobalKeyword && !(input.name instanceof StringLiteral))
       keyword = SyntaxKind.NamespaceKeyword;
@@ -1409,7 +1457,7 @@ export class DeclarationTransformer extends Transformer {
       this.needsDeclare = saveNeedsDeclare;
       this.needsScopeFixMarker = oldNeedsScopeFix;
       this.resultHasScopeMarker = oldHasScopeFix;
-      return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, updatedBody);
+      return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, attributes, updatedBody);
     }
     if (body !== undefined) {
       // A nested `namespace a.b` is transformed now: it needs no visibility painting.
@@ -1418,10 +1466,10 @@ export class DeclarationTransformer extends Transformer {
       const inner = this.lateStatementReplacements.get(original);
       this.lateStatementReplacements.delete(original);
       this.needsDeclare = saveNeedsDeclare;
-      return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, inner);
+      return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, attributes, inner);
     }
     this.needsDeclare = saveNeedsDeclare;
-    return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, undefined);
+    return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, attributes, undefined);
   }
 
   private stripExportModifiersOfList(list: NodeList): NodeList {
@@ -1489,7 +1537,7 @@ export class DeclarationTransformer extends Transformer {
       return factory.updateTypeAliasDeclaration(node, modifiers, node.name, node.typeParameters, node.type);
     if (node instanceof EnumDeclaration) return factory.updateEnumDeclaration(node, modifiers, node.name, node.members);
     if (node instanceof ModuleDeclaration)
-      return factory.updateModuleDeclaration(node, modifiers, node.keyword, node.name, node.body);
+      return factory.updateModuleDeclaration(node, modifiers, node.keyword, node.name, node.attributes, node.body);
     if (node instanceof ImportDeclaration)
       return factory.updateImportDeclaration(node, modifiers, node.importClause, node.moduleSpecifier, node.attributes);
     if (node instanceof ExportDeclaration)
@@ -2004,6 +2052,7 @@ export class DeclarationTransformer extends Transformer {
             this.declareModifiers(),
             SyntaxKind.NamespaceKeyword,
             namespaceName,
+            undefined,
             factory.created(new ModuleBlock(factory.createNodeList([classDeclaration]))),
           ),
         );
@@ -2084,6 +2133,7 @@ export class DeclarationTransformer extends Transformer {
         this.declareModifiers(),
         SyntaxKind.NamespaceKeyword,
         name,
+        undefined,
         this.factory.created(new ModuleBlock(this.factory.createNodeList(stripped))),
       ),
     );
@@ -2119,7 +2169,17 @@ export class DeclarationTransformer extends Transformer {
     const name = this.factory.createIdentifier(namespace.text);
     const property = this.tryGetPropertyName(left);
     if (property === '' || !isIdentifierText(property)) return false;
-    if (isDeclaration(declaration) && this.isDeclarationAndNotVisible(declaration)) return false;
+    const hostId = this.getExpandoHostId(declaration);
+    if (isDeclaration(declaration) && this.isDeclarationAndNotVisible(declaration)) {
+      // Writing the type of a visible declaration, such as `typeof f`, can make the host visible later.
+      let deferred = this.deferredExpandoAssignments.get(hostId);
+      if (deferred === undefined) {
+        deferred = [];
+        this.deferredExpandoAssignments.set(hostId, deferred);
+      }
+      deferred.push(node);
+      return false;
+    }
     if (declaration instanceof FunctionDeclaration && !shouldEmitFunctionProperties(declaration)) return false;
     this.transformExpandoHost(name, declaration);
     const exportName = this.factory.createIdentifier(property);
@@ -2133,21 +2193,21 @@ export class DeclarationTransformer extends Transformer {
       localName = exportName;
     if (localName === undefined || isNonContextualKeyword(stringToToken(localName.text)))
       localName = this.factory.createGeneratedNameForNode(node, GeneratedIdentifierFlags.None, '', '');
-    const hostId = this.getExpandoHostId(declaration);
     const scope = this.enterDiagnosticContext(node);
     let members = this.expandoMembers.get(hostId);
     if (members === undefined) {
       members = [];
       this.expandoMembers.set(hostId, members);
     }
+    let hasExport = false;
+    for (const member of members) if (member.kind === SyntaxKind.ExportDeclaration) hasExport = true;
     if (node.right instanceof Identifier) {
-      // Alias-like: `export { name }` or `export { name as alias }`.
+      // Alias-like: `export { name }` or `export { name as alias }`; the other members stay exported.
+      if (!hasExport) this.addExportModifierToExpandoMembers(members);
       members.push(this.transformBinaryExpressionToExportDeclaration(node, exportName));
       this.exitDiagnosticContext(scope);
       return true;
     }
-    let hasExport = false;
-    for (const member of members) if (member.kind === SyntaxKind.ExportDeclaration) hasExport = true;
     const variable = this.factory.createVariableStatement(
       hasExport ? this.factory.createModifierList([this.factory.createToken(SyntaxKind.ExportKeyword)]) : undefined,
       this.factory.createVariableDeclarationList(
@@ -2162,17 +2222,21 @@ export class DeclarationTransformer extends Transformer {
     if (local.text !== exportName.text || this.context.hasAutoGenerateInfo(local))
       statements.push(this.createExportDeclaration(local, exportName));
     // Members stay exported after an `export {}` is added.
-    if (statements.length > 1 && !hasExport)
-      for (let i = 0; i < members.length; i++)
-        members[i] = this.replaceModifiers(
-          members[i],
-          this.createModifiers(ModifierFlags.Export | getCombinedModifierFlags(members[i])),
-        );
+    if (statements.length > 1 && !hasExport) this.addExportModifierToExpandoMembers(members);
     for (const statement of statements) members.push(statement);
     this.exitDiagnosticContext(scope);
     return true;
   }
 
+  /** Adds `export` to a host's members, before the first `export {}` is added to them. */
+  private addExportModifierToExpandoMembers(members: Node[]): void {
+    for (let i = 0; i < members.length; i++)
+      members[i] = this.replaceModifiers(
+        members[i],
+        this.createModifiers(ModifierFlags.Export | getCombinedModifierFlags(members[i])),
+      );
+  }
+
   private tryGetPropertyName(node: Node): string {
     if (node instanceof ElementAccessExpression) return this.resolver.getElementAccessExpressionName(node);
     if (node instanceof PropertyAccessExpression && node.name instanceof Identifier) return node.name.text;
@@ -2251,6 +2315,12 @@ export class DeclarationTransformer extends Transformer {
 
   /** A function with its assigned properties as a namespace of the same name. */
   private createFullExpandoBlock(id: Node): Node | undefined {
+    // Assignments deferred while the host wasn't visible; they are deferred again if it still isn't.
+    const deferred = this.deferredExpandoAssignments.get(id);
+    if (deferred !== undefined) {
+      this.deferredExpandoAssignments.delete(id);
+      for (const assignment of deferred) this.transformExpandoAssignment(assignment);
+    }
     const host = this.expandoHosts.get(id);
     const addOns = this.expandoMembers.get(id);
     if (addOns === undefined || host === undefined) return host;
@@ -2274,6 +2344,7 @@ export class DeclarationTransformer extends Transformer {
           modifiers,
           SyntaxKind.NamespaceKeyword,
           name,
+          undefined,
           this.factory.created(new ModuleBlock(this.factory.createNodeList(addOns))),
         ),
       ),
@@ -2314,7 +2385,7 @@ export class DeclarationTransformer extends Transformer {
       return false;
     this.seenProperties.add(key);
     const heritage = getHeritageClauses(classNode);
-    if (heritage !== undefined && heritage.nodes.length > 0 && !isClassExtendingNull(heritage)) {
+    if (heritage !== undefined && heritage.nodes.length > 0 && !isClassExtendingNull(classNode)) {
       // A base class may provide the member; that needs types.
       this.tracker.reportInferenceFallback(classNode);
       if (this.resolver.isThisPropertyAssignmentDeclarationRedundant(node)) return false;
@@ -2323,11 +2394,12 @@ export class DeclarationTransformer extends Transformer {
     if (getTextOfPropertyName(name) === 'constructor') return false;
     if (name instanceof Identifier && !isIdentifierText(name.text))
       name = this.factory.createStringLiteralFromNode(name);
+    // JSDoc modifiers such as `@readonly` and `@private` apply to the property.
+    let modifierFlags = this.ensureModifierFlags(node);
+    if (isStaticMember) modifierFlags |= ModifierFlags.Static;
     const property = this.factory.created(
       new PropertyDeclaration(
-        isStaticMember
-          ? this.factory.createModifierList([this.factory.createToken(SyntaxKind.StaticKeyword)])
-          : undefined,
+        this.createModifiers(modifierFlags),
         name,
         undefined,
         this.ensureType(node, false),
@@ -2636,7 +2708,7 @@ export class DeclarationTransformer extends Transformer {
       declaration.modifiers,
       clause,
       this.rewriteModuleSpecifier(declaration, declaration.moduleSpecifier)!,
-      this.tryGetResolutionModeOverride(declaration.attributes),
+      declaration.attributes,
     );
   }
 
@@ -3031,10 +3103,15 @@ function isNonContextualKeyword(kind: SyntaxKind): boolean {
   );
 }
 
-function isClassExtendingNull(heritage: NodeList): boolean {
-  if (heritage.nodes.length !== 1) return false;
-  for (const type of (heritage.nodes[0] as HeritageClause).types.nodes)
-    if (getExpression(type)!.kind === SyntaxKind.NullKeyword) return true;
+/** Whether a class's `extends` clause names exactly `null`. */
+function isClassExtendingNull(node: Node): boolean {
+  const heritage = getHeritageClauses(node);
+  if (heritage === undefined) return false;
+  for (const clause of heritage.nodes) {
+    if ((clause as HeritageClause).token !== SyntaxKind.ExtendsKeyword) continue;
+    const types = (clause as HeritageClause).types.nodes;
+    return types.length === 1 && getExpression(types[0]!)?.kind === SyntaxKind.NullKeyword;
+  }
   return false;
 }
 
@@ -3118,3 +3195,12 @@ function getTextOfJSDocComment(comment: NodeList | undefined): string {
   }
   return text.trimEnd();
 }
+
+function hasAnyBindingInitializers(pattern: BindingPattern): boolean {
+  for (const element of pattern.elements.nodes) {
+    if (!(element instanceof BindingElement)) continue;
+    if (element.initializer !== undefined) return true;
+    if (element.name instanceof BindingPattern && hasAnyBindingInitializers(element.name)) return true;
+  }
+  return false;
+}

package/src/compiler/transformers/decorator-metadata.ts

@@ -67,7 +67,7 @@ export class DecoratorMetadata extends Transformer {
   private readonly legacyDecorators: boolean;
   private readonly facts: SyntaxFacts;
   private readonly serializer: MetadataSerializer;
-  /** The class whose members are visited. */
+  /** The class, or object literal, whose members are visited. */
   private parentClass: Node | undefined;
 
   constructor(context: EmitContext, options: CompilerOptions, resolver: EmitResolver, facts: SyntaxFacts) {
@@ -89,6 +89,14 @@ export class DecoratorMetadata extends Transformer {
       case SyntaxKind.ClassDeclaration:
       case SyntaxKind.ClassExpression:
         return this.visitClass(node);
+      case SyntaxKind.ObjectLiteralExpression: {
+        // Members of an object literal are not class elements and get no metadata.
+        const saved = this.parentClass;
+        this.parentClass = node;
+        const updated = this.visitEachChild(node);
+        this.parentClass = saved;
+        return updated;
+      }
       case SyntaxKind.PropertyDeclaration:
         if (node instanceof PropertyDeclaration) {
           if (!hasDecorators(node)) return this.visitEachChild(node);

package/src/compiler/transformers/destructuring.ts

@@ -189,7 +189,8 @@ class Flattener {
       if (this.hoistTempVariables) {
         const value = factory.inlineExpressions(this.expressions)!;
         this.expressions = [];
-        this.emitBinding(temp, value, -1, -1, undefined);
+        // tsgo gives this declaration the empty range at the start of the file (core.TextRange{}), not a synthesized one.
+        this.emitBinding(temp, value, 0, 0, undefined);
       } else {
         this.visitor.context.addVariableDeclaration(temp);
         const last = this.declarations[this.declarations.length - 1]!;
@@ -674,9 +675,9 @@ function convertToArrayElement(visitor: VisitorHooks, element: BindingElement):
   const factory = visitor.factory;
   const name = element.name;
   if (name === undefined) return converted(visitor, factory.created(new OmittedExpression()), element);
-  if (element.dotDotDotToken !== undefined)
-    return converted(visitor, factory.created(new SpreadElement(name)), element);
   const target = convertBindingNameToTarget(visitor, name);
+  if (element.dotDotDotToken !== undefined)
+    return converted(visitor, factory.created(new SpreadElement(target)), element);
   if (element.initializer === undefined) return target;
   return converted(visitor, factory.createAssignment(target, element.initializer), element);
 }

package/src/compiler/transformers/external-module-info.ts

@@ -366,7 +366,7 @@ export function createExternalHelpersImportDeclarationIfNeeded(
     const name = names[i];
     // Aliased when the name is used in the file.
     specifiers.push(
-      isFileLevelUniqueName(file, name)
+      isFileLevelUniqueName(context.mostOriginal(file) as SourceFile, name)
         ? factory.created(new ImportSpecifier(false, undefined, factory.createIdentifier(name)))
         : factory.created(
             new ImportSpecifier(false, factory.createIdentifier(name), factory.createUnscopedHelperName(name)),

package/src/compiler/transformers/jsx.ts

@@ -30,6 +30,7 @@ import {
   ArrayLiteralExpression,
   VariableDeclaration,
   getTagName,
+  getText,
 } from '../ast.js';
 import { isExternalOrCommonJSModule } from '../binder-utilities.js';
 import { isLineBreak, isWhiteSpaceSingleLine } from '../character-codes.js';
@@ -545,7 +546,7 @@ export class JsxTransformer extends Transformer {
   private expressionFromEntityName(entity: Node, parent: Node): Node {
     if (entity instanceof QualifiedName) {
       const left = this.expressionFromEntityName(entity.left, parent);
-      return this.factory.createPropertyAccessExpression(left, this.factory.createIdentifier(entity.right.text));
+      return this.factory.createPropertyAccessExpression(left, this.factory.createIdentifier(getText(entity.right)));
     }
     return this.createReactNamespace((entity as Identifier).text, parent);
   }

package/src/compiler/transformers/reference-resolver.ts

@@ -527,26 +527,45 @@ export class ReferenceResolver {
     const moduleDeclaration = moduleDeclarationOfSpecifier(declaration);
     if (imported === undefined || moduleDeclaration === undefined) return false;
     const moduleSymbol = this.resolveModuleSpecifier(declaration, getModuleSpecifierOf(moduleDeclaration));
-    return moduleSymbol !== undefined && this.isExportedThroughTypeOnlyStar(moduleSymbol, imported, new Set<Symbol>());
+    return moduleSymbol !== undefined && this.isExportedThroughTypeOnlyStar(moduleSymbol, imported);
   }
 
-  /** Whether a module's export `name` comes from another module through an `export type *` on the way. */
-  private isExportedThroughTypeOnlyStar(moduleSymbol: Symbol, name: string, visited: Set<Symbol>): boolean {
-    if (visited.has(moduleSymbol)) return false;
-    visited.add(moduleSymbol);
-    const exports = moduleSymbol.exports;
-    if (exports === undefined || exports.has(name) || name === InternalSymbolName.Default) return false;
+  /**
+   * Whether a module's export `name` comes from another module through an `export type *`, as tsgo's
+   * getExportsOfModuleWorker decides: a module reached through a type-only `export *` has its exports marked, and a
+   * module reached without one, even if already visited, clears the mark of its own exports.
+   */
+  private isExportedThroughTypeOnlyStar(moduleSymbol: Symbol, name: string): boolean {
+    if (name === InternalSymbolName.Default) return false;
+    const walk = new TypeOnlyStarWalk(name);
+    this.visitExportStars(walk, moduleSymbol, false, false);
+    return walk.typeOnly && !walk.nonTypeOnly;
+  }
+
+  /** Visits a module of an `export *` walk; returns whether it exports the walk's name. */
+  private visitExportStars(
+    walk: TypeOnlyStarWalk,
+    symbol: Symbol | undefined,
+    starIsTypeOnly: boolean,
+    isTypeOnly: boolean,
+  ): boolean {
+    const exports = symbol === undefined ? undefined : symbol.exports;
+    if (!isTypeOnly && exports !== undefined && exports.has(walk.name)) walk.nonTypeOnly = true;
+    if (symbol === undefined || exports === undefined || walk.visited.has(symbol)) return false;
+    walk.visited.add(symbol);
+    let found = exports.has(walk.name);
     const star = exports.get(InternalSymbolName.ExportStar);
-    if (star === undefined) return false;
-    for (const declaration of getDeclarations(star)) {
-      if (!(declaration instanceof ExportDeclaration)) continue;
-      const target = this.resolveExternalModuleSymbol(
-        this.resolveModuleSpecifier(declaration, declaration.moduleSpecifier),
-      );
-      if (target === undefined || this.getExportFromTable(target, name, new Set<Symbol>()) === undefined) continue;
-      return declaration.isTypeOnly || this.isExportedThroughTypeOnlyStar(target, name, visited);
-    }
-    return false;
+    if (star !== undefined)
+      for (const declaration of getDeclarations(star)) {
+        if (!(declaration instanceof ExportDeclaration)) continue;
+        const target = this.resolveExternalModuleSymbol(
+          this.resolveModuleSpecifier(declaration, declaration.moduleSpecifier),
+        );
+        if (this.visitExportStars(walk, target, declaration.isTypeOnly, isTypeOnly || declaration.isTypeOnly))
+          found = true;
+      }
+    if (starIsTypeOnly && found) walk.typeOnly = true;
+    return found;
   }
 
   /** Whether a symbol is declared in the global scope. */
@@ -803,6 +822,34 @@ export class ReferenceResolver {
 
   // Constant values
 
+  /**
+   * The symbol an entity name expression such as `E.A` refers to as an expression: tsgo takes the symbol its checker
+   * resolves the expression to, where each name on the left is a value, so a local `let E` hides a const enum `E`.
+   */
+  private resolveValueEntityName(name: Node): Symbol | undefined {
+    let symbol: Symbol | undefined;
+    if (name instanceof Identifier) {
+      const resolved = this.resolveName(name, name.text, SymbolFlags.Value | SymbolFlags.Alias);
+      symbol = resolved === undefined ? undefined : this.getMergedSymbol(resolved);
+    } else if (name instanceof PropertyAccessExpression) {
+      const left = this.resolveValueEntityName(name.expression);
+      const right = name.name;
+      if (left === undefined || !(right instanceof Identifier)) return undefined;
+      let member = left.exports === undefined ? undefined : left.exports.get(right.text);
+      // A namespace merged with an alias also has the members of what the alias names, as its type does.
+      if (member === undefined && (left.flags & SymbolFlags.Alias) !== 0) {
+        const target = this.resolveAlias(left);
+        const targetExports = target === undefined ? undefined : target.exports;
+        if (targetExports !== undefined) member = targetExports.get(right.text);
+      }
+      if (member === undefined || (member.flags & (SymbolFlags.Value | SymbolFlags.Alias)) === 0) return undefined;
+      symbol = this.getMergedSymbol(member);
+    } else return undefined;
+    if (symbol === undefined || (symbol.flags & SymbolFlags.Alias) === 0) return symbol;
+    const target = this.resolveAlias(symbol);
+    return target === undefined ? undefined : this.getMergedSymbol(target);
+  }
+
   /** The value of an enum member, computing the values of its whole declaration. */
   getEnumMemberValue(member: Node): Evaluation {
     const declaration = member.parent;
@@ -816,11 +863,11 @@ export class ReferenceResolver {
     if (node instanceof EnumMember) return this.getEnumMemberValue(node);
     let symbol: Symbol | undefined;
     if (node instanceof PropertyAccessExpression) {
-      if (isEntityNameExpressionNode(node)) symbol = this.resolveEntityName(node, SymbolFlags.Value, false);
+      if (isEntityNameExpressionNode(node)) symbol = this.resolveValueEntityName(node);
     } else if (node instanceof ElementAccessExpression) {
       const argument = stringLiteralText(node.argumentExpression);
       if (isEntityNameExpressionNode(node.expression) && argument !== undefined) {
-        const root = this.resolveEntityName(node.expression, SymbolFlags.Value, false);
+        const root = this.resolveValueEntityName(node.expression);
         const exports = root === undefined ? undefined : root.exports;
         const member = exports === undefined ? undefined : exports.get(argument);
         if (member !== undefined) symbol = this.getMergedSymbol(member);
@@ -1131,6 +1178,23 @@ export function getDeclarationOfAliasSymbol(symbol: Symbol): Node | undefined {
   return undefined;
 }
 
+/** The state of `isExportedThroughTypeOnlyStar`'s walk over the `export *` declarations of modules for one name. */
+class TypeOnlyStarWalk {
+  readonly name: string;
+  readonly visited: Set<Symbol>;
+  /** Whether a module reached through a type-only `export *` exports the name. */
+  typeOnly: boolean;
+  /** Whether a module reached without one exports the name itself. */
+  nonTypeOnly: boolean;
+
+  constructor(name: string) {
+    this.name = name;
+    this.visited = new Set<Symbol>();
+    this.typeOnly = false;
+    this.nonTypeOnly = false;
+  }
+}
+
 function isTypeOnlyAlias(symbol: Symbol): boolean {
   let node = getDeclarationOfAliasSymbol(symbol);
   while (node !== undefined) {