计算机是怎么长出来的
总目录/ 第 1 部/ 1.6 把程序做出来的一套工具/ 1.6.1

1.6.1 编辑器与 IDE:补全、跳转和语法高亮是怎么做到的

约 0.7 万字 · 6 张图 · 读完你能说清编辑器眼里代码是什么、 补全凭什么猜、跳转为什么有时跳到错的地方, 以及为什么同一个编辑器换个插件就能变成另一种语言的 IDE

你在编辑器里敲下 foo.,半秒内弹出一个列表。 光标下面那 20 个候选,全是你此刻能用的成员,而且常用的排在前面。

这件事快得像呼吸,所以很少有人问它凭什么。 可真要拆开,它至少要知道五件事: foo 是什么(一个变量?一个模块?)、 它是什么类型、 这个类型上有哪些成员、 哪些在这个位置可见(私有的、没导入的不能出现)、 哪个更常用。 而这一切必须在一百毫秒内完成——超过这个数,你的手指已经敲下一个键了。

这一节就拆这条链。拆完之后你会发现,编辑器里那些「聪明」的功能, 底下其实是很朴素的三样东西:一份文本、一棵语法树、一张符号表。 所有的聪明,都花在「怎么让这三样东西跟得上你的手指」上。

本节的小部分

  1. 1 代码在编辑器眼里是什么
  2. 2 语法高亮:为什么它经常错
  3. 3 补全的四层
  4. 4 补全为什么有时候很准,有时候很傻
  5. 5 LSP:把「懂语言」外包出去
  6. 6 跳转定义:为什么有时跳错
  7. 7 改一个字符之后发生了什么
  8. 8 编辑器必须能容忍半截代码
  9. 9 那条 100 毫秒的时间链
  10. 10 IDE 到底是什么
  11. 11 它撑不起什么
  12. 12 收尾:它知道语法,不知道意图

1.6.1-1代码在编辑器眼里是什么

第一个反直觉的事实:编辑器里没有「代码」,只有字符。 打开一个 .py 文件,磁盘上是一串字节,编辑器读进来是一串字符, 再加上一个光标位置。仅此而已。

你在屏幕上看到的缩进、括号配对、变量名变色,都是画上去的。 编辑器内部同时维护着三样东西,从下往上:

三层示意图:最上面是 let x = a + 1; 的逐字符格子,中间是切成 let/x/=/a/+/1/; 七个带类型的词法单元,最下面是一棵语法树,根为变量声明,子节点为标识符 x 和加法,加法下面挂着标识符 a 和数字 1
图 1.6.1-1 同一行代码的三种形态。越往下结构越多,越往下也越慢。字符层是 O(1) 就能定位的(第 12 个字符就是第 12 个),词法层要扫一遍,语法树要跑完整的解析。编辑器的大部分性能问题,都是「该用哪一层」的选择题:光标移动只碰第一层,改名要碰第三层。

三个层次各有各的用途,也各有各的代价:

层次怎么来的用来干什么代价
字符文件内容本身显示、光标、选区、复制粘贴几乎为零
词法单元按规则切词语法高亮的底色、括号匹配一行几微秒
语法树按语法规则组装补全、跳转、重命名、格式化一个文件几十毫秒

在字符这一层,还有一个容易被忽略的设计问题:文本用什么结构存。 最直觉的做法是一个字符数组,但那意味着在文件开头插一个字符,要把后面几百万个字符全部往后挪一位。 所以真实的编辑器都不用数组,而是用「片段表」(piece table) 或者「绳」(rope): 把文本切成若干块,插入只是在块的列表里加一条记录,删除只是标记某一块不显示。 改一个字符的开销从 O(n) 降到 O(1),这是编辑器能流畅编辑大文件的前提。

为什么这事值得说: 因为「文本」这个抽象看起来太自然了,自然到让人以为它没有实现成本。 实际上 VS Code 打开一个 100 MB 的文件还能滚动,靠的就是片段表 + 视口渲染: 内存里只有块结构,屏幕上只画可见的那几十行。 换成朴素实现,光是打开就要几秒。

1.6.1-2语法高亮:为什么它经常错

语法高亮看着像「给不同东西涂不同颜色」,其实是「判断每一段字符属于什么语法成分」。 判断得准不准,取决于它有没有真的理解这段代码。

两条色带对比同一行代码 char *s = "// 不是注释"; 上面按语法树着色,整段字符串是绿色;下面按逐行正则着色,字符串里的双斜杠之后被涂成棕色,标注为被误认成注释
图 1.6.1-2 同一行代码,两种着色方式。上面先解析再上色,下面按行套正则。下面那条的错误很典型:正则看到 // 就认定注释开始,它不知道这两个斜杠此刻正在一个字符串里。这类错误在模板字符串、原始字符串、多行注释里同样常见。

绝大多数编辑器(包括 VS Code)默认用的是逐行正则这条路, 也就是 TextMate 语法:一套嵌套的匹配规则,每一行独立套一遍。 它有三个明显的好处:快(一行几微秒)、简单(写个 JSON 就是一套语法)、 能容忍任何文件(哪怕是语法错误的、二进制的、超大的)。

代价就是图里那种错误。要修正它,只有一条路:真的解析。 可解析一个文件要几十毫秒,打开大文件时不能这么干。 于是现代编辑器普遍用分层的办法:

第一层:TextMate 正则给全文铺底色   ——  保证任何文件都能瞬间打开
第二层:tree-sitter 解析可见区域      ——  只算屏幕上那几十行
第三层:语言服务器的语义着色          ——  异步到达,覆盖前两层的结果

所以你会看到一个很有意思的现象:刚打开文件时颜色是「大概对」的, 滚动几下之后变准了,再过一两秒又变了一次。 那不是错觉,是三层结果依次到达。第三层最准(它知道这个符号到底是变量还是类型), 但也最慢(要跨文件查符号表)。

1.6.1-3补全的四层

补全列表里的候选,来源不止一个。按「看到的信息多少」排,可以分成四层:

四级台阶图:从低到高依次是词法补全(同一份文件里出现过的词)、语法补全(当前作用域能看见的符号)、语义补全(对象的类型上有哪些成员)、跨文件补全(整个项目加依赖库的符号),越高的台阶代价越贵
图 1.6.1-3 补全的四层,越准的越贵。底下两层几乎不要钱,上面两层要建索引。真实编辑器是四层叠着用的:先用词法结果垫底(保证一定有东西弹出来),再用语义结果往上盖。这就是为什么候选列表里偶尔会混进一两个不该出现的词——那是底层兜底兜上来的。

四层各自能回答的问题不一样:

层它知道什么典型表现
词法这个词在文件里出现过输入 str 就冒出 string、strlen、my_str,不管它们此刻可不可见
语法这个词在当前位置的作用域里函数内的局部变量会出现,别的函数里的不会
语义这个对象的类型上有哪些成员敲 foo. 之后,只有 foo 类型的方法和字段
跨文件别的文件里定义、并且被导入了的符号敲 Math. 能列出标准库的成员

候选出来之后还要排序,这一步对体验的影响比想象中大。 常见的权重是:前缀完全匹配 > 驼峰缩写匹配(gfi 匹配 getFileInfo)> 最近用过 > 在同类上下文里用得多 > 字母序。 排序错了,用户就会觉得「这编辑器不懂我」,哪怕候选其实全对。

1.6.1-4补全为什么有时候很准,有时候很傻

同一个编辑器,写 TypeScript 时补全准得像读心,写 JavaScript 时经常给一堆没用的东西。 差别不在编辑器,在语言能不能被静态分析。

在 TypeScript 里写下 const x: User = ...,编辑器立刻知道 x 是 User, User 有哪些字段在类型定义里写着。敲 x. 就是把字段列表抄一遍,准确率接近 100%。

换成 JavaScript:

const x = getUser();   // getUser 返回什么?类型信息里没写
x.                     // 这里能点什么,编辑器真的不知道

它只能做两件事:一是去读 getUser 的函数体,看看它 return 了什么 (如果函数在同一个项目里、并且没有一堆分支返回不同类型);二是把当前作用域里所有名字都列出来让你自己挑。 第二种就是「傻」的来源——不是它不想聪明,是它手上真的没有信息。

这也是为什么 Python 的类型注解(def f(x: int) -> str:)这几年越来越流行: 注解对运行时的程序毫无影响,但对编辑器来说是雪中送炭。 加了注解,补全立刻从「猜」变成「查」。

一句话记住: 补全的质量,取决于「写代码的时候能不能确定类型」。 静态类型语言天然能做到,动态类型语言要靠注解、靠推断、靠运行时观察。 这不是编辑器的能力差异,是语言把信息留在了哪个阶段的差异。

1.6.1-5LSP:把「懂语言」外包出去

2016 年之前,每个编辑器要支持一门语言,就得为它写一个插件。 N 个编辑器 × M 门语言 = N×M 份工作,而且每份都从头实现一遍词法、语法、类型推导。 这件事浪费了全世界程序员大量的时间。

语言服务器协议(LSP)把这件事拆成了两半: 编辑器只管「按键、光标、渲染」,语言服务器只管「懂这门语言」, 中间用一套标准的 JSON-RPC 消息通信。

左右两个盒子:左边是编辑器,负责按键、光标、渲染;右边是语言服务器,负责词法、语法、类型、索引;中间用双向箭头连接,标着 JSON-RPC 以及 completion、definition、hover 这些请求
图 1.6.1-4 LSP 的分工。编辑器不用懂 C++,语言服务器不用懂怎么画光标。中间那套协议只定义了「问什么、答什么」,没规定怎么实现。所以 clangd 可以用 C++ 写,tsserver 用 TypeScript 写,pyright 用 Python 写,编辑器全都能接。

协议本身很朴素,就是几条消息:

编辑器 → 服务器   initialize                 我打开了这个项目,这些是配置
编辑器 → 服务器   textDocument/didOpen        这个文件打开了,内容给你
编辑器 → 服务器   textDocument/didChange      我改了这几行(增量)
编辑器 → 服务器   textDocument/completion     光标在这儿,给候选
服务器 → 编辑器   (响应)                    这是候选列表,带类型和文档
编辑器 → 服务器   textDocument/definition     这个符号定义在哪
服务器 → 编辑器   (响应)                    file:///.../user.ts, 第 42 行

分成两个进程带来三个好处,每一个都很实际:

一是崩了不拖累。 语言服务器要解析的是你正在写的、随时处于半截状态的代码,崩溃是常态。 它在自己的进程里崩,编辑器还在,你保存一下,服务器重新拉起来。 如果全在一个进程里,那就是整个编辑器一起没。

二是语言无关。 同一个 VS Code,装 clangd 就是 C++ IDE,装 pyright 就是 Python IDE, 编辑器一行代码不用改。这就是为什么现在「编辑器 + LSP」的组合能通吃所有语言。

三是可以换实现。 嫌官方服务器慢,换一个同样说 LSP 的实现就行,编辑器那边完全无感。 协议成了生态的接口,实现之间可以竞争。

1.6.1-6跳转定义:为什么有时跳错

「跳转到定义」听起来比补全简单,其实它更难,因为要先回答「这个同名符号到底是哪一个」。

最原始的做法是全文搜索同名文本,这也是 ctags 时代的做法: 扫一遍所有文件,把所有函数名、变量名和它们的位置记下来,跳转就是查表。 它快、简单、任何语言都能用,但它不知道作用域。

void f() { int i = 0; ... }     // 这个 i
void g() { int i = 0; ... }     // 和这个 i,是两个毫不相干的变量

// 在 g 里对 i 点「跳转到定义」,全文搜索会给你两个结果

正经的做法要用到符号表 + 作用域链: 解析的时候记下每个符号属于哪个作用域,查找时从内层往外层逐级找, 找到第一个就停。这样两个 i 就不会混。

但即便这样,还是有一批情况跳不准,而且每一门语言都有自己的坑:

情况为什么难结果
函数重载同名函数有五个版本,要按参数类型选可能跳到「最像」的那个,而不是真正调用的那个
宏 / 模板展开之后才是真正的代码,展开前不存在C++ 里经常跳到宏定义,而不是宏展开后的符号
动态派发obj.method() 运行时才知道 obj 是谁只能列出所有可能的实现让你选
反射 / 字符串调用名字是拼出来的,静态看不见完全跳不了

这也解释了一个常见困惑:为什么同一个项目里,有的地方跳转很准,有的地方一跳就跑到奇怪的地方。 不是编辑器坏了,是那段代码超出了静态分析能覆盖的范围。 C++ 项目里这种情况最多,因为宏和模板能把「代码长什么样」推迟到编译期才确定。

比跳转更能暴露问题的是重命名。跳转错了你还能看出来,重命名错了是悄悄改坏。 它要把「所有引用这个符号的地方」全换掉,而这里有两个坑:

一是阴影。内层作用域可以定义一个和外层同名的变量, 这时候改外层不能动内层:

int count = 0;              // 改名要动这个
void f() {
    int count = 10;         // 这个同名,但不是同一个符号,不能动
    count++;                // 这个 ++ 属于内层的 count
}

二是同名但无关。变量叫 name,某个结构体里也有个字段叫 name, 还有一处日志字符串里写着 "name"。前两个是不同符号(一个不能动),后一个根本不是符号(是文本)。 靠全文替换,三处全改;靠符号表,只会改该改的那一处。

所以「重命名」这个功能,是检验一个编辑器的语言分析到底做得多深的试金石。 它比补全严格得多:补全错了你换个候选就行,重命名错了要回滚整个提交。

1.6.1-7改一个字符之后发生了什么

打字是连续的。你敲一个字母,语法树就过时了;再敲一个,又过时。 如果每次按键都全文重解析,一个两千行的文件要 200 毫秒——每敲一个字母卡 0.2 秒,没法用。

文件被切成五个函数块,第三个被改动。全量重解析要把五块全部重算;增量重解析只重算第三块,其余四块原样复用。底部对比:全量约 200 毫秒,增量约 3 毫秒
图 1.6.1-5 改一行,不需要整个文件重解析。只重建被改动的那一支,旁边几支连碰都不用碰。这就是 tree-sitter 这类增量解析器的核心思想:语法树上的每个节点记住自己的区间,改动只让「覆盖改动点的那条路径」失效,其余子树直接复用。3 毫秒和 200 毫秒的差别,就是「打字有延迟感」和「打字跟手」的差别。

增量解析的关键是给树的每个节点记一个区间(从第几个字符到第几个字符)。 改动进来时,从根往下找,凡是区间覆盖了改动点的节点就标记为「脏」, 其余节点原样保留。然后只对脏的那条路径重新解析。

这条路径通常是「改动点到根」,长度等于树的深度, 在正常代码里也就十几层。所以重解析的代价与文件大小无关,只与改动处嵌套多深有关。 改一个顶层语句,可能只碰 3 个节点;改一个深层表达式,可能碰 20 个。

除了增量解析,还有一道「防抖」:你连续打字的时候,编辑器不会每个键都算一次, 而是等键盘安静下来 30 到 50 毫秒再动手。 这不是偷懒,是把「打字速度」和「分析速度」解耦—— 人打字最快也就每秒十来个键,30 毫秒的等待完全感觉不到,但省掉了九成的重复计算。

1.6.1-8编辑器必须能容忍半截代码

这是编辑器和编译器最根本的区别,值得单独说。

编译器遇到语法错误会怎么办?报一行 expected ';' before '}',然后退出。 它没有义务理解一段不合法的人代码。

编辑器不行。你正在打字,代码永远处于「半截」状态: 括号没闭合、引号没配对、函数写了一半。如果解析器一遇到错误就放弃, 那你的编辑体验就是:只要有一个语法错误,整个文件所有的高亮、补全、跳转全部消失。

所以编辑器用的解析器必须能错误恢复:遇到不认识的 token 就跳过, 遇到缺失的括号就虚拟补一个,然后继续往下解析。 目标是「尽量多理解一点,而不是一遇到问题就全盘放弃」。

你正在打的代码:
  function f() {
    const x = foo(          ← 括号还没闭合,光标在这儿

编译器的反应:语法错误,终止。
编辑器的反应:假装这里有个 ),继续解析下面的内容,
              于是上面的 function 和 const 依然能被识别,
              补全依然知道 x 是什么。

这解释了一个很多人遇到过的现象:IDE 里代码标着红波浪线,但补全照样能用。 红色是「这里有错」,补全能用是「除了这里,其他地方我都读懂了」。 两件事互不干扰,因为它们背后是同一棵「带错误节点」的语法树。

1.6.1-9那条 100 毫秒的时间链

回到开头那个动作。从你敲下 . 到列表出现,中间要走完整条链:

横向时间线:按键事件 1 毫秒,防抖等待 30 毫秒,增量解析 5 毫秒,查符号表 2 毫秒,类型推导 18 毫秒,过滤排序 3 毫秒,渲染列表 10 毫秒,合计 69 毫秒,在 100 毫秒卡顿线以内
图 1.6.1-6 敲下 . 之后的 69 毫秒。防抖那 30 毫秒占了四成多,但它是划算的:用确定的 30 毫秒延迟,换掉「每敲一个字母都跑一遍完整分析」的不确定开销。最长的一段是类型推导 18 毫秒,这也是大项目里最容易超标的一步——项目一大,类型关系变成一张大网,推一个变量可能要翻几十个文件。

100 毫秒这个数不是随便定的,它是人机交互研究里那个著名的阈值: 超过 100 毫秒,人就会觉得「卡了一下」;超过 1 秒,注意力就跑了。 所以几乎所有编辑器的性能预算都按这个数来分。

超标了怎么办?三条路,按性价比排:

一是缓存。 文件解析结果缓存(改之前不用重算)、类型信息缓存(同一个类型不用推两次)、 符号索引缓存(跨文件查找不用每次扫全项目)。缓存是性价比最高的一招, 代价是要处理「什么时候失效」——这是所有缓存bug的来源。

二是异步 + 渐进。 先弹一个粗略的列表(词法层,1 毫秒就能出), 等语义结果到了再替换成精确的。你看到的「列表先闪一下再变」,就是这个策略。

三是降级。 文件太大(比如超过 10 MB)就关掉语法树相关的功能,只留高亮和基本编辑。 这不是偷懒,是明确告诉用户「这个文件我不做深度分析了」,好过让整个编辑器卡死。

1.6.1-10IDE 到底是什么

IDE 这个词被用得越来越泛,但它原本指的东西很具体: 把写代码需要的几件事集成到一个界面里—— 编辑、构建、调试、版本控制、还有「懂这门语言」的各种分析。

按「语言能力放在哪儿」,现在的 IDE 大致分两派:

形态语言能力在哪启动代表
重量级 IDE编辑器自己进程里,启动时就建索引慢,几十秒Visual Studio、CLion、IntelliJ
编辑器 + LSP外部语言服务器,按需加载快,一秒内VS Code、Neovim、Emacs

两种形态没有绝对优劣,取舍很清楚: 重量级 IDE 用启动时间换「打开就能用」, 索引在启动时建好,之后的补全和跳转都是内存查表,延迟极低; 轻量编辑器用「首次使用时等一下」换启动速度, 你打开一个 C++ 项目,clangd 会在后台花一两分钟建索引,这期间补全是不准的。

近几年的趋势是往后者走,原因不是技术更先进,是项目形态变了: 微服务、多语言、容器化之后,一个开发者一天里要在三四种语言、十几个仓库之间跳。 为每种语言装一个重量级 IDE 已经不现实了,一个编辑器配一堆语言服务器更省事。

这里有个很多人踩过的坑:语言服务器需要一份「这个项目怎么编译」的配置。 C++ 的 clangd 要 compile_commands.json, TypeScript 要 tsconfig.json,Python 要知道用哪个解释器、哪些目录在搜索路径上。

没有这份配置会发生什么?语言服务器只能猜。它猜不到 #include "foo.h" 里的 foo.h 到底在哪个目录,于是那个头文件里定义的类全部变成「未知类型」, 于是补全给不出成员,跳转跳不过去,整个项目的体验断崖式下跌。

同一份代码、同一个编辑器,配上配置和没配配置,体验能差到像两个产品。 这也是为什么「我的 IDE 不好用」的抱怨里,有相当一部分其实是配置问题—— 工具没坏,是它一直没拿到干活需要的信息。

1.6.1-11它撑不起什么

编辑器很聪明,但它的聪明有明确的边界。四件事它做不到:

它不知道你的意图。 补全能告诉你 deleteUser 这个函数存在、接受一个 id、返回 boolean, 但它不知道你此刻是想删用户还是想查用户。它给的是「语法上合法的候选」, 不是「你心里想写的那个」。

首次索引要等。 大型 C++ 项目(比如 Chromium)用 clangd 建一次索引要十几分钟到几十分钟。 这期间跳转和补全都是残缺的。这不是实现不好,是「把几十万个文件解析一遍」这件事本身就这么贵。

动态语言天然不准。 前面说过,Python、Ruby、JavaScript 的补全质量受限于「类型信息在运行时才确定」。 加注解能改善,但注解覆盖率不高的项目,补全就只能靠猜。

宏和代码生成会让静态分析失效。 代码不是手写的,是生成的(protobuf、ORM、模板引擎), 静态分析看不到生成后的样子。所以很多项目里,生成代码的补全和跳转是坏的。

一个实用推论: 如果你发现某个项目的补全和跳转特别不准,先别怀疑编辑器。 按顺序查三件事:索引建完了没(看语言服务器的状态)、 项目配置对不对(编译参数、include 路径、Python 解释器)、 代码是不是生成的。九成的问题出在这三处,而不是工具。

1.6.1-12收尾:它知道语法,不知道意图

这一节从头到尾讲的是同一件事:编辑器把「文本」变成了「结构」。 字符变词法单元,词法单元变语法树,语法树加符号表变成「能回答问题」的东西。 补全、跳转、重命名、找引用,全都是在这套结构上做的查询。

而所有的工程复杂度,都来自一个矛盾: 结构要准确,就得慢慢解析;而人的手指不会等。 增量解析、防抖、分层高亮、异步补全、缓存、降级—— 这些手段没有一个是「让解析变快」,全都是「让用户感觉不到解析的存在」。

但它终究只知道语法。它能告诉你「这个函数接受两个参数」, 不能告诉你「你传的这两个参数是不是反了」; 能告诉你「这行代码永远不会被执行」,不能告诉你「这是不是你想要的结果」。 要回答后一类问题,得让程序真的跑起来,然后在中途停下来看。 那就是下一节的事:调试器。

自测:能答上 6 题,这一节就算过了

  1. 编辑器内部为什么要用片段表或绳,而不是一个字符数组?
  2. 同一行 char *s = "// 不是注释";,为什么逐行正则会把后面涂错?
  3. 既然正则不准,为什么大多数编辑器还是默认用它?
  4. 补全的四层分别需要什么信息?为什么最底层一定要保留?
  5. 同样是 obj.,为什么写 TypeScript 时补全比 JavaScript 准?
  6. LSP 把编辑器分成两个进程,三个好处分别是什么?
  7. 两个函数里各有一个 i,全文搜索为什么会跳错?正确的做法靠什么?
  8. 增量解析为什么能做到「代价与文件大小无关」?
  9. 编辑器遇到语法错误为什么不放弃,它是怎么继续的?
  10. 为什么 IDE 里代码标红,补全却还能用?
  11. 补全链路超标时,三条应对手段按性价比怎么排?
  12. 重量级 IDE 和「编辑器 + LSP」的核心取舍是什么?
点开看答案(先自己想,别急着点)
  1. 因为数组插入要在内存里挪动后面所有元素,O(n);文件开头插一个字符就要挪几百万个。片段表把文本切成块,插入只是在块列表里加一条记录,O(1)。这是编辑器能流畅编辑大文件的前提。
  2. 因为正则的工作单位是「一行」,它没有跨行的状态记忆。看到 // 就认定注释开始,不知道这两个斜杠此刻在一个未闭合的字符串里。它缺的不是规则,是「上文」。
  3. 因为快,而且够用。打开 50 MB 的日志文件也能瞬间上色;换成完整解析要几十秒。代价是偶尔颜色错,而大多数人能忍。现代编辑器用「正则铺底 + 可见区域重解析」来折中。
  4. 词法层要知道「这个词出现过」,语法层要知道「作用域」,语义层要知道「类型」,跨文件层要知道「项目里有什么」。最底层必须保留,因为它能在任何情况下都给出候选,保证补全不会「什么都不弹」。
  5. 因为 TypeScript 有类型标注,编辑器能直接查到 x 是 User、User 有哪些字段;JavaScript 没有类型信息,只能靠读函数体猜,或者把作用域里所有名字都列出来。
  6. 一是语言服务器崩了不会拖死编辑器;二是编辑器不用为每门语言改代码,装个服务器就支持新语言;三是协议成了接口,实现可以互相替换。
  7. 因为全文搜索不知道作用域,两个 i 在它眼里是同一个名字。正确做法是解析时建符号表,记录每个符号属于哪个作用域,查找时从内层往外层逐级找,找到第一个就停。
  8. 因为每个节点都记着自己的字符区间。改动只让「覆盖改动点的那条路径」失效,这条路径的长度是树的深度(十几层),与文件总行数无关。其余子树直接复用。
  9. 因为编辑器必须能容忍半截代码——你打字时括号永远可能没闭合。它的解析器会跳过不认识的 token、虚拟补上缺失的括号,然后继续。目标是尽量多理解,而不是一遇错就全盘放弃。
  10. 因为红色和补全背后是同一棵「带错误节点的语法树」。红色表示「这个节点有问题」,补全用的是树的其他部分,那部分解析得好好的,互不干扰。
  11. 缓存(最划算,但要处理失效)、异步渐进(先给粗略结果再替换)、降级(大文件关掉深度分析)。缓存排第一,因为它通常能砍掉九成的重复计算。
  12. 重量级 IDE 用启动时间换「打开就能用」(索引在启动时建好);编辑器 + LSP 用「首次使用时等索引」换启动速度。近年后者的组合更流行,因为一个开发者一天要在多语言、多仓库之间跳。
← 1.5.4 复杂度:为什么有的程序一秒钟能做完,有的要一年