tsc-ts 0.0.9 → 0.0.10

package/src/compiler/parallel-parse.ts

@@ -226,6 +226,13 @@ const maxChunk = 16;
 /** Files from this size (bytes) on take a parse thread 25 ms or more, and go out ahead of others. */
 const largeFile = 256 * 1024;
 
+/**
+ * The most text (bytes) a chunk of other files holds, about one large file's: a chunk ends with the file
+ * that reaches it. Sixteen of tsc-ts's own compiler sources, 50-200 KB each, made one chunk that kept its
+ * thread busy for 30-45 ms after the others were done.
+ */
+const maxChunkBytes = largeFile;
+
 /**
  * The files to hand out to parse threads, each queued once. Library files go out first, one per
  * chunk, also those found later through `/// <reference lib>`: a large one (`lib.dom.d.ts`) takes a
@@ -233,7 +240,7 @@ const largeFile = 256 * 1024;
  * Then, for the same reason, large files, one per chunk: root files (TypeScript's 3 MB `checker.ts`,
  * which in a chunk of root files kept one thread busy after the others were done) and the files the
  * parse threads found (`csstype`'s 0.9 MB of declarations, found through React's). The other files go
- * out in program order, in chunks of up to `maxChunk`.
+ * out in program order, in chunks of up to `maxChunk` files and about `maxChunkBytes` of text.
  */
 export class ParseQueue {
   private readonly libraries = new LoadJobs();
@@ -281,7 +288,8 @@ export class ParseQueue {
 
   /**
    * The next chunk for one of `threads` parse threads, or `undefined` when nothing is left. With
-   * `full`, other files only go out `maxChunk` at a time, and stay queued until there are as many.
+   * `full`, other files only go out in full chunks, `maxChunk` files or `maxChunkBytes` of text, and stay
+   * queued until there are as many.
    */
   next(threads: number, full = false): LoadMessage | undefined {
     const libraries = this.libraries;
@@ -306,10 +314,13 @@ export class ParseQueue {
     }
     const queue = this.others;
     const left = queue.names.length - this.head;
-    if (left <= 0 || (full && left < maxChunk)) return undefined;
-    const size = full ? maxChunk : Math.min(maxChunk, Math.max(1, Math.floor(left / threads)));
+    if (left <= 0) return undefined;
+    const most = full ? maxChunk : Math.min(maxChunk, Math.max(1, Math.floor(left / threads)));
     const start = this.head;
-    const end = start + size;
+    let end = start;
+    let bytes = 0;
+    while (end < queue.names.length && end - start < most && bytes < maxChunkBytes) bytes += queue.sizes[end++]!;
+    if (full && end - start < maxChunk && bytes < maxChunkBytes) return undefined;
     this.head = end;
     return {
       stop: false,

package/src/compiler/parse-thread.ts

@@ -49,6 +49,9 @@ class PreparingHost extends CompilerHost {
     );
     const t2 = timeline ? performance.now() : 0;
     bindSourceFile(file);
+    // Published now, while its nodes are in cache: the chunk's publish (`ParseThread.load`) then skips
+    // them, where walking the whole chunk's files at once reads each node from memory again.
+    publish(file);
     if (timeline) {
       const t3 = performance.now();
       this.readMs += t1 - t0;

package/src/compiler/printer/emit-context.ts

@@ -287,6 +287,11 @@ export class EmitContext extends NodeFactory {
 
   // Emit data
 
+  /** Whether `node` has emit data: flags, ranges, helpers or synthesized comments. */
+  hasEmitNode(node: Node): boolean {
+    return this.lookup(node) !== undefined;
+  }
+
   getEmitFlags(node: Node): EmitFlags {
     const emitNode = this.lookup(node);
     return emitNode === undefined ? EmitFlags.None : emitNode.emitFlags;

package/src/compiler/printer/printer.ts

@@ -174,7 +174,7 @@ import { SyntaxKind } from '../syntax-kind.js';
 import { type CommentRange, TokenFlags } from '../types.js';
 import { ScriptTarget } from '../options.js';
 import { fileExtensionIs } from '../path.js';
-import { isWhiteSpaceLike } from '../character-codes.js';
+import { CharacterCodes, isWhiteSpaceLike } from '../character-codes.js';
 import type { SourceMapGenerator } from '../sourcemap.js';
 import { EmitContext, compareEmitHelpers, type SynthesizedComment } from './emit-context.js';
 import { EmitFlags, GeneratedIdentifierFlags } from './emit-flags.js';
@@ -399,6 +399,9 @@ const enum State {
   SourceMaps = 1 << 1,
 }
 
+/** The saved emit flags of a node whose comments were not looked for (`Printer.inCommentFreeRange`). */
+const commentFreeNode = -1;
+
 export class Printer extends NameGeneratorHost {
   readonly options: PrinterOptions;
   readonly context: EmitContext;
@@ -410,6 +413,13 @@ export class Printer extends NameGeneratorHost {
   currentSourceFile: SourceFile | undefined;
   private sourceText: string;
   private lineStarts: readonly number[];
+  /**
+   * The line of the last `lineOf` lookup, `lookupLine`, and the positions it spans, `[lookupLineStart, lookupLineEnd)`,
+   * with `lookupLineEnd` -1 after the last line: printing reads positions mostly in order, so most lookups fall on that line.
+   */
+  private lookupLine: number;
+  private lookupLineStart: number;
+  private lookupLineEnd: number;
   private writer: TextWriter;
   private ownWriter: TextWriter | undefined;
   private uniqueHelperNames: Map<string, Identifier> | undefined;
@@ -423,8 +433,25 @@ export class Printer extends NameGeneratorHost {
   private commentsDisabled: boolean;
   /** Emitting the `extends` clause of a conditional or infer type. */
   private inExtends: boolean;
-  /** Saved comment state: emit flags, comment pos, comment end, container pos, container end, declaration list end. */
-  private readonly commentStack: number[];
+  /**
+   * Saved comment state, 32-bit values: emit flags, comment pos, comment end, container pos, container end,
+   * declaration list end.
+   * Flags are `commentFreeNode` for a node that `emitCommentsBeforeNode` handled in a comment-free range.
+   */
+  private commentStack: Int32Array;
+  /** The used length of `commentStack`: entries are written in place and kept for reuse once popped. */
+  private commentDepth: number;
+  /** Start positions of `//` and `/*` in `sourceText`, ascending; made on first use for each file. */
+  private commentStarts: Int32Array | undefined;
+  /**
+   * A range of `sourceText`, `[freeStart, freeEnd)`, where no comment starts and the last character is not trivia,
+   * so no comment is found from any position in it; -1 when there is none. `freeOwner` is the node it was made for.
+   */
+  private freeStart: number;
+  private freeEnd: number;
+  /** Whether no trailing comment follows `freeEnd`. */
+  private freeEndTrailingNone: boolean;
+  private freeOwner: Node | undefined;
   /** Saved source map state: emit flags, pos, end, has token range. */
   private readonly sourceMapStack: number[];
   /** The token position after `enterToken` skipped trivia. */
@@ -457,6 +484,9 @@ export class Printer extends NameGeneratorHost {
     this.currentSourceFile = undefined;
     this.sourceText = '';
     this.lineStarts = [];
+    this.lookupLine = -1;
+    this.lookupLineStart = 0;
+    this.lookupLineEnd = 0;
     this.writer = new TextWriter(options.newLine, 4);
     this.ownWriter = undefined;
     this.uniqueHelperNames = undefined;
@@ -468,7 +498,13 @@ export class Printer extends NameGeneratorHost {
     this.detachedComments = [];
     this.commentsDisabled = options.removeComments;
     this.inExtends = false;
-    this.commentStack = [];
+    this.commentStack = new Int32Array(96);
+    this.commentDepth = 0;
+    this.commentStarts = undefined;
+    this.freeStart = -1;
+    this.freeEnd = -1;
+    this.freeEndTrailingNone = false;
+    this.freeOwner = undefined;
     this.sourceMapStack = [];
     this.tokenPos = 0;
     this.sourceMapsDisabled = true;
@@ -518,6 +554,11 @@ export class Printer extends NameGeneratorHost {
     this.currentSourceFile = sourceFile;
     this.sourceText = sourceFile === undefined ? '' : sourceFile.text;
     this.lineStarts = sourceFile === undefined ? [] : sourceFile.lineStarts();
+    this.lookupLine = -1;
+    this.lookupLineStart = 0;
+    this.lookupLineEnd = 0;
+    this.commentStarts = undefined;
+    this.endCommentFreeRange();
     return true;
   }
 
@@ -615,6 +656,8 @@ export class Printer extends NameGeneratorHost {
       case SyntaxKind.Identifier:
       case SyntaxKind.PrivateIdentifier:
       case SyntaxKind.JsxNamespacedName:
+        // Its text either way: the source text, or the text of a node from elsewhere.
+        if (this.textIsSourceText(node)) return (node as Identifier | PrivateIdentifier).text;
         if (!canUseSourceFile || !this.isInCurrentSourceFile(node)) {
           if (node instanceof Identifier) return node.text;
           if (node instanceof PrivateIdentifier) return node.text;
@@ -635,6 +678,38 @@ export class Printer extends NameGeneratorHost {
     return getSourceTextOfNode(this.sourceText, node);
   }
 
+  /**
+   * Whether the source text of an identifier or private identifier of the current file, from the end of its leading
+   * trivia to its end, is its text: the text ends the node, and the character before it is not part of the token, as
+   * it would be in an identifier written with escapes. Nodes from JSDoc may span other text, so they are left to the
+   * general path.
+   */
+  private textIsSourceText(node: Node): boolean {
+    if (!(node instanceof Identifier) && !(node instanceof PrivateIdentifier)) return false;
+    if ((node.flags & (NodeFlags.Reparsed | NodeFlags.JSDoc | NodeFlags.ReparserTransformedLiteral)) !== 0)
+      return false;
+    const text = node.text;
+    const source = this.sourceText;
+    const end = node.end;
+    const start = end - text.length;
+    if (text.length === 0 || start < node.pos || end > source.length) return false;
+    if (!source.startsWith(text, start)) return false;
+    if (start === node.pos) return true;
+    const before = source.charCodeAt(start - 1);
+    return !(
+      (before >= CharacterCodes.a && before <= CharacterCodes.z) ||
+      (before >= CharacterCodes.A && before <= CharacterCodes.Z) ||
+      (before >= CharacterCodes._0 && before <= CharacterCodes._9) ||
+      before === CharacterCodes._ ||
+      before === CharacterCodes.$ ||
+      before === CharacterCodes.backslash ||
+      before === CharacterCodes.openBrace ||
+      before === CharacterCodes.closeBrace ||
+      before === CharacterCodes.hash ||
+      before > CharacterCodes.maxAsciiCharacter
+    );
+  }
+
   private isInCurrentSourceFile(node: Node): boolean {
     const file = this.currentSourceFile;
     if (file === undefined) return false;
@@ -717,7 +792,28 @@ export class Printer extends NameGeneratorHost {
   // Lines between nodes
 
   private positionsAreOnSameLine(pos1: number, pos2: number): boolean {
-    return getLinesBetweenPositions(this.lineStarts, pos1, pos2) === 0;
+    if (pos1 === pos2) return true;
+    const lower = pos1 < pos2 ? pos1 : pos2;
+    const upper = pos1 < pos2 ? pos2 : pos1;
+    // What getLinesBetweenPositions finds: no line starts in (lower, upper].
+    if (lower < 0) {
+      const first = this.lineStarts.length > 0 ? this.lineStarts[0] | 0 : -1;
+      return first < 0 || upper < first;
+    }
+    this.lineOf(lower);
+    return this.lookupLineEnd < 0 || upper < this.lookupLineEnd;
+  }
+
+  /** The zero-based line of `pos` (-1 before the first line), which becomes the line of the last lookup. */
+  private lineOf(pos: number): number {
+    if (pos >= this.lookupLineStart && (pos < this.lookupLineEnd || this.lookupLineEnd < 0) && this.lookupLine >= 0)
+      return this.lookupLine;
+    const starts = this.lineStarts;
+    const line = computeLineOfPosition(starts, pos);
+    this.lookupLine = line;
+    this.lookupLineStart = line >= 0 ? starts[line] | 0 : 0;
+    this.lookupLineEnd = line + 1 < starts.length ? starts[line + 1] | 0 : -1;
+    return line;
   }
 
   private rangeStart(pos: number): number {
@@ -1049,8 +1145,13 @@ export class Printer extends NameGeneratorHost {
 
   // Names
 
-  // Source text of names reparsed from JSDoc can span lines.
+  // Source text of names reparsed from JSDoc can span lines; an identifier's own source text has no line breaks.
   private emitIdentifierText(node: Identifier): boolean {
+    if (!this.context.autoGenerate.has(node) && this.textIsSourceText(node)) {
+      // writeText's answer for text without line breaks.
+      this.writer.write(node.text);
+      return false;
+    }
     return this.writer.writeText(this.getTextOfNode(node));
   }
 
@@ -4350,10 +4451,18 @@ export class Printer extends NameGeneratorHost {
 
   private emitCommentsBeforeNode(node: Node): boolean {
     if (!this.shouldEmitComments(node)) return false;
+    if (this.inCommentFreeRange(node)) {
+      // What the general path does for a node without emit data and without comments.
+      this.pushCommentState(commentFreeNode, node.pos, node.end);
+      this.containerPos = node.pos;
+      this.containerEnd = node.end;
+      if (node.kind === SyntaxKind.VariableDeclarationList) this.declarationListContainerEnd = node.end;
+      return true;
+    }
     const flags = this.context.getEmitFlags(node);
     const pos = this.context.commentPos(node);
     const end = this.context.commentEnd(node);
-    this.commentStack.push(flags, pos, end, this.containerPos, this.containerEnd, this.declarationListContainerEnd);
+    this.pushCommentState(flags, pos, end);
     this.emitLeadingCommentsOfNode(node, flags, pos, end);
     if ((flags & EmitFlags.NoLeadingComments) === 0) {
       const synthesized = this.context.getSyntheticLeadingComments(node);
@@ -4363,17 +4472,43 @@ export class Printer extends NameGeneratorHost {
     return true;
   }
 
+  /** Saves the comment state of a node: its emit flags (or `commentFreeNode`), comment range and the containers. */
+  private pushCommentState(flags: number, pos: number, end: number): boolean {
+    let stack = this.commentStack;
+    const at = this.commentDepth;
+    if (at + 6 > stack.length) {
+      const grown = new Int32Array(stack.length * 2);
+      grown.set(stack);
+      this.commentStack = grown;
+      stack = grown;
+    }
+    stack[at] = flags;
+    stack[at + 1] = pos;
+    stack[at + 2] = end;
+    stack[at + 3] = this.containerPos;
+    stack[at + 4] = this.containerEnd;
+    stack[at + 5] = this.declarationListContainerEnd;
+    this.commentDepth = at + 6;
+    return true;
+  }
+
   private emitCommentsAfterNode(node: Node): boolean {
     const stack = this.commentStack;
-    const base = stack.length - 6;
-    // `| 0` keeps scriptc from typing array reads as possibly undefined.
-    const flags = stack[base] | 0;
-    const pos = stack[base + 1] | 0;
-    const end = stack[base + 2] | 0;
-    const containerPos = stack[base + 3] | 0;
-    const containerEnd = stack[base + 4] | 0;
-    const declarationListContainerEnd = stack[base + 5] | 0;
-    stack.length = base;
+    const base = this.commentDepth - 6;
+    const flags = stack[base]!;
+    const pos = stack[base + 1]!;
+    const end = stack[base + 2]!;
+    const containerPos = stack[base + 3]!;
+    const containerEnd = stack[base + 4]!;
+    const declarationListContainerEnd = stack[base + 5]!;
+    this.commentDepth = base;
+    if (node === this.freeOwner) this.endCommentFreeRange();
+    if (flags === commentFreeNode) {
+      this.containerPos = containerPos;
+      this.containerEnd = containerEnd;
+      this.declarationListContainerEnd = declarationListContainerEnd;
+      return true;
+    }
     if ((flags & EmitFlags.NoNestedComments) !== 0) this.commentsDisabled = false;
     if ((flags & EmitFlags.NoTrailingComments) === 0) {
       const synthesized = this.context.getSyntheticTrailingComments(node);
@@ -4395,6 +4530,83 @@ export class Printer extends NameGeneratorHost {
     return true;
   }
 
+  /**
+   * Whether `node` has no emit data and lies in a range of the source text where no comment is found, so that its
+   * comments need not be looked for. Outside such a range, a node whose own range is one starts it (`freeOwner`).
+   */
+  private inCommentFreeRange(node: Node): boolean {
+    const pos = node.pos;
+    const end = node.end;
+    if (pos < 0 || end <= pos || node.kind === SyntaxKind.JsxText || node.kind === SyntaxKind.NotEmittedStatement)
+      return false;
+    if (this.freeEnd < 0) {
+      if (!this.startCommentFreeRange(pos, end)) return false;
+      this.freeOwner = node;
+    } else if (pos < this.freeStart) return false;
+    if (this.context.hasEmitNode(node)) return false;
+    return end < this.freeEnd || (end === this.freeEnd && this.freeEndTrailingNone);
+  }
+
+  private endCommentFreeRange(): boolean {
+    this.freeStart = -1;
+    this.freeEnd = -1;
+    this.freeEndTrailingNone = false;
+    this.freeOwner = undefined;
+    return true;
+  }
+
+  /** Whether the comment-free range shows that no trailing comment follows `pos`. */
+  private noCommentsAfter(pos: number): boolean {
+    return pos >= this.freeStart && (pos < this.freeEnd || (pos === this.freeEnd && this.freeEndTrailingNone));
+  }
+
+  /** Makes `[pos, end)` the comment-free range if no comment starts in it and its last character is not trivia. */
+  private startCommentFreeRange(pos: number, end: number): boolean {
+    const text = this.sourceText;
+    if (end > text.length) return false;
+    const last = text.charCodeAt(end - 1);
+    if (
+      last === CharacterCodes.space ||
+      last === CharacterCodes.tab ||
+      last === CharacterCodes.lineFeed ||
+      last === CharacterCodes.carriageReturn ||
+      last === CharacterCodes.verticalTab ||
+      last === CharacterCodes.formFeed ||
+      last > CharacterCodes.maxAsciiCharacter
+    )
+      return false;
+    const starts = this.commentStartsOfFile();
+    // The first comment start at or after `pos`.
+    let low = 0;
+    let high = starts.length;
+    while (low < high) {
+      const middle = (low + high) >>> 1;
+      if (starts[middle]! < pos) low = middle + 1;
+      else high = middle;
+    }
+    if (low < starts.length && starts[low]! < end) return false;
+    this.freeStart = pos;
+    this.freeEnd = end;
+    this.freeEndTrailingNone = getTrailingCommentRanges(text, end) === undefined;
+    return true;
+  }
+
+  private commentStartsOfFile(): Int32Array {
+    const cached = this.commentStarts;
+    if (cached !== undefined) return cached;
+    const text = this.sourceText;
+    const length = text.length;
+    const list: number[] = [];
+    for (let i = text.indexOf('/'); i >= 0 && i + 1 < length; i = text.indexOf('/', i + 1)) {
+      const next = text.charCodeAt(i + 1);
+      if (next === CharacterCodes.slash || next === CharacterCodes.asterisk) list.push(i);
+    }
+    const starts = new Int32Array(list.length);
+    for (let i = 0; i < list.length; i++) starts[i] = list[i]!;
+    this.commentStarts = starts;
+    return starts;
+  }
+
   /** Emits comments before a token; returns whether `emitCommentsAfterToken` applies, with the token's position in `tokenPos`. */
   private emitCommentsBeforeToken(pos: number, contextNode: Node, flags: TokenEmitFlags): boolean {
     if ((flags & TokenEmitFlags.NoComments) !== 0 || this.commentsDisabled) {
@@ -4505,6 +4717,7 @@ export class Printer extends NameGeneratorHost {
   private emitLeadingComments(pos: number, elided: boolean): boolean {
     if (this.commentsDisabled || this.currentSourceFile === undefined || pos < 0 || pos === this.containerPos)
       return false;
+    if (pos >= this.freeStart && pos < this.freeEnd) return false;
     // 1: only triple-slash comments, 2: all but triple-slash comments, 0: all.
     let tripleSlash = 0;
     if (!elided) {
@@ -4552,6 +4765,7 @@ export class Printer extends NameGeneratorHost {
       (this.containerEnd !== -1 && (pos === this.containerEnd || pos === this.declarationListContainerEnd))
     )
       return false;
+    if (this.noCommentsAfter(pos)) return false;
     const ranges = getTrailingCommentRanges(this.sourceText, pos);
     if (ranges === undefined) return false;
     let comments: CommentRange[] | undefined = undefined;
@@ -4567,6 +4781,7 @@ export class Printer extends NameGeneratorHost {
     if (this.commentsDisabled || this.currentSourceFile === undefined) return false;
     if (this.containerEnd !== -1 && (pos === this.containerEnd || pos === this.declarationListContainerEnd))
       return false;
+    if (this.noCommentsAfter(pos)) return false;
     const comments = getTrailingCommentRanges(this.sourceText, pos);
     if (comments === undefined) return false;
     for (const comment of comments) {

package/src/compiler/program-checker.ts

@@ -276,6 +276,10 @@ export class CheckedProgram {
    * emit. Set once every file is checked, when checker threads emit (parallel-check.ts).
    */
   emittedInParallel: (EmitResult | undefined)[] | undefined = undefined;
+  /** Emit threads emitted only the JavaScript of `emittedInParallel`: declarations are emitted here. */
+  javaScriptEmittedOnThreads = false;
+  /** The declaration emit of each file on the declaration thread (parallel-emit.ts); undefined for one it didn't emit. */
+  declarationsEmittedAhead: (EmitResult | undefined)[] | undefined = undefined;
   /**
    * The global diagnostics of this thread's checker before it emitted files while checker threads
    * checked (`emitUncheckedFiles`), reported instead of its current ones.

package/src/compiler/program.ts

@@ -27,6 +27,7 @@ import {
   equalDiagnosticsNoRelatedInfo,
   type DiagnosticMessage,
   type Locale,
+  sortDiagnostics,
   useThreadTextCaches,
 } from './diagnostics.js';
 import {
@@ -455,30 +456,9 @@ export class Program implements OutputPathsHost {
     return this.processed.resolvedModules.get(file.path)?.get(modeAwareKey(moduleName, mode));
   }
 
-  /** The program files that the imports and type reference directives of `file` resolved to. */
-  /**
-   * The files `file` imports and references through type directives. `byFileName`, the program's
-   * files by file name, finds a file without computing its path when it is resolved by that name.
-   */
-  getResolvedFilesOf(file: SourceFile, byFileName?: ReadonlyMap<string, SourceFile>): SourceFile[] {
-    const result: SourceFile[] = [];
-    const modules = this.processed.resolvedModules.get(file.path);
-    if (modules !== undefined)
-      for (const resolved of modules.values()) {
-        const name = resolved.resolvedFileName;
-        if (name === '') continue;
-        const target = byFileName?.get(name) ?? this.getSourceFileForResolvedModule(name);
-        if (target !== undefined) result.push(target);
-      }
-    const types = this.processed.typeResolutionsInFile.get(file.path);
-    if (types !== undefined)
-      for (const resolved of types.values()) {
-        const name = resolved.resolvedFileName;
-        if (name === '') continue;
-        const target = byFileName?.get(name) ?? this.getSourceFile(name);
-        if (target !== undefined) result.push(target);
-      }
-    return result;
+  /** The files each file added to the program (`ProcessedFiles.addedFiles`), as indices of `getSourceFiles`. */
+  addedFiles(): readonly (readonly number[])[] {
+    return this.processed.addedFiles;
   }
 
   /** The specifier of the implicit JSX runtime import of `file`, if any. */
@@ -1398,7 +1378,7 @@ class NodeCollector extends NodeVisitor {
 
 /** Sorts diagnostics and merges duplicates, combining their related information. */
 export function sortAndDeduplicateDiagnostics(diagnostics: readonly Diagnostic[]): Diagnostic[] {
-  const sorted = [...diagnostics].sort(compareDiagnostics);
+  const sorted = sortDiagnostics(diagnostics);
   if (sorted.length < 2) return sorted;
   const result: Diagnostic[] = [];
   let i = 0;

package/src/compiler/relations.ts

@@ -517,6 +517,13 @@ export function isTypeRelatedTo(c: Checker, source: Type, target: Type, relation
     // Types that can't simplify must have identical flags.
     if (source.flags !== target.flags) return false;
     if ((source.flags & TypeFlags.Singleton) !== 0) return true;
+  } else {
+    // What the relater decides first for types that may simplify (Relater.isRelatedToEx): their normal forms are
+    // one type, or can be identical only with identical flags.
+    const s = getNormalizedType(c, source, false);
+    const t = getNormalizedType(c, target, true);
+    if (s === t) return true;
+    if (s.flags !== t.flags) return false;
   }
   if ((source.flags & TypeFlags.Object) !== 0 && (target.flags & TypeFlags.Object) !== 0) {
     const related = relation.get(

package/src/compiler/symbol.ts

@@ -156,12 +156,17 @@ export class SymbolRareFields implements ProgramLifetime {
   valueDeclaration: Node | undefined = undefined;
 }
 
-/** In `Symbol.bits`, above the check flags: the value declaration is the first declaration. */
-const valueDeclarationIsFirst = 1 << 30;
+/**
+ * In `Symbol.bits`, above the check flags: the value declaration is the first declaration. A const enum
+ * member, so that native builds read it as a constant rather than as a module variable.
+ */
+const enum SymbolBits {
+  ValueDeclarationIsFirst = 1 << 30,
+}
 
 export class Symbol implements ProgramLifetime {
   flags: SymbolFlags;
-  /** The check flags, and `valueDeclarationIsFirst`. */
+  /** The check flags, and `SymbolBits.ValueDeclarationIsFirst`. */
   private bits: number;
   readonly name: string;
   /**
@@ -186,19 +191,19 @@ export class Symbol implements ProgramLifetime {
   }
 
   get checkFlags(): CheckFlags {
-    return (this.bits & ~valueDeclarationIsFirst) as CheckFlags;
+    return (this.bits & ~SymbolBits.ValueDeclarationIsFirst) as CheckFlags;
   }
 
   set checkFlags(flags: CheckFlags) {
-    this.bits = (this.bits & valueDeclarationIsFirst) | flags;
+    this.bits = (this.bits & SymbolBits.ValueDeclarationIsFirst) | flags;
   }
 
   /** Makes `node` the first declaration, keeping the value declaration. */
   setFirst(node: Node | undefined): void {
-    if ((this.bits & valueDeclarationIsFirst) !== 0 && node !== this.declaration) {
+    if ((this.bits & SymbolBits.ValueDeclarationIsFirst) !== 0 && node !== this.declaration) {
       // The value declaration stays what it was.
       this.rareFieldsOrNew().valueDeclaration = this.declaration;
-      this.bits &= ~valueDeclarationIsFirst;
+      this.bits &= ~SymbolBits.ValueDeclarationIsFirst;
     }
     this.declaration = node;
   }
@@ -208,7 +213,7 @@ export class Symbol implements ProgramLifetime {
    * says; any other is kept in the rare fields.
    */
   get valueDeclaration(): Node | undefined {
-    if ((this.bits & valueDeclarationIsFirst) !== 0) return this.declaration;
+    if ((this.bits & SymbolBits.ValueDeclarationIsFirst) !== 0) return this.declaration;
     const group = this.rareFields;
     return group === undefined ? undefined : group.valueDeclaration;
   }
@@ -216,11 +221,11 @@ export class Symbol implements ProgramLifetime {
   set valueDeclaration(node: Node | undefined) {
     const group = this.rareFields;
     if (node !== undefined && node === this.declaration) {
-      this.bits |= valueDeclarationIsFirst;
+      this.bits |= SymbolBits.ValueDeclarationIsFirst;
       if (group !== undefined) group.valueDeclaration = undefined;
       return;
     }
-    this.bits &= ~valueDeclarationIsFirst;
+    this.bits &= ~SymbolBits.ValueDeclarationIsFirst;
     if (node !== undefined || group !== undefined) this.rareFieldsOrNew().valueDeclaration = node;
   }