tsc-ts 0.0.4 → 0.0.5

package/src/compiler/printer/helpers.ts

@@ -0,0 +1,291 @@
+// Runtime helpers emitted at the top of a file, or imported from tslib with `importHelpers`.
+/** A runtime helper such as `__decorate`, emitted once at the top of a file or scope. */
+export class EmitHelper {
+  readonly name: string;
+  /** Emitted in the scope that uses it rather than at the top of the file. */
+  readonly scoped: boolean;
+  readonly text: string;
+  /** Lower values are emitted first; helpers without a priority come last. */
+  readonly priority: number;
+  readonly dependencies: readonly EmitHelper[];
+  readonly importName: string;
+  /** For helpers that declare a file-level unique name: the base name, written in place of each `{name}` in `text`. */
+  readonly uniqueName: string;
+
+  constructor(
+    name: string,
+    scoped: boolean,
+    text: string,
+    priority: number,
+    dependencies: readonly EmitHelper[],
+    importName: string,
+    uniqueName: string,
+  ) {
+    this.name = name;
+    this.scoped = scoped;
+    this.text = text;
+    this.priority = priority;
+    this.dependencies = dependencies;
+    this.importName = importName;
+    this.uniqueName = uniqueName;
+  }
+}
+
+export const noPriority = -1;
+
+export function compareEmitHelpers(x: EmitHelper, y: EmitHelper): number {
+  if (x === y || x.priority === y.priority) return 0;
+  if (x.priority === noPriority) return 1;
+  if (y.priority === noPriority) return -1;
+  return x.priority - y.priority;
+}
+
+const createBindingHelper = new EmitHelper(
+  'typescript:commonjscreatebinding',
+  false,
+  `var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));`,
+  1,
+  [],
+  '__createBinding',
+  '',
+);
+
+const setModuleDefaultHelper = new EmitHelper(
+  'typescript:commonjscreatevalue',
+  false,
+  `var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});`,
+  1,
+  [],
+  '__setModuleDefault',
+  '',
+);
+
+export const importStarHelper = new EmitHelper(
+  'typescript:commonjsimportstar',
+  false,
+  `var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();`,
+  2,
+  [createBindingHelper, setModuleDefaultHelper],
+  '__importStar',
+  '',
+);
+
+export const importDefaultHelper = new EmitHelper(
+  'typescript:commonjsimportdefault',
+  false,
+  `var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};`,
+  noPriority,
+  [],
+  '__importDefault',
+  '',
+);
+
+export const exportStarHelper = new EmitHelper(
+  'typescript:export-star',
+  false,
+  `var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};`,
+  2,
+  [createBindingHelper],
+  '__exportStar',
+  '',
+);
+
+export const rewriteRelativeImportExtensionsHelper = new EmitHelper(
+  'typescript:rewriteRelativeImportExtensions',
+  false,
+  `var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\\.\\.?\\//.test(path)) {
+        return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};`,
+  noPriority,
+  [],
+  '__rewriteRelativeImportExtension',
+  '',
+);
+
+export const restHelper = new EmitHelper(
+  'typescript:rest',
+  false,
+  `var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};`,
+  noPriority,
+  [],
+  '__rest',
+  '',
+);
+
+export const classPrivateFieldGetHelper = new EmitHelper(
+  'typescript:classPrivateFieldGet',
+  false,
+  `var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};`,
+  noPriority,
+  [],
+  '__classPrivateFieldGet',
+  '',
+);
+
+export const classPrivateFieldSetHelper = new EmitHelper(
+  'typescript:classPrivateFieldSet',
+  false,
+  `var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};`,
+  noPriority,
+  [],
+  '__classPrivateFieldSet',
+  '',
+);
+
+export const classPrivateFieldInHelper = new EmitHelper(
+  'typescript:classPrivateFieldIn',
+  false,
+  `var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(state, receiver) {
+    if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
+    return typeof state === "function" ? receiver === state : state.has(receiver);
+};`,
+  noPriority,
+  [],
+  '__classPrivateFieldIn',
+  '',
+);
+
+export const makeTemplateObjectHelper = new EmitHelper(
+  'typescript:makeTemplateObject',
+  false,
+  `var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};`,
+  0,
+  [],
+  '__makeTemplateObject',
+  '',
+);
+
+// ES2018 helpers
+
+// ESNext helpers
+
+export const addDisposableResourceHelper = new EmitHelper(
+  'typescript:addDisposableResource',
+  false,
+  `var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};`,
+  noPriority,
+  [],
+  '__addDisposableResource',
+  '',
+);
+
+export const disposeResourcesHelper = new EmitHelper(
+  'typescript:disposeResources',
+  false,
+  `var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});`,
+  noPriority,
+  [],
+  '__disposeResources',
+  '',
+);

package/src/compiler/printer/name-generator.ts

@@ -0,0 +1,372 @@
+// Chooses the text of generated identifiers (`_a`, `_i`, `name_1`, …) while printing.
+import {
+  ClassExpression,
+  ExportAssignment,
+  type Node,
+  PrivateIdentifier,
+  SourceFile,
+  StringLiteral,
+  getLocals,
+  getNextContainer,
+  getText,
+  isLocalsContainer,
+} from '../ast.js';
+import { SymbolFlags } from '../symbol.js';
+import { getName } from '../ast.js';
+import { getExternalModuleName } from '../ast-utilities.js';
+import { SyntaxKind } from '../syntax-kind.js';
+import type { EmitContext } from './emit-context.js';
+import { GeneratedIdentifierFlags } from './emit-flags.js';
+import {
+  ensureLeadingHash,
+  formatGeneratedName,
+  makeIdentifierFromModuleName,
+  removeLeadingHash,
+} from './utilities.js';
+
+const enum TempFlags {
+  Auto = 0,
+  CountMask = 0x0fffffff,
+  /** `_i` is taken or preferred. */
+  I = 0x10000000,
+}
+
+class NameScope {
+  readonly next: NameScope | undefined;
+  tempFlags: number;
+  formattedNameTempFlags: Map<string, number> | undefined;
+  reservedNames: Set<string> | undefined;
+
+  constructor(next: NameScope | undefined) {
+    this.next = next;
+    this.tempFlags = TempFlags.Auto;
+    this.formattedNameTempFlags = undefined;
+    this.reservedNames = undefined;
+  }
+}
+
+/** Where to look for name conflicts outside generated names. */
+export abstract class NameGeneratorHost {
+  /** The text of an identifier, private identifier or literal as printed. */
+  abstract getTextOfNode(node: Node): string;
+  /** Whether no identifier in the file (or global scope) has this name. */
+  abstract isFileLevelUniqueName(name: string): boolean;
+}
+
+/** Whether no value declared in `container` or its nested containers has `name`, from the binder's locals. */
+function isUniqueLocalName(name: string, container: Node): boolean {
+  for (
+    let node: Node | undefined = container;
+    node !== undefined && isLocalsContainer(node);
+    node = getNextContainer(node)
+  ) {
+    if (!isDescendantOf(node, container)) break;
+    const locals = getLocals(node);
+    const local = locals === undefined ? undefined : locals.get(name);
+    if (local !== undefined && (local.flags & (SymbolFlags.Value | SymbolFlags.ExportValue | SymbolFlags.Alias)) !== 0)
+      return false;
+  }
+  return true;
+}
+
+function isDescendantOf(node: Node, ancestor: Node): boolean {
+  for (let current: Node | undefined = node; current !== undefined; current = current.parent)
+    if (current === ancestor) return true;
+  return false;
+}
+
+export class NameGenerator {
+  readonly context: EmitContext;
+  readonly host: NameGeneratorHost;
+  private readonly nodeNames: Map<Node, string>;
+  private readonly privateNodeNames: Map<Node, string>;
+  private readonly autoGeneratedNames: Map<number, string>;
+  private scope: NameScope | undefined;
+  private privateScope: NameScope | undefined;
+  private readonly generatedNames: Set<string>;
+
+  constructor(context: EmitContext, host: NameGeneratorHost) {
+    this.context = context;
+    this.host = host;
+    this.nodeNames = new Map<Node, string>();
+    this.privateNodeNames = new Map<Node, string>();
+    this.autoGeneratedNames = new Map<number, string>();
+    this.scope = undefined;
+    this.privateScope = undefined;
+    this.generatedNames = new Set<string>();
+  }
+
+  pushScope(reuseTempVariableScope: boolean): boolean {
+    this.privateScope = new NameScope(this.privateScope);
+    if (!reuseTempVariableScope) this.scope = new NameScope(this.scope);
+    return true;
+  }
+
+  popScope(reuseTempVariableScope: boolean): boolean {
+    if (this.privateScope !== undefined) this.privateScope = this.privateScope.next;
+    if (!reuseTempVariableScope && this.scope !== undefined) this.scope = this.scope.next;
+    return true;
+  }
+
+  private ensureScope(privateName: boolean): NameScope {
+    if (privateName) {
+      if (this.privateScope === undefined) this.privateScope = new NameScope(undefined);
+      return this.privateScope;
+    }
+    if (this.scope === undefined) this.scope = new NameScope(undefined);
+    return this.scope;
+  }
+
+  private getTempFlags(privateName: boolean, key: string): number {
+    const scope = privateName ? this.privateScope : this.scope;
+    if (scope === undefined) return TempFlags.Auto;
+    if (key.length === 0) return scope.tempFlags;
+    const flags = scope.formattedNameTempFlags === undefined ? undefined : scope.formattedNameTempFlags.get(key);
+    return flags === undefined ? TempFlags.Auto : flags;
+  }
+
+  private setTempFlags(privateName: boolean, key: string, flags: number): boolean {
+    const scope = this.ensureScope(privateName);
+    if (key.length === 0) scope.tempFlags = flags;
+    else {
+      if (scope.formattedNameTempFlags === undefined) scope.formattedNameTempFlags = new Map<string, number>();
+      scope.formattedNameTempFlags.set(key, flags);
+    }
+    return true;
+  }
+
+  private reserveName(name: string, privateName: boolean, scoped: boolean, temp: boolean): boolean {
+    const scope = this.ensureScope(privateName);
+    if (privateName || scoped) {
+      if (scope.reservedNames === undefined) scope.reservedNames = new Set<string>();
+      scope.reservedNames.add(name);
+    } else if (!temp) this.generatedNames.add(name);
+    return true;
+  }
+
+  /** The text of a name: generated if it has auto-generate info, else its own text. */
+  generateName(name: Node): string {
+    const info = this.context.autoGenerate.get(name);
+    if (info === undefined) return this.host.getTextOfNode(name);
+    if ((info.flags & GeneratedIdentifierFlags.KindMask) === GeneratedIdentifierFlags.Node)
+      return this.generateNameForNodeCached(
+        this.context.getNodeForGeneratedName(name),
+        name instanceof PrivateIdentifier,
+        info.flags,
+        info.prefix,
+        info.suffix,
+      );
+    const cached = this.autoGeneratedNames.get(info.id);
+    if (cached !== undefined) return cached;
+    const generated = this.makeName(name);
+    this.autoGeneratedNames.set(info.id, generated);
+    return generated;
+  }
+
+  private generateNameForNodeCached(
+    node: Node,
+    privateName: boolean,
+    flags: GeneratedIdentifierFlags,
+    prefix: string,
+    suffix: string,
+  ): string {
+    const cache = privateName ? this.privateNodeNames : this.nodeNames;
+    const cached = cache.get(node);
+    if (cached !== undefined) return cached;
+    const name = this.generateNameForNode(node, privateName, flags, prefix, suffix);
+    cache.set(node, name);
+    return name;
+  }
+
+  private generateNameForNode(
+    node: Node,
+    privateName: boolean,
+    flags: GeneratedIdentifierFlags,
+    prefix: string,
+    suffix: string,
+  ): string {
+    switch (node.kind) {
+      case SyntaxKind.Identifier:
+      case SyntaxKind.PrivateIdentifier:
+        return this.makeUniqueName(
+          this.host.getTextOfNode(node),
+          false,
+          (flags & GeneratedIdentifierFlags.Optimistic) !== 0,
+          (flags & GeneratedIdentifierFlags.ReservedInNestedScopes) !== 0,
+          privateName,
+          prefix,
+          suffix,
+        );
+      case SyntaxKind.ModuleDeclaration:
+      case SyntaxKind.EnumDeclaration: {
+        const name = this.host.getTextOfNode(getName(node)!);
+        if (isUniqueLocalName(name, node)) return name;
+        return this.makeUniqueName(name, false, false, false, false, '', '');
+      }
+      case SyntaxKind.ImportDeclaration:
+      case SyntaxKind.JSImportDeclaration:
+      case SyntaxKind.ExportDeclaration: {
+        const specifier = getExternalModuleName(node);
+        const base = specifier instanceof StringLiteral ? makeIdentifierFromModuleName(specifier.text) : 'module';
+        return this.makeUniqueName(base, false, false, false, false, '', '');
+      }
+      case SyntaxKind.FunctionDeclaration:
+      case SyntaxKind.ClassDeclaration: {
+        const name = getName(node);
+        if (name !== undefined) return this.generateNameForNode(name, false, flags, '', '');
+        return this.makeUniqueName('default', false, false, false, false, '', '');
+      }
+      case SyntaxKind.ExportAssignment:
+        if (node instanceof ExportAssignment) return this.makeUniqueName('default', false, false, false, false, '', '');
+        break;
+      case SyntaxKind.ClassExpression:
+        if (node instanceof ClassExpression) return this.makeUniqueName('class', false, false, false, false, '', '');
+        break;
+      case SyntaxKind.MethodDeclaration:
+      case SyntaxKind.GetAccessor:
+      case SyntaxKind.SetAccessor: {
+        const name = getName(node);
+        if (name !== undefined && name.kind === SyntaxKind.Identifier)
+          return this.generateNameForNodeCached(name, privateName, GeneratedIdentifierFlags.None, prefix, suffix);
+        return this.makeTempVariableName(TempFlags.Auto, false, privateName, prefix, suffix);
+      }
+      case SyntaxKind.ComputedPropertyName:
+        return this.makeTempVariableName(TempFlags.Auto, true, privateName, prefix, suffix);
+    }
+    return this.makeTempVariableName(TempFlags.Auto, false, privateName, prefix, suffix);
+  }
+
+  private makeName(name: Node): string {
+    const info = this.context.autoGenerate.get(name);
+    if (info !== undefined) {
+      const reserved = (info.flags & GeneratedIdentifierFlags.ReservedInNestedScopes) !== 0;
+      switch (info.flags & GeneratedIdentifierFlags.KindMask) {
+        case GeneratedIdentifierFlags.Auto:
+          return this.makeTempVariableName(
+            TempFlags.Auto,
+            reserved,
+            name instanceof PrivateIdentifier,
+            info.prefix,
+            info.suffix,
+          );
+        case GeneratedIdentifierFlags.Loop:
+          return this.makeTempVariableName(TempFlags.I, reserved, false, info.prefix, info.suffix);
+        case GeneratedIdentifierFlags.Unique:
+          return this.makeUniqueName(
+            getText(name),
+            (info.flags & GeneratedIdentifierFlags.FileLevel) !== 0,
+            (info.flags & GeneratedIdentifierFlags.Optimistic) !== 0,
+            reserved,
+            name instanceof PrivateIdentifier,
+            info.prefix,
+            info.suffix,
+          );
+      }
+    }
+    return this.host.getTextOfNode(name);
+  }
+
+  private makeTempVariableName(
+    flags: TempFlags,
+    reservedInNestedScopes: boolean,
+    privateName: boolean,
+    prefix: string,
+    suffix: string,
+  ): string {
+    const simple = prefix.length === 0 && suffix.length === 0;
+    let key = '';
+    if (!simple) {
+      key = formatGeneratedName(privateName, prefix, '', suffix);
+      if (privateName) key = ensureLeadingHash(key);
+    }
+    let tempFlags = this.getTempFlags(privateName, key);
+    if (flags !== 0 && (tempFlags & flags) === 0) {
+      const fullName = formatGeneratedName(privateName, prefix, '_i', suffix);
+      if (this.isUniqueName(fullName, privateName)) {
+        tempFlags |= flags;
+        this.reserveName(fullName, privateName, reservedInNestedScopes, true);
+        this.setTempFlags(privateName, key, tempFlags);
+        return fullName;
+      }
+    }
+    for (;;) {
+      const count = tempFlags & TempFlags.CountMask;
+      tempFlags++;
+      // Skip `_i` and `_n`.
+      if (count !== 8 && count !== 13) {
+        const name = count < 26 ? '_' + String.fromCharCode(0x61 + count) : '_' + (count - 26);
+        const fullName = formatGeneratedName(privateName, prefix, name, suffix);
+        if (this.isUniqueName(fullName, privateName)) {
+          this.reserveName(fullName, privateName, reservedInNestedScopes, true);
+          this.setTempFlags(privateName, key, tempFlags);
+          return fullName;
+        }
+      }
+    }
+  }
+
+  private makeUniqueName(
+    baseName: string,
+    fileLevel: boolean,
+    optimistic: boolean,
+    scoped: boolean,
+    privateName: boolean,
+    prefix: string,
+    suffix: string,
+  ): string {
+    baseName = removeLeadingHash(baseName);
+    if (optimistic) {
+      const fullName = formatGeneratedName(privateName, prefix, baseName, suffix);
+      if (this.checkUniqueName(fullName, privateName, fileLevel)) {
+        this.reserveName(fullName, privateName, scoped, false);
+        return fullName;
+      }
+    }
+    if (baseName.length > 0 && baseName.charCodeAt(baseName.length - 1) !== 0x5f) baseName += '_';
+    for (let i = 1; ; i++) {
+      const fullName = formatGeneratedName(privateName, prefix, baseName + i, suffix);
+      if (this.checkUniqueName(fullName, privateName, fileLevel)) {
+        this.reserveName(fullName, privateName, scoped, false);
+        return fullName;
+      }
+    }
+  }
+
+  makeFileLevelOptimisticUniqueName(name: string): string {
+    return this.makeUniqueName(name, true, true, false, false, '', '');
+  }
+
+  private checkUniqueName(name: string, privateName: boolean, fileLevel: boolean): boolean {
+    return fileLevel ? this.host.isFileLevelUniqueName(name) : this.isUniqueName(name, privateName);
+  }
+
+  private isUniqueName(name: string, privateName: boolean): boolean {
+    return this.host.isFileLevelUniqueName(name) && !this.isReservedName(name, privateName);
+  }
+
+  private isReservedName(name: string, privateName: boolean): boolean {
+    if (this.generatedNames.has(name)) return true;
+    for (let scope = privateName ? this.privateScope : this.scope; scope !== undefined; scope = scope.next)
+      if (scope.reservedNames !== undefined && scope.reservedNames.has(name)) return true;
+    return false;
+  }
+}
+
+// The names used in recently emitted files, kept apart from the files, which are shared and read-only.
+const identifierSets = new Map<SourceFile, Set<string>>();
+
+/** Forgets the files of earlier emits. */
+export function forgetIdentifierSets(): void {
+  identifierSets.clear();
+}
+
+/** Whether no identifier in `file` is named `name`. */
+export function isFileLevelUniqueName(file: SourceFile, name: string): boolean {
+  let set = identifierSets.get(file);
+  if (set === undefined) {
+    if (identifierSets.size >= 16) identifierSets.clear();
+    set = new Set<string>(file.identifierTexts);
+    identifierSets.set(file, set);
+  }
+  return !set.has(name);
+}