LSP 开发指南 / 第 8 章：代码动作

{
  "jsonrpc": "2.0",
  "id": 30,
  "method": "textDocument/codeAction",
  "params": {
    "textDocument": { "uri": "file:///src/main.py" },
    "range": {
      "start": { "line": 10, "character": 4 },
      "end": { "line": 10, "character": 15 }
    },
    "context": {
      "diagnostics": [
        {
          "range": {
            "start": { "line": 10, "character": 4 },
            "end": { "line": 10, "character": 15 }
          },
          "severity": 1,
          "source": "my-lsp",
          "message": "Undefined variable 'old_name'",
          "code": "undefined-variable"
        }
      ],
      "only": ["quickfix"]
    }
  }
}

{
  "jsonrpc": "2.0",
  "id": 30,
  "result": [
    {
      "title": "Rename to 'new_name'",
      "kind": "quickfix",
      "diagnostics": [
        {
          "range": { "start": { "line": 10, "character": 4 }, "end": { "line": 10, "character": 15 } },
          "severity": 1,
          "message": "Undefined variable 'old_name'"
        }
      ],
      "edit": {
        "changes": {
          "file:///src/main.py": [
            {
              "range": {
                "start": { "line": 10, "character": 4 },
                "end": { "line": 10, "character": 15 }
              },
              "newText": "new_name"
            }
          ]
        }
      }
    },
    {
      "title": "Add import for 'old_name'",
      "kind": "quickfix",
      "diagnostics": [],
      "command": {
        "title": "Add import",
        "command": "myLsp.addImport",
        "arguments": ["old_name", "file:///src/main.py"]
      }
    }
  ]
}

connection.onRequest("textDocument/codeAction", (params) => {
  const doc = docManager.get(params.textDocument.uri);
  if (!doc) return [];

  const actions: CodeAction[] = [];

  // 根据诊断生成 Quick Fix
  for (const diagnostic of params.context.diagnostics) {
    if (diagnostic.code === "undefined-variable") {
      const match = diagnostic.message.match(/Undefined variable '(\w+)'/);
      if (match) {
        const varName = match[1];

        // Quick Fix 1：自动导入
        actions.push({
          title: `Import '${varName}' from available modules`,
          kind: "quickfix",
          diagnostics: [diagnostic],
          edit: {
            changes: {
              [params.textDocument.uri]: [
                {
                  range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
                  newText: `import ${varName}\n`,
                },
              ],
            },
          },
        });

        // Quick Fix 2：拼写建议
        const suggestions = findSimilarNames(doc, varName);
        for (const suggestion of suggestions) {
          actions.push({
            title: `Rename to '${suggestion}'`,
            kind: "quickfix",
            diagnostics: [diagnostic],
            edit: {
              changes: {
                [params.textDocument.uri]: [
                  {
                    range: diagnostic.range,
                    newText: suggestion,
                  },
                ],
              },
            },
          });
        }
      }
    }
  }

  return actions;
});

function provideExtractFunctionAction(
  doc: TextDocumentItem,
  range: Range
): CodeAction | null {
  const selectedText = getTextInRange(doc.text, range);
  if (!selectedText || selectedText.trim().length === 0) return null;

  // 检查选区是否适合提取
  if (!isExtractable(selectedText)) return null;

  const funcName = "extracted_function";
  const indent = getIndentAtLine(doc.text, range.start.line);
  const params = findFreeVariables(doc.text, range);

  const funcDef =
    `${indent}def ${funcName}(${params.join(", ")}):\n` +
    selectedText
      .split("\n")
      .map((line) => "    " + line)
      .join("\n") +
    "\n\n";

  const funcCall = `${funcName}(${params.join(", ")})`;

  return {
    title: "Extract to function",
    kind: "refactor.extract",
    edit: {
      changes: {
        [doc.uri]: [
          // 在选区前插入函数定义
          {
            range: { start: range.start, end: range.start },
            newText: funcDef,
          },
          // 替换选区为函数调用
          {
            range: range,
            newText: funcCall,
          },
        ],
      },
    },
  };
}

function provideExtractVariableAction(
  doc: TextDocumentItem,
  range: Range
): CodeAction | null {
  const selectedText = getTextInRange(doc.text, range);
  if (!selectedText || !isExpression(selectedText)) return null;

  const varName = "extractedVar";
  const indent = getIndentAtLine(doc.text, range.start.line);

  const edits: TextEdit[] = [
    // 在当前行前插入变量声明
    {
      range: { start: { line: range.start.line, character: 0 }, end: { line: range.start.line, character: 0 } },
      newText: `${indent}${varName} = ${selectedText}\n`,
    },
    // 替换表达式为变量引用
    {
      range: range,
      newText: varName,
    },
  ];

  return {
    title: `Extract to variable '${varName}'`,
    kind: "refactor.extract",
    edit: {
      changes: { [doc.uri]: edits },
    },
  };
}

// Server 声明 Code Lens 支持
capabilities: {
  codeLensProvider: {
    resolveProvider: true,
  },
}

// 提供 Code Lens
connection.onRequest("textDocument/codeLens", (params) => {
  const doc = docManager.get(params.textDocument.uri);
  if (!doc) return [];

  const lenses: CodeLens[] = [];
  const lines = doc.text.split("\n");

  for (let i = 0; i < lines.length; i++) {
    const line = lines[i];

    // 类定义：显示 "X references" 和 "X implementations"
    const classMatch = line.match(/^class\s+(\w+)/);
    if (classMatch) {
      const className = classMatch[1];

      lenses.push({
        range: {
          start: { line: i, character: line.indexOf(className) },
          end: { line: i, character: line.indexOf(className) + className.length },
        },
        command: {
          title: "references",  // 初始显示，resolve 后更新
          command: "",
        },
        data: { type: "references", name: className, uri: params.textDocument.uri },
      });

      lenses.push({
        range: {
          start: { line: i, character: line.indexOf(className) },
          end: { line: i, character: line.indexOf(className) + className.length },
        },
        command: {
          title: "implementations",
          command: "",
        },
        data: { type: "implementations", name: className, uri: params.textDocument.uri },
      });
    }

    // 函数定义：显示引用数
    const funcMatch = line.match(/^(?:def|function)\s+(\w+)/);
    if (funcMatch) {
      lenses.push({
        range: {
          start: { line: i, character: line.indexOf(funcMatch[1]) },
          end: { line: i, character: line.indexOf(funcMatch[1]) + funcMatch[1].length },
        },
        command: { title: "references", command: "" },
        data: { type: "references", name: funcMatch[1], uri: params.textDocument.uri },
      });
    }
  }

  return lenses;
});

// 懒加载解析
connection.onRequest("codeLens/resolve", async (codeLens) => {
  const { type, name, uri } = codeLens.data;

  if (type === "references") {
    const refs = await findAllReferences(name, uri);
    codeLens.command = {
      title: `${refs.length} reference${refs.length !== 1 ? "s" : ""}`,
      command: "editor.action.showReferences",
      arguments: [uri, codeLens.range.start, refs],
    };
  } else if (type === "implementations") {
    const impls = await findAllImplementations(name, uri);
    codeLens.command = {
      title: `${impls.length} implementation${impls.length !== 1 ? "s" : ""}`,
      command: "editor.action.showReferences",
      arguments: [uri, codeLens.range.start, impls],
    };
  }

  return codeLens;
});

connection.onRequest("textDocument/codeAction", (params) => {
  const actions: CodeAction[] = [];

  // 整理导入
  actions.push({
    title: "Organize imports",
    kind: "source.organizeImports",
    edit: organizeImports(docManager.get(params.textDocument.uri)),
  });

  // 删除未使用的导入
  actions.push({
    title: "Remove unused imports",
    kind: "source.removeUnusedImports",
    edit: removeUnusedImports(docManager.get(params.textDocument.uri)),
  });

  // 添加所有缺失的导入
  actions.push({
    title: "Add all missing imports",
    kind: "source.addMissingImports",
    edit: addMissingImports(docManager.get(params.textDocument.uri)),
  });

  return actions;
});

// 1. 首次返回不带 edit 的轻量动作
connection.onRequest("textDocument/codeAction", (params) => {
  return [
    {
      title: "Extract to method",
      kind: "refactor.extract",
      // 不包含 edit —— 延迟加载
    },
  ];
});

// 2. 用户选中后再解析 edit
connection.onRequest("codeAction/resolve", async (action) => {
  // 此时才计算具体的编辑内容
  const edit = await computeExtractMethodEdit(action);
  return { ...action, edit };
});

{
  "capabilities": {
    "codeActionProvider": {
      "codeActionKinds": ["quickfix", "refactor", "source"],
      "resolveProvider": true
    }
  }
}