@tishlang/tish-lint 2.39.0 → 2.43.8

package/crates/tish_lsp/src/main.rs

@@ -344,6 +344,8 @@ impl LanguageServer for Backend {
         }
 
         let mut src_root: Option<PathBuf> = None;
+        let mut init_platform: Option<String> = None;
+        let mut init_surface: Option<String> = None;
         if let Some(opts) = &params.initialization_options {
             if let Some(s) = opts
                 .get("tishlangSourceRoot")
@@ -354,7 +356,23 @@ impl LanguageServer for Backend {
                     src_root = Some(PathBuf::from(s));
                 }
             }
+            // Platform file cascade for imports (same as `tish resolve-id` / Vite).
+            // settings.json: "tish.platform" / "tish.surface", or env TISH_PLATFORM / TISH_SURFACE.
+            if let Some(p) = opts.get("platform").and_then(|v| v.as_str()) {
+                init_platform = Some(p.to_string());
+            } else if let Some(p) = opts.get("tishPlatform").and_then(|v| v.as_str()) {
+                init_platform = Some(p.to_string());
+            }
+            if let Some(s) = opts.get("surface").and_then(|v| v.as_str()) {
+                init_surface = Some(s.to_string());
+            } else if let Some(s) = opts.get("tishSurface").and_then(|v| v.as_str()) {
+                init_surface = Some(s.to_string());
+            }
         }
+        let _ = tishlang_compile::apply_resolve_env(
+            init_platform.as_deref(),
+            init_surface.as_deref(),
+        );
         if src_root.is_none() {
             if let Ok(s) = std::env::var("TISHLANG_SOURCE_ROOT") {
                 let t = s.trim();

package/crates/tish_native/src/build.rs

@@ -135,6 +135,17 @@ pub fn build_via_cargo_with_config(
     project_root: Option<&Path>,
     build_config: &NativeBuildConfig,
 ) -> Result<(), String> {
+    if build_config.artifact == NativeArtifact::GbaRom {
+        return build_gba_rom(
+            rust_code,
+            native_modules,
+            output_path,
+            extra_dependencies_toml,
+            generated_native_rs,
+            project_root,
+        );
+    }
+
     let out_stem = output_path
         .file_stem()
         .and_then(|s| s.to_str())
@@ -299,6 +310,241 @@ tishlang_runtime = {{ path = {:?}{} }}
     Ok(())
 }
 
+/// Read the agb version the facade pins, from `<facade>/Cargo.toml`. This keeps the generated ROM
+/// crate's agb in lockstep with the facade's (the single source of truth) — see [`build_gba_rom`].
+/// Matches an `agb = "X"` or `agb = { version = "X", … }` line; `None` if absent (caller falls back).
+fn read_facade_agb_version(facade_path: &Path) -> Option<String> {
+    let toml = fs::read_to_string(facade_path.join("Cargo.toml")).ok()?;
+    for line in toml.lines() {
+        // Require the key to be exactly `agb` (not `agb_foo`): after `agb`, the next non-space
+        // token must be `=`.
+        let Some(after_key) = line.trim_start().strip_prefix("agb") else {
+            continue;
+        };
+        let Some(after_eq) = after_key.trim_start().strip_prefix('=') else {
+            continue;
+        };
+        // Take the first double-quoted string (the version, in either the bare or table form).
+        let rest = after_eq.trim_start();
+        if let Some(start) = rest.find('"') {
+            if let Some(len) = rest[start + 1..].find('"') {
+                return Some(rest[start + 1..start + 1 + len].to_string());
+            }
+        }
+    }
+    None
+}
+
+/// Build a Game Boy Advance ROM from generated `#![no_std]` Rust.
+///
+/// Emits an agb-style cargo project (nightly + build-std + `thumbv4t-none-eabi` +
+/// `gba.ld`) that links the `tishlang_runtime_gba` facade under the `tishlang_runtime`
+/// name (the `package =` rename), builds it, then runs `agb-gbafix` on the ELF.
+///
+/// Runs its own `cargo build` (NOT `run_cargo_build`) so the `.cargo/config.toml`
+/// rustflags (`-Tgba.ld`, `-Ctarget-cpu=arm7tdmi`) apply — `run_cargo_build` sets a
+/// `RUSTFLAGS` env that would shadow them.
+fn build_gba_rom(
+    rust_code: &str,
+    native_modules: Vec<ResolvedNativeModule>,
+    output_path: &Path,
+    extra_dependencies_toml: &str,
+    generated_native_rs: Option<&str>,
+    project_root: Option<&Path>,
+) -> Result<(), String> {
+    use std::process::Command;
+
+    // Locate the facade crate (sibling of tishlang_runtime in the tish workspace).
+    let runtime_path = tishlang_build_utils::find_runtime_path_for_project(project_root)?;
+    let facade_path = Path::new(&runtime_path)
+        .parent()
+        .ok_or_else(|| "invalid tishlang_runtime path (no parent)".to_string())?
+        .join("tish_runtime_gba");
+    if !facade_path.exists() {
+        return Err(format!(
+            "GBA runtime facade not found at {} (expected the tishlang_runtime_gba crate)",
+            facade_path.display()
+        ));
+    }
+
+    // Single-source the agb version from the facade's own Cargo.toml — the facade is the one crate
+    // that actually links agb (its `Fixed`, entry-point, and asset arenas are agb types), so it is
+    // the source of truth. The generated ROM crate must depend on the SAME agb: a skew would pull in
+    // two agb crates and mismatch types at the sprite-registration boundary. Falls back to a known
+    // pin only if the line can't be read (never blocks the build on a parse miss).
+    let agb_version =
+        read_facade_agb_version(&facade_path).unwrap_or_else(|| "0.25.0".to_string());
+
+    let out_stem = output_path
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("tish_out");
+    let cargo_name = tishlang_build_utils::cargo_target_name(out_stem);
+
+    // Persistent build dir under the project so the (expensive) build-std recompile
+    // is cached across runs; the generated Rust stays inspectable.
+    let base = project_root
+        .map(|p| p.to_path_buf())
+        .unwrap_or_else(|| std::env::current_dir().unwrap_or_default());
+    let build_dir = base.join(".tish").join("gba").join(out_stem);
+    fs::create_dir_all(build_dir.join("src"))
+        .map_err(|e| format!("Cannot create GBA build dir: {}", e))?;
+    fs::create_dir_all(build_dir.join(".cargo"))
+        .map_err(|e| format!("Cannot create .cargo dir: {}", e))?;
+
+    // Path dependencies for any `cargo:` native modules the program imported.
+    let native_deps: String = native_modules
+        .iter()
+        .filter(|m| m.use_path_dependency)
+        .map(|m| {
+            let path = m.crate_path.display().to_string().replace('\\', "/");
+            format!("{} = {{ path = {:?} }}\n", m.package_name, path)
+        })
+        .collect();
+
+    // `cargo:` module path deps arrive via `extra_dependencies_toml`
+    // (`tish.rustDependencies`); `native_modules` covers any that use a path dep
+    // resolved another way. Both are appended to `[dependencies]`.
+    let mut more_deps = native_deps;
+    if !extra_dependencies_toml.trim().is_empty() {
+        more_deps.push('\n');
+        more_deps.push_str(extra_dependencies_toml);
+    }
+
+    let facade = facade_path.display().to_string().replace('\\', "/");
+    let cargo_toml = format!(
+        r#"[package]
+name = "tish_output"
+version = "0.1.0"
+edition = "2021"
+
+# Standalone workspace so a parent Cargo workspace (e.g. the tish-gba repo, when
+# the build dir lives under it) doesn't try to absorb this generated crate.
+[workspace]
+
+[[bin]]
+name = "{cargo_name}"
+path = "src/main.rs"
+
+[dependencies]
+tishlang_runtime = {{ package = "tishlang_runtime_gba", path = {facade:?} }}
+agb = "{agb_version}"
+{more_deps}
+[profile.dev]
+opt-level = 3
+debug = true
+
+[profile.dev.build-override]
+opt-level = 3
+
+[profile.release]
+opt-level = 3
+lto = "fat"
+debug = true
+
+[profile.release.build-override]
+opt-level = 3
+"#,
+    );
+    fs::write(build_dir.join("Cargo.toml"), cargo_toml)
+        .map_err(|e| format!("Cannot write Cargo.toml: {}", e))?;
+
+    fs::write(
+        build_dir.join("rust-toolchain.toml"),
+        "[toolchain]\nchannel = \"nightly\"\ncomponents = [\"rust-src\"]\n",
+    )
+    .map_err(|e| format!("Cannot write rust-toolchain.toml: {}", e))?;
+
+    // build-std + target + gba.ld rustflags (agb ships gba.ld via its build.rs).
+    fs::write(
+        build_dir.join(".cargo").join("config.toml"),
+        r#"[unstable]
+build-std = ["core", "alloc"]
+build-std-features = ["compiler-builtins-mem"]
+
+[build]
+target = "thumbv4t-none-eabi"
+
+[target.thumbv4t-none-eabi]
+runner = ["mgba-qt", "-C", "logToStdout=1", "-C", "logLevel.gba.debug=127"]
+"#,
+    )
+    .map_err(|e| format!("Cannot write .cargo/config.toml: {}", e))?;
+
+    let rust_main = if generated_native_rs.is_some() {
+        inject_generated_native_mod(rust_code)
+    } else {
+        rust_code.to_string()
+    };
+    if let Some(gen) = generated_native_rs {
+        // The `cargo:` wrapper emits the std header (`std::cell/rc/sync`); map it
+        // to the no_std facade equivalents (`alloc` is crate-wide via main.rs's
+        // `extern crate alloc`). The module body is otherwise Value-only.
+        let gen = gen
+            .replace("use std::cell::RefCell;", "use core::cell::RefCell;")
+            .replace("use std::rc::Rc;", "use alloc::rc::Rc;")
+            .replace("use std::sync::Arc;", "use tishlang_runtime::Arc;");
+        fs::write(build_dir.join("src").join("generated_native.rs"), gen)
+            .map_err(|e| format!("Cannot write generated_native.rs: {}", e))?;
+    }
+    fs::write(build_dir.join("src").join("main.rs"), rust_main)
+        .map_err(|e| format!("Cannot write main.rs: {}", e))?;
+
+    // Pass the GBA linker/target rustflags via the RUSTFLAGS env (which REPLACES,
+    // not joins, any `[target.*].rustflags` from config files). This matters when
+    // the build dir sits inside a project that already has a `.cargo/config.toml`
+    // with `-Tgba.ld` — cargo *joins* rustflags arrays across config files, so a
+    // config-file approach would pass `-Tgba.ld` twice ("region already defined").
+    // build-std still comes from the generated `[unstable]` config (not rustflags).
+    let status = Command::new("cargo")
+        .arg("build")
+        .arg("--release")
+        .current_dir(&build_dir)
+        .env(
+            "RUSTFLAGS",
+            "-Clink-arg=-Tgba.ld -Ctarget-cpu=arm7tdmi -Cforce-frame-pointers=yes",
+        )
+        .env("CARGO_TERM_COLOR", "always")
+        .status()
+        .map_err(|e| format!("Failed to run cargo for GBA build: {}", e))?;
+    if !status.success() {
+        return Err(format!(
+            "GBA cargo build failed (see output above). Build dir: {}",
+            build_dir.display()
+        ));
+    }
+
+    // ELF → .gba via agb-gbafix.
+    let elf = build_dir
+        .join("target")
+        .join("thumbv4t-none-eabi")
+        .join("release")
+        .join(&cargo_name);
+    if !elf.exists() {
+        return Err(format!("GBA ELF not found at {}", elf.display()));
+    }
+    let rom = if output_path.extension().is_some_and(|e| e == "gba") {
+        output_path.to_path_buf()
+    } else {
+        output_path.with_extension("gba")
+    };
+    let gbafix = Command::new("agb-gbafix")
+        .arg(&elf)
+        .arg("-o")
+        .arg(&rom)
+        .status()
+        .map_err(|e| {
+            format!(
+                "Failed to run agb-gbafix ({}). Install it with: cargo install agb-gbafix",
+                e
+            )
+        })?;
+    if !gbafix.success() {
+        return Err("agb-gbafix failed to produce the ROM".to_string());
+    }
+    Ok(())
+}
+
 /// Remove a finished build's per-PID source directory (#384). Called only on SUCCESS, after the
 /// binary is copied out — the dir is then disposable (it holds only the generated crate source;
 /// compiled artifacts live in the shared workspace `target/`). Left in place on any earlier error so a

package/crates/tish_native/src/config.rs

@@ -8,6 +8,9 @@ pub enum NativeArtifact {
     #[default]
     Bin,
     StaticLib,
+    /// A GBA ROM: cargo builds an ELF for `thumbv4t-none-eabi`, then `agb-gbafix`
+    /// converts it to a `.gba`.
+    GbaRom,
 }
 
 /// Options passed from the CLI into nested `cargo build`.
@@ -32,11 +35,28 @@ impl NativeBuildConfig {
         }
     }
 
+    /// Game Boy Advance ROM build (`tish build --target gba`): cross-compile to
+    /// `thumbv4t-none-eabi` with the `Gba` emit mode.
+    pub fn gba() -> Self {
+        Self {
+            artifact: NativeArtifact::GbaRom,
+            cargo_target: Some("thumbv4t-none-eabi".to_string()),
+            emit_mode: NativeEmitMode::Gba,
+        }
+    }
+
     pub fn is_cross_compile(&self) -> bool {
         self.cargo_target.is_some()
     }
 }
 
+/// Feature cap for GBA builds: no host-only runtime capabilities (http/fs/process/
+/// timers/ws/tty/pty). The facade `compile_error!`-stubs them, but capping keeps
+/// the emitted prelude from importing names that don't exist on GBA.
+pub fn gba_runtime_features(_features: &[String]) -> Vec<String> {
+    Vec::new()
+}
+
 /// Filter runtime features for iOS sandbox builds.
 pub fn ios_runtime_features(features: &[String]) -> Vec<String> {
     const ALLOW: &[&str] = &["http", "http-hyper", "regex", "timers"];

package/crates/tish_native/src/lib.rs

@@ -97,13 +97,23 @@ pub fn compile_to_native_with_config(
 
     match backend {
         Backend::Rust => {
-            let ios_cap = build_config.cargo_target.as_ref().map(|_| {
-                ios_runtime_features(features)
+            // Cross-target builds cap runtime features to what the target supports:
+            // GBA gets none (no OS), iOS gets its sandbox allow-list.
+            let is_gba = build_config.emit_mode == tishlang_compile::NativeEmitMode::Gba;
+            let cap = |f: &[String]| -> Vec<String> {
+                if is_gba {
+                    crate::config::gba_runtime_features(f)
+                } else {
+                    ios_runtime_features(f)
+                }
+            };
+            let cross_cap = build_config.cargo_target.as_ref().map(|_| {
+                cap(features)
                     .into_iter()
                     .collect::<std::collections::HashSet<_>>()
             });
-            let compile_features = if ios_cap.is_some() {
-                ios_runtime_features(features)
+            let compile_features = if cross_cap.is_some() {
+                cap(features)
             } else {
                 features.to_vec()
             };
@@ -114,14 +124,14 @@ pub fn compile_to_native_with_config(
                     &compile_features,
                     optimize,
                     build_config.emit_mode,
-                    ios_cap.as_ref(),
+                    cross_cap.as_ref(),
                 )
                 .map_err(|e| NativeError {
                     message: e.to_string(),
                 })?;
 
             let features_for_cargo = if build_config.cargo_target.is_some() {
-                ios_runtime_features(&effective_features)
+                cap(&effective_features)
             } else {
                 effective_features
             };

package/crates/tish_parser/src/lib.rs

@@ -101,6 +101,34 @@ mod tests {
         assert!(parse("let x = async 5").is_err());
     }
 
+    /// #428 (function-expression half): `async function (…) {…}` / named `async function f(…) {…}`
+    /// in expression position parse as async ArrowFunctions — anonymous, named, object-property,
+    /// and IIFE-operand forms. Non-async function expressions keep `async_: false` (#464).
+    #[test]
+    fn async_function_expressions_parse() {
+        use tishlang_ast::Expr;
+        let fn_expr_async = |src: &str| -> bool {
+            let p = parse(src).expect("parse");
+            let Some(Statement::VarDecl { init: Some(e), .. }) = p.statements.first() else {
+                panic!("expected `let x = <fn expr>`");
+            };
+            match e {
+                Expr::ArrowFunction { async_, .. } => *async_,
+                other => panic!("expected ArrowFunction, got {other:?}"),
+            }
+        };
+        assert!(fn_expr_async("let f = async function() { return 1 }"), "anonymous");
+        assert!(fn_expr_async("let f = async function named(n) { return n }"), "named");
+        assert!(!fn_expr_async("let f = function() { return 1 }"), "plain fn expr is not async");
+        // Object-property and IIFE-operand positions.
+        assert!(parse("let o = { m: async function() { return 1 } }").is_ok());
+        assert!(parse("let p = (async function() { return 1 })()").is_ok());
+        assert!(parse("let q = (async () => { return 1 })()").is_ok());
+        // `async fn => …` stays a single-param arrow with param `fn` (#55 ident-compat) —
+        // the function-expression branch requires `(` or an identifier after `function`.
+        assert!(parse("let r = async fn => fn").is_ok());
+    }
+
     #[test]
     fn test_async_fn_parse() {
         let program = parse("async fn foo() { }").expect("parse async fn");

package/crates/tish_parser/src/parser.rs

@@ -197,6 +197,11 @@ impl<'a> Parser<'a> {
         self.peek().map(|t| t.kind)
     }
 
+    /// Kind of the token `n` positions past the current one (`peek_ahead_kind(0)` == `peek_kind`).
+    fn peek_ahead_kind(&self, n: usize) -> Option<TokenKind> {
+        self.tokens.get(self.pos + n).map(|t| t.kind)
+    }
+
     fn advance(&mut self) -> Option<&Token> {
         let t = self.tokens.get(self.pos);
         if t.is_some() {
@@ -1060,7 +1065,8 @@ impl<'a> Parser<'a> {
 
     /// `interface Name { k: T, ... }` — desugared to `type Name = { ... }` so the checker
     /// (structural matching) and codegen (native `TishStruct_*`) treat it exactly like an
-    /// object-type alias. (`extends` is not yet supported.)
+    /// object-type alias. `interface Name extends P1, P2 { ... }` desugars to an intersection
+    /// of the parents with the body (see below), so inherited fields participate too.
     fn parse_interface(&mut self) -> Result<Statement, String> {
         let span_start = self.expect(TokenKind::Interface)?.span.start;
         let name_tok = self.expect(TokenKind::Ident)?;
@@ -2464,9 +2470,11 @@ impl<'a> Parser<'a> {
                 value: Literal::Null,
                 span,
             }),
-            // `async` in expression position (#428): an async arrow — `async () => …` or
-            // `async x => …`. The body runs in async context (`await` allowed). Async function
-            // expressions / method shorthand need function-expression support, which tish lacks.
+            // `async` in expression position (#428): an async arrow — `async () => …` /
+            // `async x => …` — or an async function EXPRESSION — `async function (…) {…}` /
+            // named `async function f(…) {…}` (desugars to an async ArrowFunction exactly like
+            // the non-async `function` expression form, #464). The body runs in async context
+            // (`await` allowed).
             TokenKind::Async => {
                 if matches!(self.peek_kind(), Some(TokenKind::LParen)) {
                     self.advance(); // consume `(`
@@ -2475,6 +2483,19 @@ impl<'a> Parser<'a> {
                     }
                     return Err("Expected an arrow function after `async (`".to_string());
                 }
+                // `async function (…) {…}` / `async function f(…) {…}`: `function` (`Fn`)
+                // followed by `(` or an identifier is a function expression, mirroring the
+                // non-async arm below. Checked BEFORE the single-param-arrow branch, which
+                // would otherwise consume `function` as a parameter name and demand `=>`.
+                if matches!(self.peek_kind(), Some(TokenKind::Fn))
+                    && matches!(
+                        self.peek_ahead_kind(1),
+                        Some(TokenKind::LParen | TokenKind::Ident)
+                    )
+                {
+                    self.advance(); // consume `function`
+                    return self.parse_function_expr_tail(&span, true);
+                }
                 if matches!(
                     self.peek_kind(),
                     Some(TokenKind::Ident | TokenKind::Fn | TokenKind::Type)

package/crates/tish_runtime/src/lib.rs

@@ -16,6 +16,7 @@ pub use tishlang_core::ObjectMap;
 // pass) instead of materializing an intermediate `AHashMap` and rebuilding from it.
 pub use tishlang_core::{ObjectData, PropMap};
 pub use tishlang_core::Value;
+pub use tishlang_core::NumArrayBacking;
 pub use tishlang_core::ArcStr;
 /// Used by native codegen for `f()` / `obj()` dispatch (`Value::Function` or `__call` on objects).
 /// Wraps `tishlang_core::value_call` with a pending-throw suppression check (#381): while a thrown
@@ -79,7 +80,7 @@ pub fn normalize_for_of(v: Value) -> Value {
     // single-variant `if let Value::Array` in the spread / for-of codegen binds — otherwise it spreads
     // to zero elements.
     if let Value::NumberArray(arr) = &v {
-        let items: Vec<Value> = arr.borrow().iter().map(|n| Value::Number(*n)).collect();
+        let items: Vec<Value> = arr.borrow().to_values();
         return Value::Array(VmRef::new(items));
     }
     match tishlang_core::drain_iterator(&v) {
@@ -547,7 +548,8 @@ use tishlang_builtins::globals::{
     decode_uri as builtins_decode_uri, encode_uri as builtins_encode_uri,
     is_finite as builtins_is_finite, is_nan as builtins_is_nan,
     object_assign as builtins_object_assign, object_entries as builtins_object_entries,
-    object_from_entries as builtins_object_from_entries, object_keys as builtins_object_keys,
+    object_freeze as builtins_object_freeze, object_from_entries as builtins_object_from_entries,
+    object_is_frozen as builtins_object_is_frozen, object_keys as builtins_object_keys,
     object_values as builtins_object_values,
     number_convert as builtins_number_convert,
     string_convert as builtins_string_convert,
@@ -1389,7 +1391,10 @@ pub fn get_prop(obj: &Value, key: impl AsRef<str>) -> Value {
             if key == "length" {
                 Value::Number(arr.borrow().len() as f64)
             } else if let Ok(idx) = key.parse::<usize>() {
-                arr.borrow().get(idx).copied().map(Value::Number).unwrap_or(Value::Null)
+                arr.borrow().get(idx).map(|v| match v {
+                    Value::Number(n) if n.is_nan() => Value::Null,
+                    other => other,
+                }).unwrap_or(Value::Null)
             } else {
                 Value::Null
             }
@@ -1487,7 +1492,10 @@ pub fn get_index(obj: &Value, index: &Value) -> Value {
                 },
                 _ => return Value::Null,
             };
-            arr.borrow().get(idx).copied().map(Value::Number).unwrap_or(Value::Null)
+            arr.borrow().get(idx).map(|v| match v {
+                Value::Number(n) if n.is_nan() => Value::Null,
+                other => other,
+            }).unwrap_or(Value::Null)
         }
         // `str[i]` returns the character at index `i` (issue #17) — matches the VM /
         // interpreter; out-of-bounds / negative / non-integer indices yield null.
@@ -1558,6 +1566,14 @@ pub fn set_prop(obj: &Value, key: &str, val: Value) -> Value {
             // exists we re-use the existing `Arc<str>` and skip the
             // alloc. Only newly-inserted keys pay for `Arc::from(key)`.
             let mut m = map.borrow_mut();
+            if m.frozen {
+                // #437: a write to a frozen object throws a catchable TypeError (parked in the
+                // pending-throw slot; the generated code surfaces it at the next checkpoint).
+                tishlang_core::set_pending_throw(tishlang_core::type_error(format!(
+                    "Cannot assign to read only property '{key}' of a frozen object"
+                )));
+                return val;
+            }
             if let Some(slot) = m.strings.get_mut(key) {
                 *slot = val.clone();
             } else {
@@ -1613,14 +1629,35 @@ pub fn set_index(obj: &Value, idx: &Value, val: Value) -> Value {
                 },
                 _ => panic!("Array index must be number"),
             };
-            let mut arr_mut = arr.borrow_mut();
-            while arr_mut.len() <= index {
-                arr_mut.push(0.0);
+            let mut b = arr.borrow_mut();
+            match (b.as_packed_mut(), val.as_number()) {
+                (Some(nums), Some(n)) => {
+                    while nums.len() <= index {
+                        nums.push(f64::NAN);
+                    }
+                    nums[index] = n;
+                }
+                // Non-numeric (or already deopted): upgrade in place, store the real Value.
+                _ => {
+                    let boxed = b.deopt();
+                    while boxed.len() <= index {
+                        boxed.push(Value::Null);
+                    }
+                    boxed[index] = val.clone();
+                }
             }
-            arr_mut[index] = val.as_number().unwrap_or(f64::NAN);
             val
         }
-        Value::Object(_) => {
+        Value::Object(map) => {
+            if map.borrow().frozen {
+                // #437: a write to a frozen object throws a catchable TypeError (parked; surfaced at
+                // the next assignment checkpoint, same as `set_prop`).
+                tishlang_core::set_pending_throw(tishlang_core::type_error(format!(
+                    "Cannot assign to read only property '{}' of a frozen object",
+                    idx.to_display_string()
+                )));
+                return val;
+            }
             tishlang_core::object_set(obj, idx, val.clone()).expect("object set");
             val
         }
@@ -1673,6 +1710,14 @@ pub fn object_keys(args: &[Value]) -> Value {
     builtins_object_keys(args)
 }
 
+pub fn object_freeze(args: &[Value]) -> Value {
+    builtins_object_freeze(args)
+}
+
+pub fn object_is_frozen(args: &[Value]) -> Value {
+    builtins_object_is_frozen(args)
+}
+
 pub fn object_values(args: &[Value]) -> Value {
     builtins_object_values(args)
 }