Teyru

繁體中文 · 简体中文 · English

Teyru 是一门独立实现的编程语言：编译器完全用 Go 编写，直接生成原生可执行文件——不依赖 JVM、不依赖 javac、不产生任何 bytecode。

Teyru 的语法对 Java 开发者非常熟悉（类、接口、泛型、lambda、异常、record、enum、annotation）， 但去掉了分号、加入了原生 property，并且以原生机器码运行：编译器把整个程序降级为 C， 再交给 clang/LLVM（或 gcc）编译成可执行文件。运行时只有约 5000 行 C，其中包含自己的垃圾回收器 （conservative mark-and-sweep）、字符串、数组与异常实现，没有任何虚拟机。

Teyru 源码 (.teyru)
      │  用 Go 写的编译器：lexer → parser → 语义分析 → C 生成器
      ▼
  generated C  ──clang（Clang 前端 + LLVM 中后端）──▶  LLVM IR  ──▶  原生可执行文件
                                                          （无 JVM、无 bytecode）

后端是 LLVM：./teyru emit-llvm 可以直接打印 IR 模块，接 opt／llc／自定义 pass 都没有问题；只想看 C 也可以用 ./teyru emit。

文档：语言参考 · 原生互通 · Lombok 兼容层 · 诊断码一览 · 编译器架构 · 工作规范

目录

• 为什么比 JVM 快
• 快速开始
• 语言速览
• 支持的语言特性
• 标准库
• 编辑器与工具
• 项目结构
• 运行时模型
• 与 Java 的差异
• 命令行接口
• 开发
• 许可

为什么比 JVM 快

同一台机器实测（AMD Ryzen 7 5700X、Linux x86-64、clang 22.1.8、OpenJDK 21.0.11 Temurin； 由 RUNS=5 sh scripts/bench.sh 产生，每行取 5 次最佳。数字是墙钟（wall-clock）的整支 程序时间，包含 process 启动）：

bench_invoke 这一行现在与其它每一行一样，由同一支脚本测量。它先前不是：Java 文件的类名与文件名不符，harness 因此安静地跳过那支程序、在 Java 栏印出 -。那是脚本真正的缺陷，已经修好（commit 1ad9b8c），而且 Java 文件产不出可执行的类时，harness 现在印 !no-class 而不是 -。这一行显示 Method.invoke 这条路径仍比 HotSpot 慢约 2.4 倍。

bench_loop 从上一个版本的约 2.2 倍落到约 1.8 倍，原因是每个循环回边现在都带一次安全点检查——那是停止世界（stop-the-world）回收器刻意的代价，GC 是合作式的，说明见 docs/language.md §11。这不是测量误差。

大小那一行是成绩，而且原因是具体的。 它是同一个 hello world 在 -O2 下以 wc -c 量的，今天 55,920 字节（约 54.6 KB）。这个数字来自编译器剪掉没有调用点在用的 vtable 槽位——机制写在 docs/architecture.md 的〈为什么每个 可执行文件都带着前缀〉。这个数字一路走来：74fa648（9/13）是 48,840 字节，剪枝前是 501,072，第一版剪枝（只问「有没有调用点」）到 95,832，现在（再问「这个类有没有可能是 那个调度的接收者」）是 55,920。剪枝前的 501,072 里有 1,262 个函数存活，其中 951 个是 前缀的方法，真正被调用到的只有 42 个——其余都是靠 vtable 里的地址活着的。

这个数字要连着优化等级读。 同一个 hello world 是 -O1 75,232、-O2 55,920、 -O3 59,408 字节；这一行与 scripts/bench.sh 用的都是 -O2，也是默认值。

前后对照（同一台机器、-O2）：hello world 501,072 → 95,832 → 55,920； t84_sealed_switch 521,456 → 113,904 → 74,888、t133_arrow_blocks 509,536 → 105,688 → 61,064、t51_java25_tour 523,696 → 438,560 → 253,328，而且这些程序 的输出逐字节不变。会反射的程序不受影响：t146_reflect 是 4,859,976 字节、 t101_gson 4,823,592，剪枝前后一样，因为反射会从 main 抓住每一张成员表——所以下面 「用到反射就带上整份约 3 MB」那句仍然成立，剪枝省下的是不反射的程序的大小。速度没有 可测到的变化：六支 benchmark 交错跑二十轮，每个差异都在噪音内、checksum 全部相同。

底线在哪里，以及为什么不能再低。 剪枝后 hello world 生成的 C 里有 628 个 vtable 数组，每一个都还留着槽位 0、1、2，而只有一个数组在索引 3 以上有填东西——Class 自己的，为了 7、12、13、16 那四个索引，因为它是那个调度 owner 底下唯一可能的接收者。 槽位 0、1、2 对每个类都留着，而且不能用同一条规则收紧：运行期是拿着 void *／tyobj * 按索引读它们的（print_uncaught 与字符串辅助函数读 [0]、 ty_obj_hash 读 [1]、ty_obj_equal 读 [2]），所以它们的 owner 是继承树的根； 要再窄下去就得知道「某个类永远不会被实例化」，而生成的 C 不决定这件事——而且在那里 答错是跳到 NULL，不是浪费几个字节。

为什么快：

1. 没有 JVM 启动成本。 没有 class loading、没有 JIT 预热、没有 GC 线程启动。 适合 CLI 工具、短命进程、容器启动、serverless。
2. 编译期能做完的事不留到运行期。 泛型擦除、调用定址、字符串常量静态分配、 static final 常量折叠、vtable 与接口表都由编译器填好。
3. 没有字节码解释阶段。 clang/LLVM 直接优化整个程序（LTO 跨模块内联、 常量传播、循环向量化），不需要等 JIT 观察热点。
4. 不需要分配的对象就不分配。 逃逸分析把“不离开所在方法”的对象放在 C 栈上， LLVM 随后把它的字段提升为寄存器、把整个对象消除——与 JVM 的 scalar replacement 效果相同，bench_alloc 正是靠这一点赢过 HotSpot。
5. 分配与边界检查都走行内快速路径。 ty_alloc 的指针碰撞分配在头文件内联， 数组访问只在必要时调用慢路径；GC 会回收完全空掉的 chunk，类初始化也只测一个旗标。
6. 可预测的性能。 没有 deopt、没有预热曲线、没有 GC 调参。

诚实的边界。 逃逸分析只覆盖“不离开所在方法”的对象。会存进字段、数组、返回或 交给其他对象的对象仍然走堆与标记清除回收，而 HotSpot 有分代假设，所以在“对象长期 存活、反复回收”的负载上 JVM 仍可能胜出。上面的数字都包含 process 启动，绝对值都很 小；重现方式见 sh scripts/bench.sh，六支 benchmark 程序、启动 100 次、可执行文件大小 与峰值内存都由这支脚本测量（RUNS=5 取最佳，在上面那台机器上执行）。

大小那一行量的是 hello world，而它的数字就是剪枝进了编译器之后才会变的那个：脚本量到的 是编译器在它当时那棵树上生成什么。

快速开始

需要 Go 1.26+ 与 clang（或 gcc）。

# 构建编译器
go build -o teyru ./cmd/teyru

# 编译并运行
./teyru run hello.teyru

# 生成可执行文件
./teyru build -O2 -o hello hello.teyru
./hello

# 查看编译器生成的 C 代码
./teyru emit hello.teyru

# 查看交给 LLVM 的 IR（后端是 clang/LLVM，可交给 opt/llc）
./teyru emit-llvm hello.teyru

# 版本
./teyru version

hello.teyru：

class Hello {
  public static void main(String[] args) {
    System.out.println("Hello, Teyru!")
  }
}

注意：Teyru 不用分号。每条语句以换行结束；for 头部用两个冒号分隔三段。

语言速览

interface Shape {
  double area()
  default String describe() {
    return "area=" + area()
  }
}

class Rect implements Shape {
  public double w
  public double h
  public Rect(double w, double h) {
    this.w = w
    this.h = h
  }
  public double area() {
    return w * h
  }
}

class Circle implements Shape {
  private double r
  public double radius {      // 原生 property
    get {
      return field            // field = 底层存储
    }
    set {
      field = value < 0 ? 0 : value
    }
  }
  public Circle(double r) {
    radius = r
  }
  public double area() {
    return Math.PI * r * r
  }
}

record Point(int x, int y) {
}

enum Color {
  RED, GREEN, BLUE
}

interface Fn<R> {
  R apply(int v)
}

class Main {
  static int twice(int v) {
    return v * 2
  }

  public static void main(String[] args) {
    Shape s = new Rect(3, 4)
    System.out.println(s.describe())

    // for ( init : condition : update )
    for (int i = 0 : i < 3 : i++) {
      System.out.println(i)
    }

    int[] xs = {1, 2, 3}
    for (int x : xs) {
      System.out.print(x)
    }
    System.out.println()

    // lambda 与方法引用
    Fn<Integer> f = (v) -> v + 1
    Fn<Integer> g = Main::twice
    System.out.println(f.apply(41))
    System.out.println(g.apply(21))

    // switch 表达式与类型 pattern
    Color c = Color.GREEN
    String name = switch (c) {
      case RED -> "red"
      case GREEN -> "green"
      default -> "other"
    }
    System.out.println(name)
    System.out.println(describe(c))

    // 异常
    try {
      System.out.println(10 / 0)
    } catch (ArithmeticException e) {
      System.out.println("除以零")
    } finally {
      System.out.println("cleanup")
    }
  }

  static String describe(Object o) {
    return switch (o) {
      case String s -> "string of length " + s.length()
      case Integer i when i.intValue() > 10 -> "big int"
      case Integer i -> "small int"
      default -> "other"
    }
  }
}

Java 25 语法对照

Teyru 以 Java SE 25 最终定案的语法为基准（不含预览功能），保留 Java 语义， 只去掉分号并加入原生 property。已实现并有测试的 Java 25 项目：

Lombok 兼容层

编译器内置 Lombok：注解在语义分析阶段展开成普通的 Teyru 成员，与手写代码走同一条 类型检查与代码生成路径，不需要 annotation processor。

import lombok.*

@Data
@AllArgsConstructor
@Builder
class Person {
  private String name
  private int age
}

class Main {
  public static void main(String[] args) {
    Person p = Person.builder().name("ada").age(36).build()
    System.out.println(p.getName() + " " + p.getAge())
    System.out.println(p)
  }
}

完整清单与差异见 docs/lombok.md：@Getter／@Setter／@ToString／ @EqualsAndHashCode／@Data／@Value／@Builder／@NonNull／@Cleanup／ @SneakyThrows／@Synchronized／@With／@Accessors／@FieldDefaults／ @UtilityClass／@StandardException／@Log 系列／@ExtensionMethod／ @FieldNameConstants／@Delegate／@Helper／@Tolerate／@Locked／ @NonFinal／@PackagePrivate 全部支持，包含 @Singular（逐项累积、整批加入、 清除、build() 取得副本）、@SuperBuilder（覆盖整条继承链的字段）与 @Builder.ObtainVia。

支持的语言特性

完整的语法与语义写在 docs/language.md。

标准库

标准库以 Teyru 本身编写（lib/*.teyru），每次编译都和使用者程序一起被编译与 检查。标准库是一个 Teyru 包（teyru），所以导入写成一行 import teyru.*（只用到单个类时也可以写 import teyru.List）；Java 写法的 import java.util.* 和 import java.util.List 也照样接受，Java 源码不改就能编译：

集合以 Teyru 编写，所以 for 循环直接支持：

List<String> names = new ArrayList<String>()
names.add("ada")
names.add("grace")
for (String n : names) {
  System.out.println(n)
}

依赖用 teyru.mod 声明，获取与校验照 Go 的做法（docs/modules.md）：

teyru mod init example.com/app
teyru get example.com/greeting@v0.1.0
teyru build ./...

标准库没有清单式的一条「少了什么」：每个缺口都写在它自己所属于的包那一行或那一节 （见 docs/language.md §11），而且每条都是决定——MessageDigest 没有 SHA-3、Scanner 只读 String、闰秒被拒绝、没有 tzdata 的主机上时区是具名拒绝。

需要自己的原生库时，声明 native 方法并用 C 实现：

class Native {
  public static native int add(int a, int b)
}

teyru build --native-header native.h program.teyru   # 生成要实现的原型
teyru build --native impl.c program.teyru            # 一起编译

完整说明见 docs/native.md。

编辑器与工具

• VS Code：teyru-lang/editors 仓库的 vscode/ 提供 .teyru 的 TextMate 语法高亮、语言配置与片段。 用 npx @vscode/vsce package 打包，再用 code --install-extension teyru-0.1.0.vsix 安装。
• tree-sitter：同一仓库的 tree-sitter-teyru/ 是完整文法，附高亮 query、缩进 query 与 corpus 测试，Neovim、Helix、Zed 等可直接使用。
• GitHub 目前仍把 .teyru 显示为 Java：linguist 还没有 Teyru 的定义， .gitattributes 先映射到最接近的语法。

项目结构

运行时模型

• 对象：C struct，第一栏是 tyobj { tyclass* cls }。每个类一张 tyclass， 记录父类、接口、vtable、接口表、GC 需要追踪的引用字段偏移。
• 虚调用：obj->cls->vtable[slot]；接口调用：ty_itab(obj, selector)。 每个接口方法有全局唯一的 selector，每个类的接口表由编译期填好。
• 泛型：编译期擦除，运行期没有泛型信息（与 Java 相同）。
• 异常：以 setjmp／longjmp 实现的 handler 链；finally 以嵌套 handler 保证在任何路径（含 catch 内再抛出）都执行。
• GC：保守式标记清除。根包含原生栈（保守扫描）、静态字段注册表与寄存器 （setjmp 溢出）。对象不移动，所以 C 端的临时指针永远有效。收集前会先停住每一条 线程，再扫各自的栈（停止是世界性的，且是合作式的，见 docs/language.md §11）。
• 字符串：UTF-8 tystr { tyobj obj; int64 len; char* data }；字面量是静态对象， 不经过 GC。
• 数组：tyarr { tyobj; len; data; esize; refs }，元素内嵌在对象后方。

与 Java 的差异

Teyru 不是 Java 的子集，而是“Java 开发者一看就懂”的独立语言。主要差异：

1. 没有分号。 分号会被编译器拒绝（TY-SYN-0001）。
2. for 头部用冒号：for (int i = 0 : i < n : i++)。
3. try-with-resources 用换行分隔，不用分号。
4. enum 常量区与成员区用一个冒号分隔（没有成员时可省略）。
5. 原生 property：字段后面接 accessor 块即成 property；field 代表底层存储。 没有 accessor 块的字段就是普通 Java 字段。
6. val：推断类型的不可重绑定局部变量（不是深度不可变）。
7. 没有 checked exception 检查；throws 会被解析但不强制。
8. 没有 annotation processor；注解可以反射，但元素是按名字读 （ann.stringValue("value")），不是 Java 的 ann.value()。
9. 不是 bytecode 平台：没有 .class、没有 java.lang、没有 JNI， 目前也无法与既有 Java 库互通——这是刻意的取舍。

完整清单见 docs/language.md §12。

命令行接口

teyru build [flags] <files...>                 编译成原生可执行文件
teyru run   [flags] <files...> [-- args...]    编译后直接运行
teyru emit  [flags] <files...>                 打印生成的 C
teyru emit-llvm [flags] <files...>             打印交给 LLVM 的 IR
teyru get <module>@<version>                   获取模块到缓存并加入依赖
teyru mod init <module-path>                   为新模块写出 teyru.mod
teyru mod tidy                                 让 teyru.mod 与 teyru.sum 与源码一致
teyru version                                  版本
teyru help                                     帮助

后端与平台

两个后端，默认是 C。 默认的 C 后端为整个程序生成 C（见 docs/architecture.md）。--backend=llvm 换成后端直接生成 这个程序自己的 LLVM IR：运行期仍然是 C，clang 只负责汇编与链接。它拒绝它降不下去 的东西，不会安静地退回 C 后端——拒绝是一个 TY-INT-0100 诊断，指出是哪个构造。

那条界线是量出来的，不是猜的：tests/programs 扫过一轮的结果是 76 支逐字节相同、0 支输出错误、119 支被 emitter 以诊断拒绝、0 个模块 clang 不收。 被拒绝的那些按顺序是：闭包（lambda 与方法引用，以及局部类与匿名类）、 record／enum／注解合成出来的成员、类型 pattern 与带守卫的 switch、内部类，然后是 其余。它目前只编 linux/amd64，其他目标以 TY-INT-0101 拒绝。

平台层。 运行期对操作系统的调用都走 internal/runtime/src/tyrt_plat.h： 时间与 CPU、mutex 与 condition variable、线程、启动、socket、文件，共四十个 typlat_* 函数，实现分成 tyrt_plat_posix.c 与 tyrt_plat_win.c 两半， 只有 tyrt.c／tyrt2.c／tyrt_thread.c／tyrt_net.c 会调用它们。

teyru build --target <os>/<arch> 选的是编译器、旗标、要编哪一半的平台层与输出文件名； 没有给就编给这台机器。目标表有五列，每列的证据不一样：

这张表不是「每一列都跑过」的承诺：linux/amd64 是整套测试的那一个，其他目标如果 需要这台机器没有的交叉工具链，会在编译器那里以编译器自己的错误失败，而不是安静地 成功。macOS 没有可命名的交叉编译器，所以从别的宿主要求它是明确的错误。

这个项目没有 CI：每次改动的关卡就是上面那两条指令，在这台机器上跑，所以文档里的 数字都写着它是怎么量、在哪里量的。

开发

go build ./...          # 构建
go test ./...           # 端到端测试（会编译 tests/programs 下每个程序并比对输出）
go vet ./...
sh scripts/bench.sh       # 与 JVM 对照的性能测试（需要 java 才会跑 JVM 那一半）

新增测试只需在 tests/programs/ 放 xxx.teyru 与 xxx.expected； 若程序需要命令行参数，再放 xxx.args（每行一个参数）；程序如果应该失败， 用 xxx.exit 写它必须结束时的状态码、xxx.experr 写它应该输出到 stderr 的内容。 go test 会自动处理。

贡献前请读 AGENTS.md。

许可

见 LICENSE 与 THIRD-PARTY-NOTICES.md。