优化注释

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

@@ -59,25 +59,7 @@ public class FunctionParser implements TopLevelParser {
         List<StatementNode> body = new ArrayList<>();
 
         // 定义可变区块的解析规则
-        Map<String, SectionDefinition> sectionDefinitions = new HashMap<>();
+        Map<String, SectionDefinition> sectionDefinitions = getStringSectionDefinitionMap(parameters, returnType, body);
-
-        // 参数解析
-        sectionDefinitions.put("parameter", new SectionDefinition(
-                ts -> ts.peek().getLexeme().equals("parameter"),
-                (ctx1, ts1) -> parameters.addAll(parseParameters(ts1))
-        ));
-
-        // 返回类型解析
-        sectionDefinitions.put("return_type", new SectionDefinition(
-                ts -> ts.peek().getLexeme().equals("return_type"),
-                (ctx1, ts1) -> returnType[0] = parseReturnType(ts1)
-        ));
-
-        // 函数体解析
-        sectionDefinitions.put("body", new SectionDefinition(
-                ts -> ts.peek().getLexeme().equals("body"),
-                (ctx1, ts1) -> body.addAll(parseFunctionBody(ctx1, ts1))
-        ));
 
         // 使用 FlexibleSectionParser 解析函数的可变部分，顺序无关
         FlexibleSectionParser.parse(ctx, tokens, sectionDefinitions);
@@ -89,6 +71,29 @@ public class FunctionParser implements TopLevelParser {
         return new FunctionNode(functionName, parameters, returnType[0], body);
     }
 
+    private Map<String, SectionDefinition> getStringSectionDefinitionMap(List<ParameterNode> parameters, String[] returnType, List<StatementNode> body) {
+        Map<String, SectionDefinition> sectionDefinitions = new HashMap<>();
+
+        // 参数解析
+        sectionDefinitions.put("parameter", new SectionDefinition(
+                ts -> ts.peek().getLexeme().equals("parameter"),
+                (_, ts1) -> parameters.addAll(parseParameters(ts1))
+        ));
+
+        // 返回类型解析
+        sectionDefinitions.put("return_type", new SectionDefinition(
+                ts -> ts.peek().getLexeme().equals("return_type"),
+                (_, ts1) -> returnType[0] = parseReturnType(ts1)
+        ));
+
+        // 函数体解析
+        sectionDefinitions.put("body", new SectionDefinition(
+                ts -> ts.peek().getLexeme().equals("body"),
+                (ctx1, ts1) -> body.addAll(parseFunctionBody(ctx1, ts1))
+        ));
+        return sectionDefinitions;
+    }
+
     /**
      * 匹配并解析函数头部标记（例如：function:）。
      *

src/main/java/org/jcnc/snow/compiler/parser/util/FlexibleSectionParser.java

@@ -3,7 +3,7 @@ package org.jcnc.snow.compiler.parser.util;
 import org.jcnc.snow.compiler.lexer.token.TokenType;
 import org.jcnc.snow.compiler.parser.context.ParserContext;
 import org.jcnc.snow.compiler.parser.context.TokenStream;
-import java.util.List;
+
 import java.util.Map;
 import java.util.function.BiConsumer;
 import java.util.function.Predicate;
@@ -16,7 +16,7 @@ import java.util.function.Predicate;
  * </p>
  *
  * <p>
- * 例如，您可以使用此类解析函数定义中的多个部分（如参数、返回类型、函数体等），而不需要在解析器中显式地硬编码每个部分。
+ * 使用此类解析函数定义中的多个部分（如参数、返回类型、函数体等），而不需要在解析器中显式地硬编码每个部分。
  * </p>
  */
 public class FlexibleSectionParser {
@@ -28,9 +28,9 @@ public class FlexibleSectionParser {
      * 条件用于判断是否应该解析该区块，解析器则负责实际的解析过程。
      * </p>
      *
-     * @param ctx                  解析上下文，包含词法流等信息
+     * @param ctx                解析上下文，包含词法流等信息
-     * @param tokens               当前的 Token 流
+     * @param tokens             当前的 Token 流
-     * @param sectionDefinitions   各种区块定义，键值为区块的名称，值为对应的解析器和条件
+     * @param sectionDefinitions 各种区块定义，键值为区块的名称，值为对应的解析器和条件
      */
     public static void parse(ParserContext ctx,
                              TokenStream tokens,
@@ -48,9 +48,9 @@ public class FlexibleSectionParser {
             // 查找是否有与当前关键字匹配的区块
             SectionDefinition definition = sectionDefinitions.get(keyword);
 
-            if (definition != null && definition.getCondition().test(tokens)) {
+            if (definition != null && definition.condition().test(tokens)) {
                 // 执行解析动作
-                definition.getParser().accept(ctx, tokens);
+                definition.parser().accept(ctx, tokens);
             } else if ("end".equals(keyword)) {
                 // 如果遇到 "end"，则退出解析
                 break;
@@ -72,21 +72,19 @@ public class FlexibleSectionParser {
      * 它包含一个条件（`Predicate<TokenStream>`），用于判断当前 Token 是否符合该区块的开始标识，
      * 以及一个解析器（`BiConsumer<ParserContext, TokenStream>`），用于执行具体的解析操作。
      * </p>
+     *
+     * @param condition 条件，判断是否需要解析该区块
+     * @param parser    区块的解析器
      */
-    public static class SectionDefinition {
+    public record SectionDefinition(Predicate<TokenStream> condition, BiConsumer<ParserContext, TokenStream> parser) {
-
-        private final Predicate<TokenStream> condition; // 条件，判断是否需要解析该区块
-        private final BiConsumer<ParserContext, TokenStream> parser; // 区块的解析器
 
         /**
          * 构造一个新的区块定义。
          *
          * @param condition 判断该区块是否应该解析的条件
-         * @param parser 区块的解析器
+         * @param parser    区块的解析器
          */
-        public SectionDefinition(Predicate<TokenStream> condition, BiConsumer<ParserContext, TokenStream> parser) {
+        public SectionDefinition {
-            this.condition = condition;
-            this.parser = parser;
         }
 
         /**
@@ -94,7 +92,8 @@ public class FlexibleSectionParser {
          *
          * @return 区块的条件
          */
-        public Predicate<TokenStream> getCondition() {
+        @Override
+        public Predicate<TokenStream> condition() {
             return condition;
         }
 
@@ -103,7 +102,8 @@ public class FlexibleSectionParser {
          *
          * @return 区块的解析器
          */
-        public BiConsumer<ParserContext, TokenStream> getParser() {
+        @Override
+        public BiConsumer<ParserContext, TokenStream> parser() {
             return parser;
         }
     }