@trim21/personal-pi-extensions 0.1.460 → 0.1.463

package/src/lib/lsp/lsp.ts

@@ -25,6 +25,7 @@ import type { ExtensionAPI, ExtensionUIContext } from "@earendil-works/pi-coding
 import { minimatch } from "minimatch";
 import { type Static, Type } from "typebox";
 import { Value } from "typebox/value";
+import type { WorkspaceEdit } from "vscode-languageserver-types";
 
 import { type LspServerAdapter } from "./adapter.js";
 import {
@@ -32,6 +33,7 @@ import {
   type CreateInput,
   type Diagnostic,
   type Info as LspClient,
+  RenameNotPossibleError,
   WATCH_KIND_CHANGE,
   WATCH_KIND_CREATE,
   WATCH_KIND_DELETE,
@@ -273,6 +275,19 @@ export interface LspService {
     cwd: string,
     options?: LspRequestOptions,
   ): Promise<{ text: string; errorCount: number; warningCount: number }>;
+  /**
+   * 符号重命名：只面向 kind 为 "language" 的服务器（linter 不参与符号级
+   * 功能）；多 client 按配置顺序取第一个成功结果，全部失败时抛聚合错误。
+   * line / character 为 0-based LSP position。
+   */
+  rename(request: {
+    file: string;
+    cwd: string;
+    line: number;
+    character: number;
+    newName: string;
+    options?: LspRequestOptions;
+  }): Promise<{ serverID: string; edit: WorkspaceEdit; placeholder?: string }>;
   shutdownAll(): Promise<void>;
   /** 停止全部服务器并禁用 LSP：之后工具调用不再 spawn，直到 start/reload。 */
   stop(): Promise<void>;
@@ -450,6 +465,7 @@ export function createLspService(
     file: string,
     cwd: string,
     notify?: ExtensionUIContext["notify"],
+    adapterFilter?: (adapter: LspServerAdapter) => boolean,
   ): Promise<LspClient[]> {
     if (state.closing || state.disabled) return [];
     if (!containsPath(file, cwd)) return [];
@@ -466,6 +482,7 @@ export function createLspService(
     }
 
     for (const adapter of active) {
+      if (adapterFilter && !adapterFilter(adapter)) continue;
       if (adapter.extensions.length > 0 && !adapter.extensions.includes(extension)) continue;
       const root = await adapter.findRoot(file, cwd);
       if (!root) continue;
@@ -626,6 +643,53 @@ export function createLspService(
     return { text: report(normalized, issues), errorCount, warningCount };
   }
 
+  /** 符号重命名：只面向 language 类服务器；按配置顺序取第一个成功结果。 */
+  async function rename(request: {
+    file: string;
+    cwd: string;
+    line: number;
+    character: number;
+    newName: string;
+    options?: LspRequestOptions;
+  }): Promise<{ serverID: string; edit: WorkspaceEdit; placeholder?: string }> {
+    const clients = await getClients(
+      request.file,
+      request.cwd,
+      request.options?.notify,
+      (adapter) => adapter.kind !== "linter",
+    );
+    if (clients.length === 0) {
+      throw new RenameNotPossibleError(
+        `no LSP language server available for ${request.file} (check lsp.json servers and kind)`,
+      );
+    }
+    const failures: { serverID: string; error: unknown }[] = [];
+    for (const client of clients) {
+      try {
+        const result = await client.renameSymbol({
+          path: request.file,
+          line: request.line,
+          character: request.character,
+          newName: request.newName,
+        });
+        return {
+          serverID: client.serverID,
+          edit: result.edit,
+          ...(result.placeholder !== undefined && { placeholder: result.placeholder }),
+        };
+      } catch (error) {
+        failures.push({ serverID: client.serverID, error });
+      }
+    }
+    const allNotRenameable = failures.every((f) => f.error instanceof RenameNotPossibleError);
+    const detail = failures
+      .map((f) => `${f.serverID}: ${f.error instanceof Error ? f.error.message : String(f.error)}`)
+      .join("; ");
+    throw allNotRenameable
+      ? new RenameNotPossibleError(detail)
+      : new Error(`LSP rename failed on all servers — ${detail}`);
+  }
+
   /** 关闭全部 client 并清空缓存；closing 置 true 让 in-flight spawn 自行退出。 */
   async function closeAll(): Promise<void> {
     state.closing = true;
@@ -687,6 +751,7 @@ export function createLspService(
     notifyFile,
     diagnostics,
     lspDiagnosticsForFile,
+    rename,
     shutdownAll,
     stop,
     start,

package/src/lib/lsp/rename.ts

@@ -0,0 +1,224 @@
+/**
+ * LSP WorkspaceEdit 应用与 rename 定位辅助。
+ *
+ * - expandWorkspaceEdit：把 rename 返回的 WorkspaceEdit 展开成每文件的
+ *   old/new 文本（纯内存计算，写盘由调用方决定时机与方式）；
+ * - lineCandidates：character 缺省时在一行内按词边界枚举候选位置，
+ *   供逐候选探测消歧；
+ * - canonicalizeEdit：把两次 rename 的结果归一化成稳定字符串，
+ *   比较它们是否指向同一个符号（同名歧义消解）。
+ *
+ * 位置语义按 LSP 规范：0-based 行列，character 为 UTF-16 code unit，
+ * 行内容不含行结束符（CRLF 的 \r 不计入列号）。
+ */
+
+import { normalize } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import type { TextEdit, WorkspaceEdit } from "vscode-languageserver-types";
+
+/** 单个文件展开后的编辑结果。 */
+export interface AppliedFileEdit {
+  readonly path: string;
+  readonly oldText: string;
+  readonly newText: string;
+  readonly changeCount: number;
+}
+
+export interface LspPosition {
+  readonly line: number;
+  readonly character: number;
+}
+
+/** 应用层只关心 range + newText（TextDocumentEdit 的编辑联合的公共形状）。 */
+interface RangeLike {
+  readonly range: { readonly start: LspPosition; readonly end: LspPosition };
+  readonly newText: string;
+}
+
+/** 编辑联合里 SnippetTextEdit 没有 newText，应用层不支持且无法静默处理。 */
+function isRangeLike(edit: unknown): edit is RangeLike {
+  return (
+    typeof edit === "object" &&
+    edit !== null &&
+    "range" in edit &&
+    "newText" in edit &&
+    typeof (edit as { newText: unknown }).newText === "string"
+  );
+}
+
+/** file:// URI → 规范化本地路径；非 file scheme 是服务器的意外行为，直接报错。 */
+function toPath(uri: string): string {
+  if (!uri.startsWith("file:")) {
+    throw new Error(`lsp-rename: unsupported uri scheme: ${uri}`);
+  }
+  return normalize(fileURLToPath(uri));
+}
+
+/** 每行起始偏移（含第 0 行的 0）；换行符是 \n，\r 属于行内容之外由调用侧处理。 */
+function lineStartOffsets(text: string): number[] {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++) {
+    if (text.codePointAt(i) === 10) starts.push(i + 1);
+  }
+  return starts;
+}
+
+/** 行内容长度（不含行结束符，CRLF 时连 \r 一起排除）。 */
+function lineContentLength(text: string, starts: readonly number[], line: number): number {
+  const base = starts[line];
+  let end = line + 1 < starts.length ? starts[line + 1] - 1 : text.length;
+  if (end > base && text.codePointAt(end - 1) === 13) end--;
+  return end - base;
+}
+
+/**
+ * position → 字符串偏移。character 超出行长视为服务器返回了非法位置，
+ * 抛错而不是静默钳制（避免把编辑应用到错误位置）。
+ */
+function positionToOffset(
+  text: string,
+  starts: readonly number[],
+  position: LspPosition,
+  path: string,
+): number {
+  if (position.line < 0 || position.line >= starts.length) {
+    throw new Error(
+      `lsp-rename: edit position out of range in ${path} (line ${position.line + 1})`,
+    );
+  }
+  const base = starts[position.line];
+  const length = lineContentLength(text, starts, position.line);
+  if (position.character < 0 || position.character > length) {
+    throw new Error(
+      `lsp-rename: edit position out of range in ${path} (character ${position.character + 1} on line ${position.line + 1})`,
+    );
+  }
+  return base + position.character;
+}
+
+/** 按起始位置降序应用（后文先改，避免前文编辑使后续偏移失效）。 */
+function applyTextEdits(path: string, text: string, edits: readonly RangeLike[]): string {
+  const starts = lineStartOffsets(text);
+  let result = text;
+  const sorted = edits.toSorted(
+    (a, b) =>
+      b.range.start.line - a.range.start.line || b.range.start.character - a.range.start.character,
+  );
+  for (const edit of sorted) {
+    const start = positionToOffset(text, starts, edit.range.start, path);
+    const end = positionToOffset(text, starts, edit.range.end, path);
+    if (end < start) {
+      throw new Error(`lsp-rename: invalid edit range in ${path} (end before start)`);
+    }
+    result = result.slice(0, start) + edit.newText + result.slice(end);
+  }
+  return result;
+}
+
+/** 把 changes 与 documentChanges 里的 text edit 按（规范化）路径收集；文件级操作报不支持。 */
+function collectTextEdits(edit: WorkspaceEdit): Map<string, RangeLike[]> {
+  const byPath = new Map<string, RangeLike[]>();
+  const push = (path: string, edits: readonly RangeLike[]): void => {
+    const existing = byPath.get(path);
+    if (existing) existing.push(...edits);
+    else byPath.set(path, [...edits]);
+  };
+  for (const [uri, edits] of Object.entries(edit.changes ?? {})) {
+    push(toPath(uri), edits.filter(isRangeLike));
+  }
+  for (const change of edit.documentChanges ?? []) {
+    if ("kind" in change || !("textDocument" in change) || !("edits" in change)) {
+      throw new Error(
+        "lsp-rename: file-level document changes (create/rename/delete) are not supported",
+      );
+    }
+    push(toPath(change.textDocument.uri), change.edits.filter(isRangeLike));
+  }
+  return byPath;
+}
+
+/**
+ * 展开成每文件的新旧文本。readText 由调用方提供（工具层传磁盘读取），
+ * 任一文件读取失败即整体失败，调用方可以安全地"全部算好再写盘"。
+ */
+export async function expandWorkspaceEdit(
+  edit: WorkspaceEdit,
+  readText: (path: string) => Promise<string>,
+): Promise<AppliedFileEdit[]> {
+  const applied: AppliedFileEdit[] = [];
+  for (const [path, edits] of collectTextEdits(edit)) {
+    const oldText = await readText(path);
+    applied.push({
+      path,
+      oldText,
+      newText: applyTextEdits(path, oldText, edits),
+      changeCount: edits.length,
+    });
+  }
+  return applied;
+}
+
+/**
+ * 归一化 WorkspaceEdit 为稳定字符串（URI → 规范路径、结构化字段），供比较
+ * 两次 rename 的编辑集合是否一致（同一符号的多次出现 vs 不同符号）。
+ */
+export function canonicalizeEdit(edit: WorkspaceEdit): string {
+  const changes: Record<string, TextEdit[]> = {};
+  const documentChanges: unknown[] = [];
+  for (const [uri, edits] of Object.entries(edit.changes ?? {})) {
+    changes[toPath(uri)] = edits;
+  }
+  for (const change of edit.documentChanges ?? []) {
+    if ("kind" in change || !("textDocument" in change) || !("edits" in change)) {
+      documentChanges.push(change);
+      continue;
+    }
+    documentChanges.push({
+      textDocument: { uri: toPath(change.textDocument.uri) },
+      edits: change.edits,
+    });
+  }
+  return JSON.stringify({ changes, documentChanges });
+}
+
+const WORD_PATTERN = /[\p{L}\p{N}_$]+/gu;
+
+/**
+ * 一行内 `symbol` 的候选位置（0-based，列相对行首）：
+ * - `character` 缺省：枚举行内与 `symbol` 相同的词出现位置；
+ * - `character` 给定：该列必须落在与 `symbol` 相同的词内（消歧时防改错目标），
+ *   否则抛参数错误。
+ * 该行找不到 `symbol` 时返回空数组。
+ */
+export function symbolCandidates(
+  text: string,
+  line: number,
+  symbol: string,
+  character?: number,
+): LspPosition[] {
+  const starts = lineStartOffsets(text);
+  if (line < 0 || line >= starts.length) return [];
+  const base = starts[line];
+  const length = lineContentLength(text, starts, line);
+  const matches = [...text.slice(base, base + length).matchAll(WORD_PATTERN)];
+  if (character !== undefined) {
+    const target = matches.find((match) => {
+      const start = match.index;
+      return character >= start && character < start + match[0].length;
+    });
+    if (!target || target[0] !== symbol) {
+      const actual = target ? target[0] : "";
+      throw new Error(
+        `character ${character + 1} on line ${line + 1} does not point at symbol '${symbol}'` +
+          (actual === "" ? "" : ` (points at '${actual}')`),
+      );
+    }
+    return [{ line, character: target.index }];
+  }
+  const candidates: LspPosition[] = [];
+  for (const match of matches) {
+    if (match[0] === symbol) candidates.push({ line, character: match.index });
+  }
+  return candidates;
+}

package/src/lib/lsp/server-config.ts

@@ -18,13 +18,20 @@ import { isAbsolute, join, relative, sep } from "node:path";
 import { minimatch } from "minimatch";
 import { type Static, Type } from "typebox";
 
-import { type LspServerAdapter, type LspServerHandle, nearestRoot } from "./adapter.js";
+import {
+  type LspServerAdapter,
+  type LspServerHandle,
+  nearestRoot,
+  type ServerKind,
+} from "./adapter.js";
 import { exists, findBinaryInWorkspace, which } from "./bin.js";
 import { spawnProcess } from "./launch.js";
 
 export const serverConfigSchema = Type.Object({
   /** 文件 glob（相对项目根或调用 cwd，任一命中即可）；缺省匹配所有文件。 */
   include: Type.Optional(Type.Array(Type.String())),
+  /** 服务器类型：language（真语言服务器，缺省）或 linter（只实现 LSP 协议的 lint）。 */
+  kind: Type.Optional(Type.Union([Type.Literal("language"), Type.Literal("linter")])),
   /** 项目根标记文件（从文件目录向上查找）；缺省用调用 cwd 作为根。 */
   rootMarkers: Type.Optional(Type.Array(Type.String())),
   /** 可执行文件：绝对路径、相对调用 cwd 的路径，或名字（项目工作区优先，PATH 兜底）。 */
@@ -111,6 +118,7 @@ function matchesInclude(
 /** 由配置构建的通用 adapter；include 精确过滤在 findRoot 完成，extensions 不设扩展名过滤。 */
 export class ConfigAdapter implements LspServerAdapter {
   readonly id: string;
+  readonly kind: ServerKind;
   readonly extensions: readonly string[] = [];
   readonly startupTimeoutMs: number | undefined;
   readonly diagnosticsWaitMs: number | undefined;
@@ -119,6 +127,7 @@ export class ConfigAdapter implements LspServerAdapter {
   constructor(id: string, config: ServerConfig) {
     this.id = id;
     this.config = config;
+    this.kind = config.kind ?? "language";
     this.startupTimeoutMs = config.startupTimeoutMs;
     this.diagnosticsWaitMs = config.diagnosticsWaitMs;
   }

package/src/lib/path.ts

@@ -47,6 +47,14 @@ export async function resolveWorkdir(workdir: string, baseDir: string): Promise<
   return target;
 }
 
+/** 解析 `~` 前缀与相对路径（相对调用 cwd）；绝对路径原样返回。 */
+export function resolvePathArg(cwd: string, input: string): string {
+  if (input === "~" || input.startsWith("~/")) {
+    return join(homedir(), input.slice(1));
+  }
+  return isAbsolute(input) ? input : resolve(cwd, input);
+}
+
 /** 人类可读的显示路径：cwd 内用 `./…`，home 内用 `~/…`，否则原样绝对路径。 */
 export function formatDisplayPath(cwd: string, filePath: string): string {
   const relToCwd = relative(cwd, filePath);

package/src/lib/write-guard.ts

@@ -113,8 +113,7 @@ export interface WriteGuardOptions {
   /** The resolved absolute target path (caller has already parsed its args). */
   absolutePath: string;
   /**
-   * 待审批的变更内容；缺省时（如 aft_refactor/aft_import 无 preview diff）
-   * 审批对话框不展示 diff 预览，仅按路径审批。
+   * 待审批的变更内容；缺省时审批对话框不展示 diff 预览，仅按路径审批。
    */
   change?: PendingChange;
 }

package/src/aft/import.md

@@ -1,12 +0,0 @@
-### aft_import tool
-
-语言感知的 import 管理：add / remove。
-
-支持 TS, JS, TSX, Python, Rust, Go, Solidity, Java, C#, PHP, Kotlin, Scala, Swift, Ruby, Lua, C, C++, Perl, Vue。
-
-- `add`：添加默认导入（`default_import`）、具名导入（`names`，支持按名 `as` 别名，如 `['useState']`、`['ERC20', 'IERC20 as IToken']`）、命名空间导入（`namespace`，如 `import * as ns from 'mod'`）。
-- `remove`：移除整个 import（只给 `module`），或只移除其中某个具名导入（`remove_name`）。
-- 语言相关修饰符用 `modifiers`（如 Java/C# `static`、Swift `@testable`）；符号类导入用 `import_kind`（如 PHP `function`/`const`、Swift `struct`/`enum`）；仅类型导入用 `type_only`（仅 TS）。
-- `validate`：编辑后校验级别，默认 `syntax`，`full` 做完整校验。
-
-import 排序整理交给 lint（如 import/order + --fix），本工具不负责排序。写操作走路径级审批。

package/src/aft/imports.ts

@@ -1,141 +0,0 @@
-/**
- * aft_import —— language-aware import add / remove。
- *
- * 参数经 bridge.toolCall 以 agent 工具名 "import" 分派，Rust 侧 subc 翻译层
- * 按 op 转成内部命令（add_import / remove_import）。
- * 与 aft_refactor 相同：不支持 preview，写保护为路径级审批。
- */
-
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-
-import { type ToolPendant } from "../lib/pendant.js";
-import { guardWriteAccess } from "../lib/write-guard.js";
-import { callAftTool } from "./bridge.js";
-import {
-  type AftToolContext,
-  bridgeFor,
-  buildPendantMarkdown,
-  compactArgs,
-  resolvePathArg,
-} from "./tools.js";
-
-/** 工具使用指南，以 markdown 形式维护，读起来像文档。 */
-const IMPORT_PROMPT = readFileSync(
-  fileURLToPath(new URL("import.md", import.meta.url)),
-  "utf8",
-).trim();
-
-const IMPORT_OPS = ["add", "remove"] as const;
-const VALIDATE_LEVELS = ["syntax", "full"] as const;
-
-const ImportParams = Type.Object(
-  {
-    op: Type.Union(
-      IMPORT_OPS.map((op) => Type.Literal(op)),
-      { description: "import 操作" },
-    ),
-    path: Type.String({ description: "目标文件路径（绝对或相对项目根）" }),
-    module: Type.Optional(
-      Type.String({ description: "模块路径（add/remove 必填），如 'react'、'./utils'" }),
-    ),
-    names: Type.Optional(
-      Type.Array(Type.String(), {
-        description:
-          "要添加的具名导入，用语言原生的具名导入写法，支持按名 `as` 别名，如 ['useState']、Solidity ['ERC20', 'IERC20 as IToken']",
-      }),
-    ),
-    default_import: Type.Optional(Type.String({ description: "默认导入名（仅 ES），如 'React'" })),
-    namespace: Type.Optional(
-      Type.String({
-        description:
-          "命名空间绑定：`import * as ns from 'mod'`（ES）、`* as N from \"./X.sol\"`（Solidity）",
-      }),
-    ),
-    alias: Type.Optional(
-      Type.String({ description: '整模块别名。Solidity：`import "./X.sol" as X`' }),
-    ),
-    modifiers: Type.Optional(
-      Type.Array(Type.String(), {
-        description:
-          "语句级修饰符，按语言校验：Java/C# 'static'、C# 'global'/'unsafe'、Java/Kotlin/Scala 'wildcard'、Swift '@testable'",
-      }),
-    ),
-    import_kind: Type.Optional(
-      Type.String({
-        description:
-          "符号类导入：PHP 'function'/'const'、Swift 'struct'/'class'/'enum'、Scala 'given'",
-      }),
-    ),
-    remove_name: Type.Optional(
-      Type.String({ description: "要移除的具名导入；缺省移除整个 import" }),
-    ),
-    type_only: Type.Optional(Type.Boolean({ description: "仅类型导入（仅 TS）" })),
-    validate: Type.Optional(
-      Type.Union(
-        VALIDATE_LEVELS.map((level) => Type.Literal(level)),
-        {
-          description: "编辑后校验级别（默认 syntax）",
-        },
-      ),
-    ),
-  },
-  { additionalProperties: false },
-);
-
-export function registerImportTool(pi: ExtensionAPI, ctx: AftToolContext): void {
-  pi.registerTool({
-    name: "aft_import",
-    label: "aft_import",
-    description: [
-      "语言感知的 import 管理：add / remove。",
-      "支持 TS, JS, TSX, Python, Rust, Go, Solidity, Java, C#, PHP, Kotlin, Scala, Swift, Ruby, Lua, C, C++, Perl, Vue。",
-      "add：添加默认/具名/命名空间导入；remove：移除具名导入或整个 import。",
-      "import 排序整理交给 lint（如 import/order + --fix），本工具不负责。",
-    ].join("\n"),
-    promptSnippet: "Language-aware import add / remove",
-    promptGuidelines: [IMPORT_PROMPT],
-    parameters: ImportParams,
-    async execute(_id, params, _signal, _onUpdate, extCtx) {
-      if (params.module === undefined || params.module.trim() === "") {
-        throw new Error(`'module' is required for '${params.op}' op`);
-      }
-
-      const filePath = resolvePathArg(extCtx.cwd, params.path);
-      await guardWriteAccess(extCtx, { toolName: "aft_import", absolutePath: filePath });
-
-      const rawArgs = compactArgs({
-        op: params.op,
-        path: filePath,
-        module: params.module,
-        names: params.names,
-        defaultImport: params.default_import,
-        namespace: params.namespace,
-        alias: params.alias,
-        modifiers: params.modifiers,
-        importKind: params.import_kind,
-        removeName: params.remove_name,
-        typeOnly: params.type_only,
-        validate: params.validate,
-      });
-
-      const { text } = await callAftTool(bridgeFor(ctx), "import", rawArgs, extCtx);
-      return {
-        content: [{ type: "text", text }],
-        details: {
-          files: [filePath],
-          pendant: {
-            markdown: buildPendantMarkdown({
-              title: "aft_import",
-              input: params,
-              output: text,
-            }),
-          } satisfies ToolPendant,
-        },
-      };
-    },
-  });
-}

package/src/aft/refactor.md

@@ -1,53 +0,0 @@
-### aft_refactor tool
-
-workspace-wide 重构：跨文件移动符号、抽函数、内联，自动更新引用与 import。
-
-- `move`：把顶层符号（非嵌套函数/类方法）移到另一个文件，全 workspace 重写 import 与引用。需要 `symbol` + `destination`；同名符号歧义时用 `scope` 消歧。
-- `extract`：把行区间抽成新函数（TS/JS/TSX、Python）。需要 `name` + `start_line` + `end_line`（1 起，含端点）。
-- `inline`：把调用点替换为函数体。需要 `symbol` + `call_site_line`（1 起）。
-
-重构前先看影响面：对目标符号跑 aft_callgraph `impact`，确认波及范围符合预期再动手。
-
-#### 示例
-
-`path` 相对项目根，行号 1 起且含端点。
-
-跨文件移动顶层符号，自动重写全部 import 与引用：
-
-```json
-{
-  "op": "move",
-  "path": "src/aft/tools.ts",
-  "symbol": "buildPendantMarkdown",
-  "destination": "src/lib/pendant.ts"
-}
-```
-
-把行区间抽成新函数（先用 aft_outline 或 Read 定位区间）：
-
-```json
-{
-  "op": "extract",
-  "path": "src/aft/refactor.ts",
-  "name": "buildRefactorArgs",
-  "start_line": 121,
-  "end_line": 134
-}
-```
-
-`start_line` / `end_line` 指 `path` 文件里被抽取的代码，不是新函数所在的行。
-
-内联单个调用点：
-
-```json
-{
-  "op": "inline",
-  "path": "src/aft/refactor.ts",
-  "symbol": "requireField",
-  "call_site_line": 98
-}
-```
-
-`call_site_line` 是调用发生的那一行，不是函数定义行；只替换指定那一处，内联掉全部调用点后原定义不会被自动删除，需要自己清理。
-
-只支持顶层符号；嵌套函数与类方法不适用。