tsc-ts 0.0.9 → 0.1.0

package/README.md

@@ -31,9 +31,9 @@ npx tsc-ts -p tsconfig.json
 npx tsc-ts --noEmit src/index.ts
 ```
 
-`tsc-ts --api` serves the TypeScript API over stdin and stdout, like `tsc --api`. On Windows, `--api --pipe \\.\pipe\<name>` serves it over a named pipe it creates, as `tsc --api --pipe` does, for clients that connect to the pipe (such as scriptc under Node.js); only the native executable supports `--pipe`.
+`tsc-ts --api` serves the TypeScript API over stdin and stdout, like `tsc --api`. On Windows, `--api --pipe \\.\pipe\<name>` serves it over a named pipe it creates, as `tsc --api --pipe` does, for clients that connect to the pipe (such as scriptc under Node.js); only the native executable supports `--pipe`. On macOS and Linux, `--api --listen <path>` serves it on a Unix socket it creates, with mode 0600, to one client of the same user at a time, each until the client closes its end. Each client gets the answers a new `tsc-ts --api` process would give, except that symbol ids continue from earlier clients, and the server reads every file through the client again, but it keeps parsed files between clients and reuses those whose text is unchanged, along with the encoding `getSourceFile` sends for each, so a client that opens the same project again loads it faster. The server exits when no client connects for 60 seconds (`--idle-exit <seconds>` sets the time), or after a client when its resident memory is above 2.5 times what it held after its first client (`TSC_TS_LISTEN_MEMORY` sets the limit in megabytes). To stop, it removes the socket file, serves the clients that had connected, and exits. It replaces a socket file that no server answers on, such as one left by a server that was killed. Only the native executable supports `--listen`. With `--default-libraries-from-disk`, the server reads the files in its default library directory (`TSC_TS_LIB_DIR`, or the executable's directory) from the disk itself, even when the client handles file system calls (`--callbacks`), which saves a round trip to the client for each library file.
 
-`--checkers N` checks the program on N threads. Unless `--checkers` or `--singleThreaded` is given, the native executable uses one checker per CPU it may run on (up to 16), and at least tsgo's four; it uses fewer than the CPUs, but never fewer than four, when the estimated peak memory of more checkers would not fit 85% of the machine's memory (`TSC_TS_CHECKERS=fixed` keeps tsgo's four), and checkers beyond the fourth stop taking files, one at a time, when the process's memory reaches that share; it shares one program between its threads and also parses and binds the program's files on them. Unless `--singleThreaded` is given, the program's files are parsed and bound on threads also with `--checkers 1`, as tsgo does. Files that share costly declarations, such as a large generated schema and the few files importing it, are checked together on one checker. Under Node.js, where every thread builds its own copy of the program, tsc-ts checks on one thread unless `--checkers` is given. `--incremental`, `--watch` and `--build` always check on one thread. The diagnostics are the same as with one checker.
+`--checkers N` checks the program on N threads. Unless `--checkers` or `--singleThreaded` is given, the native executable uses one checker per CPU it may run on (up to 16), and at least tsgo's four; it uses fewer than the CPUs, but never fewer than four, when the estimated peak memory of more checkers would not fit 85% of the machine's memory (`TSC_TS_CHECKERS=fixed` keeps tsgo's four), and checkers beyond the fourth stop taking files, one at a time, when the process's memory reaches that share; it shares one program between its threads and also parses and binds the program's files on them. Unless `--singleThreaded` is given, the program's files are parsed and bound on threads also with `--checkers 1` and in the first build of `--watch`, with or without build info, as tsgo does. Files that share costly declarations, such as a large generated schema and the few files importing it, are checked together on one checker. Under Node.js, where every thread builds its own copy of the program, tsc-ts checks on one thread unless `--checkers` is given. `--incremental`, `--watch` and `--build` always check on one thread. The diagnostics are the same as with one checker.
 
 The native executable never frees syntax trees, types, signatures or symbols: it keeps them until it exits, which saves the cost of tracking them during a build. A one-shot build is unaffected, but a long-running process grows with each rebuild or project update. Native `--watch` (also with `--build`) runs in a child process, and when a change arrives while that process holds more than 2.5 times the memory it held after its first build, a new process replaces it and builds the change, reporting what the old process would have. `TSC_TS_WATCH_MEMORY` sets that limit in megabytes, and `TSC_TS_WATCH_MEMORY=0` turns the replacement off. A `--api` process grows with each project update; restart it to reclaim the memory.
 

package/bin/tsc-ts.js

@@ -2,7 +2,20 @@
 // Runs the native tsc-ts executable from this platform's package. The lib
 // files sit next to the executable, where it looks for them.
 import { spawnSync } from 'node:child_process';
-import { accessSync, chmodSync, constants } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import {
+  accessSync,
+  chmodSync,
+  closeSync,
+  constants,
+  fchmodSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeSync,
+} from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, join } from 'node:path';
 import { executableName, hostDescription, hostPlatform, packageName } from './platforms.js';
@@ -31,11 +44,67 @@ if (process.platform !== 'win32') {
   }
 }
 
+if (process.platform === 'linux') writeOnce(executable);
+
 const result = spawnSync(executable, process.argv.slice(2), { stdio: 'inherit' });
 if (result.error) fail(`could not run ${executable}: ${result.error.message}`);
 if (result.signal) process.kill(process.pid, result.signal);
 process.exitCode = result.status ?? 1;
 
+// The executable's code maps with 2 MiB pages when the page cache holds the
+// file in 2 MiB folios, which a file written with one write gets on file
+// systems with large folios (XFS, ext4 from Linux 6.16). Package managers
+// write it in chunks, which leaves 4 KiB folios until the file is read from
+// disk again. The first run writes it again with one write and renames the
+// copy into place; .tsc-ts-written beside it holds the size of the copy, so
+// later runs only read it. When the directory is not writable, the
+// executable runs as installed.
+function writeOnce(file) {
+  const marker = join(dirname(file), '.tsc-ts-written');
+  let size;
+  try {
+    size = statSync(file).size;
+    if (readFileSync(marker, 'utf8') === String(size)) return;
+  } catch {
+    if (size === undefined) return;
+  }
+  try {
+    const bytes = readFileSync(file);
+    replaceFile(file, bytes, statSync(file).mode & 0o7777);
+    replaceFile(marker, Buffer.from(String(bytes.length)), 0o644);
+  } catch {
+    // The executable runs as installed.
+  }
+}
+
+// Replaces `file` with `bytes` and `mode` through a new file beside it. The copy
+// has an unpredictable name and is created exclusively (an existing path, a
+// symbolic link included, is never opened) with mode 0600, so no other user
+// can open it while it is written; it gets `mode` from its own descriptor
+// before it is renamed into place. Only a copy this run created is removed.
+function replaceFile(file, bytes, mode) {
+  const temporary = `${file}.${randomBytes(8).toString('hex')}.tmp`;
+  const fd = openSync(
+    temporary,
+    constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW,
+    0o600,
+  );
+  try {
+    for (let offset = 0; offset < bytes.length;) offset += writeSync(fd, bytes, offset, bytes.length - offset);
+    fchmodSync(fd, mode);
+    closeSync(fd);
+    renameSync(temporary, file);
+  } catch (error) {
+    try {
+      closeSync(fd);
+    } catch {
+      // Closed before the failure.
+    }
+    unlinkSync(temporary);
+    throw error;
+  }
+}
+
 function fail(message) {
   process.stderr.write(`tsc-ts: ${message}\n`);
   process.exit(1);

package/dist/api/compiler/ast-utilities.d.ts

@@ -58,11 +58,23 @@ export declare function canHaveDecorators(node: Node): boolean;
 export declare function isStringLiteralLike(node: Node): boolean;
 /** Whether two JSX tag names (identifiers, `this`, namespaced names or property accesses) are the same. */
 export declare function tagNamesAreEquivalent(lhs: Node, rhs: Node): boolean;
+/** Whether `node` is a JSDoc type expression or a type node in one. */
+export declare function isJSDocTypeExpressionOrChild(node: Node): boolean;
+/** The text of a JSDoc type with the leading whitespace and `*` of each line removed, and LF line breaks. */
+export declare function normalizeJSDocTypeSourceText(text: string): string;
 /** The source text of a node, without leading trivia. */
 export declare function getTextOfNodeFromSourceText(sourceText: string, node: Node): string;
 export declare function isImportMeta(node: Node): boolean;
-/** `import(…)` or `import.defer(…)`. */
+/** `import(…)`, `import.defer(…)` or `import.source(…)`. */
 export declare function isImportCall(node: Node): boolean;
+/** `import.defer` or `import.source`. */
+export declare function isImportPhaseMetaProperty(node: Node): boolean;
+export declare function isImportDeferMetaProperty(node: Node): boolean;
+export declare function isImportSourceMetaProperty(node: Node): boolean;
+/** `import source x from "m"` or `import.source("m")`. */
+export declare function isSourcePhaseImport(node: Node): boolean;
+/** `import.source(…)`. */
+export declare function isSourcePhaseImportCall(node: Node): boolean;
 /** `require(x)` with one argument, a string literal if `requireStringLiteralLikeArgument`. */
 export declare function isRequireCall(node: Node, requireStringLiteralLikeArgument: boolean): boolean;
 /** The string literal of `import("x")` types. */
@@ -80,3 +92,9 @@ export declare function isAmbientModule(node: Node): boolean;
 export declare function isJSDocTypeAssertion(node: Node): boolean;
 /** The expression a check applies to: parentheses and `satisfies` are skipped, but not JavaScript casts. */
 export declare function getEffectiveCheckNode(argument: Node): Node;
+/** The entity name of a heritage clause element: a type reference's type name, or an
+ * `ExpressionWithTypeArguments`'s expression. */
+export declare function getHeritageClauseElementName(node: Node): Node;
+/** Whether a name, or the rightmost name of a qualified name, is the type name of a type reference in a
+ * heritage clause. */
+export declare function isNameOfHeritageClauseTypeReference(nodeIn: Node): boolean;

package/dist/api/compiler/ast-utilities.js

@@ -2,7 +2,9 @@
 //
 // Fields of `instanceof`-narrowed nodes are read through `as` casts: scriptc reads them
 // statically, but reads fields of a narrowed value dynamically.
-import { CallExpression, ExternalModuleReference, Identifier, ImportEqualsDeclaration, ImportTypeNode, JsxNamespacedName, LiteralTypeNode, MetaProperty, ModuleDeclaration, PropertyAccessExpression, StringLiteral, getExpression, getIsTypeOnly, getModuleSpecifier, getText, getType, } from './ast.js';
+import { CallExpression, ExternalModuleReference, Identifier, ImportDeclaration, ImportEqualsDeclaration, ImportTypeNode, JsxNamespacedName, LiteralTypeNode, MetaProperty, ModuleDeclaration, PropertyAccessExpression, StringLiteral, getExpression, getIsTypeOnly, getModuleSpecifier, getText, getType, } from './ast.js';
+import { isTypeNodeKind } from './binder-utilities.js';
+import { isLineBreak, isWhiteSpaceLike } from './character-codes.js';
 import { skipTrivia } from './scanner.js';
 export function getBinaryOperatorPrecedence(kind) {
     switch (kind) {
@@ -51,7 +53,7 @@ export function getBinaryOperatorPrecedence(kind) {
 }
 // Tokens
 export function isKeyword(token) {
-    return token >= 82 /* SyntaxKind.FirstKeyword */ && token <= 166 /* SyntaxKind.LastKeyword */;
+    return token >= 82 /* SyntaxKind.FirstKeyword */ && token <= 167 /* SyntaxKind.LastKeyword */;
 }
 export function isPunctuation(token) {
     return token >= 18 /* SyntaxKind.FirstPunctuation */ && token <= 78 /* SyntaxKind.LastPunctuation */;
@@ -121,7 +123,7 @@ export function modifierToFlag(kind) {
             return 8192 /* ModifierFlags.In */;
         case 147 /* SyntaxKind.OutKeyword */:
             return 16384 /* ModifierFlags.Out */;
-        case 171 /* SyntaxKind.Decorator */:
+        case 172 /* SyntaxKind.Decorator */:
             return 32768 /* ModifierFlags.Decorator */;
     }
     return 0 /* ModifierFlags.None */;
@@ -180,19 +182,19 @@ export function compareNodePositions(a, b) {
 }
 function isLeftHandSideExpressionKind(kind) {
     switch (kind) {
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */:
-        case 215 /* SyntaxKind.NewExpression */:
-        case 214 /* SyntaxKind.CallExpression */:
-        case 285 /* SyntaxKind.JsxElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
-        case 289 /* SyntaxKind.JsxFragment */:
-        case 216 /* SyntaxKind.TaggedTemplateExpression */:
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
-        case 232 /* SyntaxKind.ClassExpression */:
-        case 219 /* SyntaxKind.FunctionExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 286 /* SyntaxKind.JsxElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+        case 290 /* SyntaxKind.JsxFragment */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
+        case 220 /* SyntaxKind.FunctionExpression */:
         case 79 /* SyntaxKind.Identifier */:
         case 80 /* SyntaxKind.PrivateIdentifier */:
         case 13 /* SyntaxKind.RegularExpressionLiteral */:
@@ -200,17 +202,17 @@ function isLeftHandSideExpressionKind(kind) {
         case 9 /* SyntaxKind.BigIntLiteral */:
         case 10 /* SyntaxKind.StringLiteral */:
         case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
-        case 229 /* SyntaxKind.TemplateExpression */:
+        case 230 /* SyntaxKind.TemplateExpression */:
         case 96 /* SyntaxKind.FalseKeyword */:
         case 105 /* SyntaxKind.NullKeyword */:
         case 109 /* SyntaxKind.ThisKeyword */:
         case 111 /* SyntaxKind.TrueKeyword */:
         case 107 /* SyntaxKind.SuperKeyword */:
-        case 236 /* SyntaxKind.NonNullExpression */:
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
-        case 237 /* SyntaxKind.MetaProperty */:
+        case 237 /* SyntaxKind.NonNullExpression */:
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 238 /* SyntaxKind.MetaProperty */:
         case 101 /* SyntaxKind.ImportKeyword */:
-        case 283 /* SyntaxKind.MissingDeclaration */:
+        case 284 /* SyntaxKind.MissingDeclaration */:
             return true;
     }
     return false;
@@ -218,32 +220,32 @@ function isLeftHandSideExpressionKind(kind) {
 /** Partially emitted expressions, created by transforms, are skipped. */
 export function isLeftHandSideExpression(node) {
     let expression = node;
-    while (expression.kind === 348 /* SyntaxKind.PartiallyEmittedExpression */)
+    while (expression.kind === 349 /* SyntaxKind.PartiallyEmittedExpression */)
         expression = expression.expression;
     return isLeftHandSideExpressionKind(expression.kind);
 }
 export function isFunctionLikeDeclarationKind(kind) {
     switch (kind) {
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 177 /* SyntaxKind.Constructor */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             return true;
     }
     return false;
 }
 export function isFunctionLikeKind(kind) {
     switch (kind) {
-        case 174 /* SyntaxKind.MethodSignature */:
-        case 180 /* SyntaxKind.CallSignature */:
-        case 318 /* SyntaxKind.JSDocSignature */:
-        case 181 /* SyntaxKind.ConstructSignature */:
-        case 182 /* SyntaxKind.IndexSignature */:
-        case 185 /* SyntaxKind.FunctionType */:
-        case 186 /* SyntaxKind.ConstructorType */:
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 181 /* SyntaxKind.CallSignature */:
+        case 319 /* SyntaxKind.JSDocSignature */:
+        case 182 /* SyntaxKind.ConstructSignature */:
+        case 183 /* SyntaxKind.IndexSignature */:
+        case 186 /* SyntaxKind.FunctionType */:
+        case 187 /* SyntaxKind.ConstructorType */:
             return true;
     }
     return isFunctionLikeDeclarationKind(kind);
@@ -253,37 +255,37 @@ export function isFunctionLike(node) {
 }
 export function canHaveIllegalDecorators(node) {
     switch (node.kind) {
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 177 /* SyntaxKind.Constructor */:
-        case 182 /* SyntaxKind.IndexSignature */:
-        case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
-        case 283 /* SyntaxKind.MissingDeclaration */:
-        case 244 /* SyntaxKind.VariableStatement */:
-        case 265 /* SyntaxKind.InterfaceDeclaration */:
-        case 266 /* SyntaxKind.TypeAliasDeclaration */:
-        case 267 /* SyntaxKind.EnumDeclaration */:
-        case 268 /* SyntaxKind.ModuleDeclaration */:
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-        case 273 /* SyntaxKind.ImportDeclaration */:
-        case 346 /* SyntaxKind.JSImportDeclaration */:
-        case 271 /* SyntaxKind.NamespaceExportDeclaration */:
-        case 279 /* SyntaxKind.ExportDeclaration */:
-        case 278 /* SyntaxKind.ExportAssignment */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 183 /* SyntaxKind.IndexSignature */:
+        case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
+        case 284 /* SyntaxKind.MissingDeclaration */:
+        case 245 /* SyntaxKind.VariableStatement */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 274 /* SyntaxKind.ImportDeclaration */:
+        case 347 /* SyntaxKind.JSImportDeclaration */:
+        case 272 /* SyntaxKind.NamespaceExportDeclaration */:
+        case 280 /* SyntaxKind.ExportDeclaration */:
+        case 279 /* SyntaxKind.ExportAssignment */:
             return true;
     }
     return false;
 }
 export function canHaveDecorators(node) {
     switch (node.kind) {
-        case 170 /* SyntaxKind.Parameter */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 232 /* SyntaxKind.ClassExpression */:
-        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 233 /* SyntaxKind.ClassExpression */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
             return true;
     }
     return false;
@@ -307,11 +309,53 @@ export function tagNamesAreEquivalent(lhs, rhs) {
             tagNamesAreEquivalent(lhs.expression, rhs.expression));
     throw new Error('Unhandled case in tagNamesAreEquivalent');
 }
+/** Whether `node` is a JSDoc type expression or a type node in one. */
+export function isJSDocTypeExpressionOrChild(node) {
+    if (node.kind === 309 /* SyntaxKind.JSDocTypeExpression */)
+        return true;
+    if ((node.flags & (4194304 /* NodeFlags.JSDoc */ | 8 /* NodeFlags.Reparsed */)) === 0)
+        return false;
+    for (let current = node; current !== undefined; current = current.parent)
+        if (isTypeNodeKind(current.kind))
+            return true;
+    return false;
+}
+/** The text of a JSDoc type with the leading whitespace and `*` of each line removed, and LF line breaks. */
+export function normalizeJSDocTypeSourceText(text) {
+    let result = '';
+    let lineStart = 0;
+    let multiline = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text.charCodeAt(i);
+        if (!isLineBreak(ch))
+            continue;
+        result += stripLeadingJSDocComment(text.substring(lineStart, i)) + '\n';
+        multiline = true;
+        if (ch === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(i + 1) === 10 /* CharacterCodes.lineFeed */)
+            i++;
+        lineStart = i + 1;
+    }
+    if (!multiline)
+        return stripLeadingJSDocComment(text);
+    return result + stripLeadingJSDocComment(text.substring(lineStart));
+}
+function stripLeadingJSDocComment(line) {
+    let start = 0;
+    while (start < line.length && isWhiteSpaceLike(line.charCodeAt(start)))
+        start++;
+    if (start < line.length && line.charCodeAt(start) === 42 /* CharacterCodes.asterisk */)
+        start++;
+    while (start < line.length && isWhiteSpaceLike(line.charCodeAt(start)))
+        start++;
+    return start === 0 ? line : line.substring(start);
+}
 /** The source text of a node, without leading trivia. */
 export function getTextOfNodeFromSourceText(sourceText, node) {
     if (nodeIsMissing(node))
         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 & 268435456 /* NodeFlags.ReparserTransformedLiteral */) !== 0) {
         if (node instanceof StringLiteral)
             return (node.tokenFlags & 65536 /* TokenFlags.SingleQuote */) !== 0 ? "'" + text + "'" : '"' + text + '"';
@@ -326,17 +370,39 @@ export function isImportMeta(node) {
         node.keywordToken === 101 /* SyntaxKind.ImportKeyword */ &&
         node.name.text === 'meta');
 }
-/** `import(…)` or `import.defer(…)`. */
+/** `import(…)`, `import.defer(…)` or `import.source(…)`. */
 export function isImportCall(node) {
     if (!(node instanceof CallExpression))
         return false;
     const e = node.expression;
-    if (e.kind === 101 /* SyntaxKind.ImportKeyword */)
-        return true;
-    if (!(e instanceof MetaProperty))
-        return false;
-    const meta = e;
-    return meta.keywordToken === 101 /* SyntaxKind.ImportKeyword */ && meta.name.text === 'defer';
+    return e.kind === 101 /* SyntaxKind.ImportKeyword */ || isImportPhaseMetaProperty(e);
+}
+/** `import.defer` or `import.source`. */
+export function isImportPhaseMetaProperty(node) {
+    return isImportMetaPropertyNamed(node, 'defer') || isImportMetaPropertyNamed(node, 'source');
+}
+export function isImportDeferMetaProperty(node) {
+    return isImportMetaPropertyNamed(node, 'defer');
+}
+export function isImportSourceMetaProperty(node) {
+    return isImportMetaPropertyNamed(node, 'source');
+}
+function isImportMetaPropertyNamed(node, name) {
+    return (node instanceof MetaProperty &&
+        node.keywordToken === 101 /* SyntaxKind.ImportKeyword */ &&
+        node.name.text === name);
+}
+/** `import source x from "m"` or `import.source("m")`. */
+export function isSourcePhaseImport(node) {
+    if (node instanceof ImportDeclaration) {
+        const clause = node.importClause;
+        return clause !== undefined && clause.phaseModifier === 167 /* SyntaxKind.SourceKeyword */;
+    }
+    return isSourcePhaseImportCall(node);
+}
+/** `import.source(…)`. */
+export function isSourcePhaseImportCall(node) {
+    return node instanceof CallExpression && isImportSourceMetaProperty(node.expression);
 }
 /** `require(x)` with one argument, a string literal if `requireStringLiteralLikeArgument`. */
 export function isRequireCall(node, requireStringLiteralLikeArgument) {
@@ -365,36 +431,36 @@ export function isLiteralImportTypeNode(node) {
 }
 export function isAnyImportOrReExport(node) {
     switch (node.kind) {
-        case 273 /* SyntaxKind.ImportDeclaration */:
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-        case 346 /* SyntaxKind.JSImportDeclaration */:
-        case 279 /* SyntaxKind.ExportDeclaration */:
+        case 274 /* SyntaxKind.ImportDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 347 /* SyntaxKind.JSImportDeclaration */:
+        case 280 /* SyntaxKind.ExportDeclaration */:
             return true;
     }
     return false;
 }
 export function getExternalModuleName(node) {
     switch (node.kind) {
-        case 273 /* SyntaxKind.ImportDeclaration */:
-        case 346 /* SyntaxKind.JSImportDeclaration */:
-        case 279 /* SyntaxKind.ExportDeclaration */:
+        case 274 /* SyntaxKind.ImportDeclaration */:
+        case 347 /* SyntaxKind.JSImportDeclaration */:
+        case 280 /* SyntaxKind.ExportDeclaration */:
             return getModuleSpecifier(node);
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
             if (node instanceof ImportEqualsDeclaration) {
                 const reference = node.moduleReference;
                 if (reference instanceof ExternalModuleReference)
                     return reference.expression;
             }
             return undefined;
-        case 206 /* SyntaxKind.ImportType */:
+        case 207 /* SyntaxKind.ImportType */:
             return getImportTypeNodeLiteral(node);
-        case 214 /* SyntaxKind.CallExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
             if (node instanceof CallExpression) {
                 const args = node.arguments.nodes;
                 return args.length > 0 ? args[0] : undefined;
             }
             return undefined;
-        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
             if (node instanceof ModuleDeclaration) {
                 const name = node.name;
                 if (name.kind === 10 /* SyntaxKind.StringLiteral */)
@@ -409,24 +475,25 @@ export function isGlobalScopeAugmentation(node) {
 }
 /** Whether a node is written type-only: an `import type` clause, or a `type` specifier, import or export. */
 export function isTypeOnly(node) {
-    if (node.kind === 274 /* SyntaxKind.ImportClause */)
+    if (node.kind === 275 /* SyntaxKind.ImportClause */)
         return node.phaseModifier === 156 /* SyntaxKind.TypeKeyword */;
     return getIsTypeOnly(node);
 }
 /** Whether a declaration declares only a type. */
 export function isTypeDeclaration(node) {
     switch (node.kind) {
-        case 169 /* SyntaxKind.TypeParameter */:
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 265 /* SyntaxKind.InterfaceDeclaration */:
-        case 266 /* SyntaxKind.TypeAliasDeclaration */:
-        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
-        case 267 /* SyntaxKind.EnumDeclaration */:
+        case 170 /* SyntaxKind.TypeParameter */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
             return true;
-        case 274 /* SyntaxKind.ImportClause */:
-            return isTypeOnly(node);
-        case 277 /* SyntaxKind.ImportSpecifier */:
-        case 282 /* SyntaxKind.ExportSpecifier */:
+        case 275 /* SyntaxKind.ImportClause */:
+            // `import type { a } from "m"` declares no type of its own.
+            return isTypeOnly(node) && node.name !== undefined;
+        case 278 /* SyntaxKind.ImportSpecifier */:
+        case 283 /* SyntaxKind.ExportSpecifier */:
             return isTypeOnly(node.parent.parent);
     }
     return false;
@@ -439,10 +506,10 @@ export function isAmbientModule(node) {
 }
 /** Whether `node` is a JavaScript `/** @type {T} *\/ (x)` cast, reparsed as a parenthesized `as` expression. */
 export function isJSDocTypeAssertion(node) {
-    if (node.kind !== 218 /* SyntaxKind.ParenthesizedExpression */ || !isInJSFile(node))
+    if (node.kind !== 219 /* SyntaxKind.ParenthesizedExpression */ || !isInJSFile(node))
         return false;
     const expression = getExpression(node);
-    if (expression === undefined || expression.kind !== 235 /* SyntaxKind.AsExpression */)
+    if (expression === undefined || expression.kind !== 236 /* SyntaxKind.AsExpression */)
         return false;
     const type = getType(expression);
     return type !== undefined && (type.flags & 8 /* NodeFlags.Reparsed */) !== 0;
@@ -452,11 +519,29 @@ export function getEffectiveCheckNode(argument) {
     const inJS = isInJSFile(argument);
     let node = argument;
     for (;;) {
-        if (node.kind === 218 /* SyntaxKind.ParenthesizedExpression */ && !(inJS && isJSDocTypeAssertion(node)))
+        if (node.kind === 219 /* SyntaxKind.ParenthesizedExpression */ && !(inJS && isJSDocTypeAssertion(node)))
             node = getExpression(node);
-        else if (node.kind === 239 /* SyntaxKind.SatisfiesExpression */)
+        else if (node.kind === 240 /* SyntaxKind.SatisfiesExpression */)
             node = getExpression(node);
         else
             return node;
     }
 }
+/** The entity name of a heritage clause element: a type reference's type name, or an
+ * `ExpressionWithTypeArguments`'s expression. */
+export function getHeritageClauseElementName(node) {
+    if (node.kind === 185 /* SyntaxKind.TypeReference */)
+        return node.typeName;
+    return getExpression(node);
+}
+/** Whether a name, or the rightmost name of a qualified name, is the type name of a type reference in a
+ * heritage clause. */
+export function isNameOfHeritageClauseTypeReference(nodeIn) {
+    let node = nodeIn;
+    while (node.parent.kind === 168 /* SyntaxKind.QualifiedName */)
+        node = node.parent;
+    const parent = node.parent;
+    return (parent.kind === 185 /* SyntaxKind.TypeReference */ &&
+        parent.typeName === node &&
+        parent.parent?.kind === 300 /* SyntaxKind.HeritageClause */);
+}