《TypeScript高级编程》5.1 TypeScript Compiler API 入门

import ts from "typescript";
import { readFileSync } from "node:fs";

const code = readFileSync("./src/index.ts", "utf8");
const sf = ts.createSourceFile(
  "index.ts",              // 文件名，参与相对路径解析与诊断定位
  code,                    // 源码文本
  ts.ScriptTarget.ESNext,  // 解析目标，影响可选链等语法的解析方式
  true,                    // setParentNodes：是否给每个节点挂 parent 指针
  ts.ScriptKind.TS         // TS / TSX / JS / JSX，决定 <T> 是泛型还是 JSX
);

console.log(sf.statements.length); // 顶层语句数量，例如 7
console.log(sf.languageVersion);   // 99（ScriptTarget.ESNext 的枚举值）

import ts from "typescript";

const configPath = ts.findConfigFile("./", ts.sys.fileExists, "tsconfig.json");
if (!configPath) throw new Error("找不到 tsconfig.json");

const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
const parsed = ts.parseJsonConfigFileContent(
  configFile.config,
  ts.sys,
  "./"   // 基准目录，决定 include 里相对路径的解析起点
);

const program = ts.createProgram(parsed.fileNames, parsed.options);
const checker = program.getTypeChecker();

const host = ts.createCompilerHost(parsed.options);
const originalRead = host.readFile;
host.readFile = (fileName) =>
  fileName === "virtual.ts" ? "export const x = 1;" : originalRead(fileName);

function walk(node: ts.Node, depth = 0): void {
  const indent = "  ".repeat(depth);
  console.log(`${indent}${ts.SyntaxKind[node.kind]}`);
  ts.forEachChild(node, (child) => walk(child, depth + 1));
}

walk(sf);

function collectFunctions(node: ts.Node, out: ts.FunctionDeclaration[] = []) {
  if (ts.isFunctionDeclaration(node) && node.name) {
    out.push(node); // 此处 node 已被收窄为 ts.FunctionDeclaration
  }
  ts.forEachChild(node, (child) => collectFunctions(child, out));
  return out;
}

const fns = collectFunctions(sf);
console.log(fns.map((f) => f.name!.text)); // ['main', 'helper']

node.getText();                     // 需要 parent 指针，返回含前后 trivia 的文本
sf.text.slice(node.pos, node.end);  // 裸切片，不依赖 parent，但包含前导注释
node.getStart(sf);                  // 去掉前导 trivia 的起始偏移，常与 getText 配合

const type = checker.getTypeAtLocation(node);
console.log(checker.typeToString(type)); // 'string | undefined'

// 打印完整类型，不省略长联合
const full = checker.typeToString(type, node, ts.TypeFormatFlags.NoTruncation);
console.log(full); // 'string | undefined | null | { id: number; }'

function dumpExports(program: ts.Program, entry: string) {
  const checker = program.getTypeChecker();
  const sf = program.getSourceFile(entry);
  if (!sf) return;

  const moduleSymbol = checker.getSymbolAtLocation(sf);
  if (!moduleSymbol) return;

  for (const sym of checker.getExportsOfModule(moduleSymbol)) {
    const type = checker.getTypeOfSymbolAtLocation(sym, sf);
    console.log(`${sym.name}: ${checker.typeToString(type)}`);
  }
}

const diagnostics = ts.getPreEmitDiagnostics(program);

for (const d of diagnostics) {
  if (d.file && d.start !== undefined) {
    const { line, character } = d.file.getLineAndCharacterOfPosition(d.start);
    const msg = ts.flattenDiagnosticMessageText(d.messageText, "\n");
    console.log(`${d.file.fileName}:${line + 1}:${character + 1} - ${msg}`);
  } else {
    console.log(ts.flattenDiagnosticMessageText(d.messageText, "\n"));
  }
}

const host: ts.FormatDiagnosticsHost = {
  getCanonicalFileName: (f) => f,
  getCurrentDirectory: () => process.cwd(),
  getNewLine: () => "\n",
};

console.log(ts.formatDiagnosticsWithColorAndContext(diagnostics, host));

console.log(d.code, ts.DiagnosticCategory[d.category]);
// 2345 'Error' —— 与 tsc 输出里的 TS2345 完全一致

const host = ts.createIncrementalCompilerHost(parsed.options);
const builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
  parsed.fileNames,
  parsed.options,
  host
);

// 下次只要传入上一次的 builder，就只重算受影响的文件
const next = builder.getProgram();
console.log(next.getSourceFiles().length);

import ts from "typescript";

const entry = process.argv[2];
const configPath = ts.findConfigFile("./", ts.sys.fileExists, "tsconfig.json")!;
const { config } = ts.readConfigFile(configPath, ts.sys.readFile);
const { options, fileNames } = ts.parseJsonConfigFileContent(config, ts.sys, "./");

const program = ts.createProgram(fileNames, options);
const checker = program.getTypeChecker();

const sf = program.getSourceFile(entry);
if (!sf) throw new Error(`文件不在编译范围内：${entry}`);

const mod = checker.getSymbolAtLocation(sf);
if (!mod) throw new Error(`不是模块（缺少 import/export）：${entry}`);

const rows = checker.getExportsOfModule(mod).map((sym) => {
  const t = checker.getTypeOfSymbolAtLocation(sym, sf);
  return { name: sym.name, type: checker.typeToString(t) };
});

console.table(rows);