fix: sloppy eval 顶层块函数参与全局声明实例化

crates/oxide_emit/src/prepass/declare.rs

@@ -175,11 +175,12 @@ impl Emitter {
     /// - 只处理块内函数声明；switch 不推 scope（其 case 内函数声明随 switch
     ///   作用域修复一并处理）；export 声明不可能出现在块内。
     /// - `if_arm` 标记当前递归是否位于 `if` 支臂隐式块内。Annex B 下该隐式块的
-    ///   函数声明名已有外层 var 绑定承载（非 eval 脚本顶层、未被形参/词法同名
-    ///   抑制、且非全局只读三常量）时不建当前块绑定，声明点物化进该 var 槽
-    ///   （建当前块 Let 会遮蔽同名 var）；名无外层 var 绑定（形参/词法抑制、eval
-    ///   脚本顶层或全局只读三常量）时保留块级绑定承载支臂闭包，避免声明点覆写
-    ///   外层绑定。门控只作用于 `if` 支臂下的叶子，块直接子不受影响。
+    ///   函数声明名已有外层 var 绑定承载（非 eval 脚本顶层、或 sloppy eval 顶层；
+    ///   未被形参/词法同名抑制，且非全局只读三常量）时不建当前块绑定，声明点
+    ///   物化进该 var 槽（建当前块 Let 会遮蔽同名 var）；名无外层 var 绑定
+    ///   （形参/词法抑制、strict eval 顶层或全局只读三常量）时保留块级绑定承载
+    ///   支臂闭包，避免声明点覆写外层绑定。门控只作用于 `if` 支臂下的叶子，
+    ///   块直接子不受影响。
     /// - 支臂为容器（循环/`try`/`with`/标签/显式块）时按各自作用域规则继续下钻，
     ///   使嵌套 `if` 支臂的函数声明同样到达门控。
     /// - 与 lexical 预声明的顺序：本函数在前，`{ let g; function g(){} }` 时
@@ -263,11 +264,13 @@ impl Emitter {
         }
     }
 
-    /// `if` 支臂裸函数声明的名是否已有外层 var/函数绑定承载：非 eval 脚本顶层的
-    /// 非抑制名由实例化阶段建外层 var 绑定，唯一例外是脚本顶层的只读三常量
-    /// （全局属性不可配置，声明实例化刻意不建外层绑定），其名须退回块级绑定。
+    /// `if` 支臂裸函数声明的名是否已有外层 var/函数绑定承载：非 eval 脚本顶层
+    /// 与 sloppy eval 顶层的非抑制名由实例化阶段建外层 var 绑定（eval 面依
+    /// Annex B.3.3.3），唯一例外是脚本顶层的只读三常量（全局属性不可配置，
+    /// 声明实例化刻意不建外层绑定），其名须退回块级绑定。strict eval 不建外层
+    /// 承载（其块函数绑定 eval 自身词法环境），与 eval 非顶层同判。
     fn if_arm_has_outer_var_carrier(ctx: &CompileCtx, name: &str) -> bool {
-        !ctx.is_eval_script
+        (!ctx.is_eval_script || !ctx.is_strict)
             && !ctx.block_fn_suppressed.contains(name)
             && !(ctx.is_global_scope && CompileCtx::is_non_writable_global_builtin(name))
     }

crates/oxide_emit/src/program.rs

@@ -314,12 +314,13 @@ impl Emitter {
         self.predeclare_lexical_declarations(&program.body, &mut ctx, global_lexical)?;
 
         // 顶层块级函数名按 sloppy 模式下与浏览器/web 实现惯例兼容的行为处理
-        // （块级函数声明建外层 var 绑定并求值写回，非 eval）：实例化 var 绑定
+        // （块级函数声明建外层 var 绑定并求值写回；sloppy eval 代码同走
+        // Annex B.3.3.3，其名并入 eval 的 var 环境）：实例化 var 绑定
         // （新建 var 槽；顶层只读三常量名不可声明不建）、并入顶层 var 名集
         // （裸读/写路由全局对象属性）、GlobalDeclarationInstantiation 序言建属性
-        // （define-if-absent，既有属性不改动值）。
+        // （define-if-absent，既有属性不改动值）。strict 代码不建。
         let mut block_fn_names: Vec<String> = Vec::new();
-        if !ctx.is_strict && !ctx.is_eval_script {
+        if !ctx.is_strict {
             ctx.block_fn_suppressed = self.collect_block_fn_suppressed_names(&program.body, &ctx.param_names);
             block_fn_names = self.collect_block_function_names(&program.body);
             for name in &block_fn_names {

crates/oxide_vm/tests/eval_block_fn_tests.rs

@@ -0,0 +1,136 @@
+//! sloppy eval 顶层块级函数声明的 web-compat 外层绑定：Annex B.3.3.3 要求
+//! eval 代码中不属于直接词汇声明的块级函数名并入 eval var 环境，间接/全局
+//! 口径下即全局对象可配置属性。覆盖块形/嵌套块/标签、`if` 支臂、声明前读、
+//! 描述符、delete、同名 var/let 碰撞、strict 守卫与可写内置名。
+
+use std::sync::Arc;
+
+use oxide_compiler::compiler::Compiler;
+use oxide_types::value::JsValue;
+use oxide_vm::vm::Vm;
+
+fn eval(source: &str) -> Result<JsValue, String> {
+    let allocator = oxide_parser::Allocator::default();
+    let program = oxide_parser::parse(&allocator, source).map_err(|e| format!("Parse error: {:?}", e))?;
+    let module = Compiler::new().compile(&program).map_err(|e| format!("Compile error: {}", e))?;
+    let mut vm = Vm::new();
+    vm.run(&Arc::new(module))
+}
+
+/// 求值并把结果按字符串提取（`JsValue` Display 不携带字符串内容）。
+fn eval_str(source: &str) -> String {
+    let allocator = oxide_parser::Allocator::default();
+    let program = oxide_parser::parse(&allocator, source).expect("parse");
+    let module = Compiler::new().compile(&program).expect("compile");
+    let mut vm = Vm::new();
+    let result = vm.run(&Arc::new(module)).expect("run");
+    vm.lookup_str(result).unwrap_or_else(|| format!("{result}"))
+}
+
+fn assert_bool(result: Result<JsValue, String>) {
+    let value = result.unwrap();
+    assert!(value.is_bool() && value.as_bool(), "expected true, got {:?}", value);
+}
+
+// ── 主形：eval 顶层块函数泄漏到全局，调用方 typeof 见 function ──
+#[test]
+fn eval_block_function_leaks_to_global_typeof() {
+    let s = eval_str("eval('{function g(){}}'); typeof g");
+    assert_eq!(s, "function", "eval 顶层块函数应泄漏到全局，实际 {s}");
+}
+
+// ── 反射面：globalThis.g 可见 ──
+#[test]
+fn eval_block_function_visible_on_global_object() {
+    assert_bool(eval("eval('{function g(){}}'); typeof globalThis.g === 'function'"));
+}
+
+// ── 描述符：eval 全局属性可写/可枚举/可配置 ──
+#[test]
+fn eval_block_function_global_descriptor_all_true() {
+    let s = eval_str(
+        "eval('{function g(){}}'); \
+         var d = Object.getOwnPropertyDescriptor(globalThis, 'g'); \
+         String(d.writable) + ':' + String(d.enumerable) + ':' + String(d.configurable)",
+    );
+    assert_eq!(s, "true:true:true", "eval 块函数全局属性描述符应全 true，实际 {s}");
+}
+
+// ── 声明前读：var 绑定在求值前实例化为 undefined，属性已存在 ──
+#[test]
+fn eval_block_function_binding_created_before_declaration() {
+    let r = eval(
+        "var t = eval('var t = typeof f; {function f(){}}; t'); \
+         t === 'undefined' && ('f' in globalThis)",
+    );
+    assert_bool(r);
+}
+
+// ── 嵌套块：内层块函数的泄漏名仍并入 eval var 环境 ──
+#[test]
+fn eval_nested_block_function_leaks_to_global() {
+    let s = eval_str("eval('{{function g(){}}}'); typeof g");
+    assert_eq!(s, "function", "eval 嵌套块函数应泄漏到全局，实际 {s}");
+}
+
+// ── 标签包裹：块内标签直接子函数同走外层绑定 ──
+#[test]
+fn eval_labeled_block_function_leaks_to_global() {
+    let s = eval_str("eval('{ l: function g(){} }'); typeof g");
+    assert_eq!(s, "function", "eval 块内标签函数应泄漏到全局，实际 {s}");
+}
+
+// ── 顶层标签：无块包裹的标签函数声明名同样并入 eval var 环境 ──
+#[test]
+fn eval_top_level_labeled_function_leaks_to_global() {
+    let s = eval_str("eval('l: function g(){}'); typeof g");
+    assert_eq!(s, "function", "eval 顶层标签函数应泄漏到全局，实际 {s}");
+}
+
+// ── delete：eval 顶层名走可删探测，属性 configurable:true 故可删 ──
+#[test]
+fn eval_block_function_global_property_deletable() {
+    assert_bool(eval("eval('{function g(){}}'); delete g"));
+}
+
+// ── if 支臂：支臂函数声明在 eval 顶层有外层 var 承载，不以块 Let 遮蔽 ──
+#[test]
+fn eval_if_arm_function_leaks_to_global() {
+    let s = eval_str("eval('{ if(true) function g(){} }'); typeof g");
+    assert_eq!(s, "function", "eval 顶层 if 支臂函数应泄漏到全局，实际 {s}");
+}
+
+// ── if 支臂赋值：支臂后赋值写外层 var（全局属性），非支臂块 Let ──
+#[test]
+fn eval_if_arm_function_assignment_writes_global() {
+    let s = eval_str("eval('{ if(true) function g(){}; g = 123; }'); typeof globalThis.g");
+    assert_eq!(s, "number", "支臂后赋值应写全局属性，实际 {s}");
+}
+
+// ── var 碰撞：同名 var 存在时块函数写回该 var，最终值为函数 ──
+#[test]
+fn eval_block_function_overrides_same_name_var() {
+    let s = eval_str("eval('var f=1; {function f(){}}'); typeof f");
+    assert_eq!(s, "function", "同名 var 应被块函数写回覆盖，实际 {s}");
+}
+
+// ── let 碰撞守卫：同名词法声明抑制外层绑定，块函数不覆写词法值 ──
+#[test]
+fn eval_block_function_let_collision_keeps_lexical() {
+    let s = eval_str("eval('let f=1; {function f(){}} typeof f')");
+    assert_eq!(s, "number", "同名 let 不应被块函数覆写，实际 {s}");
+}
+
+// ── strict 守卫：strict eval 的块函数不泄漏全局 ──
+#[test]
+fn strict_eval_block_function_does_not_leak() {
+    let s = eval_str("eval(\"'use strict'; {function g(){}}\"); typeof g");
+    assert_eq!(s, "undefined", "strict eval 块函数不应泄漏全局，实际 {s}");
+}
+
+// ── 可写内置名：块函数覆写 parseInt 全局属性，调用取覆写值 ──
+#[test]
+fn eval_block_function_overrides_writable_builtin() {
+    let s = eval_str("eval('{function parseInt(){return \"z\"}}'); parseInt('42')");
+    assert_eq!(s, "z", "块函数应覆写可写内置名，实际 {s}");
+}