tsc-ts 0.0.10 → 0.1.1

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,
@@ -161,6 +161,7 @@ import { ConstantKind } from './reference-resolver.js';
 import { DeclarationTracker } from './declarations-tracker.js';
 import { Transformer } from './transformer.js';
 import { declarationCount, getDeclarations, SymbolFlags } from '../symbol.js';
+import { IdentifierName } from '../identifier-name.js';
 
 export class DeclarationTransformer extends Transformer {
   readonly host: OutputPathsHost;
@@ -183,6 +184,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 +224,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 +297,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 +677,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 +792,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 +882,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 +1061,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 +1121,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 +1149,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 +1164,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 +1182,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 +1194,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 +1220,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 +1287,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 +1326,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 +1396,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 +1432,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 +1458,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 +1467,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 +1538,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)
@@ -1886,7 +1935,7 @@ export class DeclarationTransformer extends Transformer {
         keyword === SyntaxKind.DefaultKeyword
       ) {
         // A parse tree node, so names it uses are resolved where it's written.
-        const identifier = new Identifier(text);
+        const identifier = new Identifier(new IdentifierName(text));
         identifier.parent = name.parent;
         return identifier;
       }
@@ -2004,6 +2053,7 @@ export class DeclarationTransformer extends Transformer {
             this.declareModifiers(),
             SyntaxKind.NamespaceKeyword,
             namespaceName,
+            undefined,
             factory.created(new ModuleBlock(factory.createNodeList([classDeclaration]))),
           ),
         );
@@ -2084,6 +2134,7 @@ export class DeclarationTransformer extends Transformer {
         this.declareModifiers(),
         SyntaxKind.NamespaceKeyword,
         name,
+        undefined,
         this.factory.created(new ModuleBlock(this.factory.createNodeList(stripped))),
       ),
     );
@@ -2119,7 +2170,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 +2194,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 +2223,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 +2316,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 +2345,7 @@ export class DeclarationTransformer extends Transformer {
           modifiers,
           SyntaxKind.NamespaceKeyword,
           name,
+          undefined,
           this.factory.created(new ModuleBlock(this.factory.createNodeList(addOns))),
         ),
       ),
@@ -2314,7 +2386,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 +2395,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 +2709,7 @@ export class DeclarationTransformer extends Transformer {
       declaration.modifiers,
       clause,
       this.rewriteModuleSpecifier(declaration, declaration.moduleSpecifier)!,
-      this.tryGetResolutionModeOverride(declaration.attributes),
+      declaration.attributes,
     );
   }
 
@@ -3031,10 +3104,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 +3196,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);
   }