Merge branch 'dev' into feat/refactor-opcode

src/main/java/org/jcnc/snow/compiler/backend/generator/CallGenerator.java

@@ -62,7 +62,7 @@ public class CallGenerator implements InstructionGenerator<CallInstruction> {
             char t = out.getSlotType(slotId);                  // 获取参数类型
             if (t == '\0') t = 'I';                            // 类型未知时默认整型
             // 生成类型相关的加载指令，如 I_LOAD、F_LOAD 等
-            out.emit(OpHelper.opcode(String.valueOf(t) + "_LOAD") + " " + slotId);
+            out.emit(OpHelper.opcode(t + "_LOAD") + " " + slotId);
         }
 
         // —— 3. 生成 CALL 调用指令 ——
@@ -70,7 +70,7 @@ public class CallGenerator implements InstructionGenerator<CallInstruction> {
 
         // —— 4. 将返回值存入目标槽，并记录槽的类型 ——
         int destSlot = slotMap.get(ins.getDest()); // 目标寄存器槽
-        out.emit(OpHelper.opcode(String.valueOf(retType) + "_STORE") + " " + destSlot);
+        out.emit(OpHelper.opcode(retType + "_STORE") + " " + destSlot);
         out.setSlotType(destSlot, retType);        // 标记返回值类型
     }
 }

src/main/java/org/jcnc/snow/compiler/parser/function/ASTPrinter.java

@@ -67,6 +67,7 @@ public class ASTPrinter {
             }
             case FunctionNode(
                     String name, List<ParameterNode> parameters, String returnType, List<StatementNode> body
+                    , _, _, _
             ) -> {
                 System.out.println(pad + "function " + name
                         + "(params=" + parameters + ", return=" + returnType + ")");
@@ -81,9 +82,12 @@ public class ASTPrinter {
                         .orElse("");
                 System.out.println(pad + "declare " + d.getName() + ":" + d.getType() + init);
             }
-            case AssignmentNode(String variable, ExpressionNode value) ->
+            case AssignmentNode(String variable, ExpressionNode value, _, int _, String _) ->
                     System.out.println(pad + variable + " = " + value);
-            case IfNode(ExpressionNode condition, List<StatementNode> thenBranch, List<StatementNode> elseBranch) -> {
+            case IfNode(
+                    ExpressionNode condition, List<StatementNode> thenBranch, List<StatementNode> elseBranch, int _,
+                    int _, String _
+            ) -> {
                 System.out.println(pad + "if " + condition);
                 for (StatementNode stmt : thenBranch) {
                     print(stmt, indent + 1);
@@ -97,6 +101,7 @@ public class ASTPrinter {
             }
             case LoopNode(
                     StatementNode initializer, ExpressionNode condition, StatementNode update, List<StatementNode> body
+                    , int _, int _, String _
             ) -> {
                 System.out.println(pad + "loop {");
                 print(initializer, indent + 1);
@@ -111,10 +116,9 @@ public class ASTPrinter {
             }
             case ReturnNode r -> System.out.println(pad + "return" +
                     r.getExpression().map(e -> " " + e).orElse(""));
-            case ExpressionStatementNode(ExpressionNode expression) ->
+            case ExpressionStatementNode(ExpressionNode expression, int _, int _, String _) ->
                     System.out.println(pad + expression);
-            case null, default ->
+            case null, default -> System.out.println(pad + n);  // 回退处理
-                    System.out.println(pad + n);  // 回退处理
         }
     }
 

src/main/java/org/jcnc/snow/compiler/parser/utils/ASTJsonSerializer.java

@@ -81,7 +81,10 @@ public class ASTJsonSerializer {
     private static Object nodeToMap(Node n) {
         return switch (n) {
             // 模块节点
-            case ModuleNode(String name, List<ImportNode> imports, List<FunctionNode> functions) -> {
+            case ModuleNode(
+                    String name, List<ImportNode> imports, List<FunctionNode> functions, _, int _,
+                    String _
+            ) -> {
                 Map<String, Object> map = newNodeMap("Module");
                 map.put("name", name);
                 List<Object> imps = new ArrayList<>(imports.size());
@@ -177,20 +180,23 @@ public class ASTJsonSerializer {
     private static Object exprToMap(ExpressionNode expr) {
         return switch (expr) {
             // 二元表达式
-            case BinaryExpressionNode(ExpressionNode left, String operator, ExpressionNode right) -> exprMap("BinaryExpression",
+            case BinaryExpressionNode(
+                    ExpressionNode left, String operator, ExpressionNode right, int _, int _, String _
+            ) -> exprMap("BinaryExpression",
                     "left", exprToMap(left),
                     "operator", operator,
                     "right", exprToMap(right)
             );
             // 一元表达式
-            case UnaryExpressionNode(String operator, ExpressionNode operand) -> exprMap("UnaryExpression",
+            case UnaryExpressionNode(String operator, ExpressionNode operand, int _, int _, String _) ->
-                    "operator", operator,
+                    exprMap("UnaryExpression",
-                    "operand", exprToMap(operand)
+                            "operator", operator,
-            );
+                            "operand", exprToMap(operand)
+                    );
             // 布尔字面量
             case BoolLiteralNode(boolean value) -> exprMap("BoolLiteral", "value", value);
             // 标识符
-            case IdentifierNode(String name) -> exprMap("Identifier", "name", name);
+            case IdentifierNode(String name, int _, int _, String _) -> exprMap("Identifier", "name", name);
             // 数字字面量
             case NumberLiteralNode(String value) -> exprMap("NumberLiteral", "value", value);
             // 字符串字面量
@@ -202,10 +208,11 @@ public class ASTJsonSerializer {
                 yield exprMap("CallExpression", "callee", exprToMap(callee), "arguments", args);
             }
             // 成员访问表达式
-            case MemberExpressionNode(ExpressionNode object, String member) -> exprMap("MemberExpression",
+            case MemberExpressionNode(ExpressionNode object, String member, int _, int _, String _) ->
-                    "object", exprToMap(object),
+                    exprMap("MemberExpression",
-                    "member", member
+                            "object", exprToMap(object),
-            );
+                            "member", member
+                    );
             // 默认兜底处理：只写类型
             default -> Map.of("type", expr.getClass().getSimpleName());
         };