修改名词

src/main/java/org/jcnc/snow/compiler/backend/RegisterAllocator.java

@@ -5,21 +5,21 @@ package org.jcnc.snow.compiler.backend;
 import org.jcnc.snow.compiler.ir.core.IRFunction;
 import org.jcnc.snow.compiler.ir.core.IRInstruction;
 import org.jcnc.snow.compiler.ir.core.IRValue;
-import org.jcnc.snow.compiler.ir.value.VirtualRegister;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 
 import java.util.HashMap;
 import java.util.Map;
 
 /** 线性扫描寄存器分配（演示级） */
 public final class RegisterAllocator {
-    private final Map<VirtualRegister,Integer> map = new HashMap<>();
+    private final Map<IRVirtualRegister,Integer> map = new HashMap<>();
 
-    public Map<VirtualRegister,Integer> allocate(IRFunction fn){
+    public Map<IRVirtualRegister,Integer> allocate(IRFunction fn){
         int next = 0;
         for (IRInstruction i : fn.body()){
             if(i.dest()!=null && !map.containsKey(i.dest())) map.put(i.dest(), next++);
             for(IRValue v : i.operands())
-                if(v instanceof VirtualRegister r && !map.containsKey(r)) map.put(r, next++);
+                if(v instanceof IRVirtualRegister r && !map.containsKey(r)) map.put(r, next++);
         }
         return map;
     }

src/main/java/org/jcnc/snow/compiler/backend/VMCodeGenerator.java

@@ -2,9 +2,9 @@ package org.jcnc.snow.compiler.backend;
 
 import org.jcnc.snow.compiler.ir.core.IRFunction;
 import org.jcnc.snow.compiler.ir.core.IRInstruction;
-import org.jcnc.snow.compiler.ir.instr.*;
+import org.jcnc.snow.compiler.ir.instruction.*;
-import org.jcnc.snow.compiler.ir.value.Constant;
+import org.jcnc.snow.compiler.ir.value.IRConstant;
-import org.jcnc.snow.compiler.ir.value.VirtualRegister;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 import org.jcnc.snow.vm.engine.VMOpCode;
 
 import java.lang.reflect.Field;
@@ -18,12 +18,12 @@ import java.util.Map;
  */
 public final class VMCodeGenerator {
 
-    private final Map<VirtualRegister,Integer> slotMap;
+    private final Map<IRVirtualRegister,Integer> slotMap;
     private final List<String>                 code = new ArrayList<>();
 
     private String currentFnName;         // ← 当前正在生成的函数名
 
-    public VMCodeGenerator(Map<VirtualRegister,Integer> slotMap){
+    public VMCodeGenerator(Map<IRVirtualRegister,Integer> slotMap){
         this.slotMap = slotMap;
     }
 
@@ -34,8 +34,8 @@ public final class VMCodeGenerator {
         for (IRInstruction inst : fn.body()) {
             switch (inst) {
                 case LoadConstInstruction c -> genLoadConst(c);
-                case BinOpInstruction   b   -> genBinOp(b);
+                case BinaryOperationInstruction b   -> genBinOp(b);
-                case UnaryOpInstruction u   -> genUnary(u);
+                case UnaryOperationInstruction u   -> genUnary(u);
                 case ReturnInstruction r    -> genRet(r);
                 default -> throw new IllegalStateException("Unsupported IR: "+inst);
             }
@@ -47,14 +47,14 @@ public final class VMCodeGenerator {
     /* ───────────── 指令生成 ───────────── */
 
     private void genLoadConst(LoadConstInstruction c){
-        Constant k = (Constant)c.operands().get(0);
+        IRConstant k = (IRConstant)c.operands().get(0);
         emit(op("I_PUSH"),  k.value().toString());
         emit(op("I_STORE"), slot(c.dest())+"");
     }
 
-    private void genBinOp(BinOpInstruction b){
+    private void genBinOp(BinaryOperationInstruction b){
-        emit(op("I_LOAD"),  slot((VirtualRegister)b.operands().get(0))+"");
+        emit(op("I_LOAD"),  slot((IRVirtualRegister)b.operands().get(0))+"");
-        emit(op("I_LOAD"),  slot((VirtualRegister)b.operands().get(1))+"");
+        emit(op("I_LOAD"),  slot((IRVirtualRegister)b.operands().get(1))+"");
 
         String opcode = switch (b.op()){
             case ADD_I32 -> "I_ADD";
@@ -67,8 +67,8 @@ public final class VMCodeGenerator {
         emit(op("I_STORE"), slot(b.dest())+"");
     }
 
-    private void genUnary(UnaryOpInstruction u){
+    private void genUnary(UnaryOperationInstruction u){
-        emit(op("I_LOAD"), slot((VirtualRegister)u.operands().get(0))+"");
+        emit(op("I_LOAD"), slot((IRVirtualRegister)u.operands().get(0))+"");
 
         String opcode = switch (u.op()){
             case NEG_I32 -> "I_NEG";
@@ -97,7 +97,7 @@ public final class VMCodeGenerator {
 
     /* ───────────── 工具函数 ───────────── */
 
-    private int slot(VirtualRegister r){
+    private int slot(IRVirtualRegister r){
         Integer s = slotMap.get(r);
         if (s == null) throw new IllegalStateException("Register "+r+" 未映射槽位");
         return s;

src/main/java/org/jcnc/snow/compiler/cli/SnowCompiler.java

@@ -2,7 +2,7 @@ package org.jcnc.snow.compiler.cli;
 
 import org.jcnc.snow.compiler.backend.RegisterAllocator;
 import org.jcnc.snow.compiler.backend.VMCodeGenerator;
-import org.jcnc.snow.compiler.ir.builder.ProgramBuilder;
+import org.jcnc.snow.compiler.ir.builder.IRProgramBuilder;
 import org.jcnc.snow.compiler.ir.core.IRFunction;
 import org.jcnc.snow.compiler.ir.core.IRProgram;
 import org.jcnc.snow.compiler.lexer.core.LexerEngine;
@@ -55,7 +55,7 @@ public class SnowCompiler {
         SemanticAnalyzerRunner.runSemanticAnalysis(ast, false);
 
         /* 4. AST → IRProgram */
-        IRProgram program = new ProgramBuilder().buildProgram(ast);
+        IRProgram program = new IRProgramBuilder().buildProgram(ast);
         System.out.println("=== IR ===");
         System.out.println(program);
 

src/main/java/org/jcnc/snow/compiler/ir/builder/ExpressionBuilder.java

@@ -1,7 +1,7 @@
 package org.jcnc.snow.compiler.ir.builder;
 
-import org.jcnc.snow.compiler.ir.core.IROp;
+import org.jcnc.snow.compiler.ir.core.IROpCode;
-import org.jcnc.snow.compiler.ir.value.VirtualRegister;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 import org.jcnc.snow.compiler.parser.ast.BinaryExpressionNode;
 import org.jcnc.snow.compiler.parser.ast.IdentifierNode;
 import org.jcnc.snow.compiler.parser.ast.NumberLiteralNode;
@@ -23,15 +23,15 @@ public class ExpressionBuilder {
     /**
      * 操作符到 IR 操作码的映射表
      */
-    private static final Map<String, IROp> OP_MAP = Map.of(
+    private static final Map<String, IROpCode> OP_MAP = Map.of(
-            "+", IROp.ADD_I32,
+            "+", IROpCode.ADD_I32,
-            "-", IROp.SUB_I32,
+            "-", IROpCode.SUB_I32,
-            "*", IROp.MUL_I32,
+            "*", IROpCode.MUL_I32,
-            "/", IROp.DIV_I32
+            "/", IROpCode.DIV_I32
     );
 
     /**
-     * 当前 IR 构建上下文，包含 IRFunction 和 Scope
+     * 当前 IR 构建上下文，包含 IRFunction 和 IRBuilderScope
      */
     private final IRContext ctx;
 
@@ -51,17 +51,17 @@ public class ExpressionBuilder {
      * @return 存放表达式计算结果的虚拟寄存器
      * @throws IllegalStateException 若遇到不支持的表达式节点或未定义变量
      */
-    public VirtualRegister build(ExpressionNode expr) {
+    public IRVirtualRegister build(ExpressionNode expr) {
         // 处理数字常量
         if (expr instanceof NumberLiteralNode(String value)) {
             int v = Integer.parseInt(value);
             // 生成加载常量指令并返回结果寄存器
-            return InstrFactory.loadConst(ctx, v);
+            return InstructionFactory.loadConst(ctx, v);
         }
         // 处理变量引用
         if (expr instanceof IdentifierNode(String name)) {
             // 从作用域查找已声明的寄存器
-            VirtualRegister vr = ctx.getScope().lookup(name);
+            IRVirtualRegister vr = ctx.getScope().lookup(name);
             if (vr == null) {
                 throw new IllegalStateException("未定义的变量: " + name);
             }
@@ -70,15 +70,15 @@ public class ExpressionBuilder {
         // 处理二元表达式
         if (expr instanceof BinaryExpressionNode(ExpressionNode left, String operator, ExpressionNode right)) {
             // 递归构建左、右子表达式
-            VirtualRegister l = build(left);
+            IRVirtualRegister l = build(left);
-            VirtualRegister r = build(right);
+            IRVirtualRegister r = build(right);
             // 根据操作符获取 IR 操作码
-            IROp op = OP_MAP.get(operator);
+            IROpCode op = OP_MAP.get(operator);
             if (op == null) {
                 throw new IllegalStateException("不支持的运算符: " + operator);
             }
             // 生成二元运算指令并返回结果寄存器
-            return InstrFactory.binOp(ctx, op, l, r);
+            return InstructionFactory.binOp(ctx, op, l, r);
         }
         // 其他表达式类型暂不支持
         throw new IllegalStateException(

src/main/java/org/jcnc/snow/compiler/ir/builder/IRBuilderScope.java

@@ -1,13 +1,13 @@
 package org.jcnc.snow.compiler.ir.builder;
 
 import org.jcnc.snow.compiler.ir.core.IRFunction;
-import org.jcnc.snow.compiler.ir.value.VirtualRegister;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 
 import java.util.HashMap;
 import java.util.Map;
 
 /**
- * Scope 用于管理单个函数的变量名与虚拟寄存器的映射。
+ * IRBuilderScope 用于管理单个函数的变量名与虚拟寄存器的映射。
  *
  * <p>功能：
  * <ul>
@@ -16,10 +16,10 @@ import java.util.Map;
  *   <li>根据变量名查找对应的虚拟寄存器。</li>
  * </ul>
  */
-final class Scope {
+final class IRBuilderScope {
 
-    /** 存储变量名到 VirtualRegister 的映射 */
+    /** 存储变量名到 IRVirtualRegister 的映射 */
-    private final Map<String, VirtualRegister> vars = new HashMap<>();
+    private final Map<String, IRVirtualRegister> vars = new HashMap<>();
 
     /**
      * 当前作用域所属的 IRFunction，用于分配新的寄存器。
@@ -41,7 +41,7 @@ final class Scope {
      * @param name 变量名
      */
     void declare(String name) {
-        VirtualRegister reg = fn.newRegister();
+        IRVirtualRegister reg = fn.newRegister();
         vars.put(name, reg);
     }
 
@@ -51,7 +51,7 @@ final class Scope {
      * @param name 变量名
      * @param reg  对应的虚拟寄存器
      */
-    void declare(String name, VirtualRegister reg) {
+    void declare(String name, IRVirtualRegister reg) {
         vars.put(name, reg);
     }
 
@@ -61,7 +61,7 @@ final class Scope {
      * @param name 变量名
      * @param reg  新的虚拟寄存器
      */
-    void put(String name, VirtualRegister reg) {
+    void put(String name, IRVirtualRegister reg) {
         vars.put(name, reg);
     }
 
@@ -69,9 +69,9 @@ final class Scope {
      * 根据变量名查找其对应的虚拟寄存器。
      *
      * @param name 变量名
-     * @return 对应的 VirtualRegister，若未声明则返回 null
+     * @return 对应的 IRVirtualRegister，若未声明则返回 null
      */
-    VirtualRegister lookup(String name) {
+    IRVirtualRegister lookup(String name) {
         return vars.get(name);
     }
 }

src/main/java/org/jcnc/snow/compiler/ir/builder/IRContext.java

@@ -2,11 +2,10 @@ package org.jcnc.snow.compiler.ir.builder;
 
 import org.jcnc.snow.compiler.ir.core.IRFunction;
 import org.jcnc.snow.compiler.ir.core.IRInstruction;
-import org.jcnc.snow.compiler.parser.ast.*;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
-import org.jcnc.snow.compiler.ir.value.VirtualRegister;
 
 /**
- * IRContext 封装了当前函数的 IRFunction 实例和作用域管理（Scope），
+ * IRContext 封装了当前函数的 IRFunction 实例和作用域管理（IRBuilderScope），
  * 并提供分配寄存器和添加 IR 指令的便利方法。
  *
  * <p>主要功能：
@@ -25,7 +24,7 @@ public class IRContext {
     /**
      * 管理变量和寄存器映射的作用域
      */
-    private final Scope scope;
+    private final IRBuilderScope IRBuilderScope;
 
     /**
      * 构造 IRContext，并绑定要构建的 IRFunction。
@@ -34,9 +33,9 @@ public class IRContext {
      */
     public IRContext(IRFunction function) {
         this.function = function;
-        this.scope = new Scope();
+        this.IRBuilderScope = new IRBuilderScope();
         // 将 IRFunction 与作用域关联，以便指令生成时使用
-        this.scope.attachFunction(function);
+        this.IRBuilderScope.attachFunction(function);
     }
 
     /**
@@ -51,19 +50,19 @@ public class IRContext {
     /**
      * 获取当前作用域，用于变量声明和查找。
      *
-     * @return 作用域对象 Scope
+     * @return 作用域对象 IRBuilderScope
      */
-    /* 包内可见：仅在 builder 包内部使用 Scope */
+    /* 包内可见：仅在 builder 包内部使用 IRBuilderScope */
-    Scope getScope() {
+    IRBuilderScope getScope() {
-        return scope;
+        return IRBuilderScope;
     }
 
     /**
      * 分配一个新的虚拟寄存器。
      *
-     * @return 新分配的 VirtualRegister 对象
+     * @return 新分配的 IRVirtualRegister 对象
      */
-    public VirtualRegister newRegister() {
+    public IRVirtualRegister newRegister() {
         return function.newRegister();
     }
 

src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java

@@ -10,7 +10,7 @@ import org.jcnc.snow.compiler.parser.ast.base.StatementNode;
 import java.util.List;
 
 /**
- * ProgramBuilder 用于将 AST 根节点列表构建为 IRProgram。
+ * IRProgramBuilder 用于将 AST 根节点列表构建为 IRProgram。
  *
  * <p>功能：
  * <ul>
@@ -19,7 +19,7 @@ import java.util.List;
  *   <li>对脚本式顶层语句自动包装为特殊的 _start 函数。</li>
  * </ul>
  */
-public final class ProgramBuilder {
+public final class IRProgramBuilder {
 
     /**
      * 构建一个完整的 IRProgram。

src/main/java/org/jcnc/snow/compiler/ir/builder/InstructionFactory.java

@@ -1,23 +1,23 @@
 package org.jcnc.snow.compiler.ir.builder;
 
-import org.jcnc.snow.compiler.ir.core.IROp;
+import org.jcnc.snow.compiler.ir.core.IROpCode;
-import org.jcnc.snow.compiler.ir.instr.BinOpInstruction;
+import org.jcnc.snow.compiler.ir.instruction.BinaryOperationInstruction;
-import org.jcnc.snow.compiler.ir.instr.LoadConstInstruction;
+import org.jcnc.snow.compiler.ir.instruction.LoadConstInstruction;
-import org.jcnc.snow.compiler.ir.instr.ReturnInstruction;
+import org.jcnc.snow.compiler.ir.instruction.ReturnInstruction;
-import org.jcnc.snow.compiler.ir.value.Constant;
+import org.jcnc.snow.compiler.ir.value.IRConstant;
-import org.jcnc.snow.compiler.ir.value.VirtualRegister;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 
 /**
- * InstrFactory 统一管理 IR 指令的创建，并自动将生成的指令添加到上下文中。
+ * InstructionFactory 统一管理 IR 指令的创建，并自动将生成的指令添加到上下文中。
  *
  * <p>提供的功能包括：
  * <ul>
  *   <li>生成加载常量指令（LoadConstInstruction）；</li>
- *   <li>生成二元运算指令（BinOpInstruction）；</li>
+ *   <li>生成二元运算指令（BinaryOperationInstruction）；</li>
  *   <li>生成返回指令（ReturnInstruction），支持有返回值和无返回值两种情况；</li>
  * </ul>
  */
-public class InstrFactory {
+public class InstructionFactory {
 
     /**
      * 生成加载整数常量的指令，并返回对应的结果寄存器。
@@ -26,9 +26,9 @@ public class InstrFactory {
      * @param value 要加载的整数值
      * @return 存放常量的虚拟寄存器
      */
-    public static VirtualRegister loadConst(IRContext ctx, int value) {
+    public static IRVirtualRegister loadConst(IRContext ctx, int value) {
-        VirtualRegister vr = ctx.newRegister();
+        IRVirtualRegister vr = ctx.newRegister();
-        LoadConstInstruction instr = new LoadConstInstruction(vr, new Constant(value));
+        LoadConstInstruction instr = new LoadConstInstruction(vr, new IRConstant(value));
         ctx.addInstruction(instr);
         return vr;
     }
@@ -42,11 +42,11 @@ public class InstrFactory {
      * @param right 右操作数寄存器
      * @return 存放运算结果的虚拟寄存器
      */
-    public static VirtualRegister binOp(IRContext ctx, IROp op,
+    public static IRVirtualRegister binOp(IRContext ctx, IROpCode op,
-                                        VirtualRegister left,
+                                          IRVirtualRegister left,
-                                        VirtualRegister right) {
+                                          IRVirtualRegister right) {
-        VirtualRegister dest = ctx.newRegister();
+        IRVirtualRegister dest = ctx.newRegister();
-        BinOpInstruction instr = new BinOpInstruction(op, dest, left, right);
+        BinaryOperationInstruction instr = new BinaryOperationInstruction(op, dest, left, right);
         ctx.addInstruction(instr);
         return dest;
     }
@@ -57,7 +57,7 @@ public class InstrFactory {
      * @param ctx   当前 IR 构建上下文
      * @param value 需要返回的虚拟寄存器
      */
-    public static void ret(IRContext ctx, VirtualRegister value) {
+    public static void ret(IRContext ctx, IRVirtualRegister value) {
         ctx.addInstruction(new ReturnInstruction(value));
     }
 

src/main/java/org/jcnc/snow/compiler/ir/builder/StatementBuilder.java

@@ -1,6 +1,6 @@
 package org.jcnc.snow.compiler.ir.builder;
 
-import org.jcnc.snow.compiler.ir.value.VirtualRegister;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 import org.jcnc.snow.compiler.parser.ast.AssignmentNode;
 import org.jcnc.snow.compiler.parser.ast.DeclarationNode;
 import org.jcnc.snow.compiler.parser.ast.ExpressionStatementNode;
@@ -26,7 +26,7 @@ public class StatementBuilder {
             return;
         }
         if (stmt instanceof AssignmentNode an) {
-            VirtualRegister vr = exprBuilder.build(an.value());
+            IRVirtualRegister vr = exprBuilder.build(an.value());
             if (ctx.getScope().lookup(an.variable()) == null) {
                 ctx.getScope().declare(an.variable(), vr);
             } else {
@@ -36,7 +36,7 @@ public class StatementBuilder {
         }
         if (stmt instanceof DeclarationNode dn) {
             if (dn.getInitializer().isPresent()) {
-                VirtualRegister init = exprBuilder.build(dn.getInitializer().get());
+                IRVirtualRegister init = exprBuilder.build(dn.getInitializer().get());
                 ctx.getScope().declare(dn.getName(), init);
             } else {
                 ctx.getScope().declare(dn.getName());
@@ -45,10 +45,10 @@ public class StatementBuilder {
         }
         if (stmt instanceof ReturnNode rn) {
             if (rn.getExpression().isPresent()) {
-                VirtualRegister vr = exprBuilder.build(rn.getExpression().get());
+                IRVirtualRegister vr = exprBuilder.build(rn.getExpression().get());
-                InstrFactory.ret(ctx, vr);
+                InstructionFactory.ret(ctx, vr);
             } else {
-                InstrFactory.retVoid(ctx);
+                InstructionFactory.retVoid(ctx);
             }
             return;
         }

src/main/java/org/jcnc/snow/compiler/ir/core/IRFunction.java

@@ -1,6 +1,6 @@
 package org.jcnc.snow.compiler.ir.core;
 
-import org.jcnc.snow.compiler.ir.value.VirtualRegister;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -35,8 +35,8 @@ public class IRFunction {
      *
      * @return 新建的虚拟寄存器
      */
-    public VirtualRegister newRegister() {
+    public IRVirtualRegister newRegister() {
-        return new VirtualRegister(regCounter++);
+        return new IRVirtualRegister(regCounter++);
     }
 
     /**

src/main/java/org/jcnc/snow/compiler/ir/core/IRInstruction.java

@@ -1,6 +1,6 @@
 package org.jcnc.snow.compiler.ir.core;
 
-import org.jcnc.snow.compiler.ir.value.VirtualRegister;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 
 import java.util.List;
 
@@ -23,9 +23,9 @@ public abstract class IRInstruction {
      * 获取指令的操作符。
      * 例如：ADD_I32、CONST、RET 等。
      *
-     * @return 操作符枚举值（IROp）
+     * @return 操作符枚举值（IROpCode）
      */
-    public abstract IROp op();
+    public abstract IROpCode op();
 
     /**
      * 获取指令的目标寄存器（若有的话）。
@@ -35,7 +35,7 @@ public abstract class IRInstruction {
      *
      * @return 目标寄存器或 null
      */
-    public VirtualRegister dest() {
+    public IRVirtualRegister dest() {
         return null;
     }
 

src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java

@@ -1,12 +1,12 @@
 package org.jcnc.snow.compiler.ir.core;
 
 /**
- * IROp —— IR 层支持的操作码（Opcode）枚举类型。
+ * IROpCode —— IR 层支持的操作码（Opcode）枚举类型。
  * <p>
  * 每种操作码代表一条基本指令的种类，供 IRInstruction 使用。
  * 可以根据编译器需求继续扩展。
  */
-public enum IROp {
+public enum IROpCode {
     /* ───── 算术运算 ───── */
 
     /** 整型加法（32位） */
@@ -52,7 +52,7 @@ public enum IROp {
     /** 存储到内存（Store） */
     STORE,
 
-    /** 加载常量（Constant） */
+    /** 加载常量（IRConstant） */
     CONST,
 
     /* ───── 控制流 ───── */
@@ -63,7 +63,7 @@ public enum IROp {
     /** 条件跳转（Jump if zero），若条件为 0 则跳转 */
     JUMP_IF_ZERO,
 
-    /** 标签（Label），跳转目标位置 */
+    /** 标签（IRLabel），跳转目标位置 */
     LABEL,
 
     /* ───── 函数调用相关 ───── */

src/main/java/org/jcnc/snow/compiler/ir/core/IRValue.java

@@ -1,20 +1,20 @@
 package org.jcnc.snow.compiler.ir.core;
 
-import org.jcnc.snow.compiler.ir.value.Constant;
+import org.jcnc.snow.compiler.ir.value.IRConstant;
-import org.jcnc.snow.compiler.ir.value.Label;
+import org.jcnc.snow.compiler.ir.value.IRLabel;
-import org.jcnc.snow.compiler.ir.value.VirtualRegister;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 
 /**
  * IRValue —— 表示在中间表示（IR）系统中能作为操作数使用的基本单位。
  * <p>
  * 包括：
- *   • VirtualRegister（虚拟寄存器）
+ *   • IRVirtualRegister（虚拟寄存器）
- *   • Constant（常量）
+ *   • IRConstant（常量）
- *   • Label（跳转标签）
+ *   • IRLabel（跳转标签）
  * <p>
  * 本接口使用 sealed 限定，明确列出所有允许实现它的子类型，
  * 保证类型安全，并便于在编译时做穷尽检查。
  */
 public sealed interface IRValue
-        permits VirtualRegister, Constant, Label {
+        permits IRVirtualRegister, IRConstant, IRLabel {
 }

src/main/java/org/jcnc/snow/compiler/ir/instruction/BinaryOperationInstruction.java

@@ -1,9 +1,9 @@
-package org.jcnc.snow.compiler.ir.instr;
+package org.jcnc.snow.compiler.ir.instruction;
 
 import org.jcnc.snow.compiler.ir.core.IRInstruction;
-import org.jcnc.snow.compiler.ir.core.IROp;
+import org.jcnc.snow.compiler.ir.core.IROpCode;
 import org.jcnc.snow.compiler.ir.core.IRValue;
-import org.jcnc.snow.compiler.ir.value.VirtualRegister;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 
 import java.util.List;
 
@@ -12,12 +12,12 @@ import java.util.List;
  * 格式为：dest = lhs (OP) rhs
  * 其中 dest 是结果寄存器，lhs 和 rhs 是操作数，OP 是操作符（如加法、减法等）。
  */
-public final class BinOpInstruction extends IRInstruction {
+public final class BinaryOperationInstruction extends IRInstruction {
     // 二元操作符，例如加法、减法、乘法、除法等
-    private final IROp op;
+    private final IROpCode op;
 
     // 存放运算结果的虚拟寄存器
-    private final VirtualRegister dest;
+    private final IRVirtualRegister dest;
 
     // 左操作数
     private final IRValue lhs;
@@ -33,7 +33,7 @@ public final class BinOpInstruction extends IRInstruction {
      * @param lhs  左侧操作数
      * @param rhs  右侧操作数
      */
-    public BinOpInstruction(IROp op, VirtualRegister dest, IRValue lhs, IRValue rhs) {
+    public BinaryOperationInstruction(IROpCode op, IRVirtualRegister dest, IRValue lhs, IRValue rhs) {
         this.op   = op;
         this.dest = dest;
         this.lhs  = lhs;
@@ -46,7 +46,7 @@ public final class BinOpInstruction extends IRInstruction {
      * @return 操作符
      */
     @Override
-    public IROp op() {
+    public IROpCode op() {
         return op;
     }
 
@@ -56,7 +56,7 @@ public final class BinOpInstruction extends IRInstruction {
      * @return 目标寄存器
      */
     @Override
-    public VirtualRegister dest() {
+    public IRVirtualRegister dest() {
         return dest;
     }
 

src/main/java/org/jcnc/snow/compiler/ir/instruction/LoadConstInstruction.java

@@ -1,24 +1,24 @@
-package org.jcnc.snow.compiler.ir.instr;
+package org.jcnc.snow.compiler.ir.instruction;
 
 import org.jcnc.snow.compiler.ir.core.IRInstruction;
-import org.jcnc.snow.compiler.ir.core.IROp;
+import org.jcnc.snow.compiler.ir.core.IROpCode;
 import org.jcnc.snow.compiler.ir.core.IRValue;
-import org.jcnc.snow.compiler.ir.value.Constant;
+import org.jcnc.snow.compiler.ir.value.IRConstant;
-import org.jcnc.snow.compiler.ir.value.VirtualRegister;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 
 import java.util.List;
 
 /**
- * 表示常量加载指令（Load Constant Instruction）。
+ * 表示常量加载指令（Load IRConstant Instruction）。
  * 格式为：dest = CONST k
  * 其中 dest 是结果寄存器，k 是要加载的常量值。
  */
 public final class LoadConstInstruction extends IRInstruction {
     // 要加载的常量值
-    private final Constant k;
+    private final IRConstant k;
     
     // 存放常量的目标虚拟寄存器
-    private final VirtualRegister dest;
+    private final IRVirtualRegister dest;
 
     /**
      * 构造函数，创建一个常量加载指令实例。
@@ -26,7 +26,7 @@ public final class LoadConstInstruction extends IRInstruction {
      * @param dest 目标寄存器，用于存放常量
      * @param k    要加载的常量值
      */
-    public LoadConstInstruction(VirtualRegister dest, Constant k) {
+    public LoadConstInstruction(IRVirtualRegister dest, IRConstant k) {
         this.dest = dest;
         this.k    = k;
     }
@@ -34,11 +34,11 @@ public final class LoadConstInstruction extends IRInstruction {
     /**
      * 获取此指令的操作符，恒为 CONST。
      *
-     * @return 操作符 IROp.CONST
+     * @return 操作符 IROpCode.CONST
      */
     @Override
-    public IROp op() {
+    public IROpCode op() {
-        return IROp.CONST;
+        return IROpCode.CONST;
     }
 
     /**
@@ -47,7 +47,7 @@ public final class LoadConstInstruction extends IRInstruction {
      * @return 目标虚拟寄存器
      */
     @Override
-    public VirtualRegister dest() {
+    public IRVirtualRegister dest() {
         return dest;
     }
 

src/main/java/org/jcnc/snow/compiler/ir/instruction/ReturnInstruction.java

@@ -1,9 +1,9 @@
-package org.jcnc.snow.compiler.ir.instr;
+package org.jcnc.snow.compiler.ir.instruction;
 
 import org.jcnc.snow.compiler.ir.core.IRInstruction;
-import org.jcnc.snow.compiler.ir.core.IROp;
+import org.jcnc.snow.compiler.ir.core.IROpCode;
 import org.jcnc.snow.compiler.ir.core.IRValue;
-import org.jcnc.snow.compiler.ir.value.VirtualRegister;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 
 import java.util.List;
 
@@ -16,25 +16,25 @@ import java.util.List;
  */
 public final class ReturnInstruction extends IRInstruction {
     // 返回值对应的虚拟寄存器，如果是 void 返回则为 null
-    private final VirtualRegister value;
+    private final IRVirtualRegister value;
 
     /**
      * 构造函数，创建一个返回指令实例。
      *
      * @param value 要返回的虚拟寄存器，如果是 void 返回则传入 null
      */
-    public ReturnInstruction(VirtualRegister value) {
+    public ReturnInstruction(IRVirtualRegister value) {
         this.value = value;
     }
 
     /**
      * 获取此指令的操作符，恒为 RET。
      *
-     * @return 操作符 IROp.RET
+     * @return 操作符 IROpCode.RET
      */
     @Override
-    public IROp op() {
+    public IROpCode op() {
-        return IROp.RET;
+        return IROpCode.RET;
     }
 
     /**
@@ -54,7 +54,7 @@ public final class ReturnInstruction extends IRInstruction {
      *
      * @return 返回值寄存器，或 null（表示 void 返回）
      */
-    public VirtualRegister value() {
+    public IRVirtualRegister value() {
         return value;
     }
 

src/main/java/org/jcnc/snow/compiler/ir/instruction/UnaryOperationInstruction.java

@@ -1,9 +1,9 @@
-package org.jcnc.snow.compiler.ir.instr;
+package org.jcnc.snow.compiler.ir.instruction;
 
 import org.jcnc.snow.compiler.ir.core.IRInstruction;
-import org.jcnc.snow.compiler.ir.core.IROp;
+import org.jcnc.snow.compiler.ir.core.IROpCode;
 import org.jcnc.snow.compiler.ir.core.IRValue;
-import org.jcnc.snow.compiler.ir.value.VirtualRegister;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 
 import java.util.List;
 
@@ -15,12 +15,12 @@ import java.util.List;
  * - OP：一元操作符（如取负、按位取反等）
  * - val：操作数
  */
-public final class UnaryOpInstruction extends IRInstruction {
+public final class UnaryOperationInstruction extends IRInstruction {
     // 一元操作符，例如 NEG（取负）、NOT（逻辑非）等
-    private final IROp op;
+    private final IROpCode op;
 
     // 运算结果存放的目标虚拟寄存器
-    private final VirtualRegister dest;
+    private final IRVirtualRegister dest;
 
     // 一元运算的操作数
     private final IRValue val;
@@ -32,7 +32,7 @@ public final class UnaryOpInstruction extends IRInstruction {
      * @param dest 结果存放的目标寄存器
      * @param val  操作数
      */
-    public UnaryOpInstruction(IROp op, VirtualRegister dest, IRValue val) {
+    public UnaryOperationInstruction(IROpCode op, IRVirtualRegister dest, IRValue val) {
         this.op = op;
         this.dest = dest;
         this.val = val;
@@ -44,7 +44,7 @@ public final class UnaryOpInstruction extends IRInstruction {
      * @return 一元操作符
      */
     @Override
-    public IROp op() {
+    public IROpCode op() {
         return op;
     }
 
@@ -54,7 +54,7 @@ public final class UnaryOpInstruction extends IRInstruction {
      * @return 目标虚拟寄存器
      */
     @Override
-    public VirtualRegister dest() {
+    public IRVirtualRegister dest() {
         return dest;
     }
 

src/main/java/org/jcnc/snow/compiler/ir/value/IRConstant.java

@@ -3,11 +3,11 @@ package org.jcnc.snow.compiler.ir.value;
 import org.jcnc.snow.compiler.ir.core.IRValue;
 
 /**
- * Constant 类 —— 表示一个常量值（例如整数常量、字符串常量等）。
+ * IRConstant 类 —— 表示一个常量值（例如整数常量、字符串常量等）。
  * <p>
  * 在中间表示（IR）中，常量通常是不可变的、直接使用的值，而不是寄存器或临时变量。
  */
-public record Constant(Object value) implements IRValue {
+public record IRConstant(Object value) implements IRValue {
 
     /**
      * 将常量值转换为字符串表示。

src/main/java/org/jcnc/snow/compiler/ir/value/IRLabel.java

@@ -3,14 +3,14 @@ package org.jcnc.snow.compiler.ir.value;
 import org.jcnc.snow.compiler.ir.core.IRValue;
 
 /**
- * Label —— 表示 IR 中的跳转目标标签。
+ * IRLabel —— 表示 IR 中的跳转目标标签。
  *
  * 在中间表示（IR）中，控制流指令（如 JUMP、JUMP_IF_ZERO）需要依赖标签来指定跳转位置。
  * 本类通过名字（字符串）唯一标识一个标签。
  *
- * Label 也是一种 IRValue，因此可以作为指令的操作数。
+ * IRLabel 也是一种 IRValue，因此可以作为指令的操作数。
  */
-public record Label(String name) implements IRValue {
+public record IRLabel(String name) implements IRValue {
 
     /**
      * 将标签转换为字符串形式。

src/main/java/org/jcnc/snow/compiler/ir/value/IRVirtualRegister.java

@@ -3,7 +3,7 @@ package org.jcnc.snow.compiler.ir.value;
 import org.jcnc.snow.compiler.ir.core.IRValue;
 
 /**
- * VirtualRegister —— 表示一个 SSA（静态单赋值）虚拟寄存器。
+ * IRVirtualRegister —— 表示一个 SSA（静态单赋值）虚拟寄存器。
  * <p>
  * 在中间表示（IR）中，每个中间值都存储在一个虚拟寄存器中。
  * <p>
@@ -11,9 +11,9 @@ import org.jcnc.snow.compiler.ir.core.IRValue;
  *   - 每个寄存器都有唯一的 id（通常由 IRBuilder 自动分配）
  *   - 遵循 SSA 形式，即每个寄存器只被赋值一次
  * <p>
- * VirtualRegister 也是一种 IRValue，可以作为指令的操作数。
+ * IRVirtualRegister 也是一种 IRValue，可以作为指令的操作数。
  */
-public record VirtualRegister(int id) implements IRValue {
+public record IRVirtualRegister(int id) implements IRValue {
 
     /**
      * 将虚拟寄存器转换为字符串形式。