tsc-ts 0.0.9 → 0.1.0

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';
@@ -375,6 +375,8 @@ const enum ListItem {
   ImportSpecifier,
   ExportSpecifier,
   ExpressionWithTypeArguments,
+  /** An `ExpressionWithTypeArguments` or a type reference in a heritage clause. */
+  HeritageClauseElement,
   JsxChild,
   JsxAttributeLike,
 }
@@ -399,6 +401,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 +415,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 +435,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 +486,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 +500,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 +556,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;
   }
 
@@ -565,7 +608,8 @@ export class Printer extends NameGeneratorHost {
 
   isFileLevelUniqueName(name: string): boolean {
     const file = this.currentSourceFile;
-    return file === undefined || isFileLevelUniqueName(file, name);
+    // The names of the source file as parsed, not as transformed.
+    return file === undefined || isFileLevelUniqueName(this.context.mostOriginal(file) as SourceFile, name);
   }
 
   private getLiteralTextOfNode(node: Node, sourceFile: SourceFile | undefined, flags: LiteralTextFlags): string {
@@ -615,6 +659,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 +681,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 +795,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 +1148,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));
   }
 
@@ -1116,7 +1220,8 @@ export class Printer extends NameGeneratorHost {
     const state = this.enterNode(node);
     this.emitEntityName(node.left);
     this.write1('.');
-    this.emitIdentifierName(node.right);
+    if (node.right instanceof PrivateIdentifier) this.emitPrivateIdentifier(node.right);
+    else this.emitIdentifierName(node.right as Identifier);
     this.exitNode(node, state);
     return true;
   }
@@ -1813,10 +1918,11 @@ export class Printer extends NameGeneratorHost {
       this.emitOptionalToken(questionToken);
       if (questionToken.kind !== SyntaxKind.QuestionToken) this.write1('?');
     }
-    this.write1(': ');
-    // tsgo's printer fails on a mapped type without a type, too.
-    if (node.type === undefined) throw new Error('Mapped type without a type');
-    this.emitTypeNodeOutsideExtends(node.type);
+    // A mapped type written without a type, `{ [K in keyof T] }`, prints without one.
+    if (node.type !== undefined) {
+      this.write1(': ');
+      this.emitTypeNodeOutsideExtends(node.type);
+    }
     this.write1(';');
     if (node.members !== undefined && node.members.nodes.length > 0) {
       if (singleLine) this.space();
@@ -2847,8 +2953,8 @@ export class Printer extends NameGeneratorHost {
       case SyntaxKind.MetaProperty:
         if (node instanceof MetaProperty) {
           const state = this.enterNode(node);
-          this.emitToken(node.keywordToken, node.pos, node);
-          this.write1('.');
+          const pos = this.emitToken(node.keywordToken, node.pos, node);
+          this.emitToken(SyntaxKind.DotToken, pos, node);
           this.emitIdentifierName(node.name);
           this.exitNode(node, state);
           return true;
@@ -3210,6 +3316,10 @@ export class Printer extends NameGeneratorHost {
       this.emitIdentifierOrString(body.name, false);
       body = body.body;
     }
+    if (node.attributes !== undefined) {
+      this.write1(' with ');
+      this.emitTypeNode(node.attributes, TypePrecedence.NonArray);
+    }
     if (body === undefined) this.write1(';');
     else if (body instanceof ModuleBlock) {
       this.space();
@@ -3318,16 +3428,21 @@ export class Printer extends NameGeneratorHost {
       this.emitBindingIdentifier(bindings.name);
       this.exitNode(bindings, bindingsState);
     } else if (bindings instanceof NamedImports) {
-      const bindingsState = this.enterNode(bindings);
-      this.write1('{');
-      this.emitList(ListItem.ImportSpecifier, bindings, bindings.elements, ListFormat.NamedImportsOrExportsElements);
-      this.write1('}');
-      this.exitNode(bindings, bindingsState);
+      this.emitNamedImports(bindings);
     }
     this.exitNode(node, state);
     return true;
   }
 
+  private emitNamedImports(node: NamedImports): boolean {
+    const state = this.enterNode(node);
+    this.write1('{');
+    this.emitList(ListItem.ImportSpecifier, node, node.elements, ListFormat.NamedImportsOrExportsElements);
+    this.write1('}');
+    this.exitNode(node, state);
+    return true;
+  }
+
   /** Import and export specifiers. */
   private emitSpecifier(
     node: Node,
@@ -3770,7 +3885,7 @@ export class Printer extends NameGeneratorHost {
     this.space();
     this.emitToken(node.token, node.pos, node);
     this.space();
-    this.emitList(ListItem.ExpressionWithTypeArguments, node, node.types, ListFormat.HeritageClauseTypes);
+    this.emitList(ListItem.HeritageClauseElement, node, node.types, ListFormat.HeritageClauseTypes);
     this.exitNode(node, state);
     return true;
   }
@@ -3991,6 +4106,10 @@ export class Printer extends NameGeneratorHost {
       case ListItem.ExpressionWithTypeArguments:
         if (node instanceof ExpressionWithTypeArguments) return this.emitExpressionWithTypeArguments(node);
         break;
+      case ListItem.HeritageClauseElement:
+        if (node instanceof ExpressionWithTypeArguments) return this.emitExpressionWithTypeArguments(node);
+        if (node.kind === SyntaxKind.TypeReference) return this.emitTypeNodeWorker(node);
+        break;
       case ListItem.JsxChild:
         return this.emitJsxChild(node);
       case ListItem.JsxAttributeLike:
@@ -4290,6 +4409,9 @@ export class Printer extends NameGeneratorHost {
       case SyntaxKind.ImportClause:
         if (node instanceof ImportClause) return this.emitImportClause(node);
         break;
+      case SyntaxKind.NamedImports:
+        if (node instanceof NamedImports) return this.emitNamedImports(node);
+        break;
       case SyntaxKind.ImportSpecifier:
         return this.emitListItem(ListItem.ImportSpecifier, node);
       case SyntaxKind.ExportSpecifier:
@@ -4350,10 +4472,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 +4493,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 +4551,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 +4738,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 +4786,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 +4802,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/printer/utilities.ts

@@ -31,7 +31,12 @@ import {
   PrivateIdentifier,
   getExpression,
 } from '../ast.js';
-import { OperatorPrecedence, getBinaryOperatorPrecedence } from '../ast-utilities.js';
+import {
+  OperatorPrecedence,
+  getBinaryOperatorPrecedence,
+  isJSDocTypeExpressionOrChild,
+  normalizeJSDocTypeSourceText,
+} from '../ast-utilities.js';
 import {
   CharacterCodes,
   isDigit,
@@ -687,7 +692,8 @@ export function getLiteralText(node: Node, sourceText: string | undefined, flags
 /** The source text of a node without leading trivia, as tsgo's GetSourceTextOfNodeFromSourceFile. */
 export function getSourceTextOfNode(sourceText: string, node: Node): string {
   if (node.pos === node.end && node.pos >= 0 && node.kind !== SyntaxKind.EndOfFile) return '';
-  const text = sourceText.substring(skipTrivia(sourceText, node.pos), node.end);
+  let text = sourceText.substring(skipTrivia(sourceText, node.pos), node.end);
+  if (isJSDocTypeExpressionOrChild(node)) text = normalizeJSDocTypeSourceText(text);
   if ((node.flags & NodeFlags.ReparserTransformedLiteral) !== 0) {
     if (node instanceof StringLiteral)
       return (node.tokenFlags & TokenFlags.SingleQuote) !== 0 ? "'" + text + "'" : '"' + text + '"';

package/src/compiler/program-checker.ts

@@ -9,7 +9,14 @@
  */
 import { type Node, ScriptKind, type SourceFile } from './ast.js';
 import { Checker, CheckerHost, disposeChecker } from './checker.js';
-import { createDiagnostic, Diagnostic, type DiagnosticMessage, Diagnostics, messageCode } from './diagnostics.js';
+import {
+  compareDiagnostics,
+  createDiagnostic,
+  Diagnostic,
+  type DiagnosticMessage,
+  Diagnostics,
+  messageCode,
+} from './diagnostics.js';
 import type { EmitResult } from './emitter.js';
 import type { CompilerOptions, ModuleKind } from './options.js';
 import type { ResolvedModule } from './module-resolution-types.js';
@@ -265,6 +272,12 @@ export class CheckedProgram {
    */
   referenceThreads = 1;
   readonly parallelGlobalDiagnostics: Diagnostic[] = [];
+  /**
+   * Whether the semantic diagnostics of a file include the global diagnostics its checker found while
+   * checking it, as an incremental program caches them (IncrementalProgram). Such a program doesn't report
+   * the global diagnostics found by checking otherwise (`reportsGlobalDiagnosticsOfChecking`, compile-program.ts).
+   */
+  globalsInFileDiagnostics = false;
   /**
    * The declaration diagnostics checker threads computed under `noEmit` (PlainProgram,
    * IncrementalProgram), by file index; `undefined` for files they did not. Set once every file is
@@ -276,6 +289,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.
@@ -399,11 +416,11 @@ export class CheckedProgram {
     return sortAndDeduplicateDiagnostics([...own, ...parallel]);
   }
 
-  /** Whether `file`'s bind and check diagnostics are reported. */
-  skipTypeChecking(file: SourceFile): boolean {
+  /** Whether `file`'s bind and check diagnostics are skipped; `ignoreNoCheck` leaves `noCheck` out. */
+  skipTypeChecking(file: SourceFile, ignoreNoCheck = false): boolean {
     const options = this.program.options;
     return (
-      options.noCheck === true ||
+      (!ignoreNoCheck && options.noCheck === true) ||
       (options.skipLibCheck === true && file.isDeclarationFile) ||
       (options.skipDefaultLibCheck === true && this.program.isSourceFileDefaultLibrary(file.path)) ||
       this.program.getProjectReferenceFromSource(file.path) !== undefined ||
@@ -432,7 +449,15 @@ export class CheckedProgram {
   private getBindAndCheckDiagnostics(file: SourceFile, checks?: readonly Diagnostic[]): Diagnostic[] {
     const options = this.program.options;
     const diagnostics = file.bindDiagnostics.slice();
-    for (const d of checks ?? this.checker.getDiagnostics(file)) diagnostics.push(d);
+    if (checks !== undefined) for (const d of checks) diagnostics.push(d);
+    else if (this.globalsInFileDiagnostics) {
+      const checker = this.checker;
+      const before = checker.getGlobalDiagnostics();
+      for (const d of checker.getDiagnostics(file)) diagnostics.push(d);
+      const after = checker.getGlobalDiagnostics();
+      if (after.length > before.length)
+        for (const d of after) if (!containsSortedDiagnostic(before, d)) diagnostics.push(d);
+    } else for (const d of this.checker.getDiagnostics(file)) diagnostics.push(d);
     if (isPlainJSFile(file, options)) {
       const result: Diagnostic[] = [];
       for (const d of diagnostics) if (plainJSErrors.has(d.code)) result.push(d);
@@ -463,6 +488,20 @@ export class CheckedProgram {
   }
 }
 
+/** Whether `sorted`, in `compareDiagnostics` order, has a diagnostic equal to `diagnostic`. */
+function containsSortedDiagnostic(sorted: readonly Diagnostic[], diagnostic: Diagnostic): boolean {
+  let low = 0;
+  let high = sorted.length - 1;
+  while (low <= high) {
+    const middle = (low + high) >>> 1;
+    const c = compareDiagnostics(sorted[middle]!, diagnostic);
+    if (c === 0) return true;
+    if (c < 0) low = middle + 1;
+    else high = middle - 1;
+  }
+  return false;
+}
+
 /** The `@ts-ignore` and `@ts-expect-error` comments of a file, by line. */
 class Directives {
   private readonly byLine = new Map<number, { pos: number; end: number; kind: CommentDirectiveKind }>();
@@ -484,6 +523,11 @@ class Directives {
     const lineStarts = this.file.diagnosticFile().getLineStarts();
     const result: Diagnostic[] = [];
     for (const diagnostic of diagnostics) {
+      // A global diagnostic, or one of another file, has no line here.
+      if (diagnostic.file === undefined || diagnostic.file.fileName !== this.file.fileName) {
+        result.push(diagnostic);
+        continue;
+      }
       let ignored = false;
       for (let line = computeLineOfPosition(lineStarts, diagnostic.pos) - 1; line >= 0; line--) {
         const directive = this.byLine.get(line);
@@ -560,6 +604,7 @@ const plainJSErrors = codesOf([
   Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement,
   Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement,
   Diagnostics.A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration,
+  Diagnostics.A_deferred_import_must_specify_a_namespace_binding,
   Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context,
   Diagnostics.A_destructuring_declaration_must_have_an_initializer,
   Diagnostics.A_get_accessor_cannot_have_parameters,
@@ -628,6 +673,13 @@ const plainJSErrors = codesOf([
   Diagnostics.X_await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules,
   Diagnostics.Private_field_0_must_be_declared_in_an_enclosing_class,
   Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value,
+  Diagnostics.A_deferred_import_must_specify_a_namespace_binding,
+  Diagnostics.A_source_phase_import_must_specify_a_local_binding,
+  Diagnostics.Named_and_namespace_imports_are_not_allowed_in_a_source_phase_import,
+  Diagnostics.Optional_chaining_cannot_be_used_with_import_source,
+  Diagnostics.Source_phase_imports_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls,
+  Diagnostics.Source_phase_imports_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve,
+  Diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_import_Did_you_mean_meta_defer_or_source,
 ]);
 
 function codesOf(messages: readonly DiagnosticMessage[]): Set<number> {