Destructuring (RG-4b): live in declarations, snapshots in let

compiler/src/ast.rs

@@ -90,6 +90,8 @@ pub enum ExprKind {
     /// RG-7b
     Use(String),
     Spread(Box<Expr>),
+    /// RG-4b: an object rest, `{ a, ...rest } = e` (the parser's own; Solid's `omit`)
+    Omit { e: Box<Expr>, keys: Vec<String> },
     /// R-f-3
     Throw(Box<Expr>),
     /// R-f-4: `e catch (x: A | B) => alt`; classes absent: every failure
@@ -422,6 +424,7 @@ impl Expr {
             ExprKind::Draft { .. } => "draft",
             ExprKind::Use(_) => "use",
             ExprKind::Spread(_) => "spread",
+            ExprKind::Omit { .. } => "omit",
             ExprKind::Throw(_) => "throw",
             ExprKind::Catch { .. } => "catch",
             ExprKind::StyleMap { .. } => "stylemap",
@@ -439,6 +442,7 @@ impl Expr {
             ExprKind::Un { op, e } => obj(vec![("k", k), ("op", s(op)), ("e", b(e))]),
             ExprKind::Pre { name, init } => obj(vec![("k", k), ("name", s(name)), ("init", ob(init))]),
             ExprKind::Peek(e) | ExprKind::Latest(e) | ExprKind::Pending(e) | ExprKind::Spread(e) | ExprKind::Throw(e) => obj(vec![("k", k), ("e", b(e))]),
+            ExprKind::Omit { e, keys } => obj(vec![("k", k), ("e", b(e)), ("keys", Some(strs(keys)))]),
             ExprKind::Await { e, init, stream } => obj(vec![("k", k), ("e", b(e)), ("init", ob(init)), ("stream", Some(Value::Bool(*stream)))]),
             ExprKind::If { c, t, f } => obj(vec![("k", k), ("c", b(c)), ("t", b(t)), ("f", b(f))]),
             ExprKind::Tpl(parts) => obj(vec![

compiler/src/check.rs

@@ -353,7 +353,7 @@ pub(crate) fn children<'a>(n: Node<'a>, paths: bool) -> Vec<Node<'a>> {
         Node::E(e) => match &e.k {
             ExprKind::Lit(_) | ExprKind::Id(_) | ExprKind::Use(_) | ExprKind::StyleMap { .. } => {}
             ExprKind::Bin { l, r, .. } => out.extend([Node::E(l), Node::E(r)]),
-            ExprKind::Un { e, .. } | ExprKind::Peek(e) | ExprKind::Latest(e) | ExprKind::Pending(e) | ExprKind::Spread(e) | ExprKind::Throw(e) => out.push(Node::E(e)),
+            ExprKind::Un { e, .. } | ExprKind::Peek(e) | ExprKind::Latest(e) | ExprKind::Pending(e) | ExprKind::Spread(e) | ExprKind::Omit { e, .. } | ExprKind::Throw(e) => out.push(Node::E(e)),
             ExprKind::Pre { init, .. } => out.extend(init.iter().map(|x| Node::E(x))),
             ExprKind::Await { e, init, .. } => {
                 out.push(Node::E(e));
@@ -438,7 +438,7 @@ fn free_names(e: &Expr, bound: &HashSet<String>, out: &mut IndexSet<String>) {
                 go(i, out);
             }
         }
-        ExprKind::Latest(x) | ExprKind::Pending(x) | ExprKind::Un { e: x, .. } | ExprKind::Spread(x) => go(x, out),
+        ExprKind::Latest(x) | ExprKind::Pending(x) | ExprKind::Un { e: x, .. } | ExprKind::Spread(x) | ExprKind::Omit { e: x, .. } => go(x, out),
         ExprKind::Bin { l, r, .. } => {
             go(l, out);
             go(r, out);
@@ -2051,7 +2051,7 @@ impl<'a> Checker<'a> {
                 self.expr(x, env, ctx, None);
                 self.model.probe = save;
             }
-            ExprKind::Un { e: x, .. } | ExprKind::Spread(x) => self.expr(x, env, ctx, None),
+            ExprKind::Un { e: x, .. } | ExprKind::Spread(x) | ExprKind::Omit { e: x, .. } => self.expr(x, env, ctx, None),
             ExprKind::Await { e: inner, init, .. } => {
                 if ctx.imperative && !self.stmt_awaits.contains(&(e as *const Expr)) {
                     let sh = show(e);

compiler/src/emit.rs

@@ -1178,6 +1178,8 @@ impl<'p> Gen<'p> {
                 rtc("preOr", vec![call(id(p), vec![]), thunk(i)])
             }
             ExprKind::Peek(x) => rtc("untrack", vec![thunk(self.expr(x, env, &sub)?)]),
+            // RG-4b: Solid's live view
+            ExprKind::Omit { e: x, keys } => rtc("omit", std::iter::once(self.expr(x, env, &sub)).chain(keys.iter().map(|k| Ok(str(k.clone())))).collect::<Result<Vec<_>, _>>()?),
             ExprKind::Await { e: x, stream, .. } => {
                 if let Some(v) = self.hoisted.get(&(e as *const Expr)) {
                     return Ok(call(id(v.clone()), vec![]));

compiler/src/infer.rs

@@ -271,7 +271,7 @@ impl Walker {
                 self.read(l, st, sh, local, depth);
                 self.read(r, st, sh, local, depth);
             }
-            ExprKind::Un { e, .. } | ExprKind::Spread(e) | ExprKind::Throw(e) => self.read(e, st, sh, local, depth),
+            ExprKind::Un { e, .. } | ExprKind::Spread(e) | ExprKind::Omit { e, .. } | ExprKind::Throw(e) => self.read(e, st, sh, local, depth),
             ExprKind::Await { e, init, .. } => {
                 self.read(e, st, sh, local, depth);
                 if let Some(i) = init {
@@ -362,7 +362,7 @@ impl Walker {
                 self.deps(l, st, sh, out);
                 self.deps(r, st, sh, out);
             }
-            ExprKind::Un { e, .. } | ExprKind::Spread(e) | ExprKind::Throw(e) => self.deps(e, st, sh, out),
+            ExprKind::Un { e, .. } | ExprKind::Spread(e) | ExprKind::Omit { e, .. } | ExprKind::Throw(e) => self.deps(e, st, sh, out),
             ExprKind::If { c, t, f } => {
                 self.deps(c, st, sh, out);
                 self.deps(t, st, sh, out);