tsc-ts 0.0.3 → 0.0.5

package/src/library/ast.ts

@@ -0,0 +1,104 @@
+// The hand-written node types of tsc-ts's public API; the node interfaces are generated in
+// ast.generated.ts (scripts/generate-api.mjs). They describe tsc-ts's own nodes, which the API hands
+// out as they are: every node has its kind, flags, position and parent, and its children in the fields
+// TypeScript 7's AST names. Lists are NodeList objects.
+
+import type {
+  EndOfFile,
+  EntityName,
+  Identifier,
+  KeywordSyntaxKind,
+  ModifierSyntaxKind,
+  NoSubstitutionTemplateLiteral,
+  PropertyAccessExpression,
+  PunctuationSyntaxKind,
+  Statement,
+  StringLiteral,
+  ThisExpression,
+  Token,
+} from './ast.generated.js';
+import type { LanguageVariant, ModifierFlags, NodeFlags, ScriptKind, SyntaxKind } from './enums.generated.js';
+
+export interface TextRange {
+  readonly pos: number;
+  readonly end: number;
+}
+
+/**
+ * A node. `pos` is where the node's leading trivia starts and `end` where the node ends, as UTF-16
+ * offsets into the file's text; `tokenStartOfNode` gives the start of its first token. `parent` is the
+ * enclosing node, and the source file for its statements; a source file's `parent` is undefined.
+ */
+export interface Node extends TextRange {
+  readonly kind: SyntaxKind;
+  readonly flags: NodeFlags;
+  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. */
+export interface NodeList<T extends Node = Node> extends TextRange {
+  readonly nodes: readonly T[];
+  /** Whether a comma follows the last node before the list's end. */
+  hasTrailingComma(): boolean;
+}
+
+/** The modifiers of a declaration, with the flags of all of them. */
+export interface ModifierList<T extends Node = Node> extends NodeList<T> {
+  readonly modifierFlags: ModifierFlags;
+}
+
+/** A `/// <reference path>`, `types` or `lib` directive. */
+export interface FileReference extends TextRange {
+  readonly fileName: string;
+  /** The `resolution-mode` attribute: ModuleKind.ESNext, ModuleKind.CommonJS, or ModuleKind.None without one. */
+  readonly resolutionMode: number;
+  readonly preserve: boolean;
+}
+
+export interface LineAndCharacter {
+  /** 0-based line number. */
+  readonly line: number;
+  /** 0-based character offset, in UTF-16 code units, from the start of the line. */
+  readonly character: number;
+}
+
+export interface SourceFile extends Node {
+  readonly kind: SyntaxKind.SourceFile;
+  readonly statements: NodeList<Statement>;
+  readonly endOfFileToken: EndOfFile;
+  readonly text: string;
+  readonly fileName: string;
+  /** The file's path: its absolute, normalized file name, lower-cased where file names are case-insensitive. */
+  readonly path: string;
+  readonly languageVariant: LanguageVariant;
+  readonly scriptKind: ScriptKind;
+  readonly isDeclarationFile: boolean;
+  readonly referencedFiles: readonly FileReference[];
+  readonly typeReferenceDirectives: readonly FileReference[];
+  readonly libReferenceDirectives: readonly FileReference[];
+  /** The module specifiers of the file's imports, exports, `require` calls and import types, in source order. */
+  readonly imports: readonly Node[];
+  readonly moduleAugmentations: readonly Node[];
+  readonly ambientModuleNames: readonly string[];
+  /** The first import or export that makes the file a module, or undefined for a script. */
+  readonly externalModuleIndicator: Node | undefined;
+}
+
+export type PunctuationToken<TKind extends PunctuationSyntaxKind> = Token<TKind>;
+export type KeywordToken<TKind extends KeywordSyntaxKind> = Token<TKind>;
+export type ModifierToken<TKind extends ModifierSyntaxKind> = KeywordToken<TKind>;
+
+export interface PropertyAccessEntityNameExpression extends PropertyAccessExpression {
+  readonly expression: EntityNameExpression;
+  readonly name: Identifier;
+}
+
+export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;
+export type StringLiteralLike = StringLiteral | NoSubstitutionTemplateLiteral;
+export type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression;
+
+export interface JsxTagNamePropertyAccess extends PropertyAccessExpression {
+  readonly expression: Identifier | ThisExpression | JsxTagNamePropertyAccess;
+}
+
+export * from './ast.generated.js';

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/compiler-options.generated.ts

@@ -0,0 +1,114 @@
+// Generated by scripts/generate-api.mjs from typescript-go _packages/native-preview/src/api/compilerOptions.ts (TypeScript 7.0.2).
+// TypeScript is Copyright Microsoft Corporation, licensed under Apache-2.0. Do not edit.
+
+import type { JsxEmit } from './enums.generated.js';
+import type { ModuleDetectionKind } from './enums.generated.js';
+import type { ModuleKind } from './enums.generated.js';
+import type { ModuleResolutionKind } from './enums.generated.js';
+import type { NewLineKind } from './enums.generated.js';
+import type { ScriptTarget } from './enums.generated.js';
+
+// Keep in sync with compileroptions.go, obviously
+
+export interface CompilerOptions {
+  allowJs?: boolean;
+  allowArbitraryExtensions?: boolean;
+  allowImportingTsExtensions?: boolean;
+  allowNonTsExtensions?: boolean;
+  allowUmdGlobalAccess?: boolean;
+  allowUnreachableCode?: boolean;
+  allowUnusedLabels?: boolean;
+  assumeChangesOnlyAffectDirectDependencies?: boolean;
+  checkJs?: boolean;
+  customConditions?: string[];
+  composite?: boolean;
+  emitDeclarationOnly?: boolean;
+  emitBOM?: boolean;
+  emitDecoratorMetadata?: boolean;
+  declaration?: boolean;
+  declarationDir?: string;
+  declarationMap?: boolean;
+  deduplicatePackages?: boolean;
+  disableSizeLimit?: boolean;
+  disableSourceOfProjectReferenceRedirect?: boolean;
+  disableSolutionSearching?: boolean;
+  disableReferencedProjectLoad?: boolean;
+  erasableSyntaxOnly?: boolean;
+  exactOptionalPropertyTypes?: boolean;
+  experimentalDecorators?: boolean;
+  forceConsistentCasingInFileNames?: boolean;
+  isolatedModules?: boolean;
+  isolatedDeclarations?: boolean;
+  ignoreConfig?: boolean;
+  ignoreDeprecations?: string;
+  importHelpers?: boolean;
+  inlineSourceMap?: boolean;
+  inlineSources?: boolean;
+  init?: boolean;
+  incremental?: boolean;
+  jsx?: JsxEmit;
+  jsxFactory?: string;
+  jsxFragmentFactory?: string;
+  jsxImportSource?: string;
+  lib?: string[];
+  libReplacement?: boolean;
+  locale?: string;
+  mapRoot?: string;
+  module?: ModuleKind;
+  moduleResolution?: ModuleResolutionKind;
+  moduleSuffixes?: string[];
+  moduleDetection?: ModuleDetectionKind;
+  newLine?: NewLineKind;
+  noEmit?: boolean;
+  noCheck?: boolean;
+  noErrorTruncation?: boolean;
+  noFallthroughCasesInSwitch?: boolean;
+  noImplicitAny?: boolean;
+  noImplicitThis?: boolean;
+  noImplicitReturns?: boolean;
+  noEmitHelpers?: boolean;
+  noLib?: boolean;
+  noPropertyAccessFromIndexSignature?: boolean;
+  noUncheckedIndexedAccess?: boolean;
+  noEmitOnError?: boolean;
+  noUnusedLocals?: boolean;
+  noUnusedParameters?: boolean;
+  noResolve?: boolean;
+  noImplicitOverride?: boolean;
+  noUncheckedSideEffectImports?: boolean;
+  outDir?: string;
+  paths?: Record<string, string[]>;
+  preserveConstEnums?: boolean;
+  preserveSymlinks?: boolean;
+  project?: string;
+  resolveJsonModule?: boolean;
+  resolvePackageJsonExports?: boolean;
+  resolvePackageJsonImports?: boolean;
+  removeComments?: boolean;
+  rewriteRelativeImportExtensions?: boolean;
+  reactNamespace?: string;
+  rootDir?: string;
+  rootDirs?: string[];
+  skipLibCheck?: boolean;
+  stableTypeOrdering?: boolean;
+  strict?: boolean;
+  strictBindCallApply?: boolean;
+  strictBuiltinIteratorReturn?: boolean;
+  strictFunctionTypes?: boolean;
+  strictNullChecks?: boolean;
+  strictPropertyInitialization?: boolean;
+  stripInternal?: boolean;
+  skipDefaultLibCheck?: boolean;
+  sourceMap?: boolean;
+  sourceRoot?: string;
+  suppressOutputPathCheck?: boolean;
+  target?: ScriptTarget;
+  traceResolution?: boolean;
+  tsBuildInfoFile?: string;
+  typeRoots?: string[];
+  types?: string[];
+  useDefineForClassFields?: boolean;
+  useUnknownInCatchVariables?: boolean;
+  verbatimModuleSyntax?: boolean;
+  maxNodeModuleJsDepth?: number;
+}

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 [];
+  }
+}