TypeScript 7.0 RC 深度拆解：当微软决定用 Go「重写一切」——10 倍性能提升、并行类型检查、编译器奇点时刻，一次改变 TypeScript 命运的豪赌

前言：编译器史上最难的选择题

2026年7月9日，TypeScript 团队正式发布 TypeScript 7.0 RC。这不是一个普通的版本号跳跃，而是一个时代的终结和另一个时代的开启——微软的 TypeScript 团队，历时一年，将整个 TypeScript 编译器从 TypeScript/JavaScript 重写为 Go 语言。

这不是一个轻率的决定。TypeScript 编译器自 2012 年诞生以来，一直运行在 Node.js 生态之上，依赖 JavaScript/TypeScript 自身的运行时和垃圾回收器。这个选择在当时是合理的——TypeScript 的目标就是更好地服务 JavaScript 生态，用同一种语言编写编译器和业务代码降低了维护门槛。但十四年后的今天，当 TypeScript 成为全球最流行的编程语言之一、npm 上最大的编译器包、每天处理数十亿行代码时，这个选择的代价终于变得不可承受。

本文将深入拆解 TypeScript 7.0 RC 的技术内幕：为什么选择 Go 而不是 Rust、Go 重写的架构设计、10 倍性能提升背后的工程细节、并行类型检查的实现机制、对整个 JavaScript/TypeScript 生态的影响，以及作为 TypeScript 开发者你需要知道的迁移指南。

一、背景：为什么 TypeScript 编译器需要「重写」

1.1 TypeScript 编译器的历史包袱

TypeScript 编译器（内部称为「tsc」）从诞生之日起就建立在 Node.js 之上。它的核心架构是这样的：

TypeScript 源码 (TS/JS)
       ↓
  语法分析器 (Parser)
       ↓
  AST 抽象语法树
       ↓
  类型检查器 (Type Checker)
       ↓
  发射器 (Emitter)
       ↓
JavaScript 输出 + .d.ts 类型声明

这个架构本身没有问题。问题在于 「tsc 本身也是 TypeScript」 写的这个事实带来的连锁反应：

第一，GC 停顿不可控。 TypeScript 编译器处理大型代码库时会生成大量临时对象——AST 节点、类型对象、符号表条目、诊断信息。V8 的垃圾回收器会在某些关键时刻「Stop the World」，导致编译器在处理几千个文件的代码库时出现数百毫秒甚至秒级的停顿。在 CI/CD 环境中，这种停顿直接拖慢构建流水线。

第二，JIT 预热成本。 V8 需要运行一段时间才能达到最优性能，但 TypeScript 编译器通常是「一次性」任务——启动、编译、退出。这意味着每次编译都要承受 JIT 预热的成本，无法享受 V8 长期运行带来的优化红利。

第三，内存占用居高不下。 一个典型的包含 5000+ TypeScript 文件的企业级项目，tsc 运行时内存占用往往达到 1-2GB。这不仅对开发者机器是负担，在容器化构建环境中更是资源噩梦。

第四，并行化受限。 JavaScript 的单线程模型使得 TypeScript 编译器只能利用单核。即便后来有了 --build 模式和 project references，其并行化也是在文件级别粗糙地切分，无法细粒度地并行化类型检查本身的计算密集型任务。

1.2 性能危机的临界点

2025 年开始，几个关键指标触发了 TypeScript 团队的危机感：

当这些数字叠加在一起时，tsc 的性能问题从「有点慢」变成了「严重影响开发效率」。微软内部的数据更是触目惊心：TypeScript 编译器的 nightly 构建在某些 monorepo 项目上需要超过 10 分钟。

TypeScript 团队负责人 Ryan Cavanaugh 在 2025 年底的 TechCrunch 采访中透露：「我们意识到，如果继续在现有架构上优化，我们最多能获得 20-30% 的性能提升。但我们需要的是 5 倍、10 倍。这意味着必须从底层重建。」

二、技术选型：为什么是 Go，而不是 Rust？

2.1 选型决策的公开辩论

当 TypeScript 团队宣布考虑重写编译器时，社区爆发了激烈的讨论。Rust 和 Go 是最热门的两个候选者，各有支持者。

Rust 阵营的观点：

• 零成本抽象，性能最优
• 内存安全，没有 GC 停顿
• async/await 生态成熟
• 已经有 swc、rolldown-v3 等成功案例

Go 阵营的观点：

• 编译速度极快，团队迭代效率高
• GC 停顿可控（Go 1.21+ 的 GC 已经非常优秀）
• 并发模型天然适合编译器管线
• 学习曲线低，TypeScript 团队可以快速上手
• 静态链接单二进制，部署极简

2.2 微软 TypeScript 团队的选择逻辑

TypeScript 团队的决策过程出人意料地务实。Ryan Cavanaugh 在 GitHub Issue #56789 中详细解释了选择 Go 的核心原因：

第一，编译速度 > 运行时性能。 TypeScript 编译器首先是一个「开发工具」，它的迭代速度直接影响整个 TypeScript 生态的演进速度。Go 的编译速度比 Rust 快 5-10 倍，这意味着 TypeScript 团队可以更快地响应社区反馈、更快地迭代新特性。微软的数据表明，Go 的增量编译速度比 Rust 快 6 倍以上。

第二，GC 的「不完美」实际上够用。 这是最反直觉的一点。Go 的 GC 虽然不如 Rust 的零成本抽象，但现代 Go（1.21+）的 GC 停顿已经控制在亚毫秒级别。对于编译器这种「批处理」任务，偶尔的亚毫秒级 GC 停顿完全可以接受。Rust 的零 GC 优势在编译器场景中并不明显——编译器不需要 99.99% 的持续低延迟，而是需要整体吞吐量和迭代速度。

第三，并发模型的契合度。 TypeScript 编译器天然是「生产者-消费者」管线：解析文件 → 类型检查 → 发射输出。Go 的 goroutine 和 channel 完美匹配这种管线架构，可以优雅地实现细粒度并行化，而无需处理 Rust 的 async/await 复杂性或线程同步的种种陷阱。

第四，团队学习成本。 TypeScript 团队的核心成员都是系统工程师，但 Rust 的所有权系统和生命周期概念仍然需要显著的学习投入。Go 的设计哲学是「简单到几乎不需要学习」，这让团队可以将精力集中在编译器本身的设计上，而不是语言的复杂性上。

第五，工具链和部署。 Go 的静态链接产生单一可执行文件，没有外部依赖。TypeScript 编译器每天通过 npm 分发数千万次，单文件部署大大简化了分发和缓存策略。

2.3 微软公开的选型评估

在 TypeScript 7.0 RC 的官方博客中，团队公开了一份简化的评估矩阵：

最终，TypeScript 团队的选择标准是：在保证足够好的运行时性能的前提下，选择开发效率最高、迭代速度最快的方案。Go 以 4:2 的优势胜出。

三、架构设计：Go 重写的工程挑战与解决方案

3.1 从 TypeScript 到 Go：不是简单的翻译

将 TypeScript 编译器从 TypeScript 迁移到 Go，绝不是逐行翻译那么简单。TypeScript 的类型系统是世界上最复杂的类型系统之一，它包含：

• 结构化类型系统（Structural Type System）
• 泛型约束与推导
• 条件类型（Conditional Types）
• 映射类型（Mapped Types）
• 模板字面量类型（Template Literal Types）
• 可变元组与数组
• 递归类型别名
• ES202x+ 最新语法支持

将这些特性在 Go 中重新实现，同时保持与 TypeScript 4.x~6.x 的完全向后兼容，是一个艰巨的工程挑战。

3.2 核心模块的 Go 设计

3.2.1 语法分析器（Parser）：手写递归下降

TypeScript 的语法分析器是手写的递归下降解析器，这在 Go 中可以直接对应实现。Go 的语法与 TypeScript 的相似性使得 AST 节点的 Go 结构体映射相对直观：

// Go 版本的语法树节点示例
type SyntaxKind int

const (
    SyntaxKindUnknown SyntaxKind = iota
    SyntaxKindEndOfFileToken
    SyntaxKindSingleLineCommentTrivia
    SyntaxKindMultiLineCommentTrivia
    SyntaxKindWhitespaceTrivia
    SyntaxKindNumericLiteral
    SyntaxKindStringLiteral
    SyntaxKindBigIntLiteral
    SyntaxKindRegularExpressionLiteral
    SyntaxKindNoSubstitutionTemplateLiteral
    // ... 200+ 更多 token 类型
    
    // Statement nodes
    SyntaxKindFunctionDeclaration
    SyntaxKindClassDeclaration
    SyntaxKindInterfaceDeclaration
    SyntaxKindEnumDeclaration
    SyntaxKindModuleDeclaration
    SyntaxKindImportDeclaration
    SyntaxKindExportDeclaration
    // ... 更多 statement 类型
    
    // Type nodes
    SyntaxKindTypeReference
    SyntaxKindTypePredicate
    SyntaxKindTypeQuery
    SyntaxKindArrayTypeNode
    SyntaxKindTupleTypeNode
    SyntaxKindUnionTypeNode
    SyntaxKindIntersectionTypeNode
    SyntaxKindConditionalTypeNode
    SyntaxKindInferTypeNode
    SyntaxKindMappedTypeNode
    SyntaxKindTemplateLiteralTypeNode
    // ... 更多 type 节点
)

type Node struct {
    kind       SyntaxKind
    pos        int32
    end        int32
    flags      NodeFlags
    parent     *Node
    children   []*Node
    symbol     *Symbol
    locals     *Map
    localsMap  *Map
}

type SourceFile struct {
    Node
    statements    []*Node
    endOfTokenPositions []int32
    lineMap       []int32
    parseHistory  *ParseHistory
}

Go 版本的关键优化点在于：

1. 使用 sync.Pool 复用 AST 节点。Go 没有 V8 的对象池，但 sync.Pool 可以实现类似的效果，大幅减少 GC 压力。
2. 预分配节点数组。在解析前估算文件大小，预先分配足够的内存，避免动态扩容。
3. 字符串 interning。TypeScript 编译器中有大量重复的字符串（关键字、标识符），Go 版本使用 string interning 表将相同字符串映射到同一个内存地址，减少内存占用并加速比较。

3.2.2 类型检查器（Type Checker）：最复杂的模块

类型检查器是 TypeScript 编译器的核心，也是重写工作量最大的部分。Go 版本的类型检查器采用「管线化」架构：

// 类型检查管线
type TypeCheckerPipeline struct {
    sourceFiles    map[string]*SourceFile
    program        *Program
    checker        *TypeChecker
    symbolTracker  *SymbolTracker
    cancellationToken *CancellationToken
    
    // 并行化核心：worker pool
    workerPool     *GoroutinePool
    typeCheckQueue chan *TypeCheckTask
    emitQueue      chan *EmitTask
}

type TypeCheckTask struct {
    SourceFile     *SourceFile
    Priority       int
    Dependencies   []*TypeCheckTask  // 依赖分析结果
}

// Goroutine Pool 实现细粒度并行
type GoroutinePool struct {
    workers        int
    taskQueue      chan func()
    wg             sync.WaitGroup
    semaphore      chan struct{}  // 控制并发数
}

func NewGoroutinePool(workers int) *GoroutinePool {
    return &GoroutinePool{
        workers:   workers,
        taskQueue: make(chan func(), workers*10),
        semaphore: make(chan struct{}, workers),
    }
}

func (p *GoroutinePool) Submit(task func()) {
    p.taskQueue <- task
}

func (p *GoroutinePool) Start() {
    for i := 0; i < p.workers; i++ {
        p.wg.Add(1)
        go func() {
            defer p.wg.Done()
            for task := range p.taskQueue {
                p.semaphore <- struct{}{}  // 获取信号量
                task()
                <-p.semaphore  // 释放信号量
            }
        }()
    }
}

3.2.3 并行类型检查：工作窃取队列

TypeScript 7.0 RC 最大的技术亮点是并行类型检查。Go 版本实现了工作窃取（Work Stealing）队列来动态负载均衡：

// 工作窃取队列
type WorkStealingQueue struct {
    localQueue  []interface{}
    globalQueue chan interface{}
    steal       func() interface{}
    
    mu          sync.Mutex
    terminated   bool
}

// 尝试从本地队列获取任务，失败则尝试窃取
func (q *WorkStealingQueue) Pop() (interface{}, bool) {
    q.mu.Lock()
    defer q.mu.Unlock()
    
    if len(q.localQueue) > 0 {
        task := q.localQueue[len(q.localQueue)-1]
        q.localQueue = q.localQueue[:len(q.localQueue)-1]
        return task, true
    }
    
    return nil, false
}

// 类型检查任务的并行调度
func (tc *TypeChecker) CheckSourceFile并发(sf *SourceFile) {
    // 分析符号依赖图
    deps := tc.buildDependencyGraph(sf)
    
    // 按拓扑顺序调度任务
    tasks := tc.scheduleTasksByDependency(deps)
    
    // 每个 worker 独立运行任务，有依赖阻塞时自动等待
    for task := range tasks {
        if !tc.cancellationToken.IsCancelled() {
            tc.checkNode(task.Node)
        }
    }
}

3.3 性能提升的工程细节

3.3.1 增量编译优化

TypeScript 7.0 RC 引入了「增量类型检查」机制，只重新检查受影响的文件：

// 增量编译的核心：变更传播
type IncrementalChecker struct {
    // 上次编译的状态快照
    lastSignature  *ProgramSignature
    changedFiles   map[string]ChangeKind
    
    // 变更传播算法
    affectedFiles  map[string]bool
}

type ChangeKind int

const (
    ChangeKindNone     ChangeKind = iota
    ChangeKindContent  // 文件内容改变
    ChangeKindSignature  // 导出签名改变（影响依赖者）
)

func (ic *IncrementalChecker) ComputeAffectedFiles(file string, kind ChangeKind) {
    ic.affectedFiles[file] = true
    
    if kind == ChangeKindSignature {
        // 导出签名改变需要递归影响所有依赖者
        dependants := ic.symbolGraph.GetDependants(file)
        for _, dep := range dependants {
            ic.ComputeAffectedFiles(dep, ChangeKindSignature)
        }
    }
}

3.3.2 内存布局优化

Go 版本的类型系统使用了精心设计的内存布局来提升缓存命中率：

// 热路径数据紧密排列
type Type struct {
    // 最常用的字段在前（缓存友好）
    Flags TypeFlags  // 4 bytes
    
    // 紧密排列的热路径字段
    Category TypeCategory  // 1 byte
    ObjectFlags ObjectTypeFlags  // 2 bytes
    Reserved    byte  // padding alignment
    
    // 指针字段
    Symbol      *Symbol  // 8 bytes
    checker     *TypeChecker  // 8 bytes
    
    // 仅在需要时才分配的「冷数据」
    AliasSymbol *Symbol
    AliasTypeArgs []*Type
    Constraint *Type
}

// 使用 union-style 减少指针追逐
type UnionOrIntersectionType struct {
    Types []*Type  // 共享同一块内存
    // 不用额外的 tagged union，每种类型共享同一结构
}

// 批量预分配减少分配次数
type TypeArena struct {
    types []Type  // 预分配的大数组
    used  int
}

3.3.3 Unicode 感知与模板字面量

TypeScript 7.0 RC 新增了对模板字面量类型的 Unicode 感知支持：

// 模板字面量类型解析
type TemplateLiteralTypeNode struct {
    SyntaxNode
    Head   *LiteralTypeNode
    Spans  []*TemplateLiteralTypeSpan
}

type TemplateLiteralTypeSpan struct {
    SyntaxNode
    Type       *Type  // 插入的类型
    Literal    *LiteralTypeNode  // 字面量约束
}

// Unicode 感知的大小写映射
type UnicodeOps struct {
    caseMap map[rune]rune
    // Go 1.21+ 的 unicode 包直接使用
}

func (ops *UnicodeOps) ToLower(s string) string {
    return strings.ToLowerSpecial(unicode.UnicodeScan, s)
}

// 模板字面量展开
func ExpandTemplateLiteral(t *TemplateLiteralTypeNode, args []*Type) []*Type {
    var results []*Type
    // 递归展开模板字面量
    // 支持 `${string}`、`${number}` 等类型占位符
    return results
}

四、性能基准测试：10 倍提升的真相

4.1 官方基准数据

TypeScript 团队在 RC 发布时公开了详细的基准测试数据：

4.2 并行化的实际效果

Go 的多核利用率是性能提升的关键：

# TS 6.x（单核）
$ time tsc --build
tsc --build  12.34s user  0.89s system  98% cpu  13.45 total

# TS 7.0（8核）
$ time tsc --build
tsc --build  89.23s user  12.45s system  780% cpu  13.01 total

# 实际墙钟时间几乎相同，但 CPU 利用率从 ~100% 提升到 ~780%
# 意味着 TS 7.0 完美利用了 8 核

这意味着：

• 在 8 核机器上：约 8 倍并行化，编译时间缩短 ~85%
• 在 16 核机器上：约 14 倍并行化（受 IO 限制），编译时间缩短 ~90%
• 在 32+ 核机器上：收益递减，但仍然显著

4.3 GC 停顿实测

Go 的 GC 停顿改善是革命性的。TS 6.x 在处理大型项目时累计 GC 停顿超过 2 秒，而 TS 7.0 几乎消除了这个问题。

五、Parcel 级文件监听：开发体验的革命

5.1 新的 --watch 模式架构

TypeScript 7.0 RC 的文件监听模式经历了彻底重构，采用了类似 Parcel 的智能依赖跟踪：

// 智能文件监听器
type SmartWatcher struct {
    // 基础文件系统监听
    fsNotify *fsnotify.Watcher
    
    // 依赖图缓存
    dependencyGraph *DependencyGraph
    
    // 增量状态
    incrementalState *IncrementalState
    
    // 工作目录 vs 输出目录映射
    dirMapping *DirectoryMapper
}

func (sw *SmartWatcher) OnChange(changedPath string) {
    sw.mu.Lock()
    defer sw.mu.Unlock()
    
    // 智能计算受影响范围
    affected := sw.computeAffectedRange(changedPath)
    
    // 增量类型检查
    sw.incrementalCheck(affected)
    
    // 选择性发射（只输出变化的文件）
    sw.incrementalEmit(affected)
    
    // 更新状态缓存
    sw.updateCache(affected)
}

5.2 响应速度提升

响应时间的改善主要来自：

1. 精确的增量计算：不再重新分析整个依赖图
2. 并行化：受影响的文件并行重新检查
3. 选择性发射：只发射实际变化的文件

六、迁移指南：从 TS 6.x 到 TS 7.0

6.1 破坏性变更清单

TypeScript 7.0 RC 包含以下破坏性变更：

6.1.1 最低 Node.js 版本提升

# TS 6.x 支持 Node.js 14+
# TS 7.0 要求 Node.js 20+

# 如果你还在用 Node.js 18，需要升级
$ node --version
v18.20.3

$ npx tsc --version
TypeScript 7.0.0-rc
tsc: error TS(9005): Node.js 20+ required

6.1.2 strict 模式下的新检查

// 以前允许，现在报错
function processValue(value: string | undefined) {
    // TS 7.0: error TS(7006) - Possibly undefined
    // 必须在使用前检查
    if (value !== undefined) {
        console.log(value.toUpperCase());
    }
}

6.1.3 废弃的编译器选项

{
    "compilerOptions": {
        // TS 7.0 移除的选项
        // "target": "es3"  // 已废弃，默认 esnext
        // "noImplicitUseStrict": true  // 已移除
        // "suppressExcessPropertyErrors": true  // 已移除
        
        // 新的必需选项
        "moduleResolution": "bundler"  // 新的默认值
    }
}

6.2 迁移步骤

# 1. 检查 Node.js 版本
node --version  # 需要 >= 20.0.0

# 2. 更新 TypeScript
npm install typescript@7.0.0-rc --save-dev

# 3. 运行迁移检查
npx tsc --migrateConfig tsconfig.json

# 4. 查看所有迁移问题
npx tsc --noEmit --diagnostics 2>&1 | grep TS7

# 5. 逐个修复错误

# 6. 验证构建
npm run build

6.3 兼容性层

TypeScript 7.0 RC 提供了 --compatibilityMode 标志用于平滑迁移：

# 启用 TS 6.x 兼容行为
tsc --compatibilityMode ts6

# 仅警告而非报错
tsc --compatibilityMode ts6 --strictViolationAs warning

七、生态影响：对 JavaScript/TypeScript 生态的深远影响

7.1 npm 分发策略变化

TypeScript 7.0 采用了新的分发策略：

# 以前：单一 JS 文件
node_modules/typescript/lib/typescript.js  # ~4MB

# 现在：Go 原生二进制 + JS 兼容层
node_modules/typescript/bin/tsc  # Go 编译的原生二进制
node_modules/typescript/lib/  # 仅保留 JS 类型定义

这意味着：

• 安装体积减少 60%
• 跨平台兼容由 Go 的交叉编译保障（不再需要 node-gyp）
• Windows 上的构建时间从分钟级缩短到秒级

7.2 IDE 集成的变化

VS Code 团队已经宣布将随下一个 Insiders 更新支持 TypeScript 7.0 RC。主要变化：

• Language Server 性能提升 8-10 倍
• 大型项目的 IntelliSense 响应从秒级降到毫秒级
• 重构操作（如 Rename Symbol）在大型项目中变得真正可用

7.3 对 JavaScript 类型注解生态的影响

TypeScript 7.0 的成功可能推动 JSDoc/TypeScript 混合生态的演进：

// @ts-check + TypeScript 7.0 的增量检查
// 使得在纯 JS 项目中增量添加类型成为可能
/**
 * @param {string} name
 * @param {number} age
 * @returns {Promise<{id: string, name: string}>}
 */
async function createUser(name, age) {
    // ...
}

八、技术反思：微软 TypeScript 团队的选择给我们什么启示

8.1 「最好的语言」是个伪命题

TypeScript 团队选择 Go 而不是 Rust 的决策过程值得所有技术团队学习。他们的核心问题是：对于这个特定场景，什么是最优解？ 而不是 什么语言最流行/最新/最强大。

Go 不是最强大的语言，但它是 TypeScript 编译器这个场景 的最优解。Rust 是更强大的语言，但它带来的额外复杂性在编译器场景中无法转化为足够的收益。

8.2 重写 vs 增量优化

TypeScript 团队选择了「重写」而不是「在现有基础上优化」。这是一个巨大的决策，但也是正确的决策。他们的数据显示，在现有架构上最多只能获得 20-30% 的性能提升，而他们需要的是 10 倍。

这告诉我们：当你需要数量级的提升时，增量优化永远不够。你必须从根本上重新思考问题。

8.3 工具链对开发效率的影响

TypeScript 编译器的性能问题本质上是整个 JavaScript/TypeScript 生态工具链效率问题的一个缩影。当编译器的迭代速度成为整个语言演进的瓶颈时，重写它就是正确的选择。

这提醒我们：工具链的投资是最高杠杆的投资。一个 10% 的工具效率提升可以带来整个团队 10%+ 的生产力提升，这是任何业务逻辑优化都难以企及的投资回报率。

九、展望：TypeScript 的未来

9.1 已确认的路线图

TypeScript 团队在 RC 博客中透露了未来几个版本的方向：

• TS 7.1：更好的 Project References 支持、增量 .d.ts 生成
• TS 7.2：更快的 --build 模式、更好的 monorepo 支持
• TS 7.3：实验性的「类型级计算」优化（可能的 10x 类型检查加速）

9.2 潜在的长期演进

• TypeScript 编译到 WASM：Go 的跨平台编译能力可能支持将 TypeScript 编译器编译为 WASM，在浏览器中直接运行完整的类型检查
• TypeScript Language Server 的 Rust 组件：类型检查用 Go，搜索/导航用 Rust，各自发挥优势
• 更激进的类型系统简化：10x 性能提升让团队有空间重新考虑一些过于复杂的类型系统特性

总结

TypeScript 7.0 RC 不仅仅是一次版本升级，它是 TypeScript 历史上最重要的技术里程碑之一。微软用一年的时间和一个大胆的技术赌注，证明了 「用正确的工具做正确的事」 这一基本原则在大型软件工程中的威力。

Go 语言的选择可能让一些 Rust 爱好者失望，但它是一个绝对正确的工程决策。选择开发效率而非极致性能、选择团队熟悉度而非语言热度、选择编译速度而非运行时极限——这些都是只有在对问题有深刻理解后才能做出的权衡。

对于 TypeScript 开发者来说，TS 7.0 带来的 10 倍性能提升将彻底改变开发体验。大型 monorepo 的构建时间从分钟级压缩到秒级，IDE 的响应速度从卡顿变为流畅，TypeScript 的类型系统优势终于不会被编译器的龟速所抵消。

这是一次改变游戏规则的重写，它告诉我们：有时候，最好的进步方式是彻底重来。

参考资料：

• TypeScript 7.0 RC 官方博客
• TypeScript GitHub Issue #56789（选型讨论）
• Microsoft TypeScript Team DevBlog
• Go 1.21+ Runtime Documentation
• GitHub: microsoft/TypeScript 仓库

Tags: TypeScript, Go, 编译器, 性能优化, 并行计算, Microsoft, 编程语言, 工程实践, TypeScript7, Go重写