360 lines
14 KiB
TypeScript
360 lines
14 KiB
TypeScript
import {
|
||
AST_NODE_TARGETS_BY_LANGUAGE,
|
||
AST_OPERATOR_TARGETS_BY_LANGUAGE,
|
||
astNodeLabel,
|
||
astOperatorLabel,
|
||
astRuleIsMeaningful,
|
||
astTargetNodeType,
|
||
astRuleSchema,
|
||
AST_SUPPORTED_LANGUAGES,
|
||
type AstRequirement,
|
||
type AstRequirements,
|
||
type AstRule,
|
||
type AstRules,
|
||
} from "@oj2/contract"
|
||
import { Language, Parser, type Node } from "web-tree-sitter"
|
||
// 语法 wasm 内嵌成资源。原来是 `Bun.resolveSync(pkg + "/" + name, import.meta.dir)`，
|
||
// 编译成单二进制后 import.meta.dir 是 /$bunfs/root，解析不到 node_modules。见 vendor/jieba.ts
|
||
import cWasmPath from "tree-sitter-c/tree-sitter-c.wasm" with { type: "file" }
|
||
import cppWasmPath from "tree-sitter-cpp/tree-sitter-cpp.wasm" with { type: "file" }
|
||
import pythonWasmPath from "tree-sitter-python/tree-sitter-python.wasm" with { type: "file" }
|
||
// web-tree-sitter 自己的运行时 wasm，Parser.init() 要用
|
||
import treeSitterWasmPath from "web-tree-sitter/web-tree-sitter.wasm" with { type: "file" }
|
||
|
||
// AstRule 的形状在契约里（astRuleSchema）—— 原来这份和前端两份各写各的。
|
||
// 这里 re-export，判题机的调用方不用再去 import 契约。
|
||
export type { AstRule } from "@oj2/contract"
|
||
|
||
export interface AstResult {
|
||
description: string
|
||
passed: boolean
|
||
/** count_* 引擎实际数到的次数。失败时前端拿它补一句「当前 N 次」 */
|
||
actual?: number
|
||
}
|
||
|
||
let initPromise: Promise<void> | undefined
|
||
const languages = new Map<string, Language>()
|
||
|
||
async function loadLanguage(language: string) {
|
||
if (!AST_SUPPORTED_LANGUAGES.includes(language)) return null
|
||
// locateFile 指到内嵌的 tree-sitter.wasm：emscripten 默认按脚本所在目录找，
|
||
// 单二进制里那个目录是 /$bunfs/root，它自己找不着
|
||
if (!initPromise) initPromise = Parser.init({ locateFile: () => treeSitterWasmPath })
|
||
await initPromise
|
||
|
||
const cached = languages.get(language)
|
||
if (cached) return cached
|
||
|
||
const wasmPath = language === "C" ? cWasmPath : language === "C++" ? cppWasmPath : pythonWasmPath
|
||
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, language?: string) {
|
||
const target = rule.target ?? ""
|
||
return rule.label || astNodeLabel(target, language) || "指定语法"
|
||
}
|
||
|
||
function countPhrase(verb: string, rule: AstRule) {
|
||
if (rule.exact !== undefined) return `${verb} ${rule.exact} 次`
|
||
if (rule.min !== undefined && rule.max !== undefined) return `${verb} ${rule.min}～${rule.max} 次`
|
||
if (rule.min !== undefined) return `至少${verb} ${rule.min} 次`
|
||
if (rule.max !== undefined) return `至多${verb} ${rule.max} 次`
|
||
return ""
|
||
}
|
||
|
||
/**
|
||
* 一条规则的中文描述。判题结果（statistic_info.ast_results）和题目页的「要求」
|
||
* 用的是同一份 —— 原来前端 ProblemContent.vue 里另有一份几乎一样的实现，
|
||
* 只有 min/max 同时给出时的措辞不一样（生产库里没有这种规则）。
|
||
*/
|
||
export function describeAstRule(rule: AstRule, language?: string): string {
|
||
if (rule.message) return rule.message
|
||
const name = targetName(rule, language)
|
||
const target = rule.target ?? ""
|
||
switch (rule.engine) {
|
||
case "must_exist_node":
|
||
return `必须使用 ${name}`
|
||
case "must_not_exist_node":
|
||
return `不能使用 ${name}`
|
||
case "count_node":
|
||
return `${name} ${countPhrase("出现", rule)}`.trim()
|
||
case "must_call_function":
|
||
return `必须调用 ${target}()`
|
||
case "must_not_call_function":
|
||
return `不能调用 ${target}()`
|
||
case "count_function_call":
|
||
return `${target}() ${countPhrase("调用", rule)}`.trim()
|
||
case "must_call_method":
|
||
return `必须调用 .${target}()`
|
||
case "must_not_call_method":
|
||
return `不能调用 .${target}()`
|
||
case "must_use_operator":
|
||
return `必须使用 ${astOperatorLabel(target, language)} 运算符`
|
||
case "must_have_nesting": {
|
||
// 这两个走 astNodeLabel 而不是裸值 —— 少了这一步文案就是
|
||
// 「必须使用 for_loop 嵌套」，旧栈 ast_checker/engines/nesting.py 是翻的
|
||
const outer = astNodeLabel(rule.outer ?? "", language)
|
||
const inner = astNodeLabel(rule.inner ?? "", language)
|
||
return outer === inner ? `必须使用 ${outer} 嵌套` : `必须在 ${outer} 中嵌套使用 ${inner}`
|
||
}
|
||
}
|
||
}
|
||
|
||
/** 标签配色用的粗分类，见契约 astRequirementSchema */
|
||
function requirementKind(engine: AstRule["engine"]): AstRequirement["kind"] {
|
||
if (engine.startsWith("must_not")) return "forbid"
|
||
if (engine.startsWith("count")) return "count"
|
||
return "require"
|
||
}
|
||
|
||
/**
|
||
* 把规则原文投影成下发给学生的「代码要求」。规则里的 engine / target 不出现在
|
||
* 响应里 —— 阶段 3 泄露评审收掉 ast_rules 时要的就是这个，见契约的注释。
|
||
*
|
||
* 只投影判题机真检查得了的语言。原来这里不看语言，给 C++ 题配的规则照样渲染成
|
||
* 「必须使用 for 循环」挂在题目页上，而 loadLanguage 对 C++ 返回 null、
|
||
* checkAst 直接放行 —— 学生看得见要求，判题从不检查。
|
||
*/
|
||
export function astRequirements(value: unknown): AstRequirements | null {
|
||
const grouped =
|
||
value && typeof value === "object" && !Array.isArray(value)
|
||
? (value as Record<string, unknown>)
|
||
: null
|
||
if (!grouped) return null
|
||
const out: AstRequirements = {}
|
||
for (const [language, rules] of Object.entries(grouped)) {
|
||
if (!Array.isArray(rules)) continue
|
||
if (!AST_SUPPORTED_LANGUAGES.includes(language)) continue
|
||
const items = rules.flatMap((rule) => {
|
||
const parsed = astRuleSchema.safeParse(rule)
|
||
if (!parsed.success) return []
|
||
if (!astRuleIsMeaningful(parsed.data)) return []
|
||
return [
|
||
{
|
||
description: describeAstRule(parsed.data, language),
|
||
kind: requirementKind(parsed.data.engine),
|
||
},
|
||
]
|
||
})
|
||
if (items.length > 0) out[language] = items
|
||
}
|
||
return Object.keys(out).length > 0 ? out : null
|
||
}
|
||
|
||
/**
|
||
* AST 规则的语义校验。zod 只管形状（engine 在枚举里、min 是整数），管不了
|
||
* 「给 C 题选了只有 Python 才有的 list_comprehension」这类组合 —— 那种规则存得进去，
|
||
* 判题时 astTargetNodeType() 找不到就回落成裸名去比节点类型，永远失败或永远通过，
|
||
* 两头都不报错，只有学生受着。
|
||
*
|
||
* 放这儿而不是 astRulesSchema 的 refine 上：那个 schema 同时用于**读**后台题目详情，
|
||
* 在读路径上抛错会让历史脏数据直接把题目详情打不开。
|
||
*/
|
||
export function astRulesError(astRules: AstRules | null): string | null {
|
||
if (!astRules) return null
|
||
for (const [language, rules] of Object.entries(astRules)) {
|
||
if (rules.length === 0) continue
|
||
if (!AST_SUPPORTED_LANGUAGES.includes(language)) {
|
||
return `代码规则暂不支持 ${language}，判题机只检查 ${AST_SUPPORTED_LANGUAGES.join(" / ")}`
|
||
}
|
||
const nodes = AST_NODE_TARGETS_BY_LANGUAGE[language] ?? {}
|
||
const operators = AST_OPERATOR_TARGETS_BY_LANGUAGE[language] ?? {}
|
||
for (const [index, rule] of rules.entries()) {
|
||
const at = `代码规则 ${language} 第 ${index + 1} 条`
|
||
const target = rule.target ?? ""
|
||
if (rule.engine.endsWith("_node")) {
|
||
if (!(target in nodes)) return `${at}：${language} 没有「${target}」这种语法`
|
||
} else if (rule.engine === "must_use_operator") {
|
||
if (!(target in operators)) return `${at}：${language} 没有「${target}」运算符`
|
||
} else if (rule.engine === "must_have_nesting") {
|
||
for (const value of [rule.outer ?? "", rule.inner ?? ""]) {
|
||
if (!(value in nodes)) return `${at}：${language} 没有「${value}」这种语法`
|
||
}
|
||
} else if (!target.trim()) {
|
||
return `${at}：要检查的函数名/方法名不能为空`
|
||
}
|
||
if (!astRuleIsMeaningful(rule)) return `${at}：次数检查至少要填一个数字`
|
||
}
|
||
}
|
||
return null
|
||
}
|
||
|
||
/**
|
||
* 保存前清掉够不着的规则分组：不在题目 languages 里的（老师改过语言列表），
|
||
* 以及判题机检查不了的（C++ / Java / …）。两者编辑器都不给开 tab，留着就是死数据。
|
||
*
|
||
* 必须先剔除再校验，否则历史脏数据会把老师锁死：一道 languages 含 C++ 的题，
|
||
* 早年配过 C++ 规则，如今 tab 里看不到那组规则，保存却被「暂不支持 C++」拦下，
|
||
* 老师在界面上无从修改。
|
||
*/
|
||
export function pickAstRules(astRules: AstRules | null, languages: string[]): AstRules | null {
|
||
if (!astRules) return null
|
||
const out: AstRules = {}
|
||
for (const [language, rules] of Object.entries(astRules)) {
|
||
if (!languages.includes(language)) continue
|
||
if (!AST_SUPPORTED_LANGUAGES.includes(language)) continue
|
||
if (rules.length > 0) out[language] = rules
|
||
}
|
||
return Object.keys(out).length > 0 ? out : null
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
const CALL_NODE_TYPES: Record<string, string> = {
|
||
C: "call_expression",
|
||
"C++": "call_expression",
|
||
Python: "call",
|
||
}
|
||
|
||
function functionCalls(root: Node, target: string, language: string) {
|
||
const callType = CALL_NODE_TYPES[language] ?? "call"
|
||
return collectNodes(root, callType).filter((call) => {
|
||
const fn = call.childForFieldName("function")
|
||
if (!fn) return false
|
||
if (fn.type === "identifier") return fn.text === target
|
||
// `std::sort(...)` 是 qualified_identifier。学生写 sort 还是 std::sort 取决于
|
||
// 有没有 using namespace std，两种都得认，所以末段也比一次
|
||
if (language === "C++" && fn.type === "qualified_identifier") {
|
||
return fn.text === target || fn.text.split("::").pop() === target
|
||
}
|
||
return false
|
||
})
|
||
}
|
||
|
||
function methodCalls(root: Node, target: string, language: string) {
|
||
// C++ 的 `a.push_back()` / `p->push_back()` 都是 call_expression + field_expression，
|
||
// 和 Python 的 attribute 不是一回事 —— 少了这个分支，C++ 的「必须调用 .push_back()」
|
||
// 会静默地永远失败
|
||
if (language === "C++") {
|
||
return collectNodes(root, "call_expression").filter((call) => {
|
||
const fn = call.childForFieldName("function")
|
||
return fn?.type === "field_expression" && fn.childForFieldName("field")?.text === target
|
||
})
|
||
}
|
||
if (language !== "Python") 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): AstResult | null {
|
||
const target = rule.target ?? ""
|
||
const nodeType = astTargetNodeType(target, language)
|
||
|
||
switch (rule.engine) {
|
||
case "must_exist_node":
|
||
return {
|
||
description: describeAstRule(rule, language),
|
||
passed: hasNode(root, nodeType),
|
||
}
|
||
case "must_not_exist_node":
|
||
return {
|
||
description: describeAstRule(rule, language),
|
||
passed: !hasNode(root, nodeType),
|
||
}
|
||
case "count_node": {
|
||
const count = collectNodes(root, nodeType).length
|
||
return {
|
||
description: describeAstRule(rule, language),
|
||
passed: rangePassed(count, rule),
|
||
actual: count,
|
||
}
|
||
}
|
||
case "must_call_function":
|
||
return {
|
||
description: describeAstRule(rule, language),
|
||
passed: functionCalls(root, target, language).length > 0,
|
||
}
|
||
case "must_not_call_function":
|
||
return {
|
||
description: describeAstRule(rule, language),
|
||
passed: functionCalls(root, target, language).length === 0,
|
||
}
|
||
case "count_function_call": {
|
||
const count = functionCalls(root, target, language).length
|
||
return {
|
||
description: describeAstRule(rule, language),
|
||
passed: rangePassed(count, rule),
|
||
actual: count,
|
||
}
|
||
}
|
||
case "must_call_method":
|
||
return {
|
||
description: describeAstRule(rule, language),
|
||
passed: methodCalls(root, target, language).length > 0,
|
||
}
|
||
case "must_not_call_method":
|
||
return {
|
||
description: describeAstRule(rule, language),
|
||
passed: methodCalls(root, target, language).length === 0,
|
||
}
|
||
case "must_use_operator":
|
||
return {
|
||
description: describeAstRule(rule, language),
|
||
passed: hasNode(root, nodeType),
|
||
}
|
||
case "must_have_nesting": {
|
||
const outer = rule.outer ?? ""
|
||
const inner = rule.inner ?? ""
|
||
const outerType = astTargetNodeType(outer, language)
|
||
const innerType = astTargetNodeType(inner, language)
|
||
const passed = collectNodes(root, outerType).some((node) =>
|
||
node.children.some((child) => hasNode(child, innerType)),
|
||
)
|
||
return { description: describeAstRule(rule, language), 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 results = rules
|
||
.filter(astRuleIsMeaningful)
|
||
.map((rule) => evaluateRule(tree.rootNode, rule, language))
|
||
.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()
|
||
}
|
||
}
|