tsc-ts 0.0.4 → 0.0.6

package/src/library/ast.ts

@@ -9,9 +9,11 @@ import type {
   Identifier,
   KeywordSyntaxKind,
   ModifierSyntaxKind,
+  NoSubstitutionTemplateLiteral,
   PropertyAccessExpression,
   PunctuationSyntaxKind,
   Statement,
+  StringLiteral,
   ThisExpression,
   Token,
 } from './ast.generated.js';
@@ -30,7 +32,7 @@ export interface TextRange {
 export interface Node extends TextRange {
   readonly kind: SyntaxKind;
   readonly flags: NodeFlags;
-  readonly parent: Node;
+  readonly parent: Node | undefined;
 }
 
 /** The children of a node in one list: `nodes`, and the range from the list's opening to its closing token. */
@@ -92,6 +94,7 @@ export interface PropertyAccessEntityNameExpression extends PropertyAccessExpres
 }
 
 export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;
+export type StringLiteralLike = StringLiteral | NoSubstitutionTemplateLiteral;
 export type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression;
 
 export interface JsxTagNamePropertyAccess extends PropertyAccessExpression {

package/src/library/checker.ts

@@ -0,0 +1,384 @@
+// The TypeChecker of tsc-ts's public API: a checker of the program for queries, independent of the
+// checker that reports the program's diagnostics, as `tsc-ts --api` answers queries. Each method answers
+// as the `tsc-ts --api` request of the same name does.
+
+import type { Node as CompilerNode } from '../compiler/ast.js';
+import { type Checker, disposeChecker } from '../compiler/checker.js';
+import { getBaseTypes, getDeclaredTypeOfSymbol } from '../compiler/checker-declared-types.js';
+import { getNonNullableType } from '../compiler/checker-flow.js';
+import {
+  getIndexInfosOfType,
+  getPropertiesOfType,
+  getPropertyOfType,
+  getSignaturesOfType,
+  isArrayLikeType,
+} from '../compiler/checker-members.js';
+import {
+  getConstantValue,
+  getShorthandAssignmentValueSymbol,
+  getSymbolAtLocation,
+  getTypeAtLocation,
+  getTypeOfSymbolAtLocation,
+  queryContextualType,
+  queryResolvedSignature,
+  querySignatureFromDeclaration,
+} from '../compiler/checker-services.js';
+import { getReturnTypeOfSignature, getTypePredicateOfSignature } from '../compiler/checker-signatures.js';
+import { getTypeOfSymbol } from '../compiler/checker-symbol-types.js';
+import { resolveAlias, resolveName } from '../compiler/checker-symbols.js';
+import {
+  getBaseTypeOfLiteralType,
+  getTypeArguments,
+  isArrayType,
+  isTupleType,
+} from '../compiler/checker-type-factory.js';
+import { getTypeFromTypeNode } from '../compiler/checker-type-nodes.js';
+import {
+  type Signature as CompilerSignature,
+  SignatureKind as CompilerSignatureKind,
+  type Type as CompilerType,
+} from '../compiler/checker-types.js';
+import { typeToStringFromTypeNode } from '../compiler/node-builder.js';
+import { isTypeAssignableTo } from '../compiler/relations.js';
+import {
+  getSymbolId,
+  type Symbol as CompilerSymbol,
+  type SymbolFlags as CompilerSymbolFlags,
+} from '../compiler/symbol.js';
+import { typeToString } from '../compiler/type-printer.js';
+import type { Expression, Identifier, Node, TypeNode } from './ast.js';
+import { SignatureKind, SymbolFlags, TypeFormatFlags, type TypePredicateKind } from './enums.generated.js';
+import { internalError } from './errors.js';
+import type {
+  IndexInfo,
+  InterfaceType,
+  Signature,
+  Symbol,
+  Type,
+  TypeChecker,
+  TypePredicate,
+  TypeReference,
+} from './types.js';
+
+// The API's objects are tsc-ts's own: these name the conversions between the public and compiler types.
+const node = (n: Node): CompilerNode => n as unknown as CompilerNode;
+const nodeOrUndefined = (n: Node | undefined): CompilerNode | undefined => n as unknown as CompilerNode | undefined;
+const type = (t: Type): CompilerType => t as unknown as CompilerType;
+const signature = (s: Signature): CompilerSignature => s as unknown as CompilerSignature;
+const compilerSymbol = (s: Symbol): CompilerSymbol => s as unknown as CompilerSymbol;
+const publicType = (t: CompilerType | undefined): Type | undefined => t as unknown as Type | undefined;
+const publicTypes = (types: readonly CompilerType[]): readonly Type[] => types.slice() as unknown as readonly Type[];
+const publicSignature = (s: CompilerSignature | undefined): Signature | undefined =>
+  s as unknown as Signature | undefined;
+
+/** `symbol`, with its id assigned: every symbol the API hands out has one. */
+export function publicSymbol(symbol: CompilerSymbol | undefined): Symbol | undefined {
+  if (symbol === undefined) return undefined;
+  getSymbolId(symbol);
+  return symbol as unknown as Symbol;
+}
+
+export function publicSymbols(symbols: readonly CompilerSymbol[]): readonly Symbol[] {
+  const result: Symbol[] = [];
+  for (const symbol of symbols) result.push(publicSymbol(symbol)!);
+  return result;
+}
+
+/** The flags of typeToString without flags, as TypeScript 7's API uses them. */
+const defaultTypeFormatFlags =
+  TypeFormatFlags.AllowUniqueESSymbolType | TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
+
+export class LibraryTypeChecker implements TypeChecker {
+  constructor(private readonly c: Checker) {}
+
+  dispose(): void {
+    disposeChecker(this.c);
+  }
+
+  getSymbolAtLocation(location: Node): Symbol | undefined {
+    try {
+      return publicSymbol(getSymbolAtLocation(this.c, node(location)));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getTypeAtLocation(location: Node): Type | undefined {
+    try {
+      return publicType(getTypeAtLocation(this.c, node(location)));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getTypeOfSymbol(symbol: Symbol): Type | undefined {
+    try {
+      return publicType(getTypeOfSymbol(this.c, compilerSymbol(symbol)));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getDeclaredTypeOfSymbol(symbol: Symbol): Type {
+    try {
+      return publicType(getDeclaredTypeOfSymbol(this.c, compilerSymbol(symbol)))!;
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getTypeOfSymbolAtLocation(symbol: Symbol, location: Node): Type {
+    try {
+      return publicType(getTypeOfSymbolAtLocation(this.c, compilerSymbol(symbol), node(location)))!;
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getTypeArguments(reference: TypeReference): readonly Type[] {
+    try {
+      return publicTypes(getTypeArguments(this.c, type(reference)));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  /** The target of an alias; throws an InternalCompilerError for any other symbol, as TypeScript 7 does. */
+  getAliasedSymbol(symbol: Symbol): Symbol {
+    try {
+      if ((symbol.flags & SymbolFlags.Alias) === 0) throw new Error('Should only get alias here');
+      return publicSymbol(resolveAlias(this.c, compilerSymbol(symbol)))!;
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getPropertyOfType(t: Type, name: string): Symbol | undefined {
+    try {
+      return publicSymbol(getPropertyOfType(this.c, type(t), name));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getPropertiesOfType(t: Type): readonly Symbol[] {
+    try {
+      return publicSymbols(getPropertiesOfType(this.c, type(t)));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getSignaturesOfType(t: Type, kind: SignatureKind): readonly Signature[] {
+    try {
+      const signatures = getSignaturesOfType(
+        this.c,
+        type(t),
+        kind === SignatureKind.Call ? CompilerSignatureKind.Call : CompilerSignatureKind.Construct,
+      );
+      return signatures.slice() as unknown as readonly Signature[];
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getIndexInfosOfType(t: Type): readonly IndexInfo[] {
+    try {
+      return getIndexInfosOfType(this.c, type(t)).slice() as unknown as readonly IndexInfo[];
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getReturnTypeOfSignature(s: Signature): Type | undefined {
+    try {
+      return publicType(getReturnTypeOfSignature(this.c, signature(s)));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getTypePredicateOfSignature(s: Signature): TypePredicate | undefined {
+    try {
+      const predicate = getTypePredicateOfSignature(this.c, signature(s));
+      if (predicate === undefined) return undefined;
+      return {
+        kind: predicate.kind as number as TypePredicateKind,
+        parameterIndex: predicate.parameterIndex,
+        parameterName: predicate.parameterName === '' ? undefined : predicate.parameterName,
+        type: publicType(predicate.type),
+      };
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getSignatureFromDeclaration(declaration: Node): Signature | undefined {
+    try {
+      return publicSignature(querySignatureFromDeclaration(this.c, node(declaration)));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getResolvedSignature(call: Node): Signature | undefined {
+    try {
+      return publicSignature(queryResolvedSignature(this.c, node(call)));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getContextualType(expression: Expression): Type | undefined {
+    try {
+      return publicType(queryContextualType(this.c, node(expression)));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getShorthandAssignmentValueSymbol(location: Node): Symbol | undefined {
+    try {
+      return publicSymbol(getShorthandAssignmentValueSymbol(this.c, node(location)));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getTypeFromTypeNode(typeNode: TypeNode): Type | undefined {
+    try {
+      return publicType(getTypeFromTypeNode(this.c, node(typeNode)));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getBaseTypeOfLiteralType(t: Type): Type | undefined {
+    try {
+      return publicType(getBaseTypeOfLiteralType(this.c, type(t)));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getNonNullableType(t: Type): Type | undefined {
+    try {
+      return publicType(getNonNullableType(this.c, type(t)));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getBaseTypes(t: InterfaceType): readonly Type[] {
+    try {
+      return publicTypes(getBaseTypes(this.c, type(t)));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getConstantValue(location: Node): string | number | undefined {
+    try {
+      return getConstantValue(this.c, node(location));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  isArrayType(t: Type): boolean {
+    try {
+      return isArrayType(this.c, type(t));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  isTupleType(t: Type): boolean {
+    try {
+      return isTupleType(type(t));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  isArrayLikeType(t: Type): boolean {
+    try {
+      return isArrayLikeType(this.c, type(t));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  isTypeAssignableTo(source: Type, target: Type): boolean {
+    try {
+      return isTypeAssignableTo(this.c, type(source), type(target));
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  resolveName(name: string, meaning: SymbolFlags, location?: Node, excludeGlobals = false): Symbol | undefined {
+    try {
+      return publicSymbol(
+        resolveName(
+          this.c,
+          nodeOrUndefined(location),
+          name,
+          meaning as number as CompilerSymbolFlags,
+          undefined,
+          false,
+          excludeGlobals,
+        ),
+      );
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  /** The value an identifier names where it is: resolveName of its text, as TypeScript 7's API defines it. */
+  getResolvedSymbol(identifier: Identifier): Symbol | undefined {
+    if (identifier.text === '') return undefined;
+    return this.resolveName(identifier.text, SymbolFlags.Value | SymbolFlags.ExportValue, identifier);
+  }
+
+  typeToString(t: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string {
+    try {
+      const enclosing = nodeOrUndefined(enclosingDeclaration);
+      const formatFlags = flags === undefined || flags === 0 ? defaultTypeFormatFlags : flags;
+      return (
+        typeToStringFromTypeNode(this.c, type(t), enclosing, formatFlags) ??
+        typeToString(this.c, type(t), enclosing, formatFlags)
+      );
+    } catch (e) {
+      throw internalError(e);
+    }
+  }
+
+  getAnyType(): Type {
+    return this.c.anyType as unknown as Type;
+  }
+
+  getUnknownType(): Type {
+    return this.c.unknownType as unknown as Type;
+  }
+
+  getNeverType(): Type {
+    return this.c.neverType as unknown as Type;
+  }
+
+  getStringType(): Type {
+    return this.c.stringType as unknown as Type;
+  }
+
+  getNumberType(): Type {
+    return this.c.numberType as unknown as Type;
+  }
+
+  getBigIntType(): Type {
+    return this.c.bigintType as unknown as Type;
+  }
+
+  getBooleanType(): Type {
+    return this.c.booleanType as unknown as Type;
+  }
+}

package/src/library/diagnostics.ts

@@ -0,0 +1,72 @@
+// The diagnostics of programs, as tsc-ts's public API and `tsc-ts --api` return them.
+
+import type { SourceFile } from '../compiler/ast.js';
+import { type Diagnostic as CompilerDiagnostic, Locale } from '../compiler/diagnostics.js';
+import { sortAndDeduplicateDiagnostics } from '../compiler/program.js';
+import type { CheckedProgram } from '../compiler/program-checker.js';
+import type { DiagnosticCategory } from './enums.generated.js';
+import type { Diagnostic } from './types.js';
+
+export type DiagnosticKind =
+  | 'config'
+  | 'program'
+  | 'global'
+  | 'syntactic'
+  | 'bind'
+  | 'semantic'
+  | 'suggestion'
+  | 'declaration';
+
+/** A diagnostic as plain data, with its text in the default locale and its chain and related information. */
+export function diagnosticOf(d: CompilerDiagnostic): Diagnostic {
+  return {
+    fileName: d.file?.fileName,
+    pos: d.pos,
+    end: d.end,
+    code: d.code,
+    category: d.category as number as DiagnosticCategory,
+    text: d.localize(Locale.Default),
+    reportsUnnecessary: d.reportsUnnecessary,
+    reportsDeprecated: d.reportsDeprecated,
+    messageChain: d.messageChain.map(diagnosticOf),
+    relatedInformation: d.relatedInformation.map(diagnosticOf),
+  };
+}
+
+/**
+ * The diagnostics of one kind for `file`, or for every file of the program without one. Global
+ * diagnostics are those of no file, after the semantic diagnostics of every file, as tsgo's API returns
+ * them. Declaration diagnostics are empty, as tsgo's API returns them.
+ */
+export function programDiagnostics(
+  checked: CheckedProgram,
+  kind: DiagnosticKind,
+  file: SourceFile | undefined,
+): readonly CompilerDiagnostic[] {
+  const program = checked.program;
+  switch (kind) {
+    case 'config':
+      return program.getConfigFileParsingDiagnostics();
+    case 'program':
+      return program.getProgramDiagnostics();
+    case 'global': {
+      checked.getSemanticDiagnostics(undefined);
+      const all = [
+        ...program.getConfigFileParsingDiagnostics(),
+        ...program.getProgramDiagnostics(),
+        ...checked.getGlobalDiagnostics(),
+      ];
+      return sortAndDeduplicateDiagnostics(all).filter((d) => d.file === undefined);
+    }
+    case 'syntactic':
+      return program.getSyntacticDiagnostics(file);
+    case 'bind':
+      return checked.getBindDiagnostics(file);
+    case 'semantic':
+      return checked.getSemanticDiagnostics(file);
+    case 'suggestion':
+      return checked.getSuggestionDiagnostics(file);
+    case 'declaration':
+      return [];
+  }
+}

package/src/library/disk.ts

@@ -0,0 +1,73 @@
+// The disk, as tsc-ts's public API and `tsc-ts --api` read it where a host doesn't answer.
+import { readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+
+export interface DirectoryEntries {
+  files: string[];
+  directories: string[];
+}
+
+export interface FileStat {
+  isDirectory: boolean;
+  size: number;
+  mtimeMs: number;
+}
+
+// Reads a text file, decoding UTF-16 byte order marks and dropping a UTF-8 one.
+export function diskReadFile(path: string): string | undefined {
+  let bytes: Uint8Array;
+  try {
+    bytes = readFileSync(path);
+  } catch {
+    return undefined;
+  }
+  if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe)
+    return new TextDecoder('utf-16le').decode(bytes.subarray(2));
+  if (bytes.length >= 2 && bytes[0] === 0xfe && bytes[1] === 0xff) return utf16be(bytes.subarray(2));
+  if (bytes.length >= 3 && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) bytes = bytes.subarray(3);
+  return new TextDecoder().decode(bytes);
+}
+
+function utf16be(bytes: Uint8Array): string {
+  const swapped = new Uint8Array(bytes.length & ~1);
+  for (let i = 0; i + 1 < bytes.length; i += 2) {
+    swapped[i] = bytes[i + 1];
+    swapped[i + 1] = bytes[i];
+  }
+  return new TextDecoder('utf-16le').decode(swapped);
+}
+
+export function diskStat(path: string): FileStat | undefined {
+  try {
+    const s = statSync(path);
+    return { isDirectory: s.isDirectory(), size: s.size, mtimeMs: s.mtimeMs };
+  } catch {
+    return undefined;
+  }
+}
+
+// Lists a directory, following symbolic links and skipping broken ones.
+export function diskEntries(path: string): DirectoryEntries {
+  const files: string[] = [];
+  const directories: string[] = [];
+  let names: string[];
+  try {
+    names = readdirSync(path);
+  } catch {
+    return { files, directories };
+  }
+  for (const name of names.sort()) {
+    const stat = diskStat(path + '/' + name);
+    if (stat === undefined) continue;
+    if (stat.isDirectory) directories.push(name);
+    else files.push(name);
+  }
+  return { files, directories };
+}
+
+export function diskRealpath(path: string): string {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}

package/src/library/errors.ts

@@ -0,0 +1,26 @@
+// Errors of tsc-ts's public API.
+
+/**
+ * A failure inside tsc-ts while it answered an API call: an exception the compiler threw, as tsgo panics.
+ * `cause` is the exception. The program's checker may be inconsistent after one; dispose of the program.
+ */
+export class InternalCompilerError extends Error {
+  constructor(cause: unknown) {
+    super('panic: ' + (cause instanceof Error ? cause.message : String(cause)), { cause });
+    this.name = 'InternalCompilerError';
+  }
+}
+
+/** A call on a program, or on its checker, after `dispose()`. */
+export class DisposedProgramError extends Error {
+  constructor() {
+    super('the program is disposed');
+    this.name = 'DisposedProgramError';
+  }
+}
+
+/** `e` as an InternalCompilerError; errors of using a disposed program are rethrown as they are. */
+export function internalError(e: unknown): Error {
+  if (e instanceof InternalCompilerError || e instanceof DisposedProgramError) return e;
+  return new InternalCompilerError(e);
+}

package/src/library/host.ts

@@ -0,0 +1,63 @@
+// The file system a program of tsc-ts's public API reads through its host.
+
+import { diskEntries, diskReadFile, diskRealpath, diskStat } from './disk.js';
+import { ParseOptions, ScriptKind, type ExternalModuleIndicatorOptions, type SourceFile } from '../compiler/ast.js';
+import { CompilerHost } from '../compiler/file-loader.js';
+import { DirectoryEntries, FileSystem } from '../compiler/file-system.js';
+import { takePreparedFile } from '../compiler/parallel-parse.js';
+import { parseSourceFile } from '../compiler/parser.js';
+import type { ProgramHost } from './types.js';
+
+/**
+ * The host's answers, and the disk's where a callback is missing or answers undefined, as `tsc-ts --api`
+ * reads through its client's callbacks. `readFile` answering null means the file doesn't exist.
+ */
+export class HostFileSystem extends FileSystem {
+  constructor(private readonly host: ProgramHost) {
+    super(host.useCaseSensitiveFileNames());
+  }
+
+  fileExists(path: string): boolean {
+    const answer = this.host.fileExists?.(path);
+    return answer ?? diskStat(path)?.isDirectory === false;
+  }
+
+  directoryExists(path: string): boolean {
+    const answer = this.host.directoryExists?.(path);
+    return answer ?? diskStat(path)?.isDirectory === true;
+  }
+
+  readFile(path: string): string | undefined {
+    const answer = this.host.readFile?.(path);
+    if (answer === null) return undefined;
+    return answer ?? diskReadFile(path);
+  }
+
+  getAccessibleEntries(path: string): DirectoryEntries {
+    const entries = this.host.getAccessibleEntries?.(path) ?? diskEntries(path);
+    return new DirectoryEntries(entries.files.slice(), entries.directories.slice(), undefined);
+  }
+
+  realpath(path: string): string {
+    return this.host.realpath?.(path) ?? diskRealpath(path);
+  }
+}
+
+/**
+ * The compiler host of a program of tsc-ts's public API. A file that parse threads prepared, reading the disk, is
+ * taken only when the host gives the same text for it; the program parses the host's text otherwise.
+ */
+export class LibraryCompilerHost extends CompilerHost {
+  getSourceFile(
+    fileName: string,
+    path: string,
+    externalModuleIndicatorOptions: ExternalModuleIndicatorOptions,
+  ): SourceFile | undefined {
+    const text = this.readFile(fileName);
+    if (text === undefined) return undefined;
+    return (
+      takePreparedFile(fileName, path, externalModuleIndicatorOptions, text) ??
+      parseSourceFile(fileName, text, new ParseOptions(path, ScriptKind.Unknown, externalModuleIndicatorOptions))
+    );
+  }
+}

package/src/library/index.ts

@@ -5,6 +5,26 @@ export * from './ast.js';
 export * from './enums.generated.js';
 export type { CompilerOptions } from './compiler-options.generated.js';
 export { symbolName } from './symbols.js';
+export { createProgram, createProgramFromConfigFile, getPreEmitDiagnostics, parseConfigFile } from './program.js';
+export { DisposedProgramError, InternalCompilerError } from './errors.js';
+export { parseSourceFile, type ParseSourceFileOptions } from './parse.js';
+export {
+  canHaveModifiers,
+  flattenDiagnosticMessageText,
+  forEachChild,
+  getCombinedModifierFlags,
+  getCombinedNodeFlags,
+  getJSDoc,
+  getLineAndCharacterOfPosition,
+  getLineStarts,
+  getModifiers,
+  getPositionOfLineAndCharacter,
+  getSourceFileOfNode,
+  getTextOfNode,
+  tokenStartOfNode,
+  tokenToString,
+  walkPreorder,
+} from './nodes.js';
 export type {
   __String,
   BigIntLiteralType,
@@ -34,6 +54,7 @@ export type {
   Symbol,
   TemplateLiteralType,
   TupleType,
+  TupleTypeReference,
   Type,
   TypeChecker,
   TypeParameter,