Merge branch 'main' into temporal_intrinsic

Author: sebastianjacmatt

.cargo/config.toml

@@ -39,7 +39,6 @@ jobs:
         with:
           shared-key: warm
       - name: Install Dylint
-        if: false
         uses: taiki-e/install-action@v2
         with:
           tool: cargo-dylint,dylint-link
@@ -50,11 +49,9 @@ jobs:
           cargo +stable clippy --all-targets -- -D warnings
           cargo +nightly-2025-05-14 clippy --all-targets --all-features -- -D warnings
       - name: Dylint tests
-        if: false
         working-directory: nova_lint
         run: cargo test
       - name: Dylint
-        if: false
         run: cargo dylint --all
 
   build:

.github/workflows/ci.yml

@@ -0,0 +1 @@
+https://github.com/aapoalas/aapoalas/blob/main/funding.json

.well-known/funding-manifest-urls

@@ -21,7 +21,6 @@ cliclack = "0.3.6"
 console = "0.15.11"
 ctrlc = "3.4.5"
 fast-float = "0.2.0"
-fast_float = "0.2.0"
 hashbrown = "0.16.0"
 lexical = { version = "7.0.4", default-features = false, features = [
     "std",
@@ -31,16 +30,16 @@ lexical = { version = "7.0.4", default-features = false, features = [
 ] }
 num-bigint = "0.4.6"
 num-traits = "0.2.19"
-oxc-miette = { version = "2.4.0", features = ["fancy"] }
-oxc_allocator = "0.89.0"
-oxc_ast = "0.89.0"
-oxc_diagnostics = "0.89.0"
-oxc_ecmascript = "0.89.0"
-oxc_parser = "0.89.0"
-oxc_regular_expression = "0.89.0"
-oxc_semantic = "0.89.0"
-oxc_span = "0.89.0"
-oxc_syntax = "0.89.0"
+oxc-miette = { version = "2.5.0", features = ["fancy"] }
+oxc_allocator = "0.90.0"
+oxc_ast = "0.90.0"
+oxc_diagnostics = "0.90.0"
+oxc_ecmascript = "0.90.0"
+oxc_parser = "0.90.0"
+oxc_regular_expression = "0.90.0"
+oxc_semantic = "0.90.0"
+oxc_span = "0.90.0"
+oxc_syntax = "0.90.0"
 rand = "0.9.2"
 regex = "1.11.2"
 ryu-js = "1.0.2"
@@ -55,8 +54,14 @@ temporal_rs = "0.0.16"
 [workspace.metadata.dylint]
 libraries = [{ path = "nova_lint" }]
 
+# The release profile, used for `cargo build --release`.
 [profile.release]
-lto = true
+# Enables "fat" LTO, for faster release builds
+lto = "fat"
+# Makes sure that all code is compiled together, for LTO
+codegen-units = 1
+# Strips debug information and symbols from the binary, reducing its size
+strip = "symbols"
 
 # This profile has all the same safety checks as dev builds. It trades slightly
 # longer compile times for faster runs, which is worth it when running test262.

Cargo.toml

@@ -1,2 +1,2 @@
 [target.'cfg(all())']
-rustflags = ["-C", "linker=dylint-link"]
+linker = "dylint-link"

nova_lint/.cargo/config.toml

@@ -25,11 +25,11 @@ name = "gc_scope_is_only_passed_by_value"
 path = "ui/gc_scope_is_only_passed_by_value.rs"
 
 [dependencies]
-clippy_utils = { git = "https://github.com/rust-lang/rust-clippy", rev = "ff4a26d442bead94a4c96fb1de967374bc4fbd8e" }
-dylint_linting = { version = "4.0.0", features = ["constituent"] }
+clippy_utils = { git = "https://github.com/rust-lang/rust-clippy", rev = "0450db33a5d8587f7c1d4b6d233dac963605766b" }
+dylint_linting = { version = "4.1.0", features = ["constituent"] }
 
 [dev-dependencies]
-dylint_testing = "4.0.0"
+dylint_testing = "4.1.0"
 nova_vm = { path = "../nova_vm" }
 
 [package.metadata.rust-analyzer]

nova_lint/Cargo.toml

@@ -1,6 +1,23 @@
-use clippy_utils::match_def_path;
+use rustc_hir::def_id::DefId;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{Ty, TyKind};
+use rustc_span::symbol::Symbol;
+
+// Copyright (c) 2014-2025 The Rust Project Developers
+//
+// Originally copied from `dylint` which in turn copied it from `clippy_utils`:
+// - https://github.com/trailofbits/dylint/blob/a2dd5c60d53d66fc791fa8184bed27a4cb142e74/internal/src/match_def_path.rs
+// - https://github.com/rust-lang/rust-clippy/blob/f62f26965817f2573c2649288faa489a03ed1665/clippy_utils/src/lib.rs
+// It was removed from `clippy_utils` by the following PR:
+// - https://github.com/rust-lang/rust-clippy/pull/14705
+/// Checks if the given `DefId` matches the path.
+pub fn match_def_path(cx: &LateContext<'_>, did: DefId, syms: &[&str]) -> bool {
+    // We should probably move to Symbols in Clippy as well rather than interning every time.
+    let path = cx.get_def_path(did);
+    syms.iter()
+        .map(|x| Symbol::intern(x))
+        .eq(path.iter().copied())
+}
 
 pub fn is_param_ty(ty: &Ty) -> bool {
     matches!(ty.kind(), TyKind::Param(_))

nova_lint/src/utils.rs

@@ -9,7 +9,8 @@ use crate::{
         builtins::{ArgumentsList, Behaviour, Builtin, BuiltinIntrinsicConstructor},
         execution::{Agent, JsResult, Realm, agent::ExceptionType},
         types::{
-            BUILTIN_STRING_MEMORY, IntoObject, IntoValue, Object, String, SymbolHeapData, Value,
+            BUILTIN_STRING_MEMORY, IntoObject, IntoValue, Object, String, Symbol, SymbolHeapData,
+            Value,
         },
     },
     engine::context::{Bindable, GcScope},
@@ -89,29 +90,59 @@ impl SymbolConstructor {
     fn r#for<'gc>(
         agent: &mut Agent,
         _this_value: Value,
-        _arguments: ArgumentsList,
-        gc: GcScope<'gc, '_>,
+        arguments: ArgumentsList,
+        mut gc: GcScope<'gc, '_>,
     ) -> JsResult<'gc, Value<'gc>> {
+        let key = arguments.get(0).bind(gc.nogc());
         // 1. Let stringKey be ? ToString(key).
+        let string_key = to_string(agent, key.unbind(), gc.reborrow())
+            .unbind()?
+            .bind(gc.nogc());
+
         // 2. For each element e of the GlobalSymbolRegistry List, do
         //        a. If e.[[Key]] is stringKey, return e.[[Symbol]].
+        if let Some(&symbol) = agent.global_symbol_registry.get(&string_key.unbind()) {
+            return Ok(symbol.into_value());
+        }
+
         // 3. Assert: The GlobalSymbolRegistry List does not currently contain an entry for stringKey.
         // 4. Let newSymbol be a new Symbol whose [[Description]] is stringKey.
+        let new_symbol = agent.heap.create(SymbolHeapData {
+            descriptor: Some(string_key.unbind()),
+        });
+
         // 5. Append the GlobalSymbolRegistry Record { [[Key]]: stringKey, [[Symbol]]: newSymbol } to the GlobalSymbolRegistry List.
+        agent
+            .global_symbol_registry
+            .insert(string_key.unbind(), new_symbol);
+
         // 6. Return newSymbol.
-        Err(agent.todo("Symbol.for", gc.into_nogc()))
+        Ok(new_symbol.into_value())
     }
 
     /// ### [20.4.2.6 Symbol.keyFor ( sym )](https://tc39.es/ecma262/#sec-symbol.keyfor)
     fn key_for<'gc>(
         agent: &mut Agent,
         _this_value: Value,
-        _arguments: ArgumentsList,
+        arguments: ArgumentsList,
         gc: GcScope<'gc, '_>,
     ) -> JsResult<'gc, Value<'gc>> {
+        let sym = arguments.get(0).bind(gc.nogc());
+
         // 1. If sym is not a Symbol, throw a TypeError exception.
+        let symbol = match sym.unbind().try_into() {
+            Ok(symbol) => symbol,
+            Err(_) => {
+                return Err(agent.throw_exception_with_static_message(
+                    ExceptionType::TypeError,
+                    "Symbol.keyFor argument is not a symbol",
+                    gc.into_nogc(),
+                ));
+            }
+        };
+
         // 2. Return KeyForSymbol(sym).
-        Err(agent.todo("Symbol.keyFor", gc.into_nogc()))
+        Ok(key_for_symbol(agent, symbol).map_or(Value::Undefined, |key| key.into_value()))
     }
 
     pub(crate) fn create_intrinsic(agent: &mut Agent, realm: Realm<'static>) {
@@ -237,3 +268,19 @@ impl SymbolConstructor {
             .build();
     }
 }
+
+/// ### [20.4.5.1 KeyForSymbol ( sym )](https://tc39.es/ecma262/#sec-keyforsymbol)
+///
+/// The abstract operation KeyForSymbol takes argument sym (a Symbol) and returns a String or undefined.
+pub(crate) fn key_for_symbol<'a>(agent: &Agent, sym: Symbol<'a>) -> Option<String<'a>> {
+    // 1. For each element e of the GlobalSymbolRegistry List, do
+    //        a. If SameValue(e.[[Symbol]], sym) is true, return e.[[Key]].
+    for (key, &symbol) in &agent.global_symbol_registry {
+        if symbol == sym {
+            return Some(*key);
+        }
+    }
+    // 2. Assert: The GlobalSymbolRegistry List does not currently contain an entry for sym.
+    // 3. Return undefined.
+    None
+}

nova_vm/src/ecmascript/builtins/fundamental_objects/symbol_objects/symbol_constructor.rs

@@ -27,7 +27,7 @@ use crate::{
         context::{Bindable, GcScope, NoGcScope},
         rootable::Scopable,
     },
-    heap::{Heap, IntrinsicConstructorIndexes},
+    heap::IntrinsicConstructorIndexes,
 };
 
 pub(crate) struct WeakSetConstructor;
@@ -196,22 +196,22 @@ fn weak_set_add_trivially_iterable_array_elements<'a>(
     iterable: Array,
     gc: NoGcScope<'a, '_>,
 ) -> JsResult<'a, ()> {
-    let Heap {
-        arrays,
-        elements,
-        weak_sets,
-        ..
-    } = &mut agent.heap;
-    let array_heap = ArrayHeap::new(elements, arrays);
+    let array_heap = ArrayHeap::new(&agent.heap.elements, &agent.heap.arrays);
     let slice = iterable.as_slice(&array_heap);
-    let weak_set_data = &mut weak_sets[set];
+
+    let mut weak_keys = Vec::new();
     for value in slice {
         let value = value.unwrap_or(Value::Undefined);
         // 3. If CanBeHeldWeakly(value) is false, throw a TypeError exception.
-        let Some(value) = can_be_held_weakly(value) else {
+        let Some(weak_key) = can_be_held_weakly(agent, value) else {
             return Err(throw_not_weak_key_error(agent, value, gc));
         };
-        weak_set_data.add(value);
+        weak_keys.push(weak_key);
+    }
+
+    let weak_set_data = &mut agent.heap.weak_sets[set];
+    for weak_key in weak_keys {
+        weak_set_data.add(weak_key);
     }
     Ok(())
 }

nova_vm/src/ecmascript/builtins/keyed_collections/weak_set_objects/weak_set_constructor.rs

@@ -54,7 +54,7 @@ impl WeakSetPrototype {
         // 2. Perform ? RequireInternalSlot(S, [[WeakSetData]]).
         let s = require_internal_slot_weak_set(agent, s, gc)?;
         // 3. If CanBeHeldWeakly(value) is false, throw a TypeError exception.
-        let Some(value) = can_be_held_weakly(value) else {
+        let Some(value) = can_be_held_weakly(agent, value) else {
             return Err(throw_not_weak_key_error(agent, value.unbind(), gc));
         };
         // 4. For each element e of S.[[WeakSetData]], do
@@ -87,7 +87,7 @@ impl WeakSetPrototype {
         // 2. Perform ? RequireInternalSlot(S, [[WeakSetData]]).
         let s = require_internal_slot_weak_set(agent, s, gc)?;
         // 3. If CanBeHeldWeakly(value) is false, return false.
-        let Some(value) = can_be_held_weakly(value) else {
+        let Some(value) = can_be_held_weakly(agent, value) else {
             return Ok(false.into_value());
         };
         // 4. For each element e of S.[[WeakSetData]], do
@@ -116,7 +116,7 @@ impl WeakSetPrototype {
         // 2. Perform ? RequireInternalSlot(S, [[WeakSetData]]).
         let s = require_internal_slot_weak_set(agent, s, gc)?;
         // 3. If CanBeHeldWeakly(value) is false, return false.
-        let Some(value) = can_be_held_weakly(value) else {
+        let Some(value) = can_be_held_weakly(agent, value) else {
             return Ok(false.into_value());
         };
         // 4. For each element e of S.[[WeakSetData]], do