From b454d6596242bc626dcef6400190abd41be951ca Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Mon, 25 Aug 2025 18:00:40 +0800
Subject: [PATCH 01/35] =?UTF-8?q?chore:=20=E6=96=B0=E5=A2=9E=20Demo14=20?=
 =?UTF-8?q?=E7=9A=84=E8=BF=90=E8=A1=8C=E9=85=8D=E7=BD=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .run/Demo14.run.xml | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/.run/Demo14.run.xml b/.run/Demo14.run.xml
index 8b0f241..0f4b83e 100644
--- a/.run/Demo14.run.xml
+++ b/.run/Demo14.run.xml
@@ -7,4 +7,12 @@
       <option name="Make" enabled="true" />
     </method>
   </configuration>
+  <configuration default="false" name="Demo14" type="Application" factoryName="Application" folderName="Demo">
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
+    <module name="Snow" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo/Demo14 -o target/Demo14" />
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
 </component>
\ No newline at end of file

From 5f42beaf2a63991d32edb5e5ddad952d4451080e Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Mon, 25 Aug 2025 18:00:54 +0800
Subject: [PATCH 02/35] =?UTF-8?q?test:=20=E6=B7=BB=E5=8A=A0=20Demo22=20?=
 =?UTF-8?q?=E6=BC=94=E7=A4=BA=E9=A1=B9=E7=9B=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 playground/Demo/Demo22/Main.snow    | 12 ++++++++++++
 playground/Demo/Demo22/ModuleA.snow | 11 +++++++++++
 playground/Demo/Demo22/OS.snow      | 11 +++++++++++
 3 files changed, 34 insertions(+)
 create mode 100644 playground/Demo/Demo22/Main.snow
 create mode 100644 playground/Demo/Demo22/ModuleA.snow
 create mode 100644 playground/Demo/Demo22/OS.snow

diff --git a/playground/Demo/Demo22/Main.snow b/playground/Demo/Demo22/Main.snow
new file mode 100644
index 0000000..1c727b4
--- /dev/null
+++ b/playground/Demo/Demo22/Main.snow
@@ -0,0 +1,12 @@
+module: Main
+    import: os,ModuleA
+    globals:
+        declare sum: int = 3
+    function: main
+        returns: void
+        body:
+            sum = sum + ModuleA._sum(1, 2)
+            os.print(sum)
+        end body
+    end function
+end module
diff --git a/playground/Demo/Demo22/ModuleA.snow b/playground/Demo/Demo22/ModuleA.snow
new file mode 100644
index 0000000..c5c9a86
--- /dev/null
+++ b/playground/Demo/Demo22/ModuleA.snow
@@ -0,0 +1,11 @@
+module: ModuleA
+    function: _sum
+        params:
+            declare a: int
+            declare b: int
+        returns: int
+        body:
+            return a + b
+        end body
+    end function
+end module
\ No newline at end of file
diff --git a/playground/Demo/Demo22/OS.snow b/playground/Demo/Demo22/OS.snow
new file mode 100644
index 0000000..1982627
--- /dev/null
+++ b/playground/Demo/Demo22/OS.snow
@@ -0,0 +1,11 @@
+module: os
+    import: os
+    function: print
+        params:
+            declare i1: int
+        returns: void
+        body:
+            syscall("PRINT",i1)
+        end body
+    end function
+end module
\ No newline at end of file

From 0a35289ad0e584d1796a2714ad97f3bfc351ee89 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Mon, 25 Aug 2025 18:01:02 +0800
Subject: [PATCH 03/35] =?UTF-8?q?chore:=20=E6=B7=BB=E5=8A=A0=20Demo22?=
 =?UTF-8?q?=E8=BF=90=E8=A1=8C=E9=85=8D=E7=BD=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .run/Demo22.run.xml | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 .run/Demo22.run.xml

diff --git a/.run/Demo22.run.xml b/.run/Demo22.run.xml
new file mode 100644
index 0000000..e76f5c1
--- /dev/null
+++ b/.run/Demo22.run.xml
@@ -0,0 +1,10 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Demo22" type="Application" factoryName="Application" folderName="Demo">
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
+    <module name="Snow" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo/Demo22 -o target/Demo22" />
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file

From 18722216664752d8db013fa3d3c96bbf9fe242ce Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 01:16:26 +0800
Subject: [PATCH 04/35] =?UTF-8?q?refactor:=20=E4=BC=98=E5=8C=96=E8=B5=8B?=
 =?UTF-8?q?=E5=80=BC=E8=AF=AD=E5=8F=A5=E8=AF=AD=E4=B9=89=E5=88=86=E6=9E=90?=
 =?UTF-8?q?=E9=80=BB=E8=BE=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../statement/AssignmentAnalyzer.java         | 64 +++++++++++--------
 1 file changed, 39 insertions(+), 25 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/statement/AssignmentAnalyzer.java b/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/statement/AssignmentAnalyzer.java
index 3cd43f4..2ad7232 100644
--- a/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/statement/AssignmentAnalyzer.java
+++ b/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/statement/AssignmentAnalyzer.java
@@ -6,22 +6,28 @@ import org.jcnc.snow.compiler.semantic.analyzers.base.StatementAnalyzer;
 import org.jcnc.snow.compiler.semantic.core.Context;
 import org.jcnc.snow.compiler.semantic.core.ModuleInfo;
 import org.jcnc.snow.compiler.semantic.error.SemanticError;
-import org.jcnc.snow.compiler.semantic.symbol.*;
+import org.jcnc.snow.compiler.semantic.symbol.Symbol;
+import org.jcnc.snow.compiler.semantic.symbol.SymbolKind;
+import org.jcnc.snow.compiler.semantic.symbol.SymbolTable;
 import org.jcnc.snow.compiler.semantic.type.Type;
 
 /**
- * {@code AssignmentAnalyzer} 是赋值语句的语义分析器。
- * <p>
- * 负责分析和验证赋值语句的合法性，包括:
+ * {@code AssignmentAnalyzer} 负责对赋值语句进行语义校验。
+ *
+ * <h2>校验要点</h2>
  * <ul>
- *   <li>变量是否已声明且可赋值（必须为 {@link SymbolKind#VARIABLE} 类型）；</li>
- *   <li>赋值右值的类型是否与变量类型兼容；</li>
- *   <li>是否允许进行数值类型的自动宽化转换（如 {@code int → float}）。</li>
+ *   <li><b>左值解析</b>：确保标识符已声明；</li>
+ *   <li><b>常量保护</b>：禁止修改 {@link SymbolKind#CONSTANT}；</li>
+ *   <li><b>类型兼容</b>：验证右值类型与目标类型兼容，若均为数值类型则允许宽化转换（如 <code>int → double</code>）。</li>
  * </ul>
- * 若类型不兼容且无法自动宽化，则将记录语义错误并输出日志信息。
+ *
+ * 任何不满足条件的情况都会向 {@link Context#getErrors()} 记录 {@link SemanticError}。
  */
 public class AssignmentAnalyzer implements StatementAnalyzer<AssignmentNode> {
 
+    /** 错误消息前缀，统一便于搜索定位 */
+    private static final String ERR_PREFIX = "赋值错误: ";
+
     /**
      * 分析赋值语句的语义有效性，包括左值合法性与类型匹配性。
      *
@@ -41,29 +47,37 @@ public class AssignmentAnalyzer implements StatementAnalyzer<AssignmentNode> {
         // 获取赋值左值变量名并进行符号解析
         ctx.log("赋值检查: " + asg.variable());
         Symbol sym = locals.resolve(asg.variable());
-
-        // 检查变量是否已声明且为可赋值的变量类型
-        if (sym == null || sym.kind() != SymbolKind.VARIABLE) {
+        if (sym == null) {
             ctx.getErrors().add(new SemanticError(asg,
-                    "未声明的变量: " + asg.variable()));
-            ctx.log("错误: 未声明的变量 " + asg.variable());
+                    ERR_PREFIX + "未声明的变量: " + asg.variable()));
+            ctx.log(ERR_PREFIX + "未声明的变量 " + asg.variable());
+            return; // 无需继续后续检查
+        }
+
+        /* ---------- 2. 常量不可修改 ---------- */
+        if (sym.kind() == SymbolKind.CONSTANT) {
+            ctx.getErrors().add(new SemanticError(asg,
+                    ERR_PREFIX + "无法修改常量: " + asg.variable()));
+            ctx.log(ERR_PREFIX + "尝试修改常量 " + asg.variable());
             return;
         }
 
-        // 分析右值表达式类型
-        Type valType = ctx.getRegistry().getExpressionAnalyzer(asg.value())
+        /* ---------- 3. 右值类型分析 ---------- */
+        Type rhsType = ctx.getRegistry()
+                .getExpressionAnalyzer(asg.value())
                 .analyze(ctx, mi, fn, locals, asg.value());
 
-        // 类型检查: 若类型不兼容，则尝试判断是否允许宽化转换
-        if (!sym.type().isCompatible(valType)) {
-            // 数值类型允许自动宽化转换（如 int → double）
-            if (!(sym.type().isNumeric() && valType.isNumeric()
-                    && Type.widen(valType, sym.type()) == sym.type())) {
-                ctx.getErrors().add(new SemanticError(asg,
-                        "赋值类型不匹配: 期望 " + sym.type()
-                                + ", 实际 " + valType));
-                ctx.log("错误: 赋值类型不匹配 " + asg.variable());
-            }
+        /* ---------- 4. 类型兼容性检查 ---------- */
+        boolean compatible = sym.type().isCompatible(rhsType);
+        boolean widenOK = sym.type().isNumeric()
+                && rhsType.isNumeric()
+                && Type.widen(rhsType, sym.type()) == sym.type();
+
+        if (!compatible && !widenOK) {
+            ctx.getErrors().add(new SemanticError(asg,
+                    ERR_PREFIX + "类型不匹配: 期望 "
+                            + sym.type() + ", 实际 " + rhsType));
+            ctx.log(ERR_PREFIX + "类型不匹配 " + asg.variable());
         }
     }
 }

From d0c34ce1c2c198584c5e5f9436f78c0efd24acf4 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 01:16:40 +0800
Subject: [PATCH 05/35] =?UTF-8?q?feat:=20=E4=BC=98=E5=8C=96=E5=A3=B0?=
 =?UTF-8?q?=E6=98=8E=E8=AF=AD=E5=8F=A5=E8=AF=AD=E4=B9=89=E5=88=86=E6=9E=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 重构代码，优化分析流程，增加对常量声明的处理
-改进错误处理和日志输出，提高可读性和调试友好性
- 修复了一些潜在的语义分析问题，如常量未初始化的检查
---
 .../statement/DeclarationAnalyzer.java        | 70 +++++++++++--------
 1 file changed, 40 insertions(+), 30 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/statement/DeclarationAnalyzer.java b/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/statement/DeclarationAnalyzer.java
index 6a5eb93..4a830fb 100644
--- a/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/statement/DeclarationAnalyzer.java
+++ b/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/statement/DeclarationAnalyzer.java
@@ -6,7 +6,9 @@ import org.jcnc.snow.compiler.semantic.analyzers.base.StatementAnalyzer;
 import org.jcnc.snow.compiler.semantic.core.Context;
 import org.jcnc.snow.compiler.semantic.core.ModuleInfo;
 import org.jcnc.snow.compiler.semantic.error.SemanticError;
-import org.jcnc.snow.compiler.semantic.symbol.*;
+import org.jcnc.snow.compiler.semantic.symbol.Symbol;
+import org.jcnc.snow.compiler.semantic.symbol.SymbolKind;
+import org.jcnc.snow.compiler.semantic.symbol.SymbolTable;
 import org.jcnc.snow.compiler.semantic.type.BuiltinType;
 import org.jcnc.snow.compiler.semantic.type.Type;
 
@@ -25,7 +27,7 @@ import org.jcnc.snow.compiler.semantic.type.Type;
 public class DeclarationAnalyzer implements StatementAnalyzer<DeclarationNode> {
 
     /**
-     * 对变量声明语句执行语义分析。
+     * 对单条声明语句执行语义分析。
      *
      * @param ctx    当前语义分析上下文对象，提供类型解析、错误记录、日志输出等功能。
      * @param mi     当前模块信息，支持跨模块引用检查（本分析器未直接使用）。
@@ -40,45 +42,53 @@ public class DeclarationAnalyzer implements StatementAnalyzer<DeclarationNode> {
                         SymbolTable locals,
                         DeclarationNode decl) {
 
-        // 1. 解析声明类型
+        /* ---------- 1. 解析类型 ---------- */
         Type varType = ctx.parseType(decl.getType());
         if (varType == null) {
+            // 未知类型：记录错误并使用 int 兜底，避免后续空指针
             ctx.getErrors().add(new SemanticError(decl,
                     "未知类型: " + decl.getType()));
             ctx.log("错误: 未知类型 " + decl.getType()
-                    + " 在声明 " + decl.getName());
-            varType = BuiltinType.INT;  // 容错处理: 默认降级为 int
+                    + " (声明 " + decl.getName() + ")");
+            varType = BuiltinType.INT;
         }
-        ctx.log("声明变量: " + decl.getName()
-                + " 类型: " + varType);
+        ctx.log("声明" + (decl.isConst() ? "常量" : "变量")
+                + ": " + decl.getName() + " 类型: " + varType);
 
-        // 2. 将变量注册到当前作用域符号表中，检查重复定义
-        if (!locals.define(new Symbol(
-                decl.getName(), varType, SymbolKind.VARIABLE
-        ))) {
+        /* ---------- 2. 常量必须初始化 ---------- */
+        if (decl.isConst() && decl.getInitializer().isEmpty()) {
             ctx.getErrors().add(new SemanticError(decl,
-                    "变量重复声明: " + decl.getName()));
-            ctx.log("错误: 变量重复声明 " + decl.getName());
+                    "常量必须在声明时初始化: " + decl.getName()));
+            // 继续分析以捕获更多错误
         }
 
-        // 3. 检查初始化表达式（如果存在）
-        Type finalVarType = varType;  // 用于 lambda 捕获
-        decl.getInitializer().ifPresent(init -> {
-            Type initType = ctx.getRegistry().getExpressionAnalyzer(init)
-                    .analyze(ctx, mi, fn, locals, init);
+        /* ---------- 3. 注册符号并检测重名 ---------- */
+        SymbolKind kind = decl.isConst() ? SymbolKind.CONSTANT
+                : SymbolKind.VARIABLE;
+        if (!locals.define(new Symbol(decl.getName(), varType, kind))) {
+            ctx.getErrors().add(new SemanticError(decl,
+                    "重复声明: " + decl.getName()));
+            ctx.log("错误: 重复声明 " + decl.getName());
+        }
 
-            // 检查类型是否兼容，或是否允许数值宽化转换
-            if (!finalVarType.isCompatible(initType)) {
-                boolean canWiden = finalVarType.isNumeric()
-                        && initType.isNumeric()
-                        && Type.widen(initType, finalVarType) == finalVarType;
-                if (!canWiden) {
-                    ctx.getErrors().add(new SemanticError(decl,
-                            "初始化类型不匹配: 期望 " + finalVarType
-                                    + ", 实际 " + initType));
-                    ctx.log("错误: 初始化类型不匹配 "
-                            + decl.getName());
-                }
+        /* ---------- 4. 校验初始化表达式（若存在） ---------- */
+        Type finalVarType = varType;
+        decl.getInitializer().ifPresent(initExpr -> {
+            // 4.1 获取初始化表达式类型
+            Type initType = ctx.getRegistry()
+                    .getExpressionAnalyzer(initExpr)
+                    .analyze(ctx, mi, fn, locals, initExpr);
+
+            // 4.2 类型兼容性检查 + 数值宽化
+            boolean compatible = finalVarType.isCompatible(initType);
+            boolean widenOK = finalVarType.isNumeric()
+                    && initType.isNumeric()
+                    && Type.widen(initType, finalVarType) == finalVarType;
+
+            if (!compatible && !widenOK) {
+                ctx.getErrors().add(new SemanticError(decl,
+                        "初始化类型不匹配: 期望 " + finalVarType + ", 实际 " + initType));
+                ctx.log("错误: 初始化类型不匹配 " + decl.getName());
             }
         });
     }

From da7d7bbcaa4de912954c4e115ffc5da487a4ef31 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 01:17:13 +0800
Subject: [PATCH 06/35] =?UTF-8?q?feat:=20=E5=A2=9E=E5=8A=A0=E5=B8=B8?=
 =?UTF-8?q?=E9=87=8F=E5=A3=B0=E6=98=8E=E6=94=AF=E6=8C=81=E5=B9=B6=E4=BC=98?=
 =?UTF-8?q?=E5=8C=96=E5=A3=B0=E6=98=8E=E8=AF=AD=E5=8F=A5=E8=A7=A3=E6=9E=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 增加对常量声明的支持，通过匹配 "const" 关键字
-优化代码结构，使用 var tokens变量引用词法 token 流
- 简化代码逻辑，提高可读性和可维护性
---
 .../statement/DeclarationStatementParser.java | 28 +++++++++++--------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/parser/statement/DeclarationStatementParser.java b/src/main/java/org/jcnc/snow/compiler/parser/statement/DeclarationStatementParser.java
index 5e0470b..319986a 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/statement/DeclarationStatementParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/statement/DeclarationStatementParser.java
@@ -34,45 +34,51 @@ public class DeclarationStatementParser implements StatementParser {
      */
     @Override
     public DeclarationNode parse(ParserContext ctx) {
+        // 便捷引用词法 token 流
+        var tokens = ctx.getTokens();
+
         // 获取当前 token 的行号、列号和文件名
-        int line = ctx.getTokens().peek().getLine();
-        int column = ctx.getTokens().peek().getCol();
+        int line = tokens.peek().getLine();
+        int column = tokens.peek().getCol();
         String file = ctx.getSourceName();
 
         // 声明语句必须以 "declare" 开头
-        ctx.getTokens().expect("declare");
+        tokens.expect("declare");
+
+        // 是否声明为常量
+        boolean isConst = tokens.match("const");
 
         // 获取变量名称（标识符）
-        String name = ctx.getTokens()
+        String name = tokens
                 .expectType(TokenType.IDENTIFIER)
                 .getLexeme();
 
         // 类型标注的冒号分隔符
-        ctx.getTokens().expect(":");
+        tokens.expect(":");
 
         // 获取变量类型（类型标识符）
         StringBuilder type = new StringBuilder(
-                ctx.getTokens()
+                tokens
                         .expectType(TokenType.TYPE)
                         .getLexeme()
         );
 
         // 消费多维数组类型后缀 "[]"
-        while (ctx.getTokens().match("[")) {
-            ctx.getTokens().expectType(TokenType.RBRACKET); // 必须配对
+        while (tokens.match("[")) {
+            tokens.expectType(TokenType.RBRACKET); // 必须配对
             type.append("[]"); // 类型名称拼接 []，如 int[][] 等
         }
 
         // 可选初始化表达式（=号右侧）
         ExpressionNode init = null;
-        if (ctx.getTokens().match("=")) {
+        if (tokens.match("=")) {
             init = new PrattExpressionParser().parse(ctx);
         }
 
         // 声明语句必须以换行符结尾
-        ctx.getTokens().expectType(TokenType.NEWLINE);
+        tokens.expectType(TokenType.NEWLINE);
 
         // 返回构建好的声明语法树节点
-        return new DeclarationNode(name, type.toString(), init, new NodeContext(line, column, file));
+        return new DeclarationNode(name, type.toString(), isConst, init, new NodeContext(line, column, file));
     }
 }

From c4e9e541fba4af7efe208f51280d50476f188568 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 01:17:47 +0800
Subject: [PATCH 07/35] =?UTF-8?q?refactor:=20=E4=BC=98=E5=8C=96=E5=85=A8?=
 =?UTF-8?q?=E5=B1=80=E5=8F=98=E9=87=8F=E5=A3=B0=E6=98=8E=E7=9A=84=E9=94=99?=
 =?UTF-8?q?=E8=AF=AF=E4=BF=A1=E6=81=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

-根据变量是否为常量，动态设置符号种类
-针对常量和变量分别定制重复声明的错误信息
---
 .../snow/compiler/semantic/core/FunctionChecker.java   | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/semantic/core/FunctionChecker.java b/src/main/java/org/jcnc/snow/compiler/semantic/core/FunctionChecker.java
index 50f1ec6..f60d854 100644
--- a/src/main/java/org/jcnc/snow/compiler/semantic/core/FunctionChecker.java
+++ b/src/main/java/org/jcnc/snow/compiler/semantic/core/FunctionChecker.java
@@ -57,13 +57,17 @@ public record FunctionChecker(Context ctx) {
 
             // 先构建全局符号表
             SymbolTable globalScope = new SymbolTable(null);
+            // 根据 isConst() 决定种类
             for (DeclarationNode g : mod.globals()) {
                 var t = ctx.parseType(g.getType());
-                // 检查全局变量是否重复声明
-                if (!globalScope.define(new Symbol(g.getName(), t, SymbolKind.VARIABLE))) {
+                SymbolKind k = g.isConst() ? SymbolKind.CONSTANT : SymbolKind.VARIABLE;
+
+                // 错误信息按常量/变量区分
+                String dupType = g.isConst() ? "常量" : "变量";
+                if (!globalScope.define(new Symbol(g.getName(), t, k))) {
                     ctx.errors().add(new SemanticError(
                             g,
-                            "全局变量重复声明: " + g.getName()
+                            dupType + "重复声明: " + g.getName()
                     ));
                 }
             }

From c44f8a4630de0eb53bde54c76a45cb8cda1f7740 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 01:18:07 +0800
Subject: [PATCH 08/35] =?UTF-8?q?refactor:=20=E4=BC=98=E5=8C=96=20declare?=
 =?UTF-8?q?=20=E8=AF=AD=E5=8F=A5=E7=9A=84=E6=A0=87=E8=AF=86=E7=AC=A6?=
 =?UTF-8?q?=E5=A4=84=E7=90=86=E9=80=BB=E8=BE=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 允许 declare 后跟随 const 关键字
-调整错误提示信息，使其更加清晰
- 优化代码结构，提高可读性
---
 .../snow/compiler/lexer/core/LexerEngine.java | 27 ++++++++++++-------
 1 file changed, 18 insertions(+), 9 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/lexer/core/LexerEngine.java b/src/main/java/org/jcnc/snow/compiler/lexer/core/LexerEngine.java
index 74f74f3..56cb63d 100644
--- a/src/main/java/org/jcnc/snow/compiler/lexer/core/LexerEngine.java
+++ b/src/main/java/org/jcnc/snow/compiler/lexer/core/LexerEngine.java
@@ -1,11 +1,9 @@
 package org.jcnc.snow.compiler.lexer.core;
 
-import org.jcnc.snow.common.SnowConfig;
 import org.jcnc.snow.compiler.lexer.base.TokenScanner;
 import org.jcnc.snow.compiler.lexer.scanners.*;
 import org.jcnc.snow.compiler.lexer.token.Token;
 import org.jcnc.snow.compiler.lexer.token.TokenType;
-import org.jcnc.snow.compiler.lexer.utils.TokenPrinter;
 
 import java.io.File;
 import java.util.ArrayList;
@@ -127,8 +125,8 @@ public class LexerEngine {
 
     /**
      * 目前包含2条规则: <br>
-     * 1. Declare-Ident declare 后必须紧跟合法标识符，并且只能一个<br>
-     * 2. Double-Ident declare 后若出现第二个 IDENTIFIER 视为多余<br>
+     * 1. Declare-Ident declare 后必须紧跟合法标识符（或 const + 标识符），并且只能一个<br>
+     * 2. Double-Ident declare 后若出现第二个多余的 IDENTIFIER<br>
      * <p>发现问题仅写入 {@link #errors}，不抛异常。</p>
      */
     private void validateTokens() {
@@ -139,17 +137,28 @@ public class LexerEngine {
             if (tok.getType() == TokenType.KEYWORD
                     && "declare".equalsIgnoreCase(tok.getLexeme())) {
 
-                // 第一个非 NEWLINE token
-                Token id1 = findNextNonNewline(i);
+                // 找 declare 后第一个非 NEWLINE token
+                Token t1 = findNextNonNewline(i);
+
+                // 如果有 const，允许
+                boolean hasConst = t1 != null
+                        && t1.getType() == TokenType.KEYWORD
+                        && "const".equalsIgnoreCase(t1.getLexeme());
+                int identStartIdx = hasConst ? tokens.indexOf(t1) : i;
+
+                // 找下一个非 NEWLINE token，如果有 const，就找下一个
+                Token id1 = findNextNonNewline(identStartIdx);
+
+                // id1 必须是 IDENTIFIER
                 if (id1 == null || id1.getType() != TokenType.IDENTIFIER) {
                     errors.add(err(
-                            (id1 == null ? tok : id1),
-                            "declare 后必须跟合法标识符 (以字母或 '_' 开头)"
+                            (id1 == null ? (hasConst ? t1 : tok) : id1),
+                            "declare 后必须跟合法标识符 (可选 const 关键字)"
                     ));
                     continue; // 若首标识符就错，后续检查可略
                 }
 
-                // 检查是否有第二个 IDENTIFIER
+                // 检查是否有第二个多余的 IDENTIFIER
                 Token id2 = findNextNonNewline(tokens.indexOf(id1));
                 if (id2 != null && id2.getType() == TokenType.IDENTIFIER) {
                     errors.add(err(id2, "declare 声明中出现多余的标识符"));

From 3b39e9059b007f47fde34eff92d805cd2b575aed Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 01:18:24 +0800
Subject: [PATCH 09/35] =?UTF-8?q?feat:=20=E6=B7=BB=E5=8A=A0=20const=20?=
 =?UTF-8?q?=E5=85=B3=E9=94=AE=E5=AD=97=E6=94=AF=E6=8C=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 在 TokenFactory 类中的 KEYWORDS 集合中添加了 "const" 关键字
- 此修改为编译器增加了对常量声明的支持，扩展了语言的功能
---
 .../org/jcnc/snow/compiler/lexer/token/TokenFactory.java    | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/lexer/token/TokenFactory.java b/src/main/java/org/jcnc/snow/compiler/lexer/token/TokenFactory.java
index 1b0afe3..01713b3 100644
--- a/src/main/java/org/jcnc/snow/compiler/lexer/token/TokenFactory.java
+++ b/src/main/java/org/jcnc/snow/compiler/lexer/token/TokenFactory.java
@@ -26,9 +26,9 @@ public class TokenFactory {
      * 语言的保留关键字集合。
      */
     private static final Set<String> KEYWORDS = Set.of
-             ("module", "function", "params", "returns", "body", "end",
-             "if", "then", "else", "loop", "declare", "return", "import", "init",
-             "cond", "step", "globals", "break", "continue");
+            ("module", "function", "params", "returns", "body", "end",
+                    "if", "then", "else", "loop", "declare", "return", "import", "init",
+                    "cond", "step", "globals", "break", "continue", "const");
 
     /**
      * 内置类型名称集合，如 int、string 等。

From d10b7336c1fda44499b25f765af77650a88c3946 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 01:18:40 +0800
Subject: [PATCH 10/35] =?UTF-8?q?test:=20=E9=87=8D=E6=9E=84=E7=A4=BA?=
 =?UTF-8?q?=E4=BE=8B=E4=BB=A3=E7=A0=81=20Demo22?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 playground/Demo/Demo22/Main.snow    |  4 ++--
 playground/Demo/Demo22/ModuleA.snow | 11 ++---------
 2 files changed, 4 insertions(+), 11 deletions(-)

diff --git a/playground/Demo/Demo22/Main.snow b/playground/Demo/Demo22/Main.snow
index 1c727b4..91865ef 100644
--- a/playground/Demo/Demo22/Main.snow
+++ b/playground/Demo/Demo22/Main.snow
@@ -1,11 +1,11 @@
 module: Main
     import: os,ModuleA
     globals:
-        declare sum: int = 3
+        declare sum: int
     function: main
         returns: void
         body:
-            sum = sum + ModuleA._sum(1, 2)
+            sum = ModuleA.a
             os.print(sum)
         end body
     end function
diff --git a/playground/Demo/Demo22/ModuleA.snow b/playground/Demo/Demo22/ModuleA.snow
index c5c9a86..5561ef6 100644
--- a/playground/Demo/Demo22/ModuleA.snow
+++ b/playground/Demo/Demo22/ModuleA.snow
@@ -1,11 +1,4 @@
 module: ModuleA
-    function: _sum
-        params:
-            declare a: int
-            declare b: int
-        returns: int
-        body:
-            return a + b
-        end body
-    end function
+    globals:
+        declare const a: int =10
 end module
\ No newline at end of file

From 310e90935904a8adf45affdb3798198e6546b583 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 01:43:27 +0800
Subject: [PATCH 11/35] =?UTF-8?q?test:=20=E9=87=8D=E6=9E=84=20Demo22=20?=
 =?UTF-8?q?=E6=A8=A1=E5=9D=97=E5=AF=BC=E5=85=A5=E5=92=8C=E6=96=87=E4=BB=B6?=
 =?UTF-8?q?=E5=B8=83=E5=B1=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 修改 Main.snow，移除未使用的 ModuleA 导入
- 将 ModuleA.snow 文件内容合并到 Main.snow 中
---
 playground/Demo/Demo22/Main.snow    | 7 ++++++-
 playground/Demo/Demo22/ModuleA.snow | 4 ----
 2 files changed, 6 insertions(+), 5 deletions(-)
 delete mode 100644 playground/Demo/Demo22/ModuleA.snow

diff --git a/playground/Demo/Demo22/Main.snow b/playground/Demo/Demo22/Main.snow
index 91865ef..37333f1 100644
--- a/playground/Demo/Demo22/Main.snow
+++ b/playground/Demo/Demo22/Main.snow
@@ -1,5 +1,5 @@
 module: Main
-    import: os,ModuleA
+    import: os
     globals:
         declare sum: int
     function: main
@@ -10,3 +10,8 @@ module: Main
         end body
     end function
 end module
+
+module: ModuleA
+    globals:
+        declare const a: int =10
+end module
diff --git a/playground/Demo/Demo22/ModuleA.snow b/playground/Demo/Demo22/ModuleA.snow
deleted file mode 100644
index 5561ef6..0000000
--- a/playground/Demo/Demo22/ModuleA.snow
+++ /dev/null
@@ -1,4 +0,0 @@
-module: ModuleA
-    globals:
-        declare const a: int =10
-end module
\ No newline at end of file

From 18c9cbad7b8bc5ca6e9f100a06e547516f6ebf33 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 01:44:16 +0800
Subject: [PATCH 12/35] =?UTF-8?q?feat:=20=E5=A2=9E=E5=8A=A0=E5=B8=B8?=
 =?UTF-8?q?=E9=87=8F=E5=A3=B0=E6=98=8E=E6=94=AF=E6=8C=81=E5=B9=B6=E4=BC=98?=
 =?UTF-8?q?=E5=8C=96=E5=8F=98=E9=87=8F=E5=A3=B0=E6=98=8E=E8=8A=82=E7=82=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 在 DeclarationNode 类中添加 isConst 字段，用于表示是否为常量声明
-增加 isConst() 方法以判断声明是否为常量
- 优化类注释，明确变量和方法的作用
- 更新构造函数以支持常量声明
---
 .../compiler/parser/ast/DeclarationNode.java  | 28 +++++++++++++++----
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/DeclarationNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/DeclarationNode.java
index dd5bea6..af2cdae 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/DeclarationNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/DeclarationNode.java
@@ -10,21 +10,26 @@ import java.util.Optional;
  * {@code DeclarationNode} 表示抽象语法树（AST）中的变量声明语句节点。
  * <p>
  * 变量声明用于在语法层引入新的标识符及其类型信息，
- * 通常格式为 {@code type name = initializer;}，其中初始化表达式可省略。
  * </p>
  */
 public class DeclarationNode implements StatementNode {
 
-    /** 声明的变量名称 */
+    /** 声明的变量名称。 */
     private final String name;
 
-    /** 变量的数据类型（如 "int", "string"） */
+    /** 变量的数据类型（如 "int", "string"）。 */
     private final String type;
 
-    /** 可选的初始化表达式 */
+    /** 是否为常量声明（true 表示 const 变量，false 表示普通变量）。 */
+    private final boolean isConst;
+
+    /**
+     * 可选的初始化表达式。
+     * 如果未指定初始化表达式，则为 Optional.empty()。
+     */
     private final Optional<ExpressionNode> initializer;
 
-    /** 节点上下文信息（包含行号、列号等） */
+    /** 节点上下文信息（如源码中的行号、列号等）。 */
     private final NodeContext context;
 
     /**
@@ -32,12 +37,14 @@ public class DeclarationNode implements StatementNode {
      *
      * @param name        变量名称
      * @param type        变量类型字符串（如 "int"、"string"）
+     * @param isConst     是否为常量声明
      * @param initializer 可选初始化表达式，若为 {@code null} 表示未初始化
      * @param context     节点上下文信息（包含行号、列号等）
      */
-    public DeclarationNode(String name, String type, ExpressionNode initializer, NodeContext context) {
+    public DeclarationNode(String name, String type, boolean isConst, ExpressionNode initializer, NodeContext context) {
         this.name = name;
         this.type = type;
+        this.isConst = isConst;
         this.initializer = Optional.ofNullable(initializer);
         this.context = context;
     }
@@ -60,6 +67,15 @@ public class DeclarationNode implements StatementNode {
         return type;
     }
 
+    /**
+     * 判断该声明是否为常量（const）。
+     *
+     * @return 如果为常量声明则返回 true，否则返回 false
+     */
+    public boolean isConst() {
+        return isConst;
+    }
+
     /**
      * 获取可选的初始化表达式。
      *

From 91aef32a4286f6610beca718c5608b9535b1a2bb Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 01:45:00 +0800
Subject: [PATCH 13/35] =?UTF-8?q?feat:=20=E6=B7=BB=E5=8A=A0=E5=B8=B8?=
 =?UTF-8?q?=E9=87=8F=E7=AC=A6=E5=8F=B7=E7=B1=BB=E5=9E=8B=E5=B9=B6=E5=AE=8C?=
 =?UTF-8?q?=E5=96=84=E6=96=87=E6=A1=A3=E6=B3=A8=E9=87=8A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 在 SymbolKind 枚举中添加 CONSTANT 类型，用于表示只读、不可变的公开常量- 完善了各符号类型的文档注释，明确其用途和特点
- 优化了代码格式和段落结构，提高了代码可读性
---
 .../compiler/semantic/symbol/SymbolKind.java  | 23 ++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/semantic/symbol/SymbolKind.java b/src/main/java/org/jcnc/snow/compiler/semantic/symbol/SymbolKind.java
index 5034d59..6eef2c2 100644
--- a/src/main/java/org/jcnc/snow/compiler/semantic/symbol/SymbolKind.java
+++ b/src/main/java/org/jcnc/snow/compiler/semantic/symbol/SymbolKind.java
@@ -3,31 +3,47 @@ package org.jcnc.snow.compiler.semantic.symbol;
 /**
  * {@code SymbolKind} 枚举用于标识符号表中不同类型的命名实体。
  * <p>
- * 在语义分析过程中，编译器需要根据符号的种类（Kind）采用不同的处理策略:
+ * 在语义分析过程中，编译器需要根据符号的种类（Kind）采用不同的处理策略：
  * 例如变量参与类型推导、函数用于调用匹配、模块用于跨作用域引用等。
+ * </p>
  * <p>
- * 当前支持的符号种类包括:
+ * 当前支持的符号种类包括：
  * <ul>
  *   <li>{@link #VARIABLE}: 变量符号（局部变量、全局变量、成员变量等）；</li>
+ *   <li>{@link #CONSTANT}: 常量符号（只读、不可变的公开常量）；</li>
  *   <li>{@link #FUNCTION}: 函数符号（自由函数、方法、构造函数等）；</li>
  *   <li>{@link #MODULE}: 模块符号（代表命名空间、库或逻辑模块）；</li>
  * </ul>
+ * <p>
+ * 可根据需求扩展更多符号种类。
+ * </p>
  */
 public enum SymbolKind {
 
     /**
      * 变量符号，表示在作用域中声明的可赋值实体。
      * <p>
-     * 包括函数参数、局部变量、全局变量、常量等，
+     * 包括函数参数、局部变量、全局变量、成员变量等。
      * 分析器会基于其类型参与表达式类型校验和赋值检查。
+     * </p>
      */
     VARIABLE,
 
+    /**
+     * 常量符号，表示只读、不可变的公开常量。
+     * <p>
+     * 常量在声明后不可被修改，仅可读取。常用于定义全局、模块级的常量值，
+     * 在类型推断、常量折叠等语义分析过程中单独处理。
+     * </p>
+     */
+    CONSTANT,
+
     /**
      * 函数符号，表示可调用的过程实体。
      * <p>
      * 包括普通函数、方法、构造器等。
      * 用于函数签名注册、函数调用检查及返回值推导。
+     * </p>
      */
     FUNCTION,
 
@@ -35,6 +51,7 @@ public enum SymbolKind {
      * 模块符号，表示一个命名空间或模块单元。
      * <p>
      * 在跨模块调用、导入语句校验、作用域隔离中发挥作用。
+     * </p>
      */
     MODULE
 }

From 2dfcc4c95e990ee1d025b0b719952f6fa15f16e1 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 09:52:14 +0800
Subject: [PATCH 14/35] =?UTF-8?q?chore:=20=E6=9B=B4=E6=96=B0=E9=A1=B9?=
 =?UTF-8?q?=E7=9B=AE=E6=9E=84=E5=BB=BA=E9=85=8D=E7=BD=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .run/Demo22.run.xml                |  2 +-
 .run/build-project2tar.ps1.run.xml |  6 ++++++
 .run/build-release-all.ps1.run.xml |  4 ++++
 .run/build_project2tar.ps1.run.xml | 10 ----------
 4 files changed, 11 insertions(+), 11 deletions(-)
 create mode 100644 .run/build-project2tar.ps1.run.xml
 delete mode 100644 .run/build_project2tar.ps1.run.xml

diff --git a/.run/Demo22.run.xml b/.run/Demo22.run.xml
index e76f5c1..67c1bf6 100644
--- a/.run/Demo22.run.xml
+++ b/.run/Demo22.run.xml
@@ -2,7 +2,7 @@
   <configuration default="false" name="Demo22" type="Application" factoryName="Application" folderName="Demo">
     <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
     <module name="Snow" />
-    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo/Demo22 -o target/Demo22" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo/Demo22 -o target/Demo22 --debug" />
     <method v="2">
       <option name="Make" enabled="true" />
     </method>
diff --git a/.run/build-project2tar.ps1.run.xml b/.run/build-project2tar.ps1.run.xml
new file mode 100644
index 0000000..42d6b2d
--- /dev/null
+++ b/.run/build-project2tar.ps1.run.xml
@@ -0,0 +1,6 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="build-project2tar.ps1" type="PowerShellRunType" factoryName="PowerShell" scriptUrl="$PROJECT_DIR$/build/build-project2tar.ps1" executablePath="C:/WINDOWS/System32/WindowsPowerShell/v1.0/powershell.exe">
+    <envs />
+    <method v="2" />
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/.run/build-release-all.ps1.run.xml b/.run/build-release-all.ps1.run.xml
index 2a862b4..f408fc6 100644
--- a/.run/build-release-all.ps1.run.xml
+++ b/.run/build-release-all.ps1.run.xml
@@ -3,4 +3,8 @@
     <envs />
     <method v="2" />
   </configuration>
+  <configuration default="false" name="build-release-all.ps1" type="PowerShellRunType" factoryName="PowerShell" scriptUrl="$PROJECT_DIR$/build/build-release-all.ps1" executablePath="C:/WINDOWS/System32/WindowsPowerShell/v1.0/powershell.exe">
+    <envs />
+    <method v="2" />
+  </configuration>
 </component>
\ No newline at end of file
diff --git a/.run/build_project2tar.ps1.run.xml b/.run/build_project2tar.ps1.run.xml
deleted file mode 100644
index 19c0a66..0000000
--- a/.run/build_project2tar.ps1.run.xml
+++ /dev/null
@@ -1,10 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="build_project2tar.ps1" type="PowerShellRunType" factoryName="PowerShell" scriptUrl="$PROJECT_DIR$/build/build_project2tar.ps1" executablePath="C:/WINDOWS/System32/WindowsPowerShell/v1.0/powershell.exe">
-    <envs />
-    <method v="2" />
-  </configuration>
-  <configuration default="false" name="build_project2tar.ps1" type="PowerShellRunType" factoryName="PowerShell" scriptUrl="$PROJECT_DIR$/build/build_project2tar.ps1" executablePath="C:/WINDOWS/System32/WindowsPowerShell/v1.0/powershell.exe">
-    <envs />
-    <method v="2" />
-  </configuration>
-</component>
\ No newline at end of file

From 139c42a90eb1722d81fc444293c8f15b6096959c Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 11:29:03 +0800
Subject: [PATCH 15/35] =?UTF-8?q?feat:=20=E5=AE=9E=E7=8E=B0=E6=88=90?=
 =?UTF-8?q?=E5=91=98=E8=AE=BF=E9=97=AE=E8=A1=A8=E8=BE=BE=E5=BC=8F=E5=88=86?=
 =?UTF-8?q?=E6=9E=90=E5=99=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 替换 UnsupportedExpressionAnalyzer 为 MemberExpressionAnalyzer
---
 .../jcnc/snow/compiler/semantic/core/AnalyzerRegistrar.java   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/semantic/core/AnalyzerRegistrar.java b/src/main/java/org/jcnc/snow/compiler/semantic/core/AnalyzerRegistrar.java
index f0b301a..74b4d3f 100644
--- a/src/main/java/org/jcnc/snow/compiler/semantic/core/AnalyzerRegistrar.java
+++ b/src/main/java/org/jcnc/snow/compiler/semantic/core/AnalyzerRegistrar.java
@@ -65,8 +65,8 @@ public final class AnalyzerRegistrar {
         // ---------- 注册一元表达式分析器 ----------
         registry.registerExpressionAnalyzer(UnaryExpressionNode.class, new UnaryExpressionAnalyzer());
 
-        // 对尚未实现的表达式类型使用兜底处理器
+        // ---------- 成员访问表达式 ----------
         registry.registerExpressionAnalyzer(MemberExpressionNode.class,
-                new UnsupportedExpressionAnalyzer<>());
+                new MemberExpressionAnalyzer());
     }
 }

From fcdc3a49f8921d8b1284ee3c1c993fe3a4646c3d Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 11:30:20 +0800
Subject: [PATCH 16/35] =?UTF-8?q?feat:=20=E6=94=AF=E6=8C=81=E6=88=90?=
 =?UTF-8?q?=E5=91=98=E8=AE=BF=E9=97=AE=E8=A1=A8=E8=BE=BE=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 添加对成员访问表达式（如 ModuleA.a）的支持
- 实现 buildMember 方法来处理成员表达式节点
- 增加对全局常量和作用域内常量的处理逻辑
---
 .../ir/builder/ExpressionBuilder.java         | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/ExpressionBuilder.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/ExpressionBuilder.java
index 47bb4a4..05aefa5 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/builder/ExpressionBuilder.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/ExpressionBuilder.java
@@ -1,5 +1,6 @@
 package org.jcnc.snow.compiler.ir.builder;
 
+import org.jcnc.snow.compiler.ir.common.GlobalConstTable;
 import org.jcnc.snow.compiler.ir.core.IROpCode;
 import org.jcnc.snow.compiler.ir.core.IRValue;
 import org.jcnc.snow.compiler.ir.instruction.CallInstruction;
@@ -48,6 +49,8 @@ public record ExpressionBuilder(IRContext ctx) {
                 if (reg == null) throw new IllegalStateException("未定义标识符: " + id.name());
                 yield reg;
             }
+            // 模块常量 / 全局变量，如 ModuleA.a
+            case MemberExpressionNode mem -> buildMember(mem);
             // 二元表达式（如 a+b, x==y）
             case BinaryExpressionNode bin -> buildBinary(bin);
             // 函数/方法调用表达式
@@ -62,6 +65,40 @@ public record ExpressionBuilder(IRContext ctx) {
         };
     }
 
+    /**
+     * 成员访问表达式构建
+     *
+     * @param mem 成员表达式节点
+     * @return 存储结果的虚拟寄存器
+     */
+    private IRVirtualRegister buildMember(MemberExpressionNode mem) {
+        if (!(mem.object() instanceof IdentifierNode id)) {
+            throw new IllegalStateException("不支持的成员访问对象类型: "
+                    + mem.object().getClass().getSimpleName());
+        }
+        String qualified = id.name() + "." + mem.member();
+
+        /* 1) 尝试直接获取已有寄存器绑定 */
+        IRVirtualRegister reg = ctx.getScope().lookup(qualified);
+        if (reg != null) {
+            return reg;
+        }
+
+        /* 2) 折叠为编译期常量：先查作用域，再查全局常量表 */
+        Object v = ctx.getScope().getConstValue(qualified);
+        if (v == null) {
+            v = GlobalConstTable.get(qualified);
+        }
+        if (v != null) {
+            IRVirtualRegister r = ctx.newRegister();
+            ctx.addInstruction(new LoadConstInstruction(r, new IRConstant(v)));
+            return r;
+        }
+
+        throw new IllegalStateException("未定义的常量: " + qualified);
+    }
+
+
     /* ───────────────── 写入指定寄存器 ───────────────── */
 
     /**

From 1a0c3a38cbf22eeecfccfc0629e42feece59625e Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 11:32:48 +0800
Subject: [PATCH 17/35] =?UTF-8?q?feat:=20=E6=9B=B4=E6=96=B0=20FunctionBuil?=
 =?UTF-8?q?der=E6=9E=84=E5=BB=BA=E6=B5=81=E7=A8=8B=E4=B8=8E=E6=96=87?=
 =?UTF-8?q?=E6=A1=A3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 在全局函数表中注册函数名与返回类型
- 初始化 IRFunction 实例与 IRContext 上下文对象
- 自动导入全局常量（包括跨模块 const 变量）到当前作用域
- 根据函数返回类型设置表达式推断的默认字面量类型后缀
- 遍历声明形参，每个参数分配虚拟寄存器，并注册到作用域
- 依次转换函数体中的每条语句为 IR指令
- 函数体转换完成后，清理默认类型后缀
---
 .../compiler/ir/builder/FunctionBuilder.java  | 58 +++++++++++++------
 1 file changed, 41 insertions(+), 17 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/FunctionBuilder.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/FunctionBuilder.java
index 56ffd3f..2fb428f 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/builder/FunctionBuilder.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/FunctionBuilder.java
@@ -1,5 +1,6 @@
 package org.jcnc.snow.compiler.ir.builder;
 
+import org.jcnc.snow.compiler.ir.common.GlobalConstTable;
 import org.jcnc.snow.compiler.ir.common.GlobalFunctionTable;
 import org.jcnc.snow.compiler.ir.core.IRFunction;
 import org.jcnc.snow.compiler.ir.utils.ExpressionUtils;
@@ -13,6 +14,13 @@ import org.jcnc.snow.compiler.parser.ast.base.StatementNode;
  * <p>
  * 负责将语法树中的 FunctionNode 节点转化为可执行的 IRFunction，
  * 包含参数声明、返回类型推断、函数体语句转换等步骤。
+ *
+ * <ul>
+ *   <li>支持自动导入全局/跨模块常量，使跨模块常量引用（如 ModuleA.a）在 IR 阶段可用。</li>
+ *   <li>将函数形参声明为虚拟寄存器，并注册到作用域，便于后续指令生成。</li>
+ *   <li>根据返回类型设置表达式默认字面量类型，保证 IR 层类型一致性。</li>
+ *   <li>遍历并转换函数体语句为 IR 指令。</li>
+ * </ul>
  */
 public class FunctionBuilder {
 
@@ -21,11 +29,15 @@ public class FunctionBuilder {
      * <p>
      * 构建过程包括:
      * <ol>
-     *     <li>初始化 IRFunction 实例和上下文</li>
-     *     <li>根据函数返回类型，设置默认类型后缀，便于表达式推断</li>
-     *     <li>声明参数到作用域，并为每个参数分配虚拟寄存器</li>
-     *     <li>遍历并转换函数体内的每条语句为 IR 指令</li>
-     *     <li>函数构建完成后，清理默认类型后缀，防止影响其他函数</li>
+     *     <li>在全局函数表注册函数签名，便于后续模块/语义分析阶段查询。</li>
+     *     <li>初始化 IRFunction 实例和 IRContext 上下文对象（包含作用域与寄存器信息）。</li>
+     *     <li>自动导入全局常量（包括跨模块 const 变量）到当前作用域，
+     *         使成员访问如 ModuleA.a 可直接折叠为常量。</li>
+     *     <li>根据函数返回类型，设置表达式推断的默认字面量类型后缀
+     *         （如 double→d, float→f），避免类型不一致。</li>
+     *     <li>遍历声明形参，每个参数分配虚拟寄存器，并注册到作用域。</li>
+     *     <li>依次转换函数体中的每条语句为 IR 指令。</li>
+     *     <li>函数体转换完成后，清理默认类型后缀，防止影响后续函数构建。</li>
      * </ol>
      *
      * @param functionNode 表示函数定义的语法树节点
@@ -33,44 +45,56 @@ public class FunctionBuilder {
      */
     public IRFunction build(FunctionNode functionNode) {
 
-        // 在全局函数表中注册函数信息
+        // 1. 在全局函数表注册函数名与返回类型
+        // 方便其他阶段/模块调用、类型检查。
         GlobalFunctionTable.register(functionNode.name(), functionNode.returnType());
 
-
-        // 0) 基本初始化: 创建 IRFunction 实例与对应上下文
+        // 2. 初始化 IRFunction 实例与上下文对象
+        // IRFunction: 表示该函数的中间代码容器
+        // IRContext: 负责作用域、寄存器分配等编译上下文管理
         IRFunction irFunction = new IRFunction(functionNode.name());
         IRContext  irContext  = new IRContext(irFunction);
 
-        // 1) 把函数返回类型注入为默认类型后缀（供表达式类型推断）
+        // 3. 自动导入所有全局/跨模块常量到当前作用域
+        // 支持如 ModuleA.a 这样的常量访问/折叠（参见 ExpressionBuilder）
+        GlobalConstTable.all().forEach((k, v) ->
+                irContext.getScope().importExternalConst(k, v));
+
+        // 4. 根据函数返回类型设置默认类型后缀
+        // 例如返回类型为 double 时, 字面量表达式自动用 d 后缀。
         char _returnSuffix = switch (functionNode.returnType().toLowerCase()) {
             case "double" -> 'd';
             case "float"  -> 'f';
             case "long"   -> 'l';
             case "short"  -> 's';
             case "byte"   -> 'b';
-            default       -> '\0';
+            default       -> '\0'; // 其它类型不设默认后缀
         };
         ExpressionUtils.setDefaultSuffix(_returnSuffix);
 
         try {
-            // 2) 声明形参: 为每个参数分配虚拟寄存器并声明到作用域
+            // 5. 遍历函数参数列表
+            //   - 为每个参数分配一个新的虚拟寄存器
+            //   - 注册参数名、类型、寄存器到当前作用域
+            //   - 添加参数寄存器到 IRFunction（用于后续调用与指令生成）
             for (ParameterNode p : functionNode.parameters()) {
-                IRVirtualRegister reg = irFunction.newRegister(); // 新寄存器
-                irContext.getScope().declare(p.name(), p.type(), reg);      // 变量名→寄存器绑定
-                irFunction.addParameter(reg);                     // 添加到函数参数列表
+                IRVirtualRegister reg = irFunction.newRegister();
+                irContext.getScope().declare(p.name(), p.type(), reg);
+                irFunction.addParameter(reg);
             }
 
-            // 3) 生成函数体 IR: 遍历每条语句，逐一转化
+            // 6. 遍历函数体语句节点，转换为 IR 指令
+            //    StatementBuilder 负责将每条语句递归转换为 IR
             StatementBuilder stmtBuilder = new StatementBuilder(irContext);
             for (StatementNode stmt : functionNode.body()) {
                 stmtBuilder.build(stmt);
             }
         } finally {
-            // 4) 清除默认后缀，避免影响后续函数的推断
+            // 7. 清理默认类型后缀，防止影响后续其他函数的类型推断
             ExpressionUtils.clearDefaultSuffix();
         }
 
-        // 返回构建好的 IRFunction
+        // 8. 返回构建完成的 IRFunction
         return irFunction;
     }
 }

From 1e2b0e4e0d83ff0862727acedbb109ea5224775e Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 11:35:08 +0800
Subject: [PATCH 18/35] =?UTF-8?q?feat:=20=E6=96=B0=E5=A2=9E=E5=85=A8?=
 =?UTF-8?q?=E5=B1=80=E5=B8=B8=E9=87=8F=E8=A1=A8=E6=94=AF=E6=8C=81=E8=B7=A8?=
 =?UTF-8?q?=E6=A8=A1=E5=9D=97=E5=B8=B8=E9=87=8F=E7=AE=A1=E7=90=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 添加 GlobalConstTable 类，用于编译期间跨模块常量查询和折叠
- 提供注册常量、查询常量和获取所有常量的功能
- 保证线程安全，支持并发操作- 常量的 key采用“模块名.常量名”的格式，确保唯一性
---
 .../compiler/ir/common/GlobalConstTable.java  | 70 +++++++++++++++++++
 1 file changed, 70 insertions(+)
 create mode 100644 src/main/java/org/jcnc/snow/compiler/ir/common/GlobalConstTable.java

diff --git a/src/main/java/org/jcnc/snow/compiler/ir/common/GlobalConstTable.java b/src/main/java/org/jcnc/snow/compiler/ir/common/GlobalConstTable.java
new file mode 100644
index 0000000..ad9795b
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/compiler/ir/common/GlobalConstTable.java
@@ -0,0 +1,70 @@
+package org.jcnc.snow.compiler.ir.common;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * 全局常量表，用于跨模块编译期常量查询和折叠。
+ *
+ * <p>
+ * 主要功能：
+ * <ul>
+ *   <li>在 IRProgramBuilder 预扫描阶段，将所有模块级 <code>const</code> 常量
+ *       （如 ModuleA.a）注册到全局常量表，支持跨模块访问。</li>
+ *   <li>后续任何阶段均可通过 {@link #get(String)} 查询已注册常量，实现编译期常量折叠。</li>
+ *   <li>保证线程安全，支持并发注册和访问。</li>
+ * </ul>
+ * <p>
+ * 常量的 key 格式为“模块名.常量名”，如 "ModuleA.a"，以便唯一标识。
+ *
+ * <p>
+ * 典型用法：
+ * <pre>
+ *   GlobalConstTable.register("ModuleA.a", 10);    // 注册常量
+ *   Object val = GlobalConstTable.get("ModuleA.a"); // 查询常量
+ * </pre>
+ */
+public final class GlobalConstTable {
+
+    /** 存储全局常量: “ModuleName.constName” → 常量值。线程安全。 */
+    private static final Map<String, Object> CONSTS = new ConcurrentHashMap<>();
+
+    /**
+     * 工具类构造器，防止实例化。
+     */
+    private GlobalConstTable() { /* utility class */ }
+
+    /**
+     * 注册一个全局常量到表中（只在首次注册时生效，避免被覆盖）。
+     *
+     * @param qualifiedName 常量的全限定名（如 "ModuleA.a"）
+     * @param value         常量的字面值（如 10、字符串、布尔等）
+     * @throws IllegalArgumentException 名称为 null 或空串时抛出
+     */
+    public static void register(String qualifiedName, Object value) {
+        if (qualifiedName == null || qualifiedName.isBlank()) {
+            throw new IllegalArgumentException("常量名不能为空");
+        }
+        CONSTS.putIfAbsent(qualifiedName, value);
+    }
+
+    /**
+     * 获取指定全局常量的值。
+     *
+     * @param qualifiedName 常量的全限定名（如 "ModuleA.a"）
+     * @return 查到的常量值，如果未注册则返回 null
+     */
+    public static Object get(String qualifiedName) {
+        return CONSTS.get(qualifiedName);
+    }
+
+    /**
+     * 返回全部已注册常量的不可变视图（快照）。
+     * <p>注意：只读，不可修改。</p>
+     *
+     * @return key=常量名，value=常量值的不可变 Map
+     */
+    public static Map<String, Object> all() {
+        return Map.copyOf(CONSTS);
+    }
+}

From cc66eee75f0bc3e4894aea83db4dd72eafc40e07 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 11:37:05 +0800
Subject: [PATCH 19/35] =?UTF-8?q?feat:=20=E6=94=AF=E6=8C=81=E8=B7=A8?=
 =?UTF-8?q?=E6=A8=A1=E5=9D=97=E5=85=A8=E5=B1=80=E5=B8=B8=E9=87=8F=E6=9F=A5?=
 =?UTF-8?q?=E6=89=BE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 新增 externalConsts 字典用于存放跨模块导入的全局常量
- 修改 getConstValue 方法以支持查找外部常量
- 添加 importExternalConst 方法用于导入外部常量
---
 .../compiler/ir/builder/IRBuilderScope.java   | 54 +++++++++++--------
 1 file changed, 33 insertions(+), 21 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRBuilderScope.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRBuilderScope.java
index 774c883..7d277ca 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRBuilderScope.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRBuilderScope.java
@@ -15,30 +15,25 @@ import java.util.Map;
  *   <li>支持变量与虚拟寄存器的重新绑定与查找</li>
  *   <li>支持变量的类型信息记录与查询</li>
  *   <li>支持变量的编译期常量值记录与查询（便于常量折叠等优化）</li>
+ *   <li>支持跨模块全局常量（如 ModuleA.a）查找</li>
  * </ul>
  */
 final class IRBuilderScope {
 
-    /**
-     * 变量名到虚拟寄存器的映射表。
-     * 用于跟踪所有声明和分配的变量。
-     */
+    /** 变量名到虚拟寄存器的映射表（本地变量） */
     private final Map<String, IRVirtualRegister> vars = new HashMap<>();
+    /** 变量名到类型字符串的映射表 */
+    private final Map<String, String> varTypes = new HashMap<>();
+    /** 变量名到编译期常量值的映射表（本作用域） */
+    private final Map<String, Object> varConstValues = new HashMap<>();
 
     /**
-     * 变量名到类型字符串的映射表。
-     * 用于类型分析与推断。
-     */
-    private final Map<String, String> varTypes = new HashMap<>();
-    /**
-     * 变量名到编译期常量值的映射表。
-     * 用于常量折叠优化（如 int、string、数组等常量）。
-     */
-    private final Map<String, Object> varConstValues = new HashMap<>();
-    /**
-     * 当前作用域所绑定的 IRFunction 实例。
-     * 用于申请新的虚拟寄存器。
+     * 额外：存放跨模块导入的全局常量
+     * key 形如 "ModuleA.a"   value 为其常量值
      */
+    private final Map<String, Object> externalConsts = new HashMap<>();
+
+    /** 当前作用域所绑定的 IRFunction 实例 */
     private IRFunction fn;
 
     /**
@@ -118,7 +113,7 @@ final class IRBuilderScope {
     // ---------------- 编译期常量相关接口 ----------------
 
     /**
-     * 设置变量的编译期常量值。
+     * 设置变量的编译期常量值（本地变量）。
      *
      * @param name  变量名称
      * @param value 常量值（null 表示清除）
@@ -129,21 +124,38 @@ final class IRBuilderScope {
     }
 
     /**
-     * 获取变量的编译期常量值（如没有则返回 null）。
+     * 获取变量的编译期常量值（本地变量或导入的外部常量）。
+     * <br>
+     * 优先查找本地常量，未命中再查外部（如 "ModuleA.a"）。
      *
-     * @param name 变量名称
+     * @param name 变量名称或"模块名.常量名"
      * @return 编译期常量值，或 null
      */
     Object getConstValue(String name) {
-        return varConstValues.get(name);
+        Object v = varConstValues.get(name);
+        if (v != null) return v;
+        // 支持跨模块常量/全局变量
+        return externalConsts.get(name);
     }
 
     /**
-     * 清除变量的编译期常量值绑定。
+     * 清除变量的编译期常量值绑定（本地）。
      *
      * @param name 变量名称
      */
     void clearConstValue(String name) {
         varConstValues.remove(name);
     }
+
+    // ---------------- 跨模块常量导入支持 ----------------
+
+    /**
+     * 导入外部（其他模块）的全局常量/变量。
+     *
+     * @param qualifiedName 形如 "ModuleA.a"
+     * @param value         其常量值
+     */
+    void importExternalConst(String qualifiedName, Object value) {
+        externalConsts.put(qualifiedName, value);
+    }
 }

From 06bb647c831dcfd560d4ded31ef98fddf5f14ba5 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 11:44:04 +0800
Subject: [PATCH 20/35] =?UTF-8?q?feat:=20=E5=AE=9E=E7=8E=B0=E5=85=A8?=
 =?UTF-8?q?=E5=B1=80=E5=B8=B8=E9=87=8F=E9=A2=84=E5=8A=A0=E8=BD=BD=E5=8F=8A?=
 =?UTF-8?q?=E8=B7=A8=E6=A8=A1=E5=9D=97=E5=B8=B8=E9=87=8F=E6=8A=98=E5=8F=A0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 新增 preloadGlobals 方法，扫描所有模块节点，将常量注册到全局常量表- 支持整数、浮点数、字符串和布尔字面量的直接评估
- 优化了 IRProgram 的构建过程，增加了对全局常量的处理
---
 .../compiler/ir/builder/IRProgramBuilder.java | 71 ++++++++++++++++---
 1 file changed, 63 insertions(+), 8 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java
index 28e89c2..290cbb4 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java
@@ -1,9 +1,10 @@
 package org.jcnc.snow.compiler.ir.builder;
 
+import org.jcnc.snow.compiler.ir.common.GlobalConstTable;
 import org.jcnc.snow.compiler.ir.core.IRFunction;
 import org.jcnc.snow.compiler.ir.core.IRProgram;
-import org.jcnc.snow.compiler.parser.ast.FunctionNode;
-import org.jcnc.snow.compiler.parser.ast.ModuleNode;
+import org.jcnc.snow.compiler.parser.ast.*;
+import org.jcnc.snow.compiler.parser.ast.base.ExpressionNode;
 import org.jcnc.snow.compiler.parser.ast.base.Node;
 import org.jcnc.snow.compiler.parser.ast.base.NodeContext;
 import org.jcnc.snow.compiler.parser.ast.base.StatementNode;
@@ -12,13 +13,12 @@ import java.util.ArrayList;
 import java.util.List;
 
 /**
- * IRProgramBuilder 负责将 AST 根节点(如模块、函数、顶层语句)转换为可执行的 IRProgram 实例。
- * <p>
- * 主要职责:
+ * IRProgramBuilder 负责将 AST 顶层节点转换为可执行的 {@link IRProgram}。
+ *
  * <ul>
- *   <li>遍历 AST 根节点，根据类型分别处理(模块、函数、顶层语句)。</li>
- *   <li>对模块内的函数添加全限定名，并在函数体前注入全局变量声明。</li>
- *   <li>将单独的顶层语句封装为特殊的 "_start" 函数。</li>
+ *   <li>预扫描所有模块，将 <code>declare const</code> 常量登记到全局常量表，支持跨模块常量折叠。</li>
+ *   <li>对模块内的函数加上模块前缀，保证命名唯一，并将本模块全局声明注入到函数体前部。</li>
+ *   <li>将独立顶层语句自动包装为特殊的 "_start" 函数（脚本模式支持）。</li>
  * </ul>
  */
 public final class IRProgramBuilder {
@@ -31,6 +31,9 @@ public final class IRProgramBuilder {
      * @throws IllegalStateException 遇到不支持的顶层节点类型时抛出
      */
     public IRProgram buildProgram(List<Node> roots) {
+        // 预先收集并登记全部模块常量到全局常量表
+        preloadGlobals(roots);
+
         IRProgram irProgram = new IRProgram();
         for (Node node : roots) {
             switch (node) {
@@ -54,6 +57,58 @@ public final class IRProgramBuilder {
         return irProgram;
     }
 
+    // ===================== 全局常量收集 =====================
+    /**
+     * 扫描所有模块节点，将其中声明的 const 全局变量（compile-time 常量）
+     * 以 "模块名.常量名" 形式注册到全局常量表。
+     * <p>
+     * 只处理直接字面量（数字、字符串、布尔），暂不支持复杂表达式。
+     *
+     * @param roots 所有顶层 AST 节点
+     */
+    private void preloadGlobals(List<Node> roots) {
+        for (Node n : roots) {
+            if (n instanceof ModuleNode mod) {
+                String moduleName = mod.name();
+                if (mod.globals() == null) continue;
+                for (DeclarationNode decl : mod.globals()) {
+                    if (!decl.isConst() || decl.getInitializer().isEmpty()) continue;
+                    ExpressionNode init = decl.getInitializer().get();
+                    Object value = evalLiteral(init);
+                    if (value != null) {
+                        GlobalConstTable.register(moduleName + "." + decl.getName(), value);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 字面量提取工具。仅支持整数/浮点、字符串、布尔字面量，其它返回 null。
+     *
+     * @param expr 常量初始化表达式
+     * @return 字面量值（如 123, 3.14, "abc", 1/0），否则 null
+     */
+    private Object evalLiteral(ExpressionNode expr) {
+        return switch (expr) {
+            case NumberLiteralNode num -> {
+                String s = num.value();
+                try {
+                    if (s.contains(".") || s.contains("e") || s.contains("E"))
+                        yield Double.parseDouble(s);
+                    yield Integer.parseInt(s);
+                } catch (NumberFormatException ignore) {
+                    yield null;
+                }
+            }
+            case StringLiteralNode str -> str.value();
+            case BoolLiteralNode b -> b.getValue() ? 1 : 0;
+            default -> null;
+        };
+    }
+
+    // ===================== IRFunction 构建辅助 =====================
+
     /**
      * 构建带有模块全局声明“注入”的函数，并将函数名加上模块前缀，保证模块内函数名唯一。
      * <p>

From 0d6c6cef5a450fa99e4929939e07a4f2816980d3 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 11:52:47 +0800
Subject: [PATCH 21/35] =?UTF-8?q?feat:=20=E6=B7=BB=E5=8A=A0=E6=88=90?=
 =?UTF-8?q?=E5=91=98=E8=A1=A8=E8=BE=BE=E5=BC=8F=E8=AF=AD=E4=B9=89=E5=88=86?=
 =?UTF-8?q?=E6=9E=90=E5=99=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 实现了 MemberExpressionAnalyzer 类，用于分析成员访问表达式
- 目前仅支持 ModuleName.constOrVar 形式的跨模块常量/全局变量访问
- 不支持对象成员访问，如 a.b.c- 类型降级为 int，后续由 IR 阶段进行常量折叠
---
 .../expression/MemberExpressionAnalyzer.java  | 75 +++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/MemberExpressionAnalyzer.java

diff --git a/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/MemberExpressionAnalyzer.java b/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/MemberExpressionAnalyzer.java
new file mode 100644
index 0000000..a115e61
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/MemberExpressionAnalyzer.java
@@ -0,0 +1,75 @@
+package org.jcnc.snow.compiler.semantic.analyzers.expression;
+
+import org.jcnc.snow.compiler.parser.ast.FunctionNode;
+import org.jcnc.snow.compiler.parser.ast.IdentifierNode;
+import org.jcnc.snow.compiler.parser.ast.MemberExpressionNode;
+import org.jcnc.snow.compiler.parser.ast.base.NodeContext;
+import org.jcnc.snow.compiler.semantic.analyzers.base.ExpressionAnalyzer;
+import org.jcnc.snow.compiler.semantic.core.Context;
+import org.jcnc.snow.compiler.semantic.core.ModuleInfo;
+import org.jcnc.snow.compiler.semantic.error.SemanticError;
+import org.jcnc.snow.compiler.semantic.symbol.SymbolTable;
+import org.jcnc.snow.compiler.semantic.type.BuiltinType;
+import org.jcnc.snow.compiler.semantic.type.Type;
+
+/**
+ * {@code MemberExpressionAnalyzer} – 成员访问表达式的语义分析器。
+ *
+ * <p>
+ * 当前实现仅支持 <code>ModuleName.constOrVar</code> 形式的跨模块常量 /
+ * 全局变量访问，不支持对象成员（如 a.b.c）。
+ * </p>
+ *
+ * <ul>
+ *   <li>示例：ModuleA.a 或 ModuleB.CONST_X</li>
+ *   <li>仅检查模块是否存在且已导入，类型降级为 int，后续由 IR 阶段常量折叠</li>
+ *   <li>暂不支持复杂的对象/类型成员访问</li>
+ * </ul>
+ */
+public class MemberExpressionAnalyzer implements ExpressionAnalyzer<MemberExpressionNode> {
+
+    /**
+     * 对成员访问表达式执行语义分析。
+     *
+     * @param ctx     全局语义上下文，包含模块表、错误收集等
+     * @param mi      当前模块信息（含本模块名、已导入模块）
+     * @param fn      当前所在函数节点
+     * @param locals  当前作用域符号表
+     * @param expr    当前要分析的成员表达式（如 ModuleA.a）
+     * @return 分析推断得到的类型（目前恒定降级为 int），如有错误也会记录
+     */
+    @Override
+    public Type analyze(Context ctx,
+                        ModuleInfo mi,
+                        FunctionNode fn,
+                        SymbolTable locals,
+                        MemberExpressionNode expr) {
+
+        ctx.log("检查成员访问: " + expr);
+
+        /* ---------- 仅支持 ModuleName.member 形式 ---------- */
+        if (expr.object() instanceof IdentifierNode(String mod, NodeContext _)) {
+
+            // 1. 检查模块是否存在、且已在当前模块 import 或为本模块
+            if (!ctx.getModules().containsKey(mod)
+                    || (!mi.getImports().contains(mod) && !mi.getName().equals(mod))) {
+                ctx.getErrors().add(new SemanticError(expr,
+                        "未知或未导入模块: " + mod));
+                ctx.log("错误: 未导入模块 " + mod);
+                return BuiltinType.INT;          // 语义降级：默认 int
+            }
+
+            // 2. 目前不做类型精确推断。后续可解析目标模块 globals 获取精确类型。
+            //    这里只做语法级校验，类型降级为 INT，由后续阶段折叠。
+            return BuiltinType.INT;
+        }
+
+        /* ---------- 其它对象成员（如 a.b.c）暂不支持 ---------- */
+        ctx.getErrors().add(new SemanticError(expr,
+                "不支持的成员访问对象类型: "
+                        + expr.object().getClass().getSimpleName()));
+        ctx.log("错误: 不支持的成员访问对象类型 "
+                + expr.object().getClass().getSimpleName());
+        return BuiltinType.INT;                  // 语义降级
+    }
+}

From f8a331809f30b7340297b225cf72f6672089fe4c Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 11:55:10 +0800
Subject: [PATCH 22/35] =?UTF-8?q?chore:=20=E7=A7=BB=E9=99=A4=20Demo22.run.?=
 =?UTF-8?q?xml=20=E4=B8=AD=E7=9A=84=E8=B0=83=E8=AF=95=E5=8F=82=E6=95=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .run/Demo22.run.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.run/Demo22.run.xml b/.run/Demo22.run.xml
index 67c1bf6..e76f5c1 100644
--- a/.run/Demo22.run.xml
+++ b/.run/Demo22.run.xml
@@ -2,7 +2,7 @@
   <configuration default="false" name="Demo22" type="Application" factoryName="Application" folderName="Demo">
     <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
     <module name="Snow" />
-    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo/Demo22 -o target/Demo22 --debug" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo/Demo22 -o target/Demo22" />
     <method v="2">
       <option name="Make" enabled="true" />
     </method>

From 1f8176d15e5c19352e2724e8a59cfa5789d26573 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 11:55:25 +0800
Subject: [PATCH 23/35] =?UTF-8?q?test:=20=E4=BF=AE=E6=94=B9=20Demo22?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 playground/Demo/Demo22/Main.snow | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/playground/Demo/Demo22/Main.snow b/playground/Demo/Demo22/Main.snow
index 37333f1..8fa2149 100644
--- a/playground/Demo/Demo22/Main.snow
+++ b/playground/Demo/Demo22/Main.snow
@@ -1,12 +1,10 @@
 module: Main
-    import: os
-    globals:
-        declare sum: int
+    import: ModuleA,os
     function: main
         returns: void
         body:
-            sum = ModuleA.a
-            os.print(sum)
+           declare sum: int = ModuleA.a+2
+           os.print(sum+1)
         end body
     end function
 end module

From 1c86c1dce7801b8dfb691ec4fd7978c8babc1c7b Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 14:01:19 +0800
Subject: [PATCH 24/35] =?UTF-8?q?feat:=20=E6=94=B9=E8=BF=9B=20IR=20?=
 =?UTF-8?q?=E6=8C=87=E4=BB=A4=E7=94=9F=E6=88=90=E9=80=BB=E8=BE=91=E5=B9=B6?=
 =?UTF-8?q?=E6=94=AF=E6=8C=81=E6=B5=AE=E7=82=B9=E6=95=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 新增对 long、float 和 double 类型常量加载的支持
- 优化二元运算指令生成，支持不同类型的操作数
- 实现基于变量类型的 move 指令，提高类型兼容性
- 简化控制流指令的生成逻辑
- 优化代码结构，提高可读性和可维护性
---
 .../ir/builder/InstructionFactory.java        | 165 ++++++++++++------
 1 file changed, 108 insertions(+), 57 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/InstructionFactory.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/InstructionFactory.java
index 1c4dd8a..0d1fa69 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/builder/InstructionFactory.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/InstructionFactory.java
@@ -6,23 +6,16 @@ import org.jcnc.snow.compiler.ir.value.IRConstant;
 import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 
 /**
- * InstructionFactory —— 统一生成并注册 IR 指令的工厂类。
- * <p>
- * 该类封装了常见的 IR 指令生成方式，包括常量加载、二元运算、赋值、控制流等，
- * 统一简化指令插入和寄存器分配逻辑，提升 IR 生成阶段的代码可维护性和复用性。
- * </p>
+ * IR 指令统一生成工厂类，负责封装常量加载、二元运算、赋值、控制流等指令生成逻辑。
+ * 提高 IR 生成阶段的可维护性与复用性。
  */
 public class InstructionFactory {
 
-    /* ====================================================================== */
-    /*                     常量 / 通用二元运算（新寄存器）                     */
-    /* ====================================================================== */
-
     /**
      * 加载整数常量，将其写入一个新分配的虚拟寄存器，并返回该寄存器。
      *
-     * @param ctx   当前 IR 上下文（用于分配寄存器与添加指令）
-     * @param value 要加载的整数常量值
+     * @param ctx   当前 IR 上下文
+     * @param value 整数常量值
      * @return 存储该常量的新虚拟寄存器
      */
     public static IRVirtualRegister loadConst(IRContext ctx, int value) {
@@ -31,88 +24,150 @@ public class InstructionFactory {
         return r;
     }
 
+    /**
+     * 加载 long 类型常量到新寄存器。
+     *
+     * @param ctx   当前 IR 上下文
+     * @param value long 类型常量值
+     * @return 存储该常量的新虚拟寄存器
+     */
+    public static IRVirtualRegister loadConst(IRContext ctx, long value) {
+        IRVirtualRegister r = ctx.newRegister();
+        ctx.addInstruction(new LoadConstInstruction(r, new IRConstant(value)));
+        return r;
+    }
+
+    /**
+     * 加载 float 类型常量到新寄存器。
+     *
+     * @param ctx   当前 IR 上下文
+     * @param value float 类型常量值
+     * @return 存储该常量的新虚拟寄存器
+     */
+    public static IRVirtualRegister loadConst(IRContext ctx, float value) {
+        IRVirtualRegister r = ctx.newRegister();
+        ctx.addInstruction(new LoadConstInstruction(r, new IRConstant(value)));
+        return r;
+    }
+
+    /**
+     * 加载 double 类型常量到新寄存器。
+     *
+     * @param ctx   当前 IR 上下文
+     * @param value double 类型常量值
+     * @return 存储该常量的新虚拟寄存器
+     */
+    public static IRVirtualRegister loadConst(IRContext ctx, double value) {
+        IRVirtualRegister r = ctx.newRegister();
+        ctx.addInstruction(new LoadConstInstruction(r, new IRConstant(value)));
+        return r;
+    }
+
     /**
      * 执行二元运算（如加法、减法等），结果写入新分配的虚拟寄存器并返回该寄存器。
      *
      * @param ctx 当前 IR 上下文
-     * @param op  运算类型（IROpCode 枚举，如 ADD_I32 等）
-     * @param a   第一个操作数寄存器
-     * @param b   第二个操作数寄存器
-     * @return 保存运算结果的新虚拟寄存器
+     * @param op  二元运算操作码
+     * @param a   左操作数寄存器
+     * @param b   右操作数寄存器
+     * @return 存储结果的新虚拟寄存器
      */
-    public static IRVirtualRegister binOp(IRContext ctx, IROpCode op,
-                                          IRVirtualRegister a, IRVirtualRegister b) {
+    public static IRVirtualRegister binOp(IRContext ctx, IROpCode op, IRVirtualRegister a, IRVirtualRegister b) {
         IRVirtualRegister dest = ctx.newRegister();
         ctx.addInstruction(new BinaryOperationInstruction(op, dest, a, b));
         return dest;
     }
 
-    /* ====================================================================== */
-    /*                        直接写入指定寄存器                    */
-    /* ====================================================================== */
-
     /**
-     * 加载整数常量到指定虚拟寄存器。
+     * 加载常量到指定寄存器。
      *
      * @param ctx   当前 IR 上下文
-     * @param dest  目标寄存器
-     * @param value 要加载的整数常量
+     * @param dest  目标虚拟寄存器
+     * @param value IR 常量值
      */
     public static void loadConstInto(IRContext ctx, IRVirtualRegister dest, IRConstant value) {
         ctx.addInstruction(new LoadConstInstruction(dest, value));
     }
 
     /**
-     * 对两个寄存器执行二元运算，将结果写入指定目标寄存器。
+     * 执行二元运算，并将结果写入指定寄存器。
      *
      * @param ctx  当前 IR 上下文
-     * @param op   运算类型（IROpCode 枚举）
-     * @param a    第一个操作数寄存器
-     * @param b    第二个操作数寄存器
-     * @param dest 运算结果目标寄存器
+     * @param op   二元运算操作码
+     * @param a    左操作数寄存器
+     * @param b    右操作数寄存器
+     * @param dest 目标虚拟寄存器
      */
-    public static void binOpInto(IRContext ctx, IROpCode op,
-                                 IRVirtualRegister a, IRVirtualRegister b,
-                                 IRVirtualRegister dest) {
+    public static void binOpInto(IRContext ctx, IROpCode op, IRVirtualRegister a, IRVirtualRegister b, IRVirtualRegister dest) {
         ctx.addInstruction(new BinaryOperationInstruction(op, dest, a, b));
     }
 
     /**
-     * Move 指令（src → dest）。若寄存器相同也安全。
-     * <p>
-     * 实现方式: dest = src + 0（即加上常量 0）。
-     * </p>
+     * 生成“值拷贝”语义（src → dest）。
+     * 若类型无法推断，默认采用 int 方案（ADD_I32, src+0）。
      *
      * @param ctx  当前 IR 上下文
      * @param src  源寄存器
      * @param dest 目标寄存器
      */
     public static void move(IRContext ctx, IRVirtualRegister src, IRVirtualRegister dest) {
-        // 自赋值无需任何操作，避免生成多余的常量 0 寄存器
         if (src == dest) {
             return;
         }
-        // 回退实现: dest = src + 0
-        IRVirtualRegister zero = loadConst(ctx, 0);
-        ctx.addInstruction(new BinaryOperationInstruction(IROpCode.ADD_I32, dest, src, zero));
+        String varType = ctx.getVarType(); // 需要 IRContext 提供
+        char suffix = '\0';
+        if (varType != null) {
+            switch (varType) {
+                case "byte" -> suffix = 'b';
+                case "short" -> suffix = 's';
+                case "int" -> suffix = 'i';
+                case "long" -> suffix = 'l';
+                case "float" -> suffix = 'f';
+                case "double" -> suffix = 'd';
+            }
+        }
+        IRVirtualRegister zero;
+        IROpCode op = switch (suffix) {
+            case 'd' -> {
+                zero = loadConst(ctx, 0.0);
+                yield IROpCode.ADD_D64;
+            }
+            case 'f' -> {
+                zero = loadConst(ctx, 0.0f);
+                yield IROpCode.ADD_F32;
+            }
+            case 'l' -> {
+                zero = loadConst(ctx, 0L);
+                yield IROpCode.ADD_L64;
+            }
+            case 's' -> {
+                zero = loadConst(ctx, 0);
+                yield IROpCode.ADD_S16;
+            }
+            case 'b' -> {
+                zero = loadConst(ctx, 0);
+                yield IROpCode.ADD_B8;
+            }
+            default -> {
+                zero = loadConst(ctx, 0);
+                yield IROpCode.ADD_I32;
+            }
+        };
+        ctx.addInstruction(new BinaryOperationInstruction(op, dest, src, zero));
     }
 
-    /* ====================================================================== */
-    /*                            控制流指令                                  */
-    /* ====================================================================== */
-
     /**
-     * 生成无条件跳转（JMP）指令，跳转到指定标签。
+     * 生成无条件跳转指令。
      *
      * @param ctx   当前 IR 上下文
-     * @param label 目标标签名
+     * @param label 跳转目标标签
      */
     public static void jmp(IRContext ctx, String label) {
         ctx.addInstruction(new IRJumpInstruction(label));
     }
 
     /**
-     * 在 IR 中插入一个标签（Label）。
+     * 在 IR 流中插入标签。
      *
      * @param ctx   当前 IR 上下文
      * @param label 标签名
@@ -122,22 +177,18 @@ public class InstructionFactory {
     }
 
     /**
-     * 比较跳转（如 if a < b goto label），根据条件跳转到目标标签。
+     * 比较两个寄存器，并根据结果跳转到指定标签。
      *
      * @param ctx         当前 IR 上下文
-     * @param cmp         比较操作码（如 IROpCode.LT_I32 等）
-     * @param a           第一个操作数寄存器
-     * @param b           第二个操作数寄存器
+     * @param cmp         比较操作码
+     * @param a           左操作数寄存器
+     * @param b           右操作数寄存器
      * @param targetLabel 跳转目标标签
      */
-    public static void cmpJump(IRContext ctx, IROpCode cmp,
-                               IRVirtualRegister a, IRVirtualRegister b,
-                               String targetLabel) {
+    public static void cmpJump(IRContext ctx, IROpCode cmp, IRVirtualRegister a, IRVirtualRegister b, String targetLabel) {
         ctx.addInstruction(new IRCompareJumpInstruction(cmp, a, b, targetLabel));
     }
 
-    /* ---------------- 返回 ---------------- */
-
     /**
      * 生成返回指令（带返回值）。
      *
@@ -149,7 +200,7 @@ public class InstructionFactory {
     }
 
     /**
-     * 生成无返回值的 return 指令（如 void 函数）。
+     * 生成无返回值（void）返回指令。
      *
      * @param ctx 当前 IR 上下文
      */

From 6e31185519648de264949785f7735f414d16c07c Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 14:29:37 +0800
Subject: [PATCH 25/35] =?UTF-8?q?feat:=20=E9=87=8D=E6=9E=84=20FunctionChec?=
 =?UTF-8?q?ker=20=E9=87=87=E7=94=A8=E4=B8=A4=E9=81=8D=E6=89=AB=E6=8F=8F?=
 =?UTF-8?q?=E7=AD=96=E7=95=A5?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 设计核心：采用“两遍扫描”方案，彻底解决跨模块全局变量/常量类型推断和引用依赖问题
  - 第一遍：为所有模块预先构建并注册全局符号表（globals）
  - 第二遍：在全局符号表全部就绪后，依次分析所有模块的函数体
-功能职责：
  - 遍历所有模块，先建立 globals，再遍历并检查所有函数体语句
  - 为每个函数体构建完整符号表，并注册参数变量
  - 分发每条语句到对应 StatementAnalyzer进行类型检查和错误校验
  - 自动检查非 void 函数 return 完备性
  - 记录所有语义错误，便于前端高亮和诊断
---
 .../semantic/core/FunctionChecker.java        | 87 +++++++++++--------
 1 file changed, 49 insertions(+), 38 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/semantic/core/FunctionChecker.java b/src/main/java/org/jcnc/snow/compiler/semantic/core/FunctionChecker.java
index f60d854..c57bd07 100644
--- a/src/main/java/org/jcnc/snow/compiler/semantic/core/FunctionChecker.java
+++ b/src/main/java/org/jcnc/snow/compiler/semantic/core/FunctionChecker.java
@@ -1,8 +1,8 @@
 package org.jcnc.snow.compiler.semantic.core;
 
+import org.jcnc.snow.compiler.parser.ast.DeclarationNode;
 import org.jcnc.snow.compiler.parser.ast.FunctionNode;
 import org.jcnc.snow.compiler.parser.ast.ModuleNode;
-import org.jcnc.snow.compiler.parser.ast.DeclarationNode;
 import org.jcnc.snow.compiler.parser.ast.ReturnNode;
 import org.jcnc.snow.compiler.semantic.analyzers.base.StatementAnalyzer;
 import org.jcnc.snow.compiler.semantic.error.SemanticError;
@@ -11,59 +11,64 @@ import org.jcnc.snow.compiler.semantic.symbol.SymbolKind;
 import org.jcnc.snow.compiler.semantic.symbol.SymbolTable;
 import org.jcnc.snow.compiler.semantic.type.BuiltinType;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
- * {@code FunctionChecker} 是语义分析阶段中用于检查函数体语句合法性的调度器。
+ * {@code FunctionChecker} 是 Snow 编译器语义分析阶段用于检查所有函数体合法性的总控调度器。
  * <p>
- * 它逐个遍历所有模块中的函数定义，并对函数体中的每一条语句调用对应的语义分析器，
- * 执行类型检查、作用域验证、错误记录等任务。
- * <p>
- * 核心职责包括:
+ * <b>设计核心：</b>采用“两遍扫描”方案，彻底解决跨模块全局变量/常量类型推断和引用依赖问题：
  * <ul>
- *   <li>为每个函数构建局部符号表并注册函数参数为变量；</li>
- *   <li>分发函数体语句至相应的 {@link StatementAnalyzer}；</li>
- *   <li>记录未支持语句类型为语义错误；</li>
- *   <li>依赖上下文 {@link Context} 提供模块信息、类型解析、错误收集等服务。</li>
+ *   <li><b>第一遍</b>：为所有模块预先构建并注册其全局符号表（globals），保证跨模块引用时可见。</li>
+ *   <li><b>第二遍</b>：在全局符号表全部就绪后，依次分析所有模块的函数体，实现局部作用域、类型推断、语义校验等任务。</li>
+ * </ul>
+ * <b>功能职责：</b>
+ * <ul>
+ *   <li>遍历所有模块，先建立 globals，再遍历并检查所有函数体语句。</li>
+ *   <li>为每个函数体构建完整符号表，并注册参数变量。</li>
+ *   <li>分发每条语句到对应 {@link StatementAnalyzer} 进行类型检查和错误校验。</li>
+ *   <li>自动检查非 void 函数 return 完备性。</li>
+ *   <li>记录所有语义错误，便于前端高亮和诊断。</li>
  * </ul>
  *
- * @param ctx 全局语义分析上下文，提供模块信息、注册表、错误记录等支持
+ * @param ctx 全局语义分析上下文，持有模块信息、符号表、错误收集等资源
  */
 public record FunctionChecker(Context ctx) {
 
     /**
-     * 构造函数体检查器。
-     *
-     * @param ctx 当前语义分析上下文
-     */
-    public FunctionChecker {
-    }
-
-    /**
-     * 执行函数体检查流程。
+     * 主入口：对所有模块的所有函数体进行语义检查（两遍扫描实现）。
      * <p>
-     * 对所有模块中的所有函数依次进行处理:
-     * <ol>
-     *   <li>查找模块对应的 {@link ModuleInfo}；</li>
-     *   <li>创建函数局部符号表 {@link SymbolTable}，并注册所有参数变量；</li>
-     *   <li>对函数体中的每一条语句分发到已注册的分析器进行语义分析；</li>
-     *   <li>若某条语句无可用分析器，则记录为 {@link SemanticError}。</li>
-     * </ol>
+     * <b>第一遍</b>：为每个模块提前构建全局符号表（包含本模块所有全局变量和常量），
+     * 并注册到 {@link ModuleInfo}，确保跨模块引用时所有全局符号都已可用。
+     * <br>
+     * <b>第二遍</b>：遍历所有模块的所有函数，对每个函数体：
+     * <ul>
+     *   <li>构建局部作用域，父作用域为对应模块的 globals；</li>
+     *   <li>注册参数变量；</li>
+     *   <li>依次分发每条语句到对应 {@link StatementAnalyzer}，进行类型和语义检查；</li>
+     *   <li>自动校验非 void 函数 return 完备性；</li>
+     *   <li>将所有发现的问题统一记录到 {@link SemanticError} 列表。</li>
+     * </ul>
      *
      * @param mods 所有模块的 AST 根节点集合
      */
     public void check(Iterable<ModuleNode> mods) {
+        List<ModuleNode> moduleList = new ArrayList<>();
+        // ---------- 第1遍：收集所有全局符号表 ----------
         for (ModuleNode mod : mods) {
-            // 获取当前模块对应的语义信息
-            ModuleInfo mi = ctx.modules().get(mod.name());
+            moduleList.add(mod);
 
-            // 先构建全局符号表
+            // 获取当前模块的元信息
+            ModuleInfo mi = ctx.modules().get(mod.name());
+            // 创建本模块全局作用域（无父作用域）
             SymbolTable globalScope = new SymbolTable(null);
-            // 根据 isConst() 决定种类
+
+            // 注册所有全局变量/常量到符号表
             for (DeclarationNode g : mod.globals()) {
                 var t = ctx.parseType(g.getType());
                 SymbolKind k = g.isConst() ? SymbolKind.CONSTANT : SymbolKind.VARIABLE;
-
-                // 错误信息按常量/变量区分
                 String dupType = g.isConst() ? "常量" : "变量";
+                // 检查重复声明
                 if (!globalScope.define(new Symbol(g.getName(), t, k))) {
                     ctx.errors().add(new SemanticError(
                             g,
@@ -71,14 +76,20 @@ public record FunctionChecker(Context ctx) {
                     ));
                 }
             }
+            // 注册到模块信息，供跨模块引用
+            mi.setGlobals(globalScope);
+        }
+
+        // ---------- 第2遍：遍历所有函数，分析函数体 ----------
+        for (ModuleNode mod : moduleList) {
+            ModuleInfo mi = ctx.modules().get(mod.name());
+            SymbolTable globalScope = mi.getGlobals();
 
-            // 遍历模块中所有函数定义
             for (FunctionNode fn : mod.functions()) {
-
-                // 构建函数局部作用域符号表，父作用域为 globalScope
+                // 构建函数局部作用域，父作用域为 globalScope
                 SymbolTable locals = new SymbolTable(globalScope);
 
-                // 将函数参数注册为局部变量
+                // 注册函数参数为局部变量
                 fn.parameters().forEach(p ->
                         locals.define(new Symbol(
                                 p.name(),
@@ -87,7 +98,7 @@ public record FunctionChecker(Context ctx) {
                         ))
                 );
 
-                // 遍历并分析函数体内的每条语句
+                // 分析函数体内每条语句
                 for (var stmt : fn.body()) {
                     var analyzer = ctx.getRegistry().getStatementAnalyzer(stmt);
                     if (analyzer != null) {

From 439304c86a33d8ef25a369ee32b12f210cb4a31f Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 14:32:13 +0800
Subject: [PATCH 26/35] =?UTF-8?q?feat:=20=E5=A2=9E=E5=BC=BA=E5=85=A8?=
 =?UTF-8?q?=E5=B1=80=E5=B8=B8=E9=87=8F=E5=A4=84=E7=90=86=E4=B8=8E=E5=AD=97?=
 =?UTF-8?q?=E9=9D=A2=E9=87=8F=E8=A7=A3=E6=9E=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 支持整数、浮点数、字符串和布尔字面量的解析
- 添加类型后缀支持（b/s/l/f/d），并进行相应的类型转换
- 优化数字字面量的解析逻辑，支持科学计数法和下划线分隔符
- 改进字面量提取工具的文档注释，明确支持的类型和转换规则
---
 .../compiler/ir/builder/IRProgramBuilder.java | 49 +++++++++++++++----
 1 file changed, 39 insertions(+), 10 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java
index 290cbb4..8d0a340 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java
@@ -58,6 +58,7 @@ public final class IRProgramBuilder {
     }
 
     // ===================== 全局常量收集 =====================
+
     /**
      * 扫描所有模块节点，将其中声明的 const 全局变量（compile-time 常量）
      * 以 "模块名.常量名" 形式注册到全局常量表。
@@ -84,26 +85,54 @@ public final class IRProgramBuilder {
     }
 
     /**
-     * 字面量提取工具。仅支持整数/浮点、字符串、布尔字面量，其它返回 null。
+     * 字面量提取与类型折叠工具。
+     * <p>
+     * 用于从表达式节点中解析出直接可用于全局常量表注册的 Java 值，
+     * 支持以下字面量类型：
+     * <ul>
+     *   <li>整数与浮点（可带下划线分隔符，支持类型后缀 b/s/l/f/d，自动转换为对应 Java 基本类型）</li>
+     *   <li>字符串字面量，直接返回内容</li>
+     *   <li>布尔字面量，true 返回 1，false 返回 0（用于数值语境）</li>
+     * </ul>
+     * 不支持的表达式或解析失败将返回 null。
      *
-     * @param expr 常量初始化表达式
-     * @return 字面量值（如 123, 3.14, "abc", 1/0），否则 null
+     * @param expr 字面量表达式节点，通常为 NumberLiteralNode/StringLiteralNode/BoolLiteralNode
+     * @return 提取出的 Java 值，可为 Integer/Byte/Short/Long/Double/String/Integer(布尔) 或 null
      */
     private Object evalLiteral(ExpressionNode expr) {
         return switch (expr) {
             case NumberLiteralNode num -> {
-                String s = num.value();
+                String raw = num.value();
+                // 1. 去掉下划线分隔符，便于解析（如 1_000_000）
+                String s = raw.replace("_", "");
+                // 2. 提取类型后缀（b/s/l/f/d），若有则去除
+                char last = Character.toLowerCase(s.charAt(s.length() - 1));
+                String core = switch (last) {
+                    case 'b', 's', 'l', 'f', 'd' -> s.substring(0, s.length() - 1);
+                    default -> s;
+                };
                 try {
-                    if (s.contains(".") || s.contains("e") || s.contains("E"))
-                        yield Double.parseDouble(s);
-                    yield Integer.parseInt(s);
+                    // 3. 若为浮点字面量或科学计数法，直接转 double
+                    if (core.contains(".") || core.contains("e") || core.contains("E")) {
+                        double dv = Double.parseDouble(core);
+                        yield dv;
+                    }
+                    // 4. 整数字面量，先转 long，再根据后缀决定精度
+                    long lv = Long.parseLong(core);
+                    yield switch (last) {
+                        case 'b' -> (byte) lv;   // 末尾 b，转 byte
+                        case 's' -> (short) lv;  // 末尾 s，转 short
+                        case 'l' -> lv;          // 末尾 l，转 long
+                        default -> (int) lv;    // 无后缀，转 int
+                    };
                 } catch (NumberFormatException ignore) {
+                    // 解析失败，返回 null
                     yield null;
                 }
             }
-            case StringLiteralNode str -> str.value();
-            case BoolLiteralNode b -> b.getValue() ? 1 : 0;
-            default -> null;
+            case StringLiteralNode str -> str.value();        // 字符串字面量，返回内容
+            case BoolLiteralNode b -> b.getValue() ? 1 : 0;   // 布尔字面量，true=1，false=0
+            default -> null;                                  // 其它类型不支持
         };
     }
 

From f39aece9cf87482bdc3aaed0ac6db2550ce89426 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 14:32:58 +0800
Subject: [PATCH 27/35] =?UTF-8?q?feat:=20=E6=94=AF=E6=8C=81=E6=A8=A1?=
 =?UTF-8?q?=E5=9D=97=E6=88=90=E5=91=98=E8=AE=BF=E9=97=AE=E7=9A=84=E8=AF=AD?=
 =?UTF-8?q?=E4=B9=89=E5=88=86=E6=9E=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 实现了跨模块常量和全局变量访问的语义分析- 能根据目标模块的全局符号表返回准确的类型信息- 完全支持跨模块类型推断
- 对非模块成员访问的情况增加了错误处理
---
 .../expression/MemberExpressionAnalyzer.java  | 59 ++++++++++++-------
 1 file changed, 39 insertions(+), 20 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/MemberExpressionAnalyzer.java b/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/MemberExpressionAnalyzer.java
index a115e61..5080545 100644
--- a/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/MemberExpressionAnalyzer.java
+++ b/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/MemberExpressionAnalyzer.java
@@ -8,35 +8,42 @@ import org.jcnc.snow.compiler.semantic.analyzers.base.ExpressionAnalyzer;
 import org.jcnc.snow.compiler.semantic.core.Context;
 import org.jcnc.snow.compiler.semantic.core.ModuleInfo;
 import org.jcnc.snow.compiler.semantic.error.SemanticError;
+import org.jcnc.snow.compiler.semantic.symbol.Symbol;
 import org.jcnc.snow.compiler.semantic.symbol.SymbolTable;
 import org.jcnc.snow.compiler.semantic.type.BuiltinType;
 import org.jcnc.snow.compiler.semantic.type.Type;
 
 /**
- * {@code MemberExpressionAnalyzer} – 成员访问表达式的语义分析器。
+ * {@code MemberExpressionAnalyzer} 用于分析模块成员访问表达式的类型和语义。
  *
  * <p>
- * 当前实现仅支持 <code>ModuleName.constOrVar</code> 形式的跨模块常量 /
- * 全局变量访问，不支持对象成员（如 a.b.c）。
+ * 当前实现支持 <code>ModuleName.constOrVar</code> 形式的跨模块常量/全局变量访问，
+ * 能根据目标模块的全局符号表，返回准确的类型信息，完全支持跨模块类型推断。
+ * <br>
+ * 对于非模块成员的访问（如对象.属性、多级 a.b.c），暂不支持，遇到时将报告语义错误。
  * </p>
  *
+ * <p>
+ * <b>核心特性：</b>
  * <ul>
- *   <li>示例：ModuleA.a 或 ModuleB.CONST_X</li>
- *   <li>仅检查模块是否存在且已导入，类型降级为 int，后续由 IR 阶段常量折叠</li>
- *   <li>暂不支持复杂的对象/类型成员访问</li>
+ *   <li>校验模块是否存在、是否已导入（或自身）；</li>
+ *   <li>跨模块访问目标模块的全局符号表，查找指定成员符号及其类型；</li>
+ *   <li>若成员不存在，报告“模块成员未定义”语义错误；</li>
+ *   <li>暂不支持更复杂的对象成员访问，遇到将报“不支持的成员访问对象类型”错误。</li>
  * </ul>
+ * </p>
  */
 public class MemberExpressionAnalyzer implements ExpressionAnalyzer<MemberExpressionNode> {
 
     /**
-     * 对成员访问表达式执行语义分析。
+     * 语义分析模块成员访问表达式。
      *
-     * @param ctx     全局语义上下文，包含模块表、错误收集等
-     * @param mi      当前模块信息（含本模块名、已导入模块）
-     * @param fn      当前所在函数节点
-     * @param locals  当前作用域符号表
-     * @param expr    当前要分析的成员表达式（如 ModuleA.a）
-     * @return 分析推断得到的类型（目前恒定降级为 int），如有错误也会记录
+     * @param ctx    全局语义分析上下文，持有所有模块及错误记录
+     * @param mi     当前模块信息（用于判断导入关系）
+     * @param fn     当前函数节点
+     * @param locals 当前局部符号表
+     * @param expr   当前要分析的成员表达式（如 ModuleA.a）
+     * @return 成员表达式的类型；出错时类型降级为 int，并记录语义错误
      */
     @Override
     public Type analyze(Context ctx,
@@ -47,29 +54,41 @@ public class MemberExpressionAnalyzer implements ExpressionAnalyzer<MemberExpres
 
         ctx.log("检查成员访问: " + expr);
 
-        /* ---------- 仅支持 ModuleName.member 形式 ---------- */
+        // -------- 仅支持 ModuleName.member 形式 --------
         if (expr.object() instanceof IdentifierNode(String mod, NodeContext _)) {
 
-            // 1. 检查模块是否存在、且已在当前模块 import 或为本模块
+            // 1. 校验模块存在且已导入或为本模块自身
             if (!ctx.getModules().containsKey(mod)
                     || (!mi.getImports().contains(mod) && !mi.getName().equals(mod))) {
                 ctx.getErrors().add(new SemanticError(expr,
                         "未知或未导入模块: " + mod));
                 ctx.log("错误: 未导入模块 " + mod);
-                return BuiltinType.INT;          // 语义降级：默认 int
+                return BuiltinType.INT;
             }
 
-            // 2. 目前不做类型精确推断。后续可解析目标模块 globals 获取精确类型。
-            //    这里只做语法级校验，类型降级为 INT，由后续阶段折叠。
+            // 2. 查找目标模块的全局符号表，精确返回成员类型
+            ModuleInfo target = ctx.getModules().get(mod);
+            SymbolTable globals = target.getGlobals();
+            if (globals != null) {
+                Symbol sym = globals.resolve(expr.member());
+                if (sym != null) {
+                    return sym.type(); // 找到成员，返回其真实类型
+                }
+            }
+
+            // 3. 成员不存在，记录语义错误并类型降级
+            ctx.getErrors().add(new SemanticError(expr,
+                    "模块成员未定义: " + mod + "." + expr.member()));
+            ctx.log("错误: 模块成员未定义 " + mod + "." + expr.member());
             return BuiltinType.INT;
         }
 
-        /* ---------- 其它对象成员（如 a.b.c）暂不支持 ---------- */
+        // -------- 其它对象成员（如 a.b.c）暂不支持 --------
         ctx.getErrors().add(new SemanticError(expr,
                 "不支持的成员访问对象类型: "
                         + expr.object().getClass().getSimpleName()));
         ctx.log("错误: 不支持的成员访问对象类型 "
                 + expr.object().getClass().getSimpleName());
-        return BuiltinType.INT;                  // 语义降级
+        return BuiltinType.INT;
     }
 }

From c412d1194beedeb128803160259a6c1f9ae55dd2 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 14:33:45 +0800
Subject: [PATCH 28/35] =?UTF-8?q?feat:=20=E5=A2=9E=E5=8A=A0=E5=85=A8?=
 =?UTF-8?q?=E5=B1=80=E7=AC=A6=E5=8F=B7=E8=A1=A8=E6=94=AF=E6=8C=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 在 ModuleInfo 类中添加 SymbolTable 类型的 globals 字段
- 实现 getGlobals 和 setGlobals 方法，用于获取和设置全局符号表
---
 .../compiler/semantic/core/ModuleInfo.java    | 68 +++++++++++++++----
 1 file changed, 56 insertions(+), 12 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/semantic/core/ModuleInfo.java b/src/main/java/org/jcnc/snow/compiler/semantic/core/ModuleInfo.java
index 0761d50..d71dd42 100644
--- a/src/main/java/org/jcnc/snow/compiler/semantic/core/ModuleInfo.java
+++ b/src/main/java/org/jcnc/snow/compiler/semantic/core/ModuleInfo.java
@@ -1,33 +1,55 @@
 package org.jcnc.snow.compiler.semantic.core;
 
+import org.jcnc.snow.compiler.semantic.symbol.SymbolTable;
 import org.jcnc.snow.compiler.semantic.type.FunctionType;
 
-import java.util.*;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * {@code ModuleInfo} 表示单个模块在语义分析阶段的元信息封装。
  * <p>
- * 用于在分析期间管理模块间依赖、函数签名查找等关键任务。
- * 每个模块对应一个唯一的 {@code ModuleInfo} 实例。
- * <p>
- * 包含信息包括: 
+ * 用于在分析期间管理模块间依赖、函数签名查找、全局符号表等关键任务。
+ * 每个模块对应一个唯一的 {@code ModuleInfo} 实例，贯穿整个语义分析流程。
+ *
+ * <p><b>包含信息：</b>
  * <ul>
- *   <li>模块名称（唯一标识）；</li>
- *   <li>该模块导入的其他模块名集合；</li>
- *   <li>该模块中定义的所有函数签名 {@code Map<String, FunctionType>}。</li>
+ *   <li>模块名称（全局唯一标识）；</li>
+ *   <li>该模块导入的其他模块名集合（跨模块引用支持）；</li>
+ *   <li>该模块中定义的所有函数签名 {@code Map<String, FunctionType>}；</li>
+ *   <li>模块级全局符号表 {@link SymbolTable}（常量 / 全局变量，支持跨模块类型推断）。</li>
+ * </ul>
+ *
+ * <p><b>典型用途：</b>
+ * <ul>
+ *   <li>用于函数签名类型查找、重名检测、跨模块引用校验等；</li>
+ *   <li>全局符号表为类型检查与后端 IR 常量折叠等模块级分析提供支撑。</li>
  * </ul>
  */
 public class ModuleInfo {
 
-    /** 模块名称，作为全局唯一标识 */
+    /**
+     * 模块名称，作为全局唯一标识
+     */
     private final String name;
 
-    /** 该模块显式导入的模块名集合（用于跨模块访问符号） */
+    /**
+     * 该模块显式导入的模块名集合（用于跨模块访问符号）
+     */
     private final Set<String> imports = new HashSet<>();
 
-    /** 该模块中定义的函数名 → 函数类型映射 */
+    /**
+     * 该模块中定义的函数名 → 函数类型映射
+     */
     private final Map<String, FunctionType> functions = new HashMap<>();
 
+    /**
+     * 模块级全局符号表（常量 / 全局变量）
+     */
+    private SymbolTable globals;
+
     /**
      * 构造模块信息对象。
      *
@@ -49,7 +71,7 @@ public class ModuleInfo {
     /**
      * 获取该模块导入的模块名称集合。
      * <p>
-     * 返回集合为内部数据的直接引用，调用方可通过 {@code add/remove} 方法动态维护导入信息。
+     * 返回集合为内部数据的直接引用，调用方可通过 {@code add}/{@code remove} 方法动态维护导入信息。
      *
      * @return 可变集合，包含所有导入模块名
      */
@@ -69,4 +91,26 @@ public class ModuleInfo {
         return functions;
     }
 
+    /**
+     * 获取模块的全局符号表（包含常量与全局变量）。
+     * <p>
+     * 该符号表由语义分析的 FunctionChecker 阶段构建完成并注入。
+     * 提供跨模块类型检查、常量折叠等能力。
+     *
+     * @return 当前模块的全局符号表
+     */
+    public SymbolTable getGlobals() {
+        return globals;
+    }
+
+    /**
+     * 设置模块的全局符号表。
+     * <p>
+     * 仅应由 FunctionChecker 在语义分析全局扫描阶段调用。
+     *
+     * @param globals 全局符号表实例
+     */
+    public void setGlobals(SymbolTable globals) {
+        this.globals = globals;
+    }
 }

From f69dd853659eef83363937fb75ef48c4780c8476 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 14:40:45 +0800
Subject: [PATCH 29/35] =?UTF-8?q?test:=20=E5=A2=9E=E5=8A=A0=20Demo23?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 playground/Demo/Demo23/Main.snow | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 playground/Demo/Demo23/Main.snow

diff --git a/playground/Demo/Demo23/Main.snow b/playground/Demo/Demo23/Main.snow
new file mode 100644
index 0000000..dbd6d1e
--- /dev/null
+++ b/playground/Demo/Demo23/Main.snow
@@ -0,0 +1,14 @@
+module: Main
+    import: ModuleA
+    function: main
+        returns: void
+        body:
+           declare sum: byte = ModuleA.a
+        end body
+    end function
+end module
+
+module: ModuleA
+    globals:
+        declare const a: byte = 2b
+end module

From ac0d3b9785b2a826a443c9bbb3e43507785d4cb7 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 16:22:28 +0800
Subject: [PATCH 30/35] =?UTF-8?q?chore:=20=E6=B7=BB=E5=8A=A0=20Demo23=20?=
 =?UTF-8?q?=E5=92=8C=20Demo24=20=E7=9A=84=E8=BF=90=E8=A1=8C=E9=85=8D?=
 =?UTF-8?q?=E7=BD=AE=E6=96=87=E4=BB=B6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .run/Demo23.run.xml | 10 ++++++++++
 .run/Demo24.run.xml | 10 ++++++++++
 2 files changed, 20 insertions(+)
 create mode 100644 .run/Demo23.run.xml
 create mode 100644 .run/Demo24.run.xml

diff --git a/.run/Demo23.run.xml b/.run/Demo23.run.xml
new file mode 100644
index 0000000..43e35ba
--- /dev/null
+++ b/.run/Demo23.run.xml
@@ -0,0 +1,10 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Demo23" type="Application" factoryName="Application" folderName="Demo">
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
+    <module name="Snow" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo/Demo23 -o target/Demo23 --debug" />
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/.run/Demo24.run.xml b/.run/Demo24.run.xml
new file mode 100644
index 0000000..2e71df7
--- /dev/null
+++ b/.run/Demo24.run.xml
@@ -0,0 +1,10 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Demo24" type="Application" factoryName="Application" folderName="Demo">
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
+    <module name="Snow" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo/Demo24 -o target/Demo24 --debug" />
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file

From 71cbb3a73702e7d290225aeab6192b3d2c6d5422 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 16:22:53 +0800
Subject: [PATCH 31/35] =?UTF-8?q?test:=20=E5=A2=9E=E5=8A=A0=20Demo=2024?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 playground/Demo/Demo24/Main.snow | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 playground/Demo/Demo24/Main.snow

diff --git a/playground/Demo/Demo24/Main.snow b/playground/Demo/Demo24/Main.snow
new file mode 100644
index 0000000..a18b417
--- /dev/null
+++ b/playground/Demo/Demo24/Main.snow
@@ -0,0 +1,23 @@
+module: Main
+    import: ModuleA,os
+    function: main
+        returns: void
+        body:
+            declare a: int = ModuleA.sum(1,2)
+        end body
+    end function
+end module
+
+module: ModuleA
+    globals:
+        declare a: int = 10
+    function: sum
+        params:
+            declare a: int
+            declare b: int
+        returns: int
+        body:
+            return a + b
+        end body
+    end function
+end module
\ No newline at end of file

From b058ee452685df0f66edb549d0e89fed2055e517 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 16:25:19 +0800
Subject: [PATCH 32/35] =?UTF-8?q?refactor:=20=E4=BC=98=E5=8C=96=E5=85=A8?=
 =?UTF-8?q?=E5=B1=80=E5=8F=98=E9=87=8F=E5=A4=84=E7=90=86=E5=92=8C=E5=B8=B8?=
 =?UTF-8?q?=E9=87=8F=E6=8A=98=E5=8F=A0=E9=80=BB=E8=BE=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 过滤与函数参数重名的全局声明，避免命名冲突
- 优化常量折叠逻辑，支持跨模块常量优化- 修复字符串字面量和布尔字面量的处理
- 优化代码结构，提高可读性和可维护性
---
 .../compiler/ir/builder/IRProgramBuilder.java | 104 +++++++++---------
 1 file changed, 55 insertions(+), 49 deletions(-)

diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java
index 8d0a340..730b731 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java
@@ -10,7 +10,9 @@ import org.jcnc.snow.compiler.parser.ast.base.NodeContext;
 import org.jcnc.snow.compiler.parser.ast.base.StatementNode;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 /**
  * IRProgramBuilder 负责将 AST 顶层节点转换为可执行的 {@link IRProgram}。
@@ -38,16 +40,16 @@ public final class IRProgramBuilder {
         for (Node node : roots) {
             switch (node) {
                 case ModuleNode moduleNode -> {
-                    // 处理模块节点:遍历其中所有函数，统一用“模块名.函数名”作为全限定名
+                    // 处理模块节点：遍历其中所有函数，统一用“模块名.函数名”作为全限定名，避免命名冲突
                     for (FunctionNode f : moduleNode.functions()) {
                         irProgram.add(buildFunctionWithGlobals(moduleNode, f));
                     }
                 }
                 case FunctionNode functionNode ->
-                    // 处理顶层函数节点:直接构建为 IRFunction 并加入
+                    // 处理顶层函数节点：直接构建为 IRFunction 并加入
                         irProgram.add(buildFunction(functionNode));
                 case StatementNode statementNode ->
-                    // 处理脚本式顶层语句:封装成 "_start" 函数后构建并添加
+                    // 处理脚本式顶层语句：封装成 "_start" 函数后构建并添加
                         irProgram.add(buildFunction(wrapTopLevel(statementNode)));
                 default ->
                     // 遇到未知类型节点，抛出异常
@@ -62,10 +64,9 @@ public final class IRProgramBuilder {
     /**
      * 扫描所有模块节点，将其中声明的 const 全局变量（compile-time 常量）
      * 以 "模块名.常量名" 形式注册到全局常量表。
-     * <p>
-     * 只处理直接字面量（数字、字符串、布尔），暂不支持复杂表达式。
+     * 支持跨模块常量折叠，用于后续 IR 生成过程中的常量折叠优化。
      *
-     * @param roots 所有顶层 AST 节点
+     * @param roots AST 顶层节点列表
      */
     private void preloadGlobals(List<Node> roots) {
         for (Node n : roots) {
@@ -73,6 +74,7 @@ public final class IRProgramBuilder {
                 String moduleName = mod.name();
                 if (mod.globals() == null) continue;
                 for (DeclarationNode decl : mod.globals()) {
+                    // 只处理 compile-time 的 const 常量，并要求有初始值
                     if (!decl.isConst() || decl.getInitializer().isEmpty()) continue;
                     ExpressionNode init = decl.getInitializer().get();
                     Object value = evalLiteral(init);
@@ -86,53 +88,40 @@ public final class IRProgramBuilder {
 
     /**
      * 字面量提取与类型折叠工具。
-     * <p>
-     * 用于从表达式节点中解析出直接可用于全局常量表注册的 Java 值，
-     * 支持以下字面量类型：
-     * <ul>
-     *   <li>整数与浮点（可带下划线分隔符，支持类型后缀 b/s/l/f/d，自动转换为对应 Java 基本类型）</li>
-     *   <li>字符串字面量，直接返回内容</li>
-     *   <li>布尔字面量，true 返回 1，false 返回 0（用于数值语境）</li>
-     * </ul>
-     * 不支持的表达式或解析失败将返回 null。
+     * 用于将表达式节点还原为 Java 原生类型（int、long、double、String等），仅支持直接字面量。
      *
-     * @param expr 字面量表达式节点，通常为 NumberLiteralNode/StringLiteralNode/BoolLiteralNode
-     * @return 提取出的 Java 值，可为 Integer/Byte/Short/Long/Double/String/Integer(布尔) 或 null
+     * @param expr 要计算的表达式节点
+     * @return 提取到的原生常量值，不支持的情况返回 null
      */
     private Object evalLiteral(ExpressionNode expr) {
         return switch (expr) {
             case NumberLiteralNode num -> {
                 String raw = num.value();
-                // 1. 去掉下划线分隔符，便于解析（如 1_000_000）
                 String s = raw.replace("_", "");
-                // 2. 提取类型后缀（b/s/l/f/d），若有则去除
                 char last = Character.toLowerCase(s.charAt(s.length() - 1));
                 String core = switch (last) {
                     case 'b', 's', 'l', 'f', 'd' -> s.substring(0, s.length() - 1);
                     default -> s;
                 };
                 try {
-                    // 3. 若为浮点字面量或科学计数法，直接转 double
                     if (core.contains(".") || core.contains("e") || core.contains("E")) {
-                        double dv = Double.parseDouble(core);
-                        yield dv;
+                        // 浮点数处理
+                        yield Double.parseDouble(core);
                     }
-                    // 4. 整数字面量，先转 long，再根据后缀决定精度
                     long lv = Long.parseLong(core);
                     yield switch (last) {
-                        case 'b' -> (byte) lv;   // 末尾 b，转 byte
-                        case 's' -> (short) lv;  // 末尾 s，转 short
-                        case 'l' -> lv;          // 末尾 l，转 long
-                        default -> (int) lv;    // 无后缀，转 int
+                        case 'b' -> (byte) lv;
+                        case 's' -> (short) lv;
+                        case 'l' -> lv;
+                        default -> (int) lv;
                     };
                 } catch (NumberFormatException ignore) {
-                    // 解析失败，返回 null
                     yield null;
                 }
             }
-            case StringLiteralNode str -> str.value();        // 字符串字面量，返回内容
-            case BoolLiteralNode b -> b.getValue() ? 1 : 0;   // 布尔字面量，true=1，false=0
-            default -> null;                                  // 其它类型不支持
+            case StringLiteralNode str -> str.value();
+            case BoolLiteralNode b -> b.getValue() ? 1 : 0;
+            default -> null;
         };
     }
 
@@ -140,23 +129,41 @@ public final class IRProgramBuilder {
 
     /**
      * 构建带有模块全局声明“注入”的函数，并将函数名加上模块前缀，保证模块内函数名唯一。
-     * <p>
-     * 如果模块有全局声明，则这些声明会被插入到函数体前部。
+     * 如果模块有全局声明，则这些声明会被插入到函数体前部（**会过滤掉与参数同名的全局声明**）。
      *
-     * @param moduleNode   当前模块节点
-     * @param functionNode 模块中的函数节点
-     * @return 包含全局声明、已加前缀函数名的 IRFunction
+     * @param moduleNode   所属模块节点
+     * @param functionNode 待构建的函数节点
+     * @return 包含全局声明的 IRFunction
      */
     private IRFunction buildFunctionWithGlobals(ModuleNode moduleNode, FunctionNode functionNode) {
         // 拼接模块名和函数名，生成全限定名
         String qualifiedName = moduleNode.name() + "." + functionNode.name();
-        // 若无全局声明，仅重命名后直接构建
         if (moduleNode.globals() == null || moduleNode.globals().isEmpty()) {
+            // 无全局声明，直接重命名构建
             return buildFunction(renameFunction(functionNode, qualifiedName));
         }
-        // 若有全局声明，插入到函数体最前面
-        List<StatementNode> newBody = new ArrayList<>(moduleNode.globals().size() + functionNode.body().size());
-        newBody.addAll(moduleNode.globals());
+
+        // ------- 过滤与参数重名的全局声明 -------
+        Set<String> paramNames = new HashSet<>();
+        for (ParameterNode p : functionNode.parameters()) {
+            paramNames.add(p.name());
+        }
+        List<StatementNode> filteredGlobals = new ArrayList<>();
+        for (DeclarationNode g : moduleNode.globals()) {
+            // 避免全局声明和参数重名，优先参数
+            if (!paramNames.contains(g.getName())) {
+                filteredGlobals.add(g);
+            }
+        }
+
+        if (filteredGlobals.isEmpty()) {
+            // 过滤后已无可插入的全局声明
+            return buildFunction(renameFunction(functionNode, qualifiedName));
+        }
+
+        // 合并全局声明与函数体，前插全局声明
+        List<StatementNode> newBody = new ArrayList<>(filteredGlobals.size() + functionNode.body().size());
+        newBody.addAll(filteredGlobals);
         newBody.addAll(functionNode.body());
         FunctionNode wrapped = new FunctionNode(
                 qualifiedName,
@@ -169,11 +176,11 @@ public final class IRProgramBuilder {
     }
 
     /**
-     * 生成一个重命名的 FunctionNode(只修改函数名，其他属性保持不变)。
+     * 生成一个重命名的 FunctionNode（只修改函数名，其他属性保持不变）。
      *
      * @param fn      原始函数节点
-     * @param newName 新的函数名(通常为全限定名)
-     * @return 重命名后的 FunctionNode
+     * @param newName 新的函数名（全限定名）
+     * @return 重命名后的函数节点
      */
     private FunctionNode renameFunction(FunctionNode fn, String newName) {
         return new FunctionNode(
@@ -188,8 +195,8 @@ public final class IRProgramBuilder {
     /**
      * 构建 IRFunction。
      *
-     * @param functionNode 要转换的函数节点
-     * @return 转换结果 IRFunction
+     * @param functionNode 待构建的 FunctionNode
+     * @return 构建后的 IRFunction
      */
     private IRFunction buildFunction(FunctionNode functionNode) {
         return new FunctionBuilder().build(functionNode);
@@ -197,11 +204,10 @@ public final class IRProgramBuilder {
 
     /**
      * 将顶层语句节点封装成特殊的 "_start" 函数。
-     * <p>
-     * 这对于脚本式文件支持至关重要(即文件最外层直接写语句)。
+     * 主要用于脚本模式支持，使得顶层语句也可以被 IR 执行引擎统一处理。
      *
-     * @param stmt 要封装的顶层语句
-     * @return 包装成 FunctionNode 的 "_start" 函数
+     * @param stmt 顶层语句节点
+     * @return 封装后的 FunctionNode
      */
     private FunctionNode wrapTopLevel(StatementNode stmt) {
         return new FunctionNode(

From b02af0728a20106bef6bf905279fa50bb2d6d189 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 16:59:25 +0800
Subject: [PATCH 33/35] =?UTF-8?q?test:=20=E4=BF=AE=E6=94=B9=20Demo24?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 playground/Demo/Demo24/Main.snow | 10 +++++-----
 playground/Demo/Demo24/OS.snow   | 11 +++++++++++
 2 files changed, 16 insertions(+), 5 deletions(-)
 create mode 100644 playground/Demo/Demo24/OS.snow

diff --git a/playground/Demo/Demo24/Main.snow b/playground/Demo/Demo24/Main.snow
index a18b417..69de980 100644
--- a/playground/Demo/Demo24/Main.snow
+++ b/playground/Demo/Demo24/Main.snow
@@ -3,19 +3,19 @@ module: Main
     function: main
         returns: void
         body:
-            declare a: int = ModuleA.sum(1,2)
+            declare a: byte = ModuleA.sum(1b,2b)
         end body
     end function
 end module
 
 module: ModuleA
     globals:
-        declare a: int = 10
+        declare a: byte = 10b
     function: sum
         params:
-            declare a: int
-            declare b: int
-        returns: int
+            declare a: byte
+            declare b: byte
+        returns: byte
         body:
             return a + b
         end body
diff --git a/playground/Demo/Demo24/OS.snow b/playground/Demo/Demo24/OS.snow
new file mode 100644
index 0000000..1982627
--- /dev/null
+++ b/playground/Demo/Demo24/OS.snow
@@ -0,0 +1,11 @@
+module: os
+    import: os
+    function: print
+        params:
+            declare i1: int
+        returns: void
+        body:
+            syscall("PRINT",i1)
+        end body
+    end function
+end module
\ No newline at end of file

From 8eda4fcbce5b0fdbde3790f0a8cd3afcb648c9d8 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 17:29:51 +0800
Subject: [PATCH 34/35] =?UTF-8?q?chore:=20=E4=BF=AE=E6=94=B9=20Demo24=20?=
 =?UTF-8?q?=E9=85=8D=E7=BD=AE=E6=96=87=E4=BB=B6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .run/Demo24.run.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.run/Demo24.run.xml b/.run/Demo24.run.xml
index 2e71df7..7e0d44b 100644
--- a/.run/Demo24.run.xml
+++ b/.run/Demo24.run.xml
@@ -2,7 +2,7 @@
   <configuration default="false" name="Demo24" type="Application" factoryName="Application" folderName="Demo">
     <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
     <module name="Snow" />
-    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo/Demo24 -o target/Demo24 --debug" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo/Demo24 -o target/Demo24" />
     <method v="2">
       <option name="Make" enabled="true" />
     </method>

From b033d53d28df6675f0e9060029669e048b2b7983 Mon Sep 17 00:00:00 2001
From: Luke <luke.k.xu@hotmail.com>
Date: Tue, 26 Aug 2025 17:30:15 +0800
Subject: [PATCH 35/35] =?UTF-8?q?test:=20Demo24=20=E5=A2=9E=E5=8A=A0?=
 =?UTF-8?q?=E6=9B=B4=E5=A4=9A=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 playground/Demo/Demo24/Main.snow | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/playground/Demo/Demo24/Main.snow b/playground/Demo/Demo24/Main.snow
index 69de980..abda9ee 100644
--- a/playground/Demo/Demo24/Main.snow
+++ b/playground/Demo/Demo24/Main.snow
@@ -1,21 +1,24 @@
 module: Main
     import: ModuleA,os
+    globals:
+        declare const c: int = 10
     function: main
         returns: void
         body:
-            declare a: byte = ModuleA.sum(1b,2b)
+            declare a: int = ModuleA.sum(c,2)
+            os.print(a)
         end body
     end function
 end module
 
 module: ModuleA
     globals:
-        declare a: byte = 10b
+        declare const a: int = 10
     function: sum
         params:
-            declare a: byte
-            declare b: byte
-        returns: byte
+            declare a: int
+            declare b: int
+        returns: int
         body:
             return a + b
         end body