update

ast_checker/checker.py

@@ -4,7 +4,7 @@ from .engines import get_engine
 from .mappings import get_language, get_mapping
 
 
-def check_ast(code: str, language: str, rules: list[dict]) -> tuple[bool, list[str]]:
+def check_ast(code: str, language: str, rules: list[dict]) -> tuple[bool, list[dict]]:
     if not rules:
         return True, []
 
@@ -20,12 +20,16 @@ def check_ast(code: str, language: str, rules: list[dict]) -> tuple[bool, list[s
     except Exception:
         return True, []
 
-    errors = []
+    results = []
+    all_passed = True
     for rule in rules:
         engine = get_engine(rule.get("engine", ""))
         if engine is None:
             continue
-        rule_errors = engine.check(tree, rule, language, mapping)
-        errors.extend(rule_errors)
+        errors = engine.check(tree, rule, language, mapping)
+        passed = len(errors) == 0
+        if not passed:
+            all_passed = False
+        results.append({"description": engine.describe(rule, language, mapping), "passed": passed})
 
-    return len(errors) == 0, errors
+    return all_passed, results

ast_checker/engines/base.py

@@ -16,3 +16,6 @@ class BaseEngine:
 
     def check(self, tree, rule, language, mapping) -> list[str]:
         raise NotImplementedError
+
+    def describe(self, rule, language, mapping) -> str:
+        raise NotImplementedError

ast_checker/engines/function_call.py

@@ -19,29 +19,56 @@ class _FunctionCallBase(BaseEngine):
 
 
 class MustCallFunctionEngine(_FunctionCallBase):
+    def _message(self, rule):
+        return rule.get("message") or f"必须调用 {rule['target']}()"
+
     def check(self, tree, rule, language, mapping):
-        target = rule["target"]
-        if not self._find_function_calls(tree.root_node, target, language):
-            return [rule.get("message", f"必须调用 {target}()")]
+        if not self._find_function_calls(tree.root_node, rule["target"], language):
+            return [self._message(rule)]
         return []
 
+    def describe(self, rule, language, mapping):
+        return self._message(rule)
+
 
 class MustNotCallFunctionEngine(_FunctionCallBase):
+    def _message(self, rule):
+        return rule.get("message") or f"不能调用 {rule['target']}()"
+
     def check(self, tree, rule, language, mapping):
-        target = rule["target"]
-        if self._find_function_calls(tree.root_node, target, language):
-            return [rule.get("message", f"不能调用 {target}()")]
+        if self._find_function_calls(tree.root_node, rule["target"], language):
+            return [self._message(rule)]
         return []
 
+    def describe(self, rule, language, mapping):
+        return self._message(rule)
+
 
 class CountFunctionCallEngine(_FunctionCallBase):
-    def check(self, tree, rule, language, mapping):
+    def _message(self, rule, count):
         target = rule["target"]
-        count = len(self._find_function_calls(tree.root_node, target, language))
         min_count = rule.get("min")
         max_count = rule.get("max")
         if min_count is not None and count < min_count:
-            return [rule.get("message", f"{target}() 至少调用 {min_count} 次，当前 {count} 次")]
+            return rule.get("message") or f"{target}() 至少调用 {min_count} 次，当前 {count} 次"
         if max_count is not None and count > max_count:
-            return [rule.get("message", f"{target}() 至多调用 {max_count} 次，当前 {count} 次")]
-        return []
+            return rule.get("message") or f"{target}() 至多调用 {max_count} 次，当前 {count} 次"
+        return None
+
+    def check(self, tree, rule, language, mapping):
+        count = len(self._find_function_calls(tree.root_node, rule["target"], language))
+        msg = self._message(rule, count)
+        return [msg] if msg else []
+
+    def describe(self, rule, language, mapping):
+        target = rule["target"]
+        min_count = rule.get("min")
+        max_count = rule.get("max")
+        if rule.get("message"):
+            return rule["message"]
+        parts = []
+        if min_count is not None:
+            parts.append(f"至少 {min_count} 次")
+        if max_count is not None:
+            parts.append(f"至多 {max_count} 次")
+        return f"{target}() " + "、".join(parts)

ast_checker/engines/method_call.py

@@ -23,16 +23,26 @@ class _MethodCallBase(BaseEngine):
 
 
 class MustCallMethodEngine(_MethodCallBase):
+    def _message(self, rule):
+        return rule.get("message") or f"必须调用 .{rule['target']}()"
+
     def check(self, tree, rule, language, mapping):
-        target = rule["target"]
-        if not self._find_method_calls(tree.root_node, target, language):
-            return [rule.get("message", f"必须调用 .{target}()")]
+        if not self._find_method_calls(tree.root_node, rule["target"], language):
+            return [self._message(rule)]
         return []
 
+    def describe(self, rule, language, mapping):
+        return self._message(rule)
+
 
 class MustNotCallMethodEngine(_MethodCallBase):
+    def _message(self, rule):
+        return rule.get("message") or f"不能调用 .{rule['target']}()"
+
     def check(self, tree, rule, language, mapping):
-        target = rule["target"]
-        if self._find_method_calls(tree.root_node, target, language):
-            return [rule.get("message", f"不能调用 .{target}()")]
+        if self._find_method_calls(tree.root_node, rule["target"], language):
+            return [self._message(rule)]
         return []
+
+    def describe(self, rule, language, mapping):
+        return self._message(rule)

ast_checker/engines/node_count.py

@@ -2,15 +2,32 @@ from .base import BaseEngine
 
 
 class CountNodeEngine(BaseEngine):
-    def check(self, tree, rule, language, mapping):
+    def _message(self, rule, count):
         target = rule["target"]
-        node_type = mapping.get(target, target)
-        nodes = self.collect_nodes(tree.root_node, node_type)
-        count = len(nodes)
         min_count = rule.get("min")
         max_count = rule.get("max")
         if min_count is not None and count < min_count:
-            return [rule.get("message", f"{target} 至少出现 {min_count} 次，当前 {count} 次")]
+            return rule.get("message") or f"{target} 至少出现 {min_count} 次，当前 {count} 次"
         if max_count is not None and count > max_count:
-            return [rule.get("message", f"{target} 至多出现 {max_count} 次，当前 {count} 次")]
-        return []
+            return rule.get("message") or f"{target} 至多出现 {max_count} 次，当前 {count} 次"
+        return None
+
+    def check(self, tree, rule, language, mapping):
+        target = rule["target"]
+        node_type = mapping.get(target, target)
+        count = len(self.collect_nodes(tree.root_node, node_type))
+        msg = self._message(rule, count)
+        return [msg] if msg else []
+
+    def describe(self, rule, language, mapping):
+        target = rule["target"]
+        min_count = rule.get("min")
+        max_count = rule.get("max")
+        if rule.get("message"):
+            return rule["message"]
+        parts = []
+        if min_count is not None:
+            parts.append(f"至少 {min_count} 次")
+        if max_count is not None:
+            parts.append(f"至多 {max_count} 次")
+        return f"{target} " + "、".join(parts)

ast_checker/engines/node_exists.py

@@ -2,18 +2,28 @@ from .base import BaseEngine
 
 
 class MustExistNodeEngine(BaseEngine):
+    def _message(self, rule):
+        return rule.get("message") or f"必须使用 {rule['target']}"
+
     def check(self, tree, rule, language, mapping):
-        target = rule["target"]
-        node_type = mapping.get(target, target)
+        node_type = mapping.get(rule["target"], rule["target"])
         if not self.has_node(tree.root_node, node_type):
-            return [rule.get("message", f"必须使用 {target}")]
+            return [self._message(rule)]
         return []
 
+    def describe(self, rule, language, mapping):
+        return self._message(rule)
+
 
 class MustNotExistNodeEngine(BaseEngine):
+    def _message(self, rule):
+        return rule.get("message") or f"不能使用 {rule['target']}"
+
     def check(self, tree, rule, language, mapping):
-        target = rule["target"]
-        node_type = mapping.get(target, target)
+        node_type = mapping.get(rule["target"], rule["target"])
         if self.has_node(tree.root_node, node_type):
-            return [rule.get("message", f"不能使用 {target}")]
+            return [self._message(rule)]
         return []
+
+    def describe(self, rule, language, mapping):
+        return self._message(rule)

ast_checker/engines/operator.py

@@ -2,9 +2,14 @@ from .base import BaseEngine
 
 
 class MustUseOperatorEngine(BaseEngine):
+    def _message(self, rule):
+        return rule.get("message") or f"必须使用 {rule['target']} 运算符"
+
     def check(self, tree, rule, language, mapping):
-        target = rule["target"]
-        mapped_op = mapping.get(target, target)
+        mapped_op = mapping.get(rule["target"], rule["target"])
         if not self.has_node(tree.root_node, mapped_op):
-            return [rule.get("message", f"必须使用 {target} 运算符")]
+            return [self._message(rule)]
         return []
+
+    def describe(self, rule, language, mapping):
+        return self._message(rule)

judge/dispatcher.py

@@ -213,10 +213,10 @@ class JudgeDispatcher(DispatcherBase):
                 if ast_rules and language in ast_rules:
                     from ast_checker.checker import check_ast
 
-                    passed, errors = check_ast(self.submission.code, language, ast_rules[language])
+                    passed, results = check_ast(self.submission.code, language, ast_rules[language])
                     if not passed:
                         self.submission.result = JudgeStatus.AST_CHECK_FAILED
-                        self.submission.statistic_info["err_info"] = "\n".join(errors)
+                        self.submission.statistic_info["ast_results"] = results
         self.submission.save(update_fields=["result", "info", "statistic_info"])
 
         # 推送判题完成状态