diff --git a/src/main/java/org/jcnc/snow/compiler/semantic/core/SemanticAnalyzer.java b/src/main/java/org/jcnc/snow/compiler/semantic/core/SemanticAnalyzer.java
index c4e94b8..0b3c0af 100644
--- a/src/main/java/org/jcnc/snow/compiler/semantic/core/SemanticAnalyzer.java
+++ b/src/main/java/org/jcnc/snow/compiler/semantic/core/SemanticAnalyzer.java
@@ -55,37 +55,123 @@ public class SemanticAnalyzer {
         this.ctx = new Context(modules, errors, verbose, registry);
         registerAnalyzers();
     }
-
     /**
-     * 注册所有语句与表达式分析器到 {@link AnalyzerRegistry}。
+     * 注册所有的语句分析器 (StatementAnalyzer) 和表达式分析器 (ExpressionAnalyzer) 到
+     * {@link AnalyzerRegistry} 中，以便框架在遍历 AST 时能够根据节点类型分发到对应的分析器。
      * <p>
-     * 包括：声明、赋值、分支、循环、返回、表达式语句以及
-     * 数字、字符串、标识符、调用、二元、兜底表达式分析器。
+     * <strong>语句分析器</strong>（StatementAnalyzer）：
+     * <ul>
+     *   <li>{@link DeclarationNode} → {@link DeclarationAnalyzer}，处理变量声明</li>
+     *   <li>{@link AssignmentNode} → {@link AssignmentAnalyzer}，处理赋值语句</li>
+     *   <li>{@link IfNode} → {@link IfAnalyzer}，处理条件分支</li>
+     *   <li>{@link LoopNode} → {@link LoopAnalyzer}，处理循环语句</li>
+     *   <li>{@link ReturnNode} → {@link ReturnAnalyzer}，处理返回语句</li>
+     *   <li>{@link ExpressionStatementNode} → 直接委托给相应的表达式分析器</li>
+     * </ul>
+     * <p>
+     * <strong>表达式分析器</strong>（ExpressionAnalyzer）：
+     * <ul>
+     *   <li>{@link NumberLiteralNode} → {@link NumberLiteralAnalyzer}，数字字面量</li>
+     *   <li>{@link StringLiteralNode} → {@link StringLiteralAnalyzer}，字符串字面量</li>
+     *   <li>{@link IdentifierNode} → {@link IdentifierAnalyzer}，标识符</li>
+     *   <li>{@link CallExpressionNode} → {@link CallExpressionAnalyzer}，函数调用</li>
+     *   <li>{@link BinaryExpressionNode} → {@link BinaryExpressionAnalyzer}，二元运算</li>
+     * </ul>
+     * <p>
+     * <strong>默认兜底</strong>：
+     * <ul>
+     *   <li>未注册的表达式节点会由 {@link UnsupportedExpressionAnalyzer} 处理，记录错误并降级类型</li>
+     * </ul>
      */
     private void registerAnalyzers() {
-        // 语句分析器
-        registry.registerStatementAnalyzer(DeclarationNode.class, new DeclarationAnalyzer());
-        registry.registerStatementAnalyzer(AssignmentNode.class,  new AssignmentAnalyzer());
-        registry.registerStatementAnalyzer(IfNode.class,          new IfAnalyzer());
-        registry.registerStatementAnalyzer(LoopNode.class,        new LoopAnalyzer());
-        registry.registerStatementAnalyzer(ReturnNode.class,      new ReturnAnalyzer());
-        registry.registerStatementAnalyzer(ExpressionStatementNode.class,
-                (c, mi, fn, locals, stmt) -> {
-                    var exprAn = c.getRegistry().getExpressionAnalyzer(stmt.expression());
-                    exprAn.analyze(c, mi, fn, locals, stmt.expression());
+        // -----------------------------------------------------------------
+        // 语句分析器注册（StatementAnalyzer）
+        // -----------------------------------------------------------------
+        // 变量声明语句：DeclarationNode
+        registry.registerStatementAnalyzer(
+                DeclarationNode.class,
+                new DeclarationAnalyzer()
+        );
+
+        // 赋值语句：AssignmentNode
+        registry.registerStatementAnalyzer(
+                AssignmentNode.class,
+                new AssignmentAnalyzer()
+        );
+
+        // if 分支语句：IfNode
+        registry.registerStatementAnalyzer(
+                IfNode.class,
+                new IfAnalyzer()
+        );
+
+        // loop 循环语句：LoopNode
+        registry.registerStatementAnalyzer(
+                LoopNode.class,
+                new LoopAnalyzer()
+        );
+
+        // return 语句：ReturnNode
+        registry.registerStatementAnalyzer(
+                ReturnNode.class,
+                new ReturnAnalyzer()
+        );
+
+        // 表达式语句（仅执行表达式，不产生新的值）：ExpressionStatementNode
+        registry.registerStatementAnalyzer(
+                ExpressionStatementNode.class,
+                (ctx, mi, fn, locals, stmt) -> {
+                    // 将表达式语句委托给对应的表达式分析器
+                    var exprAnalyzer = ctx.getRegistry().getExpressionAnalyzer(stmt.expression());
+                    exprAnalyzer.analyze(ctx, mi, fn, locals, stmt.expression());
                 }
         );
 
-        // 表达式分析器
-        registry.registerExpressionAnalyzer(NumberLiteralNode.class, new NumberLiteralAnalyzer());
-        registry.registerExpressionAnalyzer(StringLiteralNode.class, new StringLiteralAnalyzer());
-        registry.registerExpressionAnalyzer(IdentifierNode.class,    new IdentifierAnalyzer());
-        registry.registerExpressionAnalyzer(CallExpressionNode.class,new CallExpressionAnalyzer());
-        registry.registerExpressionAnalyzer(BinaryExpressionNode.class, new BinaryExpressionAnalyzer());
-        // 默认兜底
-        registry.registerExpressionAnalyzer(MemberExpressionNode.class, new UnsupportedExpressionAnalyzer<>());
+
+        // -----------------------------------------------------------------
+        // 表达式分析器注册（ExpressionAnalyzer）
+        // -----------------------------------------------------------------
+        // 数字字面量：NumberLiteralNode → INT
+        registry.registerExpressionAnalyzer(
+                NumberLiteralNode.class,
+                new NumberLiteralAnalyzer()
+        );
+
+        // 字符串字面量：StringLiteralNode → STRING
+        registry.registerExpressionAnalyzer(
+                StringLiteralNode.class,
+                new StringLiteralAnalyzer()
+        );
+
+        // 标识符：IdentifierNode → 查符号表
+        registry.registerExpressionAnalyzer(
+                IdentifierNode.class,
+                new IdentifierAnalyzer()
+        );
+
+        // 函数调用：CallExpressionNode → 查函数签名并校验参数
+        registry.registerExpressionAnalyzer(
+                CallExpressionNode.class,
+                new CallExpressionAnalyzer()
+        );
+
+        // 二元运算：BinaryExpressionNode → 根据运算符和操作数推导类型
+        registry.registerExpressionAnalyzer(
+                BinaryExpressionNode.class,
+                new BinaryExpressionAnalyzer()
+        );
+
+        // -----------------------------------------------------------------
+        // 默认兜底：所有未显式注册的 MemberExpressionNode 及其它表达式
+        // -----------------------------------------------------------------
+        // 如果遇到不支持的表达式节点类型，将由此分析器记录错误并降级为 INT
+        registry.registerExpressionAnalyzer(
+                MemberExpressionNode.class,
+                new UnsupportedExpressionAnalyzer<>()
+        );
     }
 
+
     /**
      * 对给定的模块 AST 列表执行完整的语义分析。
      *