✨ feat(vscode): 代码阅读的链式调用卡片：语言插件读链、翻译模板排成起点和步骤

契约加 LanguageAdapter.chain、Translator.chain、RuleContext.chain、PropertyRow.chain、TextTranslation.rows；跨行写或实参里有闭包的链排成卡片，连着同名调用合成一步列出每次实参，注释挂在步骤上，闭包收起、子块挂到那一步（BlockView.step）；Rust 插件读链、标准库常见方法写中文名；挤成一行时另起一行的 . 贴着前面

vscode/src/codeReader/contract.ts

@@ -392,6 +392,60 @@ export interface CallFacts {
   arguments: CallArgument[]
 }
 
+/**
+ * 链式调用里收起来的一个实参：主体是语句块（或只有一个 match）的闭包、async 块。主体里的各句是这条语句的子块，挂在这一步下面；
+ * 卡片上它收成一行「闭包 |参数| · N 句」，点开才看见那些子块。
+ */
+export interface DeferredFacts {
+  /** closure 是闭包，async 是 async 块 */
+  kind: 'closure' | 'async'
+  /** 闭包的参数表（`|app, event|` 整个）；async 块没有 */
+  parameters?: Node
+  /** 主体里写了几句，注释不算 */
+  statements: number
+  /** 主体只有一个 match（`|app, event| match event { … }`）时：整个 match、它匹配的那个值、有几支 */
+  match?: { node: Node, value: Node, arms: number }
+}
+
+/** 链里一步的一个实参，照源码顺序；注释不算。 */
+export interface ChainArgument {
+  /** 整个实参 */
+  node: Node
+  /** 实参是闭包、async 块（不管主体怎么写）：实参里有它的链写在一行里也排成卡片 */
+  closure: boolean
+  /** 收起来的闭包、async 块（见 [DeferredFacts]）；别的实参没有 */
+  deferred?: DeferredFacts
+}
+
+/** 链式调用的一步：`.方法(实参)`，连同紧跟在调用后面的 `.await`、`?`。 */
+export interface ChainStepFacts {
+  /** 方法名前面的 `.`：它和上一步的结尾（第一步是起点）不在同一行，这条链就是跨行写的 */
+  dot: Node
+  method: Node
+  /** 方法名后面写的泛型实参（`::<Vec<_>>`）；没写没有 */
+  typeArguments?: Node
+  /** 这一步的调用，从链的开头算起（`a.b(…).c(…)` 整个） */
+  call: Node
+  /** 括号连同里面的实参 */
+  argumentList: Node
+  arguments: ChainArgument[]
+  /** 跟在调用后面的 `.await`、`?` 各套的那一层（Rust 的 await_expression、try_expression），从里往外 */
+  after: Node[]
+  /** 写在这一步前面（上一步和 `.` 之间）的注释，照源码顺序 */
+  comments: Node[]
+}
+
+/**
+ * 链式调用（`tauri::Builder::default().plugin(…).setup(…)`、`rows.iter().filter(…).collect()`）：语言插件从语法树读出结构
+ * （[LanguageAdapter.chain]），翻译插件把它排成链式调用卡片（见 [ChainStep]）。节点都指向源码。
+ */
+export interface ChainFacts {
+  /** 链最前面的接收者或起始表达式（`tauri::Builder::default()`、`rows`） */
+  start: Node
+  /** 照源码顺序，至少两步 */
+  steps: ChainStepFacts[]
+}
+
 /**
  * 命令的一个重定向：把输出（1）、错误输出（2）或两样都写到 / 追加到一个文件，并进另一路，或从文件读输入。
  * `>&2` 是输出并进错误输出，`2>/dev/null` 是错误输出写到 /dev/null。
@@ -623,9 +677,10 @@ export interface Segment { text: string, role: TokenRole, offset?: number, refer
  * - condition：按条件（渲染大纲里 `cond &&` 的「当 … 时」、三元的「如果 …」），图标、颜色同「条件」块；
  * - branch：条件的一支（三元的「是」「否」），颜色同「条件」块，不带图标；
  * - tag：小标签（名称后面的「具名导出」、属性名后面的「回调」），只有框头的字，颜色是 SegmentGroup.color；
- * - classes：收起来的一串类名（「样式 N 个类」），中性色，点开、悬停看 SegmentGroup.detail。
+ * - classes：收起来的一串类名（「样式 N 个类」），中性色，点开、悬停看 SegmentGroup.detail；
+ * - fold：链式调用卡片里收起来的闭包、async 块（见 [DeferredFacts]），框头是「闭包」，框里是参数和句数，点它展开、收起这一步下面挂着的子块。
  */
-export type GroupStyle = 'iteration' | 'condition' | 'branch' | 'tag' | 'classes'
+export type GroupStyle = 'iteration' | 'condition' | 'branch' | 'tag' | 'classes' | 'fold'
 
 /**
  * 框起来的一组词：译文里自成一体的一段（写在表达式里的遍历、渲染大纲一行前面的条件），预览把它画成嵌在前后文字里的一个小框，
@@ -717,6 +772,8 @@ export interface PropertyRow extends Defines {
   note?: Markdown
   items?: PropertyItem[]
   columns?: string[]
+  /** 值是一条链式调用的起点时，链的各步：排成一条竖轨道，接在值下面（见 [ChainStep]）。 */
+  chain?: ChainStep[]
 }
 
 /** 一张带表头和边框的表：列名，每行几列对齐的格子，同 PropertyRow 给了 columns 的子行。 */
@@ -725,6 +782,53 @@ export interface PreviewTable {
   items: PropertyItem[]
 }
 
+/**
+ * 链式调用卡片的一步，排在竖轨道上：方法那一列、值那一列，下面依次是小链、几行属性、表，再是挂在这一步下面的子块
+ * （实参里收起来的闭包、async 块的主体，宿主挂，见 BlockView.step）。连着几次调用同一个方法的合成一步；
+ * 库规则还能把连着的几步合成一步、起叫法、换成表（见 [ChainGroup]）。
+ */
+export interface ChainStep {
+  /**
+   * 方法那一列：`.名字`，名字带源码下标。翻译插件、库规则起了叫法的写叫法（遍历、启动时）：悬停看原来的方法名，
+   * ⌘ / Ctrl + 点击跳到方法的定义（[Segment] 的 refers）。
+   */
+  name: Inline[]
+  /**
+   * 值那一列：实参照抄成一行（名字带源码下标），`.await`、`?` 照常翻、接在后面，收起来的闭包、async 块是一个 fold 框；
+   * 合成的一步是「N 次」，规则换掉的照规则的（命令名）。
+   */
+  value: Inline[]
+  /** 值那一列下面缩进的一条小链，一节一行：实参本身是一条链（第一行是它的起点），或规则合成的几步不同的方法（一步一行） */
+  lines?: Inline[][]
+  /** 这一步下面的几行属性，属性名在方法那一列：写在这一步上面的注释 */
+  rows?: PropertyRow[]
+  /** 合成的一步每次调用的实参（一行一次），或规则换成的表（插件 | 配置） */
+  table?: PreviewTable
+  /** 这一步在源码里的范围（`.` 到这一步的结尾，合成的一步到最后一次）：宿主按它把实参里闭包体的子块挂到这一步下面。 */
+  range: SourceRange
+}
+
+/** 一条链排成的样子（[Translator.chain]）：起点照抄成一行，各步见 [ChainStep]。 */
+export interface ChainView {
+  start: Inline[]
+  steps: ChainStep[]
+}
+
+/**
+ * 库规则给一条链的读法：把第 `from` 到第 `to` 步（[ChainFacts] 的 steps 下标，含两头）合成一步，起叫法，可以换掉值、换成表。
+ * 只起叫法的一步 `from` 等于 `to`。
+ */
+export interface ChainGroup {
+  from: number
+  to: number
+  /** 这一步的叫法，规则自己的用词 */
+  label: string
+  /** 换掉值那一列；不给时一步的照常是实参，几步的空着、每步一行排成小链（见 [ChainStep] 的 lines） */
+  value?: Inline[]
+  /** 换成的表，给了就不排小链 */
+  table?: PreviewTable
+}
+
 /**
  * 一行译文的块翻出来的：一行译文（注释块是 Markdown 说明）；预览排在这一行下面的，跨几行写的字面量是拆开的各项（items，同 PropertyItem.items），
  * 跨几行写的调用是摊开各个实参的表（table）。
@@ -733,6 +837,11 @@ export interface TextTranslation {
   text: PreviewText
   items?: PropertyItem[]
   table?: PreviewTable
+  /**
+   * 排在这一行下面的几行属性：整句是一条该排成卡片的链式调用时是「起点」「步骤」两行，链的各步在「步骤」那一行上（PropertyRow.chain）；
+   * text 这时只剩链外面的词（「返回」），没有就是空的。
+   */
+  rows?: PropertyRow[]
 }
 
 /**
@@ -766,6 +875,11 @@ export interface LanguageAdapter {
   call?: (node: Node) => CallFacts | undefined
   /** node 是写出各项的字面量（字典、列表……）时给出它的各项，别的节点没有；没给的语言不拆字面量，照常一行译文。 */
   collection?: (node: Node) => CollectionFacts | undefined
+  /**
+   * node 是两步以上的链式调用（`a.b(…).c(…)`，最外面可以套着 `.await`、`?`）时给出它的结构，别的节点没有；
+   * 没给的语言不排链式调用卡片，照常一行译文。排不排成卡片归翻译插件（跨行写、实参里有闭包才排）。
+   */
+  chain?: (node: Node) => ChainFacts | undefined
   /** node 是执行一条命令（shell）时给出它的结构，交给命令规则读；别的节点没有，没有命令的语言不填。 */
   command?: (node: Node) => CommandFacts | undefined
   /** 一份源码里自己认得出的名字（见 LocalSymbol）；VS Code 有这种语言的定义、高亮提供者时用不上，不填。 */
@@ -876,6 +990,11 @@ export interface Translator {
    * 拆出块标签；正文同属性表的「说明」。几条行文档注释连成一段的（Rust 的 `///`），node 是第一条，翻译插件自己往下连。没有文字时没有。
    */
   doc: (node: Node, document: SourceDocument) => Doc | undefined
+  /**
+   * 语言插件认得出的链式调用（[LanguageAdapter.chain]）排成链式调用卡片的样子，不管它值不值得排成卡片：库规则拿它改叫法（`groups`，见 [ChainGroup]）。
+   * node 不是链时没有；不给就不排链式调用卡片，照常一行。
+   */
+  chain?: (node: Node, document: SourceDocument, groups?: readonly ChainGroup[]) => ChainView | undefined
   /** 筛选属性和值叫什么，和属性表里的属性名、值用同一套叫法；不给就都显示 id。 */
   attributeNames?: AttributeNames
 }
@@ -1095,6 +1214,11 @@ export interface RuleContext {
   verbatim: (node: Node, role?: TokenRole) => Inline[]
   /** 用当前翻译插件读一段说明文字（Translator.doc）：正文和块标签；没有翻译插件、没有文字时没有。 */
   doc: (node: Node) => Doc | undefined
+  /**
+   * 用当前翻译插件把一条链式调用排成链式调用卡片（[Translator.chain]），`groups` 是规则自己的读法（见 [ChainGroup]）：
+   * 结构从 `document.language.chain` 读，步的下标同它。不是链、翻译插件不排链时没有。
+   */
+  chain: (node: Node, groups?: readonly ChainGroup[]) => ChainView | undefined
   /**
    * 源码里 name 这个名字（例如 raise 后面的异常类名）指的定义在 index 里认出的那一项，规则从定义处读出的值在 IndexEntry.value 里：
    * 定义由语言扩展查（同 ⌘ + 点击），落在 index 认出的某一项的名字上才算；同一份源码里同名的名字按一处查。