fix: 结构哈希补全全部变体（消除 code cache 确定性碰撞）

crates/oxide_compiler/src/hash/class.rs

@@ -37,6 +37,15 @@ pub(super) fn hash_class_element(element: &ClassElement, h: &mut rustc_hash::FxH
                 statement::hash_statement(stmt, h, include_binding_names);
             }
         }
+        ClassElement::AccessorProperty(prop) => {
+            prop.r#static.hash(h);
+            prop.computed.hash(h);
+            property::hash_property_key(&prop.key, h, include_binding_names);
+            if let Some(value) = &prop.value {
+                expression::hash_expression(value, h, include_binding_names);
+            }
+        }
+        // TS 索引签名变体在 JS 模式（SourceType::unambiguous）下不可达，落入兜底。
         _ => {}
     });
 }

crates/oxide_compiler/src/hash/expression.rs

@@ -154,11 +154,89 @@ pub(super) fn hash_expression(expr: &Expression, h: &mut rustc_hash::FxHasher, i
             hash_chain_element(&chain.expression, h, include_binding_names);
         }
         Expression::Super(_) => {}
+        Expression::NullLiteral(_) => {
+            1u8.hash(h);
+        }
+        Expression::ThisExpression(_) => {
+            2u8.hash(h);
+        }
+        Expression::BigIntLiteral(big) => {
+            big.value.hash(h);
+        }
         Expression::RegExpLiteral(lit) => {
             if let Some(raw) = &lit.raw {
                 raw.to_string().hash(h);
             }
         }
+        Expression::ArrayExpression(arr) => {
+            (arr.elements.len() as u32).hash(h);
+            for element in &arr.elements {
+                match element {
+                    ArrayExpressionElement::SpreadElement(spread) => {
+                        hash_expression(&spread.argument, h, include_binding_names);
+                    }
+                    ArrayExpressionElement::Elision(_) => {
+                        1u8.hash(h);
+                    }
+                    other => {
+                        if let Some(expr) = other.as_expression() {
+                            hash_expression(expr, h, include_binding_names);
+                        }
+                    }
+                }
+            }
+        }
+        Expression::MetaProperty(mp) => {
+            mp.meta.name.as_str().hash(h);
+            mp.property.name.as_str().hash(h);
+        }
+        Expression::AwaitExpression(ae) => {
+            hash_expression(&ae.argument, h, include_binding_names);
+        }
+        Expression::YieldExpression(ye) => {
+            ye.delegate.hash(h);
+            if let Some(arg) = &ye.argument {
+                hash_expression(arg, h, include_binding_names);
+            }
+        }
+        Expression::ImportExpression(ie) => {
+            hash_expression(&ie.source, h, include_binding_names);
+            if let Some(options) = &ie.options {
+                hash_expression(options, h, include_binding_names);
+            }
+            match &ie.phase {
+                Some(phase) => std::mem::discriminant(phase).hash(h),
+                None => 0u8.hash(h),
+            }
+        }
+        Expression::ParenthesizedExpression(p) => {
+            hash_expression(&p.expression, h, include_binding_names);
+        }
+        Expression::TSAsExpression(ts) => {
+            hash_expression(&ts.expression, h, include_binding_names);
+        }
+        Expression::TSSatisfiesExpression(ts) => {
+            hash_expression(&ts.expression, h, include_binding_names);
+        }
+        Expression::TSTypeAssertion(ts) => {
+            hash_expression(&ts.expression, h, include_binding_names);
+        }
+        Expression::TSNonNullExpression(ts) => {
+            hash_expression(&ts.expression, h, include_binding_names);
+        }
+        Expression::TSInstantiationExpression(ts) => {
+            hash_expression(&ts.expression, h, include_binding_names);
+        }
+        Expression::V8IntrinsicExpression(v8) => {
+            v8.name.name.as_str().hash(h);
+            (v8.arguments.len() as u32).hash(h);
+            for arg in &v8.arguments {
+                if let Some(expr) = arg.as_expression() {
+                    hash_expression(expr, h, include_binding_names);
+                }
+            }
+        }
+        // JSX 变体在 JS 模式（SourceType::unambiguous）下不可达，落入兜底。
         _ => {}
     });
 }

crates/oxide_compiler/src/hash/mod.rs

@@ -5,8 +5,9 @@
 //! `compiled_module_hash` 纳入绑定名（精确匹配避免错误复用）。
 
 use oxide_parser::{
-    BindingPattern, ChainElement, ClassElement, Expression, ForStatementInit, ObjectPropertyKind, PropertyKey,
-    SimpleAssignmentTarget, Statement,
+    ArrayExpressionElement, BindingPattern, ChainElement, Class, ClassElement, Declaration, ExportDefaultDeclarationKind,
+    Expression, ForStatementInit, ForStatementLeft, Function, ImportDeclarationSpecifier, ModuleExportName,
+    ObjectPropertyKind, PropertyKey, SimpleAssignmentTarget, Statement,
 };
 use std::hash::Hash;
 

crates/oxide_compiler/src/hash/statement.rs

@@ -53,9 +53,26 @@ pub(super) fn hash_statement(stmt: &Statement, h: &mut rustc_hash::FxHasher, inc
             expression::hash_expression(&dw.test, h, include_binding_names);
         }
         Statement::ForInStatement(fi) => {
+            hash_for_statement_left(&fi.left, h, include_binding_names);
             expression::hash_expression(&fi.right, h, include_binding_names);
             hash_statement(&fi.body, h, include_binding_names);
         }
+        Statement::ForOfStatement(fo) => {
+            fo.r#await.hash(h);
+            hash_for_statement_left(&fo.left, h, include_binding_names);
+            expression::hash_expression(&fo.right, h, include_binding_names);
+            hash_statement(&fo.body, h, include_binding_names);
+        }
+        Statement::WithStatement(ws) => {
+            expression::hash_expression(&ws.object, h, include_binding_names);
+            hash_statement(&ws.body, h, include_binding_names);
+        }
+        Statement::EmptyStatement(_) => {
+            1u8.hash(h);
+        }
+        Statement::DebuggerStatement(_) => {
+            2u8.hash(h);
+        }
         Statement::SwitchStatement(sw) => {
             expression::hash_expression(&sw.discriminant, h, include_binding_names);
             for case in &sw.cases {
@@ -71,16 +88,7 @@ pub(super) fn hash_statement(stmt: &Statement, h: &mut rustc_hash::FxHasher, inc
             hash_function_declaration(fd, h, include_binding_names);
         }
         Statement::ClassDeclaration(class) => {
-            if let Some(id) = &class.id {
-                id.name.as_str().hash(h);
-            }
-            class.super_class.is_some().hash(h);
-            if let Some(super_class) = &class.super_class {
-                expression::hash_expression(super_class, h, include_binding_names);
-            }
-            for element in &class.body.body {
-                class::hash_class_element(element, h, include_binding_names);
-            }
+            hash_class(class, h, include_binding_names);
         }
         Statement::ThrowStatement(ts) => {
             expression::hash_expression(&ts.argument, h, include_binding_names);
@@ -88,6 +96,67 @@ pub(super) fn hash_statement(stmt: &Statement, h: &mut rustc_hash::FxHasher, inc
         Statement::TryStatement(ts) => {
             hash_try_statement(ts, h, include_binding_names);
         }
+        Statement::ImportDeclaration(imp) => {
+            imp.source.value.hash(h);
+            if let Some(specifiers) = &imp.specifiers {
+                (specifiers.len() as u32).hash(h);
+                for spec in specifiers {
+                    match spec {
+                        ImportDeclarationSpecifier::ImportSpecifier(s) => {
+                            hash_module_export_name(&s.imported, h);
+                            if include_binding_names {
+                                s.local.name.as_str().hash(h);
+                            }
+                        }
+                        ImportDeclarationSpecifier::ImportDefaultSpecifier(s) => {
+                            if include_binding_names {
+                                s.local.name.as_str().hash(h);
+                            }
+                        }
+                        ImportDeclarationSpecifier::ImportNamespaceSpecifier(s) => {
+                            if include_binding_names {
+                                s.local.name.as_str().hash(h);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        Statement::ExportNamedDeclaration(exp) => {
+            if let Some(decl) = &exp.declaration {
+                hash_declaration(decl, h, include_binding_names);
+            }
+            (exp.specifiers.len() as u32).hash(h);
+            for spec in &exp.specifiers {
+                hash_module_export_name(&spec.local, h);
+                hash_module_export_name(&spec.exported, h);
+            }
+            if let Some(source) = &exp.source {
+                source.value.hash(h);
+            }
+        }
+        Statement::ExportDefaultDeclaration(exp) => {
+            match &exp.declaration {
+                ExportDefaultDeclarationKind::FunctionDeclaration(fd) => {
+                    hash_function_declaration(fd, h, include_binding_names);
+                }
+                ExportDefaultDeclarationKind::ClassDeclaration(class) => {
+                    hash_class(class, h, include_binding_names);
+                }
+                other => {
+                    if let Some(expr) = other.as_expression() {
+                        expression::hash_expression(expr, h, include_binding_names);
+                    }
+                }
+            }
+        }
+        Statement::ExportAllDeclaration(exp) => {
+            if let Some(exported) = &exp.exported {
+                hash_module_export_name(exported, h);
+            }
+            exp.source.value.hash(h);
+        }
+        // TS 声明/JSX 等变体在 JS 模式（SourceType::unambiguous）下不可达，落入兜底。
         _ => {}
     });
 }
@@ -125,7 +194,7 @@ fn hash_for_statement(fr: &oxide_parser::ForStatement<'_>, h: &mut rustc_hash::F
 }
 
 fn hash_function_declaration(
-    fd: &oxide_parser::Function<'_>, h: &mut rustc_hash::FxHasher, include_binding_names: bool,
+    fd: &Function<'_>, h: &mut rustc_hash::FxHasher, include_binding_names: bool,
 ) {
     if include_binding_names {
         if let Some(id) = &fd.id {
@@ -147,6 +216,45 @@ fn hash_function_declaration(
     }
 }
 
+fn hash_class(class: &Class<'_>, h: &mut rustc_hash::FxHasher, include_binding_names: bool) {
+    if let Some(id) = &class.id {
+        id.name.as_str().hash(h);
+    }
+    class.super_class.is_some().hash(h);
+    if let Some(super_class) = &class.super_class {
+        expression::hash_expression(super_class, h, include_binding_names);
+    }
+    for element in &class.body.body {
+        class::hash_class_element(element, h, include_binding_names);
+    }
+}
+
+fn hash_declaration(decl: &Declaration<'_>, h: &mut rustc_hash::FxHasher, include_binding_names: bool) {
+    match decl {
+        Declaration::VariableDeclaration(vd) => hash_variable_declaration(vd, h, include_binding_names),
+        Declaration::FunctionDeclaration(fd) => hash_function_declaration(fd, h, include_binding_names),
+        Declaration::ClassDeclaration(class) => hash_class(class, h, include_binding_names),
+        _ => {}
+    }
+}
+
+fn hash_module_export_name(name: &ModuleExportName<'_>, h: &mut rustc_hash::FxHasher) {
+    match name {
+        ModuleExportName::IdentifierName(ident) => ident.name.as_str().hash(h),
+        ModuleExportName::IdentifierReference(ident) => ident.name.as_str().hash(h),
+        ModuleExportName::StringLiteral(s) => s.value.hash(h),
+    }
+}
+
+fn hash_for_statement_left(left: &ForStatementLeft<'_>, h: &mut rustc_hash::FxHasher, include_binding_names: bool) {
+    std::mem::discriminant(left).hash(h);
+    if let ForStatementLeft::VariableDeclaration(decl) = left {
+        hash_variable_declaration(decl, h, include_binding_names);
+    } else if let Some(target) = left.as_simple_assignment_target() {
+        target::hash_simple_assignment_target(target, h, include_binding_names);
+    }
+}
+
 fn hash_try_statement(ts: &oxide_parser::TryStatement<'_>, h: &mut rustc_hash::FxHasher, include_binding_names: bool) {
     for s in &ts.block.body {
         hash_statement(s, h, include_binding_names);

crates/oxide_compiler/src/hash/target.rs

@@ -22,6 +22,17 @@ pub(super) fn hash_simple_assignment_target(
             expression::hash_expression(&member.object, h, include_binding_names);
             member.field.name.as_str().hash(h);
         }
-        _ => {}
+        SimpleAssignmentTarget::TSAsExpression(ts) => {
+            expression::hash_expression(&ts.expression, h, include_binding_names);
+        }
+        SimpleAssignmentTarget::TSSatisfiesExpression(ts) => {
+            expression::hash_expression(&ts.expression, h, include_binding_names);
+        }
+        SimpleAssignmentTarget::TSNonNullExpression(ts) => {
+            expression::hash_expression(&ts.expression, h, include_binding_names);
+        }
+        SimpleAssignmentTarget::TSTypeAssertion(ts) => {
+            expression::hash_expression(&ts.expression, h, include_binding_names);
+        }
     });
 }

crates/oxide_compiler/tests/hash_collision_tests.rs

@@ -0,0 +1,92 @@
+//! 结构哈希确定性碰撞的回归测试：
+//! 补全 hash 的 `_ => {}` 兜底漏掉的变体后，不同 AST 不得产生相同哈希。
+
+use oxide_parser::Allocator;
+
+fn compiled(source: &str) -> u64 {
+    let allocator = Allocator::default();
+    let program = oxide_parser::parse(&allocator, source).expect("parse failed");
+    oxide_compiler::compiler::compiled_module_hash(&program)
+}
+
+fn structural(source: &str) -> u64 {
+    let allocator = Allocator::default();
+    let program = oxide_parser::parse(&allocator, source).expect("parse failed");
+    oxide_compiler::compiler::structural_hash(&program)
+}
+
+#[test]
+fn array_literals_distinguished() {
+    assert_ne!(compiled("[1, 2, 3]"), compiled("[4, 5, 6]"));
+    assert_ne!(compiled("[1, 2, 3]"), compiled("[1, , 3]"), "elision vs value must differ");
+    assert_ne!(compiled("[1, 2, ...a]"), compiled("[1, 2, 3]"), "spread vs value must differ");
+    assert_ne!(compiled("[...a]"), compiled("[...b]"), "different spread sources must differ");
+}
+
+#[test]
+fn meta_property_distinguished() {
+    // `new.target` 是 MetaProperty，`a.b` 是普通成员访问，结构不同。
+    assert_ne!(compiled("function f(){ return new.target }"), compiled("function f(){ return a.b }"));
+    // 同为 MetaProperty 时 meta/property 名字必须参与哈希（修复前两者哈希相同）。
+    assert_ne!(
+        compiled("import './x.js'; function f(){ return import.meta }"),
+        compiled("import './x.js'; function f(){ return new.target }"),
+        "meta/property names must be part of the hash"
+    );
+}
+
+#[test]
+fn parenthesized_distinguished() {
+    assert_ne!(compiled("(a)"), compiled("a"), "parenthesized vs bare expression must differ");
+    assert_ne!(compiled("(a + b)"), compiled("a + b"));
+    assert_ne!(compiled("(a)"), compiled("(b)"), "inner expression must be hashed");
+}
+
+#[test]
+fn await_yield_plain_distinguished() {
+    let await_h = compiled("async function f(){ await x }");
+    let yield_h = compiled("function* f(){ yield x }");
+    let plain_h = compiled("function f(){ x }");
+    assert_ne!(await_h, yield_h);
+    assert_ne!(await_h, plain_h);
+    assert_ne!(yield_h, plain_h);
+
+    // yield 的 delegate 标志与参数必须参与哈希。
+    assert_ne!(compiled("function* f(){ yield x }"), compiled("function* f(){ yield* x }"));
+    assert_ne!(compiled("function* f(){ yield x }"), compiled("function* f(){ yield y }"));
+}
+
+#[test]
+fn object_literals_distinguished() {
+    assert_ne!(compiled("var o = { a: 1 }"), compiled("var o = { a: 2 }"));
+    assert_ne!(compiled("var o = { a: 1 }"), compiled("var o = { b: 1 }"));
+    assert_ne!(compiled("var o = { a: 1 }"), compiled("var o = { a: 1, b: 2 }"), "property count must be hashed");
+}
+
+#[test]
+fn function_statement_hash_distinguished() {
+    assert_ne!(compiled("function f(){ return 1 }"), compiled("function f(){ return 2 }"));
+    assert_ne!(compiled("function f(){ return 1 }"), compiled("function g(){ return 1 }"));
+}
+
+#[test]
+fn for_of_with_distinguished() {
+    assert_ne!(compiled("for (x of xs) { body(x) }"), compiled("for (x of ys) { body(x) }"));
+    assert_ne!(compiled("for (x of xs) { body(x) }"), compiled("for (x in xs) { body(x) }"));
+    assert_ne!(compiled("with (a) { f() }"), compiled("with (b) { f() }"));
+}
+
+#[test]
+fn import_expression_distinguished() {
+    assert_ne!(compiled("import('./a.js')"), compiled("import('./b.js')"));
+    assert_ne!(compiled("import('./a.js')"), compiled("import('./a.js', { with: { type: 'json' } })"));
+}
+
+#[test]
+fn structural_hash_ignores_binding_names() {
+    // 结构哈希忽略绑定名：仅参数/变量改名后哈希相等。
+    assert_eq!(structural("function f(x){ return x }"), structural("function f(y){ return y }"));
+    assert_eq!(structural("var a = 1; a + a"), structural("var b = 1; b + b"));
+    // 编译模块哈希纳入绑定名：改名的程序哈希不等。
+    assert_ne!(compiled("function f(x){ return x }"), compiled("function f(y){ return y }"));
+}