Build Phase 2 judge vertical slice

2026-08-06 22:42:39 -06:00
parent e6329ecabb
commit ec274419c3
41 changed files with 2945 additions and 669 deletions
@@ -0,0 +1,243 @@
+import { Language, Parser, type Node } from "web-tree-sitter"
+
+export interface AstRule {
+  engine?: string
+  target?: string
+  outer?: string
+  inner?: string
+  label?: string
+  message?: string
+  exact?: number
+  min?: number
+  max?: number
+}
+
+export interface AstResult {
+  description: string
+  passed: boolean
+}
+
+const mappings: Record<string, Record<string, string>> = {
+  C: {
+    for_loop: "for_statement",
+    while_loop: "while_statement",
+    do_while: "do_statement",
+    if_statement: "if_statement",
+    else_clause: "else_clause",
+    break: "break_statement",
+    continue: "continue_statement",
+    function_definition: "function_definition",
+    return: "return_statement",
+    switch_statement: "switch_statement",
+    case_statement: "case_statement",
+    assignment: "assignment_expression",
+    struct: "struct_specifier",
+    include: "preproc_include",
+    and: "&&",
+    or: "||",
+    not: "!",
+  },
+  Python3: {
+    for_loop: "for_statement",
+    while_loop: "while_statement",
+    if_statement: "if_statement",
+    else_clause: "else_clause",
+    elif_clause: "elif_clause",
+    break: "break_statement",
+    continue: "continue_statement",
+    function_definition: "function_definition",
+    return: "return_statement",
+    try_except: "try_statement",
+    with_statement: "with_statement",
+    list_comprehension: "list_comprehension",
+    list_literal: "list",
+    dict_literal: "dictionary",
+    set_literal: "set",
+    f_string: "format_string",
+    import: "import_statement",
+    import_from: "import_from_statement",
+    assignment: "assignment",
+    class_definition: "class_definition",
+  },
+}
+
+let initPromise: Promise<void> | undefined
+const languages = new Map<string, Language>()
+
+async function loadLanguage(language: string) {
+  if (!(language in mappings)) return null
+  if (!initPromise) initPromise = Parser.init()
+  await initPromise
+
+  const cached = languages.get(language)
+  if (cached) return cached
+
+  const packageName = language === "C" ? "tree-sitter-c" : "tree-sitter-python"
+  const wasmName = language === "C" ? "tree-sitter-c.wasm" : "tree-sitter-python.wasm"
+  const wasmPath = Bun.resolveSync(`${packageName}/${wasmName}`, import.meta.dir)
+  const loaded = await Language.load(wasmPath)
+  languages.set(language, loaded)
+  return loaded
+}
+
+function collectNodes(root: Node, type: string, result: Node[] = []) {
+  if (root.type === type) result.push(root)
+  for (const child of root.children) collectNodes(child, type, result)
+  return result
+}
+
+function hasNode(root: Node, type: string): boolean {
+  if (root.type === type) return true
+  return root.children.some((child) => hasNode(child, type))
+}
+
+function targetName(rule: AstRule) {
+  return rule.label || rule.target || "指定语法"
+}
+
+function rangeDescription(subject: string, rule: AstRule) {
+  if (rule.message) return rule.message
+  if (rule.exact !== undefined) return `${subject} 出现 ${rule.exact} 次`
+  const parts: string[] = []
+  if (rule.min !== undefined) parts.push(`至少 ${rule.min} 次`)
+  if (rule.max !== undefined) parts.push(`至多 ${rule.max} 次`)
+  return `${subject} ${parts.join("、")}`.trim()
+}
+
+function rangePassed(count: number, rule: AstRule) {
+  if (rule.exact !== undefined && count !== rule.exact) return false
+  if (rule.min !== undefined && count < rule.min) return false
+  if (rule.max !== undefined && count > rule.max) return false
+  return true
+}
+
+function functionCalls(root: Node, target: string, language: string) {
+  const callType = language === "C" ? "call_expression" : "call"
+  return collectNodes(root, callType).filter((call) => {
+    const fn = call.childForFieldName("function")
+    return fn?.type === "identifier" && fn.text === target
+  })
+}
+
+function methodCalls(root: Node, target: string, language: string) {
+  if (language === "C") return []
+  return collectNodes(root, "call").filter((call) => {
+    const fn = call.childForFieldName("function")
+    return (
+      fn?.type === "attribute" &&
+      fn.childForFieldName("attribute")?.text === target
+    )
+  })
+}
+
+function evaluateRule(
+  root: Node,
+  rule: AstRule,
+  language: string,
+  mapping: Record<string, string>,
+): AstResult | null {
+  const target = rule.target ?? ""
+  const nodeType = mapping[target] ?? target
+
+  switch (rule.engine) {
+    case "must_exist_node":
+      return {
+        description: rule.message || `必须使用 ${targetName(rule)}`,
+        passed: hasNode(root, nodeType),
+      }
+    case "must_not_exist_node":
+      return {
+        description: rule.message || `不能使用 ${targetName(rule)}`,
+        passed: !hasNode(root, nodeType),
+      }
+    case "count_node": {
+      const count = collectNodes(root, nodeType).length
+      return {
+        description: rangeDescription(targetName(rule), rule),
+        passed: rangePassed(count, rule),
+      }
+    }
+    case "must_call_function":
+      return {
+        description: rule.message || `必须调用 ${target}()`,
+        passed: functionCalls(root, target, language).length > 0,
+      }
+    case "must_not_call_function":
+      return {
+        description: rule.message || `不能调用 ${target}()`,
+        passed: functionCalls(root, target, language).length === 0,
+      }
+    case "count_function_call": {
+      const count = functionCalls(root, target, language).length
+      return {
+        description: rangeDescription(`${target}()`, rule),
+        passed: rangePassed(count, rule),
+      }
+    }
+    case "must_call_method":
+      return {
+        description: rule.message || `必须调用 .${target}()`,
+        passed: methodCalls(root, target, language).length > 0,
+      }
+    case "must_not_call_method":
+      return {
+        description: rule.message || `不能调用 .${target}()`,
+        passed: methodCalls(root, target, language).length === 0,
+      }
+    case "must_use_operator":
+      return {
+        description: rule.message || `必须使用 ${target} 运算符`,
+        passed: hasNode(root, nodeType),
+      }
+    case "must_have_nesting": {
+      const outer = rule.outer ?? ""
+      const inner = rule.inner ?? ""
+      const outerType = mapping[outer] ?? outer
+      const innerType = mapping[inner] ?? inner
+      const passed = collectNodes(root, outerType).some((node) =>
+        node.children.some((child) => hasNode(child, innerType)),
+      )
+      return {
+        description:
+          rule.message ||
+          (outer === inner
+            ? `必须使用 ${outer} 嵌套`
+            : `必须在 ${outer} 中嵌套使用 ${inner}`),
+        passed,
+      }
+    }
+    default:
+      return null
+  }
+}
+
+export async function checkAst(
+  code: string,
+  language: string,
+  rules: AstRule[],
+): Promise<{ passed: boolean; results: AstResult[] }> {
+  if (rules.length === 0) return { passed: true, results: [] }
+
+  const treeSitterLanguage = await loadLanguage(language)
+  if (!treeSitterLanguage) return { passed: true, results: [] }
+
+  const parser = new Parser()
+  try {
+    parser.setLanguage(treeSitterLanguage)
+    const tree = parser.parse(code)
+    if (!tree) return { passed: true, results: [] }
+    try {
+      const mapping = mappings[language] ?? {}
+      const results = rules
+        .map((rule) => evaluateRule(tree.rootNode, rule, language, mapping))
+        .filter((result): result is AstResult => result !== null)
+      return { passed: results.every((result) => result.passed), results }
+    } finally {
+      tree.delete()
+    }
+  } catch {
+    return { passed: true, results: [] }
+  } finally {
+    parser.delete()
+  }
+}