@tishlang/tish 1.9.2 → 1.12.0

package/crates/tish_parser/src/parser.rs

@@ -209,11 +209,11 @@ impl<'a> Parser<'a> {
         let opened_with_brace = matches!(self.peek_kind(), Some(TokenKind::LBrace));
         if opened_with_brace {
             self.advance(); // {
-            // After `{`, the lexer often emits `Indent` for the first indented line of the body.
-            // `parse_statement` treats a leading `Indent` as starting a *nested* indent-block, so
-            // without consuming this token we get `Block { Block { let ... } ; ... }` and the first
-            // `let`/`const` is scoped too narrowly (JS ReferenceError). This indent is layout for
-            // *this* brace block, not an inner block.
+                            // After `{`, the lexer often emits `Indent` for the first indented line of the body.
+                            // `parse_statement` treats a leading `Indent` as starting a *nested* indent-block, so
+                            // without consuming this token we get `Block { Block { let ... } ; ... }` and the first
+                            // `let`/`const` is scoped too narrowly (JS ReferenceError). This indent is layout for
+                            // *this* brace block, not an inner block.
             if matches!(self.peek_kind(), Some(TokenKind::Indent)) {
                 self.advance();
             }
@@ -291,10 +291,7 @@ impl<'a> Parser<'a> {
             start: name_tok.span.start,
             end: name_tok.span.end,
         };
-        let name = name_tok
-            .literal
-            .clone()
-            .ok_or("Expected identifier")?;
+        let name = name_tok.literal.clone().ok_or("Expected identifier")?;
 
         // Optional type annotation: `: Type`
         let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
@@ -348,10 +345,7 @@ impl<'a> Parser<'a> {
                     start: name_tok.span.start,
                     end: name_tok.span.end,
                 };
-                let name = name_tok
-                    .literal
-                    .clone()
-                    .ok_or("Expected identifier")?;
+                let name = name_tok.literal.clone().ok_or("Expected identifier")?;
                 elements.push(Some(DestructElement::Rest(name, name_span)));
                 break;
             }
@@ -368,10 +362,7 @@ impl<'a> Parser<'a> {
                         start: name_tok.span.start,
                         end: name_tok.span.end,
                     };
-                    let name = name_tok
-                        .literal
-                        .clone()
-                        .ok_or("Expected identifier")?;
+                    let name = name_tok.literal.clone().ok_or("Expected identifier")?;
                     DestructElement::Ident(name, name_span)
                 }
                 _ => return Err("Expected identifier or pattern in destructuring".to_string()),
@@ -399,10 +390,7 @@ impl<'a> Parser<'a> {
                 start: key_tok.span.start,
                 end: key_tok.span.end,
             };
-            let key = key_tok
-                .literal
-                .clone()
-                .ok_or("Expected identifier")?;
+            let key = key_tok.literal.clone().ok_or("Expected identifier")?;
 
             let value = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
                 self.advance();
@@ -418,10 +406,7 @@ impl<'a> Parser<'a> {
                             start: name_tok.span.start,
                             end: name_tok.span.end,
                         };
-                        let name = name_tok
-                            .literal
-                            .clone()
-                            .ok_or("Expected identifier")?;
+                        let name = name_tok.literal.clone().ok_or("Expected identifier")?;
                         DestructElement::Ident(name, name_span)
                     }
                     _ => return Err("Expected identifier or pattern after ':'".to_string()),
@@ -474,10 +459,7 @@ impl<'a> Parser<'a> {
             start: param_tok.span.start,
             end: param_tok.span.end,
         };
-        let param_name = param_tok
-            .literal
-            .clone()
-            .ok_or("Expected param name")?;
+        let param_name = param_tok.literal.clone().ok_or("Expected param name")?;
         let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
             self.advance();
             Some(self.parse_type_annotation()?)
@@ -549,11 +531,27 @@ impl<'a> Parser<'a> {
                 self.advance(); // {
                 let mut props = Vec::new();
                 while !matches!(self.peek_kind(), Some(TokenKind::RBrace)) {
-                    let key = self
-                        .expect(TokenKind::Ident)?
-                        .literal
-                        .clone()
-                        .ok_or("Expected property name")?;
+                    // `for` is a keyword but a common method name (`Symbol.for`); allow it here.
+                    let key: Arc<str> = match self.peek_kind() {
+                        Some(TokenKind::Ident) => {
+                            let tok = self.expect(TokenKind::Ident)?;
+                            Arc::from(
+                                tok.literal
+                                    .as_deref()
+                                    .ok_or("Expected property name")?,
+                            )
+                        }
+                        Some(TokenKind::For) => {
+                            self.advance();
+                            Arc::from("for")
+                        }
+                        _ => {
+                            return Err(format!(
+                                "Expected Ident or `for` as object type property name, got {:?}",
+                                self.peek_kind()
+                            ));
+                        }
+                    };
                     self.expect(TokenKind::Colon)?;
                     let typ = self.parse_type_annotation()?;
                     props.push((key, typ));
@@ -601,10 +599,7 @@ impl<'a> Parser<'a> {
             start: name_tok.span.start,
             end: name_tok.span.end,
         };
-        let name = name_tok
-            .literal
-            .clone()
-            .ok_or("Expected function name")?;
+        let name = name_tok.literal.clone().ok_or("Expected function name")?;
         self.expect(TokenKind::LParen)?;
         let mut params = Vec::with_capacity(4);
         let mut rest_param = None;
@@ -616,10 +611,7 @@ impl<'a> Parser<'a> {
                     start: rest_tok.span.start,
                     end: rest_tok.span.end,
                 };
-                let param_name = rest_tok
-                    .literal
-                    .clone()
-                    .ok_or("Expected rest param name")?;
+                let param_name = rest_tok.literal.clone().ok_or("Expected rest param name")?;
                 // Optional type annotation for rest param
                 let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
                     self.advance();
@@ -702,10 +694,7 @@ impl<'a> Parser<'a> {
             start: name_tok.span.start,
             end: name_tok.span.end,
         };
-        let name = name_tok
-            .literal
-            .clone()
-            .ok_or("Expected type alias name")?;
+        let name = name_tok.literal.clone().ok_or("Expected type alias name")?;
         self.expect(TokenKind::Assign)?;
         let ty = self.parse_type_annotation()?;
         Ok(Statement::TypeAlias {
@@ -747,10 +736,7 @@ impl<'a> Parser<'a> {
             start: name_tok.span.start,
             end: name_tok.span.end,
         };
-        let name = name_tok
-            .literal
-            .clone()
-            .ok_or("Expected identifier")?;
+        let name = name_tok.literal.clone().ok_or("Expected identifier")?;
         let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
             self.advance();
             Some(self.parse_type_annotation()?)
@@ -780,10 +766,7 @@ impl<'a> Parser<'a> {
             start: name_tok.span.start,
             end: name_tok.span.end,
         };
-        let name = name_tok
-            .literal
-            .clone()
-            .ok_or("Expected function name")?;
+        let name = name_tok.literal.clone().ok_or("Expected function name")?;
         self.expect(TokenKind::LParen)?;
         let mut params = Vec::with_capacity(4);
         let mut rest_param = None;
@@ -795,10 +778,7 @@ impl<'a> Parser<'a> {
                     start: rest_tok.span.start,
                     end: rest_tok.span.end,
                 };
-                let param_name = rest_tok
-                    .literal
-                    .clone()
-                    .ok_or("Expected rest param name")?;
+                let param_name = rest_tok.literal.clone().ok_or("Expected rest param name")?;
                 let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
                     self.advance();
                     Some(self.parse_type_annotation()?)
@@ -893,10 +873,7 @@ impl<'a> Parser<'a> {
                 start: for_name_tok.span.start,
                 end: for_name_tok.span.end,
             };
-            let name = for_name_tok
-                .literal
-                .clone()
-                .ok_or("Expected identifier")?;
+            let name = for_name_tok.literal.clone().ok_or("Expected identifier")?;
             if matches!(self.peek_kind(), Some(TokenKind::Of)) {
                 self.advance();
                 let iterable = self.parse_expr()?;
@@ -1186,10 +1163,7 @@ impl<'a> Parser<'a> {
                 start: def_tok.span.start,
                 end: def_tok.span.end,
             };
-            let name = def_tok
-                .literal
-                .clone()
-                .ok_or("Expected identifier")?;
+            let name = def_tok.literal.clone().ok_or("Expected identifier")?;
             vec![ImportSpecifier::Default { name, name_span }]
         } else {
             return Err("Expected { }, * as name, or default import".to_string());
@@ -1271,7 +1245,9 @@ impl<'a> Parser<'a> {
             // Member assignment: obj.prop = val
             if let Expr::Member {
                 object,
-                prop: MemberProp::Name { name: prop_name, .. },
+                prop: MemberProp::Name {
+                    name: prop_name, ..
+                },
                 ..
             } = &left
             {
@@ -1510,10 +1486,7 @@ impl<'a> Parser<'a> {
                     let optional = kind == TokenKind::OptionalChain;
                     self.advance();
                     let prop_tok = self.expect_ident_or_type_member_name()?;
-                    let prop = prop_tok
-                        .literal
-                        .clone()
-                        .ok_or("Expected property name")?;
+                    let prop = prop_tok.literal.clone().ok_or("Expected property name")?;
                     let prop_span = Span {
                         start: prop_tok.span.start,
                         end: prop_tok.span.end,
@@ -1630,10 +1603,7 @@ impl<'a> Parser<'a> {
                     let optional = kind == TokenKind::OptionalChain;
                     self.advance();
                     let prop_tok = self.expect_ident_or_type_member_name()?;
-                    let prop = prop_tok
-                        .literal
-                        .clone()
-                        .ok_or("Expected property name")?;
+                    let prop = prop_tok.literal.clone().ok_or("Expected property name")?;
                     let prop_span = Span {
                         start: prop_tok.span.start,
                         end: prop_tok.span.end,

package/crates/tish_pg/src/error.rs

@@ -1,5 +1,5 @@
-use std::fmt::Write as _;
 use std::error::Error as StdError;
+use std::fmt::Write as _;
 
 use deadpool::managed::PoolError;
 use thiserror::Error;

package/crates/tish_pg/src/lib.rs

@@ -90,15 +90,9 @@ fn params_to_sql(values: &[JsonValue]) -> Result<Vec<Box<dyn ToSql + Sync + Send
                 } else if let Some(u) = n.as_u64() {
                     Box::new(u as i64)
                 } else if let Some(f) = n.as_f64() {
-                    if f.fract() == 0.0
-                        && f >= i32::MIN as f64
-                        && f <= i32::MAX as f64
-                    {
+                    if f.fract() == 0.0 && f >= i32::MIN as f64 && f <= i32::MAX as f64 {
                         Box::new(f as i32)
-                    } else if f.fract() == 0.0
-                        && f >= i64::MIN as f64
-                        && f <= i64::MAX as f64
-                    {
+                    } else if f.fract() == 0.0 && f >= i64::MIN as f64 && f <= i64::MAX as f64 {
                         Box::new(f as i64)
                     } else {
                         Box::new(f)
@@ -110,7 +104,9 @@ fn params_to_sql(values: &[JsonValue]) -> Result<Vec<Box<dyn ToSql + Sync + Send
                 }
             }
             JsonValue::String(s) => Box::new(s.clone()),
-            JsonValue::Array(_) | JsonValue::Object(_) => Box::new(tokio_postgres::types::Json(v.clone())),
+            JsonValue::Array(_) | JsonValue::Object(_) => {
+                Box::new(tokio_postgres::types::Json(v.clone()))
+            }
         };
         out.push(b);
     }
@@ -222,7 +218,7 @@ fn row_to_value_direct(row: &Row) -> tishlang_runtime::Value {
         };
         om.insert(key, v);
     }
-    RtValue::Object(VmRef::new(om))
+    RtValue::object(om)
 }
 
 fn row_to_object(row: &Row) -> Result<JsonValue> {
@@ -378,8 +374,8 @@ pub struct PerWorkerClient {
 impl PerWorkerClient {
     /// Open a single direct connection (no pool).
     pub async fn connect(connection_string: &str) -> Result<Self> {
-        let cfg = parse_connection_string(connection_string)
-            .map_err(TishPgError::BadConnectionString)?;
+        let cfg =
+            parse_connection_string(connection_string).map_err(TishPgError::BadConnectionString)?;
         let (client, connection) = cfg.connect(NoTls).await?;
         let driver = tokio::spawn(async move {
             if let Err(e) = connection.await {
@@ -530,13 +526,11 @@ mod tish_sync {
     use super::*;
     use once_cell::sync::Lazy;
     use slab::Slab;
-    use std::sync::Mutex;
     use tishlang_runtime::Value as TishValue;
     use tokio::runtime::Runtime as TokioRuntime;
 
-    static RT: Lazy<TokioRuntime> = Lazy::new(|| {
-        TokioRuntime::new().expect("tish_pg: failed to build tokio runtime")
-    });
+    static RT: Lazy<TokioRuntime> =
+        Lazy::new(|| TokioRuntime::new().expect("tish_pg: failed to build tokio runtime"));
     // `RwLock` (not `Mutex`) on the registries: hot path is read-only —
     // every query does `get_client(id)` + `get_statement(id)`. Inserts
     // happen once per `connect`/`prepare` at startup. With multiple HTTP
@@ -544,8 +538,7 @@ mod tish_sync {
     // serialised every query through one global lock; `RwLock` lets all
     // concurrent reads run lock-free against each other.
     use std::sync::RwLock;
-    static CLIENTS: Lazy<RwLock<Slab<PerWorkerClient>>> =
-        Lazy::new(|| RwLock::new(Slab::new()));
+    static CLIENTS: Lazy<RwLock<Slab<PerWorkerClient>>> = Lazy::new(|| RwLock::new(Slab::new()));
     static STATEMENTS: Lazy<RwLock<Slab<(usize, Statement)>>> =
         Lazy::new(|| RwLock::new(Slab::new()));
 
@@ -609,12 +602,10 @@ mod tish_sync {
                 .map(JsonValue::Number)
                 .unwrap_or(JsonValue::Null),
             TishValue::String(s) => JsonValue::String(s.to_string()),
-            TishValue::Array(a) => {
-                JsonValue::Array(a.borrow().iter().map(tish_to_json).collect())
-            }
+            TishValue::Array(a) => JsonValue::Array(a.borrow().iter().map(tish_to_json).collect()),
             TishValue::Object(o) => {
                 let mut m = serde_json::Map::new();
-                for (k, v) in o.borrow().iter() {
+                for (k, v) in o.borrow().strings.iter() {
                     m.insert(k.to_string(), tish_to_json(v));
                 }
                 JsonValue::Object(m)
@@ -623,35 +614,35 @@ mod tish_sync {
         }
     }
 
-    fn json_to_tish(v: JsonValue) -> TishValue {
-        use std::cell::RefCell;
-        use std::rc::Rc;
-        use std::sync::Arc;
-        use tishlang_runtime::ObjectMap;
-        match v {
-            JsonValue::Null => TishValue::Null,
-            JsonValue::Bool(b) => TishValue::Bool(b),
-            JsonValue::Number(n) => TishValue::Number(n.as_f64().unwrap_or(0.0)),
-            JsonValue::String(s) => TishValue::String(s.into()),
-            JsonValue::Array(a) => {
-                let mut out = Vec::with_capacity(a.len());
-                for item in a {
-                    out.push(json_to_tish(item));
-                }
-                TishValue::Array(VmRef::new(out))
-            }
-            JsonValue::Object(m) => {
-                // Pre-allocate ObjectMap capacity so HashMap doesn't rehash
-                // on every insert. Common TFB rows are 2 columns (id,
-                // randomnumber or id, message).
-                let mut om = ObjectMap::with_capacity(m.len());
-                for (k, v) in m {
-                    om.insert(Arc::from(k), json_to_tish(v));
-                }
-                TishValue::Object(VmRef::new(om))
-            }
-        }
-    }
+    // fn json_to_tish(v: JsonValue) -> TishValue {
+    //     use std::cell::RefCell;
+    //     use std::rc::Rc;
+    //     use std::sync::Arc;
+    //     use tishlang_runtime::ObjectMap;
+    //     match v {
+    //         JsonValue::Null => TishValue::Null,
+    //         JsonValue::Bool(b) => TishValue::Bool(b),
+    //         JsonValue::Number(n) => TishValue::Number(n.as_f64().unwrap_or(0.0)),
+    //         JsonValue::String(s) => TishValue::String(s.into()),
+    //         JsonValue::Array(a) => {
+    //             let mut out = Vec::with_capacity(a.len());
+    //             for item in a {
+    //                 out.push(json_to_tish(item));
+    //             }
+    //             TishValue::Array(VmRef::new(out))
+    //         }
+    //         JsonValue::Object(m) => {
+    //             // Pre-allocate ObjectMap capacity so HashMap doesn't rehash
+    //             // on every insert. Common TFB rows are 2 columns (id,
+    //             // randomnumber or id, message).
+    //             let mut om = ObjectMap::with_capacity(m.len());
+    //             for (k, v) in m {
+    //                 om.insert(Arc::from(k), json_to_tish(v));
+    //             }
+    //             TishValue::object(om)
+    //         }
+    //     }
+    // }
 
     fn tish_err(msg: impl Into<String>) -> TishValue {
         use std::sync::Arc;
@@ -659,16 +650,14 @@ mod tish_sync {
         let mut om = ObjectMap::with_capacity(2);
         om.insert(Arc::from("error"), TishValue::String(msg.into().into()));
         om.insert(Arc::from("ok"), TishValue::Bool(false));
-        TishValue::Object(VmRef::new(om))
+        TishValue::object(om)
     }
 
-    fn rows_to_value(res: QueryResult) -> TishValue {
-        use std::cell::RefCell;
-        use std::rc::Rc;
-        TishValue::Array(VmRef::new(
-            res.rows.into_iter().map(json_to_tish).collect(),
-        ))
-    }
+    // fn rows_to_value(res: QueryResult) -> TishValue {
+    //     use std::cell::RefCell;
+    //     use std::rc::Rc;
+    //     TishValue::Array(VmRef::new(res.rows.into_iter().map(json_to_tish).collect()))
+    // }
 
     /// `perWorkerClient(connection_string) -> client_handle` (blocking).
     pub fn per_worker_client(args: &[TishValue]) -> TishValue {
@@ -682,7 +671,10 @@ mod tish_sync {
                 let id = g.insert(c);
                 TishValue::Number(id as f64)
             }
-            Err(e) => tish_err(format!("perWorkerClient: {}", crate::format_tish_pg_error(&e))),
+            Err(e) => tish_err(format!(
+                "perWorkerClient: {}",
+                crate::format_tish_pg_error(&e)
+            )),
         }
     }
 
@@ -694,9 +686,8 @@ mod tish_sync {
         let cs = match args.first() {
             Some(TishValue::String(s)) => s.to_string(),
             Some(TishValue::Object(obj)) => {
-                use std::sync::Arc;
                 let b = obj.borrow();
-                match b.get(&Arc::from("connectionString")) {
+                match b.strings.get("connectionString") {
                     Some(TishValue::String(s)) => s.to_string(),
                     _ => return tish_err("connect: options.connectionString missing"),
                 }
@@ -754,11 +745,7 @@ mod tish_sync {
             return tish_err("queryPrepared: expected (client, stmt, params)");
         };
         let params = match args.get(2) {
-            Some(TishValue::Array(a)) => a
-                .borrow()
-                .iter()
-                .map(tish_to_json)
-                .collect::<Vec<_>>(),
+            Some(TishValue::Array(a)) => a.borrow().iter().map(tish_to_json).collect::<Vec<_>>(),
             Some(TishValue::Null) | None => Vec::new(),
             Some(v) => vec![tish_to_json(v)],
         };
@@ -773,7 +760,10 @@ mod tish_sync {
         // produces. Fewer allocations + interned column-name `Arc`s.
         match block_on(client.query_prepared_to_values(&stmt, &params)) {
             Ok(rows) => TishValue::Array(VmRef::new(rows)),
-            Err(e) => tish_err(format!("queryPrepared: {}", crate::format_tish_pg_error(&e))),
+            Err(e) => tish_err(format!(
+                "queryPrepared: {}",
+                crate::format_tish_pg_error(&e)
+            )),
         }
     }
 
@@ -895,10 +885,8 @@ mod tish_sync {
             let rows = raw_client
                 .query("SELECT name FROM _tish_pg_migrations", &[])
                 .await?;
-            let already: std::collections::HashSet<String> = rows
-                .iter()
-                .map(|r| r.get::<_, String>(0))
-                .collect();
+            let already: std::collections::HashSet<String> =
+                rows.iter().map(|r| r.get::<_, String>(0)).collect();
 
             let mut applied_now: Vec<String> = Vec::new();
             for (name, path) in &files {
@@ -942,7 +930,7 @@ mod tish_sync {
         let mut om = ObjectMap::with_capacity(2);
         om.insert(Arc::from("ok"), TishValue::Bool(true));
         om.insert(Arc::from("applied"), TishValue::Array(VmRef::new(applied)));
-        TishValue::Object(VmRef::new(om))
+        TishValue::object(om)
     }
 }