@tishlang/tish-lsp 2.38.0 → 2.43.8

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)
 }
@@ -1735,7 +1780,7 @@ pub use pty::{pty_kill, pty_pid, pty_read, pty_resize, pty_spawn, pty_write};
 #[cfg(feature = "ws")]
 pub use ws::{
     web_socket_client, web_socket_server_accept, web_socket_server_construct,
-    web_socket_server_listen, ws_broadcast_native, ws_send_native,
+    web_socket_server_listen, ws_broadcast_native, ws_send_native, ws_serve_accept,
 };
 
 #[cfg(feature = "http")]

package/crates/tish_runtime/src/ws.rs

@@ -82,6 +82,83 @@ fn unregister(id: u32) {
     CONNS.lock().unwrap().remove(&id);
 }
 
+/// Bridge an already-handshaked WebSocket stream into the `CONNS` registry — spawning the read and
+/// write pump tasks — and return its connection id. Shared by the `tish:ws` server-accept loop and
+/// the `serve()` HTTP→WS upgrade path (see `http_hyper.rs`). Must be called inside a tokio runtime.
+pub(crate) fn register_ws_stream<S>(ws_stream: tokio_tungstenite::WebSocketStream<S>) -> u32
+where
+    S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send + 'static,
+{
+    let (send_tx, mut send_rx) = tokio_mpsc::unbounded_channel::<String>();
+    let (recv_tx, recv_rx) = mpsc::sync_channel::<String>(64);
+    let id = register(send_tx, recv_rx);
+    let recv_tx_task = Arc::new(recv_tx);
+    let (mut write, mut read) = ws_stream.split();
+    tokio::spawn(async move {
+        while let Some(Ok(msg)) = read.next().await {
+            if let tokio_tungstenite::tungstenite::Message::Text(t) = msg {
+                let _ = recv_tx_task.send(t.to_string());
+            }
+        }
+        unregister(id);
+    });
+    tokio::spawn(async move {
+        while let Some(text) = send_rx.recv().await {
+            let _ = write
+                .send(tokio_tungstenite::tungstenite::Message::Text(text.into()))
+                .await;
+        }
+    });
+    id
+}
+
+lazy_static! {
+    /// Connections upgraded from HTTP by `serve()` (http_hyper), waiting for the program to pick them
+    /// up via `wsAccept`. Per-process: an upgraded socket stays in whatever SO_REUSEPORT worker
+    /// accepted it, so each worker drains its own queue and there's no cross-process routing problem.
+    static ref UPGRADE_QUEUE: (Mutex<std::collections::VecDeque<u32>>, std::sync::Condvar) =
+        (Mutex::new(std::collections::VecDeque::new()), std::sync::Condvar::new());
+}
+
+/// Enqueue a `serve()`-upgraded connection id for `wsAccept` to hand to the program.
+pub(crate) fn enqueue_upgraded_conn(id: u32) {
+    let (m, cv) = &*UPGRADE_QUEUE;
+    if let Ok(mut q) = m.lock() {
+        q.push_back(id);
+    }
+    cv.notify_all();
+}
+
+/// `wsAccept(timeoutMs?)` — return the next connection upgraded on the HTTP server's port (see the
+/// `serve()` HTTP→WS upgrade path) as a normal `tish:ws` connection object, or `Null` if none arrives
+/// within the timeout (default 0 = non-blocking).
+pub fn ws_serve_accept(args: &[Value]) -> Value {
+    let timeout_ms = match args.first() {
+        Some(Value::Number(n)) if n.is_finite() && *n >= 0.0 => (*n as u64).min(3_600_000),
+        _ => 0,
+    };
+    let (m, cv) = &*UPGRADE_QUEUE;
+    let mut q = match m.lock() {
+        Ok(q) => q,
+        Err(_) => return Value::Null,
+    };
+    if q.is_empty() && timeout_ms > 0 {
+        let res = cv.wait_timeout_while(
+            q,
+            std::time::Duration::from_millis(timeout_ms),
+            |q| q.is_empty(),
+        );
+        q = match res {
+            Ok((g, _)) => g,
+            Err(e) => e.into_inner().0,
+        };
+    }
+    match q.pop_front() {
+        Some(id) => conn_object(id),
+        None => Value::Null,
+    }
+}
+
 /// Max simultaneous WebSocket connections. Each accepted conn registers in `CONNS` and
 /// spawns tasks + channels, freed only on close — unbounded accepts exhaust tasks/memory.
 /// Override with `TISH_WS_MAX_CONNS`; default 10000.
@@ -399,27 +476,7 @@ pub fn web_socket_server_listen(args: &[Value]) -> Value {
                         continue;
                     }
                 };
-                let (send_tx, mut send_rx) = tokio_mpsc::unbounded_channel::<String>();
-                let (recv_tx, recv_rx) = mpsc::sync_channel::<String>(64);
-                let id = register(send_tx, recv_rx);
-                let recv_tx = Arc::new(recv_tx);
-                let recv_tx_task = Arc::clone(&recv_tx);
-                let (mut write, mut read) = ws_stream.split();
-                tokio::spawn(async move {
-                    while let Some(Ok(msg)) = read.next().await {
-                        if let tokio_tungstenite::tungstenite::Message::Text(t) = msg {
-                            let _ = recv_tx_task.send(t.to_string());
-                        }
-                    }
-                    unregister(id);
-                });
-                tokio::spawn(async move {
-                    while let Some(text) = send_rx.recv().await {
-                        let _ = write
-                            .send(tokio_tungstenite::tungstenite::Message::Text(text.into()))
-                            .await;
-                    }
-                });
+                let id = register_ws_stream(ws_stream);
                 if conn_tx.send(id).is_err() {
                     break;
                 }
@@ -578,6 +635,22 @@ mod tests {
     use std::thread;
     use std::time::Duration;
 
+    /// The serve() HTTP→WS upgrade queue: `wsAccept` hands out enqueued conns FIFO and returns Null
+    /// when empty. (End-to-end upgrade over a live hyper port is covered by the native smoke test.)
+    #[test]
+    fn upgrade_queue_drains_then_empty() {
+        assert!(matches!(ws_serve_accept(&[Value::Number(0.0)]), Value::Null));
+        enqueue_upgraded_conn(4242);
+        match ws_serve_accept(&[Value::Number(0.0)]) {
+            Value::Object(o) => {
+                let b = o.borrow();
+                assert!(matches!(b.strings.get("_id"), Some(Value::Number(n)) if *n == 4242.0));
+            }
+            other => panic!("expected a conn object, got {:?}", other),
+        }
+        assert!(matches!(ws_serve_accept(&[Value::Number(0.0)]), Value::Null));
+    }
+
     #[test]
     fn ws_echo_roundtrip() {
         let port: u16 = 18_742;