fix: implement %ThrowTypeError% intrinsic per spec (14/14 Test262 pass)

- Create proper %ThrowTypeError% object per realm: closure-backed, non-extensible,
  length=0 and name='' both non-configurable/non-writable/non-enumerable
- Fix delete handler: non-configurable length/name on closures no longer force-deleted
- Fix cross-realm TypeError identity: restrictedThrow uses function's own realm
- Add OriginGlobal slot on ThrowTypeError for get_function_realm
- Fix Function constructor: propagate body_is_strict to closure_data.is_strict
- Strict arguments callee uses ThrowTypeError accessor (getter+setter)

Author: ssrlive

ci/feature_probes/Temporal.js

@@ -0,0 +1,4 @@
+// feature probe for 'Temporal'
+if (typeof Temporal === 'undefined') throw new Error('Temporal not supported');
+console.log('OK');
+

src/core/eval.rs

@@ -17135,21 +17135,10 @@ fn evaluate_expr_delete<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'g
                 }
 
                 if obj.borrow().non_configurable.contains(&key_val) {
-                    let is_function_like = obj.borrow().get_closure().is_some();
-                    if is_function_like && (key == "length" || key == "name") {
-                        if let Some(cl_ptr) = obj.borrow().get_closure()
-                            && let Value::Function(func_name) = &*cl_ptr.borrow()
-                        {
-                            mark_builtin_function_virtual_prop_deleted(mc, env, func_name, key)?;
-                        }
-                        let mut o = obj.borrow_mut(mc);
-                        let _ = o.properties.shift_remove(&key_val);
-                        let _ = o.non_configurable.remove(&key_val);
-                        let _ = o.non_writable.remove(&key_val);
-                        let _ = o.non_enumerable.remove(&key_val);
-                        Ok(Value::Boolean(true))
-                    } else {
+                    if env_get_strictness(env) {
                         Err(crate::raise_type_error!(format!("Cannot delete non-configurable property '{key}'",)).into())
+                    } else {
+                        Ok(Value::Boolean(false))
                     }
                 } else {
                     let _ = obj.borrow_mut(mc).properties.shift_remove(&key_val);
@@ -17225,27 +17214,14 @@ fn evaluate_expr_delete<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'g
                     return Ok(Value::Boolean(true));
                 }
                 if obj.borrow().non_configurable.contains(&key) {
-                    let is_fn_length_or_name = matches!(&key, PropertyKey::String(s) if s == "length" || s == "name");
-                    let is_function_like = obj.borrow().get_closure().is_some();
-                    if is_function_like && is_fn_length_or_name {
-                        if let PropertyKey::String(s) = &key
-                            && let Some(cl_ptr) = obj.borrow().get_closure()
-                            && let Value::Function(func_name) = &*cl_ptr.borrow()
-                        {
-                            mark_builtin_function_virtual_prop_deleted(mc, env, func_name, s)?;
-                        }
-                        let mut o = obj.borrow_mut(mc);
-                        let _ = o.properties.shift_remove(&key);
-                        let _ = o.non_configurable.remove(&key);
-                        let _ = o.non_writable.remove(&key);
-                        let _ = o.non_enumerable.remove(&key);
-                        Ok(Value::Boolean(true))
-                    } else {
+                    if env_get_strictness(env) {
                         Err(crate::raise_type_error!(format!(
                             "Cannot delete non-configurable property '{}'",
                             value_to_string(&key_val_res)
                         ))
                         .into())
+                    } else {
+                        Ok(Value::Boolean(false))
                     }
                 } else {
                     let _ = obj.borrow_mut(mc).properties.shift_remove(&key);
@@ -19083,7 +19059,13 @@ pub fn call_native_function<'gc>(
 
     // Restricted accessor used to implement the throwing 'caller'/'arguments' accessors on Function.prototype
     if name == "Function.prototype.restrictedThrow" {
-        return Err(raise_type_error!("Access to 'caller' or 'arguments' is restricted").into());
+        // Use the env passed to this function (which is the ThrowTypeError's own realm
+        // when called cross-realm) so the TypeError is instanceof that realm's TypeError.
+        return Err(throw_realm_type_error(
+            mc,
+            env,
+            "'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them",
+        ));
     }
 
     if name == "AsyncGenerator.prototype.next" {
@@ -19850,7 +19832,11 @@ pub(crate) fn call_accessor<'gc>(
         Value::Function(name) => {
             // Special-case restricted accessor thrower
             if name == "Function.prototype.restrictedThrow" {
-                return Err(raise_type_error!("Access to 'caller' or 'arguments' is restricted").into());
+                return Err(throw_realm_type_error(
+                    mc,
+                    env,
+                    "'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them",
+                ));
             }
             if let Some(res) = call_native_function(mc, name, Some(&Value::Object(*receiver)), &[], env)? {
                 Ok(res)
@@ -19864,7 +19850,11 @@ pub(crate) fn call_accessor<'gc>(
                     Ok(v) => Ok(v),
                     Err(_) => {
                         if name.contains("restrictedThrow") {
-                            Err(raise_type_error!("Access to 'caller' or 'arguments' is restricted").into())
+                            Err(throw_realm_type_error(
+                                mc,
+                                env,
+                                "'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them",
+                            ))
                         } else {
                             Err(raise_type_error!(format!("Accessor function {name} not supported")).into())
                         }

src/core/value.rs

@@ -503,6 +503,7 @@ pub enum InternalSlot {
     SuppressDynamicImportResult, // __suppress_dynamic_import_result
     SymbolRegistry,              // __symbol_registry
     TemplateRegistry,            // __template_registry
+    ThrowTypeError,              // __throw_type_error
 
     // --- Misc ---
     Eof,          // __eof
@@ -680,6 +681,7 @@ pub fn str_to_internal_slot(s: &str) -> Option<InternalSlot> {
         "__suppress_dynamic_import_result" => return Some(InternalSlot::SuppressDynamicImportResult),
         "__symbol_registry" => return Some(InternalSlot::SymbolRegistry),
         "__template_registry" => return Some(InternalSlot::TemplateRegistry),
+        "__throw_type_error" => return Some(InternalSlot::ThrowTypeError),
         // Misc
         "__eof" => return Some(InternalSlot::Eof),
         "__lookupGetter__" => return Some(InternalSlot::LookupGetter),

src/js_class.rs

@@ -687,7 +687,12 @@ pub fn create_arguments_object<'gc>(
 
     if let Some(callee_val) = callee {
         if crate::core::env_get_strictness(func_env) {
-            let thrower_val = Value::Function("Function.prototype.restrictedThrow".to_string());
+            // Use the realm's %ThrowTypeError% intrinsic if available
+            let thrower_val = if let Some(tte_rc) = crate::core::slot_get_chained(func_env, &crate::core::InternalSlot::ThrowTypeError) {
+                tte_rc.borrow().clone()
+            } else {
+                Value::Function("Function.prototype.restrictedThrow".to_string())
+            };
 
             let prop = crate::core::Value::Property {
                 value: None,

src/js_function.rs

@@ -1474,6 +1474,8 @@ fn function_constructor<'gc>(
             let mut closure_data = ClosureData::new(params, body, Some(global_env), None);
             // Function constructor created functions should not inherit strict mode from the context
             closure_data.enforce_strictness_inheritance = false;
+            // Propagate "use strict" directive from the body to the closure
+            closure_data.is_strict = body_is_strict;
             let closure_val = Value::Closure(Gc::new(mc, closure_data));
 
             // Create a function object wrapper so it has a proper `prototype` and property attributes
@@ -3691,14 +3693,33 @@ pub fn initialize_function<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr
     let proto_name_desc = crate::core::create_descriptor_object(mc, &Value::String(utf8_to_utf16("")), false, false, true)?;
     crate::js_object::define_property_internal(mc, &func_proto, "name", &proto_name_desc)?;
 
-    // Define restricted 'caller' and 'arguments' accessors that throw a TypeError when accessed or assigned
+    // §10.2.4 Create %ThrowTypeError% intrinsic — a unique frozen function object per realm.
+    let throw_type_error = crate::core::new_js_object_data(mc);
+    throw_type_error.borrow_mut(mc).set_closure(Some(crate::core::new_gc_cell_ptr(
+        mc,
+        Value::Function("Function.prototype.restrictedThrow".to_string()),
+    )));
+    // Set [[Prototype]] to Function.prototype
+    throw_type_error.borrow_mut(mc).prototype = Some(func_proto);
+    // Stamp OriginGlobal so get_function_realm returns this realm's env
+    // (critical for cross-realm ThrowTypeError to throw the correct realm's TypeError).
+    crate::core::slot_set(mc, &throw_type_error, crate::core::InternalSlot::OriginGlobal, &Value::Object(*env));
+    // length = 0: { writable: false, enumerable: false, configurable: false }
+    let tte_len_desc = crate::core::create_descriptor_object(mc, &Value::Number(0.0), false, false, false)?;
+    crate::js_object::define_property_internal(mc, &throw_type_error, "length", &tte_len_desc)?;
+    // name = "": { writable: false, enumerable: false, configurable: false }
+    let tte_name_desc = crate::core::create_descriptor_object(mc, &Value::String(utf8_to_utf16("")), false, false, false)?;
+    crate::js_object::define_property_internal(mc, &throw_type_error, "name", &tte_name_desc)?;
+    // Make non-extensible
+    throw_type_error.borrow_mut(mc).prevent_extensions();
+    // Store on env for reuse (arguments.callee in strict mode, etc.)
+    crate::core::slot_set(mc, env, crate::core::InternalSlot::ThrowTypeError, &Value::Object(throw_type_error));
+
+    // Define restricted 'caller' and 'arguments' accessors using %ThrowTypeError%
+    let thrower_val = Value::Object(throw_type_error);
     let restricted_desc = crate::core::new_js_object_data(mc);
-    let val = Value::Function("Function.prototype.restrictedThrow".to_string());
-    object_set_key_value(mc, &restricted_desc, "get", &val)?;
-
-    let val = Value::Function("Function.prototype.restrictedThrow".to_string());
-    object_set_key_value(mc, &restricted_desc, "set", &val)?;
-
+    object_set_key_value(mc, &restricted_desc, "get", &thrower_val)?;
+    object_set_key_value(mc, &restricted_desc, "set", &thrower_val)?;
     object_set_key_value(mc, &restricted_desc, "configurable", &Value::Boolean(true))?;
     crate::js_object::define_property_internal(mc, &func_proto, "caller", &restricted_desc)?;
     crate::js_object::define_property_internal(mc, &func_proto, "arguments", &restricted_desc)?;