koatl 0.1.12__tar.gz → 0.1.13__tar.gz

{koatl-0.1.12 → koatl-0.1.13}/Cargo.lock

@@ -99,7 +99,7 @@ checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "koatl"
-version = "0.1.12"
+version = "0.1.13"
 dependencies = [
  "ariadne",
  "koatl-core",

{koatl-0.1.12 → koatl-0.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koatl
-Version: 0.1.12
+Version: 0.1.13
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{koatl-0.1.12 → koatl-0.1.13}/koatl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "koatl"
-version = "0.1.12"
+version = "0.1.13"
 edition = "2021"
 
 [lib]

{koatl-0.1.12 → koatl-0.1.13}/koatl/tests/e2e/base/coal.tl

@@ -12,7 +12,7 @@ obj = (class:
 assert_eq((x => x)?(1), 1)
 assert_eq([1]?[0], 1)
 assert_eq(obj?.a, 1)
-assert_eq(1?.($ + 1), 2)
+assert_eq(1?.($ + 1)(), 2)
 
 assert_eq(None ?? 1, 1)
 assert_eq(int(5) ?? 1, 5)
@@ -26,5 +26,5 @@ assert_eq(type(try [0][5]), IndexError)
 assert_eq(try 5, 5)
 
 
-assert_eq((try 5)?.($+1), 6)
-assert_eq(type((try x)?.($+1)), NameError)
+assert_eq((try 5)?.($+1)?(), 6)
+assert_eq(type((try x)?.($+1)?()), NameError)

koatl-0.1.13/koatl/tests/e2e/base/placeholder.tl

@@ -0,0 +1,37 @@
+import util.assert_eq
+
+# basic usage
+
+call_with_five = f => f(5)
+
+assert_eq(call_with_five($ + 1), 6)
+
+res = call_with_five($)
+assert_eq(callable(res), True)
+
+assert_eq(callable([1, 2, $]), True)
+
+
+# weird cases
+
+assert_eq((x => x)($ + 1)(1), 2)
+
+assert_eq(1
+    | $ + 1
+    | $ * 2
+    | $ * 5, 20)
+
+f = $ + 1
+
+assert_eq(f(2), 3)
+
+f = x => x * 2
+g = f($)
+
+assert_eq(g(3), 6)
+
+assert_eq(3 | f($), 6)
+
+assert_eq(3 | [$, 2, 3], [3, 2, 3])
+f = [$, 2, 3]
+assert_eq(f(3), [3, 2, 3])

{koatl-0.1.12 → koatl-0.1.13}/koatl-core/parser/src/ast.rs

@@ -174,15 +174,15 @@ pub enum Expr<'a> {
 
     Call(Box<SExpr<'a>>, Vec<SCallItem<'a>>),
     Subscript(Box<SExpr<'a>>, Vec<ListItem<'a>>),
+    RawAttribute(Box<SExpr<'a>>, SIdent<'a>),
+    ScopedAttribute(Box<SExpr<'a>>, Box<SExpr<'a>>),
     Attribute(Box<SExpr<'a>>, SIdent<'a>),
-    ScopedExtension(Box<SExpr<'a>>, Box<SExpr<'a>>),
-    Extension(Box<SExpr<'a>>, SIdent<'a>),
 
     MappedCall(Box<SExpr<'a>>, Vec<SCallItem<'a>>),
     MappedSubscript(Box<SExpr<'a>>, Vec<ListItem<'a>>),
+    MappedRawAttribute(Box<SExpr<'a>>, SIdent<'a>),
+    MappedScopedAttribute(Box<SExpr<'a>>, Box<SExpr<'a>>),
     MappedAttribute(Box<SExpr<'a>>, SIdent<'a>),
-    MappedThen(Box<SExpr<'a>>, Box<SExpr<'a>>),
-    MappedExtension(Box<SExpr<'a>>, SIdent<'a>),
 
     Checked(Box<SExpr<'a>>, Option<Box<SPattern<'a>>>),
 

{koatl-0.1.12 → koatl-0.1.13}/koatl-core/parser/src/parser.rs

@@ -121,7 +121,7 @@ where
         .or_not()
         .then(qualified_ident.clone())
         .try_map(|(q, value), _e| {
-            Ok(if let Expr::Attribute(..) = value.0 {
+            Ok(if let Expr::RawAttribute(..) = value.0 {
                 Pattern::Value(value)
             } else if q.is_some() {
                 Pattern::Value(value)
@@ -588,7 +588,7 @@ where
         .clone()
         .foldl_with(
             symbol(".").ignore_then(ident.clone()).repeated(),
-            |lhs, rhs, e| (Expr::Attribute(Box::new(lhs), rhs), e.span()),
+            |lhs, rhs, e| (Expr::RawAttribute(Box::new(lhs), rhs), e.span()),
         )
         .boxed();
 
@@ -687,10 +687,10 @@ where
     enum Postfix<'a> {
         Call(Vec<SCallItem<'a>>),
         Subscript(Vec<ListItem<'a>>),
-        Extension(SIdent<'a>),
-        Then(SExpr<'a>),
-        ThenCall(SExpr<'a>, Vec<SCallItem<'a>>),
         Attribute(SIdent<'a>),
+        ScopedAttribute(SExpr<'a>),
+        ScopedAttributeCall(SExpr<'a>, Vec<SCallItem<'a>>),
+        RawAttribute(SIdent<'a>),
     }
 
     let call_args = enumeration(
@@ -735,7 +735,7 @@ where
 
     let attribute = symbol(".")
         .ignore_then(ident.clone())
-        .map(Postfix::Extension)
+        .map(Postfix::Attribute)
         .labelled("extension-attribute");
 
     let then = symbol(".")
@@ -743,9 +743,9 @@ where
         .then(call_args.or_not())
         .map(|(rhs, args)| {
             if let Some(args) = args {
-                Postfix::ThenCall(rhs, args)
+                Postfix::ScopedAttributeCall(rhs, args)
             } else {
-                Postfix::Then(rhs)
+                Postfix::ScopedAttribute(rhs)
             }
         })
         .labelled("then-attribute")
@@ -753,8 +753,8 @@ where
 
     let extension = symbol("!")
         .ignore_then(ident.clone())
-        .map(Postfix::Attribute)
-        .labelled("native-attribute")
+        .map(Postfix::RawAttribute)
+        .labelled("raw-attribute")
         .boxed();
 
     let postfix = atom
@@ -771,34 +771,38 @@ where
                         match op {
                             Postfix::Call(args) => Expr::Call(Box::new(expr), args),
                             Postfix::Subscript(args) => Expr::Subscript(Box::new(expr), args),
-                            Postfix::Attribute(attr) => Expr::Attribute(Box::new(expr), attr),
-                            Postfix::Then(rhs) => {
-                                Expr::ScopedExtension(Box::new(expr), Box::new(rhs))
+                            Postfix::RawAttribute(attr) => Expr::RawAttribute(Box::new(expr), attr),
+                            Postfix::ScopedAttribute(rhs) => {
+                                Expr::ScopedAttribute(Box::new(expr), Box::new(rhs))
                             }
-                            Postfix::ThenCall(rhs, args) => Expr::Call(
+                            Postfix::ScopedAttributeCall(rhs, args) => Expr::Call(
                                 // TODO optimize this case in the AST by skipping partial application
                                 Box::new((
-                                    Expr::ScopedExtension(Box::new(expr), Box::new(rhs)),
+                                    Expr::ScopedAttribute(Box::new(expr), Box::new(rhs)),
                                     e.span(),
                                 )),
                                 args,
                             ),
-                            Postfix::Extension(rhs) => Expr::Extension(Box::new(expr), rhs),
+                            Postfix::Attribute(rhs) => Expr::Attribute(Box::new(expr), rhs),
                         }
                     } else {
                         match op {
                             Postfix::Call(args) => Expr::MappedCall(Box::new(expr), args),
                             Postfix::Subscript(args) => Expr::MappedSubscript(Box::new(expr), args),
-                            Postfix::Attribute(attr) => Expr::MappedAttribute(Box::new(expr), attr),
-                            Postfix::Then(rhs) => Expr::MappedThen(Box::new(expr), Box::new(rhs)),
-                            Postfix::ThenCall(rhs, args) => Expr::Call(
+                            Postfix::RawAttribute(attr) => {
+                                Expr::MappedRawAttribute(Box::new(expr), attr)
+                            }
+                            Postfix::ScopedAttribute(rhs) => {
+                                Expr::MappedScopedAttribute(Box::new(expr), Box::new(rhs))
+                            }
+                            Postfix::ScopedAttributeCall(rhs, args) => Expr::Call(
                                 Box::new((
-                                    Expr::MappedThen(Box::new(expr), Box::new(rhs)),
+                                    Expr::MappedScopedAttribute(Box::new(expr), Box::new(rhs)),
                                     e.span(),
                                 )),
                                 args,
                             ),
-                            Postfix::Extension(rhs) => Expr::MappedExtension(Box::new(expr), rhs),
+                            Postfix::Attribute(rhs) => Expr::MappedAttribute(Box::new(expr), rhs),
                         }
                     },
                     e.span(),

{koatl-0.1.12 → koatl-0.1.13}/koatl-core/parser/src/util.rs

@@ -147,14 +147,14 @@ impl AstBuilder {
         attr: impl Into<Cow<'src, str>>,
     ) -> SExpr<'src> {
         (
-            Expr::Attribute(Box::new(value), (attr.into(), self.span)),
+            Expr::RawAttribute(Box::new(value), (attr.into(), self.span)),
             self.span,
         )
     }
 
     pub fn then<'src>(&self, left: SExpr<'src>, right: SExpr<'src>) -> SExpr<'src> {
         (
-            Expr::ScopedExtension(Box::new(left), Box::new(right)),
+            Expr::ScopedAttribute(Box::new(left), Box::new(right)),
             self.span,
         )
     }

{koatl-0.1.12 → koatl-0.1.13}/koatl-core/src/transform.rs

@@ -505,13 +505,13 @@ fn destructure<'src, 'ast>(
     let assign_to: SPyExpr<'src>;
 
     match &target.0 {
-        Expr::Ident(..) | Expr::Attribute(..) | Expr::Extension(..) | Expr::Subscript(..) => {
+        Expr::Ident(..) | Expr::RawAttribute(..) | Expr::Attribute(..) | Expr::Subscript(..) => {
             let target_node = match &target.0 {
                 Expr::Ident(id) => {
                     decls.push(ctx.escape_ident(&id.0));
                     target.transform_with_access(ctx, PyAccessCtx::Store)?
                 }
-                Expr::Attribute(..) | Expr::Subscript(..) => {
+                Expr::RawAttribute(..) | Expr::Subscript(..) => {
                     if decl_only {
                         return Err(TfErrBuilder::default()
                             .message("Only identifiers allowed in this destructuring")
@@ -520,7 +520,7 @@ fn destructure<'src, 'ast>(
                     }
                     target.transform_with_access(ctx, PyAccessCtx::Store)?
                 }
-                Expr::Extension(lhs, ext) => {
+                Expr::Attribute(lhs, ext) => {
                     if decl_only {
                         return Err(TfErrBuilder::default()
                             .message("Only identifiers allowed in this destructuring")
@@ -532,7 +532,7 @@ fn destructure<'src, 'ast>(
                     // when assigning to it
 
                     // TODO avoid this clone
-                    let new_target = (Expr::Attribute(lhs.clone(), ext.clone()), target.1);
+                    let new_target = (Expr::RawAttribute(lhs.clone(), ext.clone()), target.1);
 
                     new_target.transform_with_access(ctx, PyAccessCtx::Store)?
                 }
@@ -1282,7 +1282,7 @@ fn transform_match_expr<'src, 'ast>(
     fill_default_case: bool,
     span: &Span,
 ) -> TfResult<(SPyExprWithPre<'src>, bool)> {
-    let subject = subject.transform_with_placeholder_guard(ctx)?;
+    let subject = subject.transform(ctx)?;
     let mut pre = subject.pre;
     let a = PyAstBuilder::new(*span);
 
@@ -1321,10 +1321,7 @@ fn transform_match_expr<'src, 'ast>(
         };
 
         let guard = if let Some(guard) = &case.guard {
-            Some(bind_pre(
-                &mut pre,
-                guard.transform_with_placeholder_guard(ctx)?,
-            ))
+            Some(bind_pre(&mut pre, guard.transform(ctx)?))
         } else {
             None
         };
@@ -1669,7 +1666,7 @@ fn transform_subscript_items<'src, 'ast>(
     };
 
     let subscript_expr = if let Some(single_item) = single_item {
-        let e = single_item.transform_with_deep_placeholder_guard(ctx)?;
+        let e = single_item.transform(ctx)?;
         aux_stmts.extend(e.pre);
         e.value
     } else {
@@ -1679,12 +1676,12 @@ fn transform_subscript_items<'src, 'ast>(
                     .into_iter()
                     .map(|i| match i {
                         ListItem::Item(expr) => {
-                            let e = expr.transform_with_deep_placeholder_guard(ctx)?;
+                            let e = expr.transform(ctx)?;
                             aux_stmts.extend(e.pre);
                             Ok(PyListItem::Item(e.value))
                         }
                         ListItem::Spread(expr) => {
-                            let e = expr.transform_with_deep_placeholder_guard(ctx)?;
+                            let e = expr.transform(ctx)?;
                             aux_stmts.extend(e.pre);
                             Ok(PyListItem::Spread(e.value))
                         }
@@ -1860,16 +1857,16 @@ fn transform_postfix_expr<'src, 'ast>(
 ) -> TfResult<SPyExprWithPre<'src>> {
     let mut aux = PyBlock::new();
     let (lift_lhs, lhs_node) = match &expr.0 {
-        Expr::Attribute(obj, _) => (false, obj),
+        Expr::RawAttribute(obj, _) => (false, obj),
         Expr::Subscript(obj, _) => (false, obj),
         Expr::Call(obj, _) => (false, obj),
-        Expr::ScopedExtension(obj, _) => (false, obj),
-        Expr::Extension(obj, _) => (false, obj),
-        Expr::MappedAttribute(obj, _) => (true, obj),
+        Expr::ScopedAttribute(obj, _) => (false, obj),
+        Expr::Attribute(obj, _) => (false, obj),
+        Expr::MappedRawAttribute(obj, _) => (true, obj),
         Expr::MappedSubscript(obj, _) => (true, obj),
         Expr::MappedCall(obj, _) => (true, obj),
-        Expr::MappedThen(obj, _) => (true, obj),
-        Expr::MappedExtension(obj, _) => (true, obj),
+        Expr::MappedScopedAttribute(obj, _) => (true, obj),
+        Expr::MappedAttribute(obj, _) => (true, obj),
         _ => {
             return Err(TfErrBuilder::default()
                 .message("Internal error: Postfix expressions can only be attributes, subscripts, calls, or extensions")
@@ -1895,81 +1892,85 @@ fn transform_postfix_expr<'src, 'ast>(
         t.value
     };
 
-    placeholder_guard(ctx, &expr.1, |ctx| {
-        let a = PyAstBuilder::new(expr.1);
+    let a = PyAstBuilder::new(expr.1);
 
-        let guard_if_expr = |expr| {
-            a.if_expr(
-                a.call(a.tl_builtin("ok"), vec![a.call_arg(lhs.clone())]),
-                expr,
-                lhs.clone(),
-            )
-        };
+    let guard_if_expr = |expr| {
+        a.if_expr(
+            a.call(a.tl_builtin("ok"), vec![a.call_arg(lhs.clone())]),
+            expr,
+            lhs.clone(),
+        )
+    };
 
-        let node = match &expr.0 {
-            Expr::Call(_, list) => {
-                let t = transform_call_items(ctx, &list, &expr.1)?;
-                aux.extend(t.0);
-                a.call(lhs, t.1)
-            }
-            Expr::MappedCall(_, list) => {
-                let t = transform_call_items(ctx, &list, &expr.1)?;
-                aux.extend(t.0);
-                guard_if_expr(a.call(lhs.clone(), t.1))
-            }
-            Expr::Subscript(_, list) => {
-                let t = transform_subscript_items(ctx, &list, &expr.1)?;
-                aux.extend(t.0);
-                a.subscript(lhs, t.1, access_ctx)
-            }
-            Expr::MappedSubscript(_, list) => {
-                let t = transform_subscript_items(ctx, &list, &expr.1)?;
-                aux.extend(t.0);
-                guard_if_expr(a.subscript(lhs.clone(), t.1, access_ctx))
-            }
-            Expr::Attribute(_, attr) => a.attribute(lhs, ctx.escape_ident(&attr.0), access_ctx),
-            Expr::MappedAttribute(_, attr) => {
-                guard_if_expr(a.attribute(lhs.clone(), ctx.escape_ident(&attr.0), access_ctx))
-            }
-            Expr::ScopedExtension(_, rhs) => {
-                let rhs_node = rhs.transform_with_placeholder_guard(ctx)?;
-                aux.extend(rhs_node.pre);
-                a.call(
-                    a.tl_builtin("partial"),
-                    vec![PyCallItem::Arg(rhs_node.value), PyCallItem::Arg(lhs)],
-                )
-            }
-            Expr::MappedThen(_, rhs) => {
-                let rhs_node = rhs.transform_with_placeholder_guard(ctx)?;
-                aux.extend(rhs_node.pre);
-                guard_if_expr(a.call(rhs_node.value, vec![PyCallItem::Arg(lhs.clone())]))
-            }
-            Expr::Extension(_, rhs) => a.call(
-                a.tl_builtin("vget"),
-                vec![
-                    a.call_arg(lhs),
-                    a.call_arg(a.literal(PyLiteral::Str(ctx.escape_ident(&rhs.0)))),
-                ],
-            ),
-            Expr::MappedExtension(_, rhs) => guard_if_expr(a.call(
-                a.tl_builtin("vget"),
+    let node = match &expr.0 {
+        Expr::Call(_, list) => {
+            let t = transform_call_items(ctx, &list, &expr.1)?;
+            aux.extend(t.0);
+            a.call(lhs, t.1)
+        }
+        Expr::MappedCall(_, list) => {
+            let t = transform_call_items(ctx, &list, &expr.1)?;
+            aux.extend(t.0);
+            guard_if_expr(a.call(lhs.clone(), t.1))
+        }
+        Expr::Subscript(_, list) => {
+            let t = transform_subscript_items(ctx, &list, &expr.1)?;
+            aux.extend(t.0);
+            a.subscript(lhs, t.1, access_ctx)
+        }
+        Expr::MappedSubscript(_, list) => {
+            let t = transform_subscript_items(ctx, &list, &expr.1)?;
+            aux.extend(t.0);
+            guard_if_expr(a.subscript(lhs.clone(), t.1, access_ctx))
+        }
+        Expr::RawAttribute(_, attr) => a.attribute(lhs, ctx.escape_ident(&attr.0), access_ctx),
+        Expr::MappedRawAttribute(_, attr) => {
+            guard_if_expr(a.attribute(lhs.clone(), ctx.escape_ident(&attr.0), access_ctx))
+        }
+        Expr::ScopedAttribute(_, rhs) => {
+            let rhs_node = rhs.transform_with_placeholder_guard(ctx)?;
+            aux.extend(rhs_node.pre);
+            a.call(
+                a.tl_builtin("partial"),
+                vec![PyCallItem::Arg(rhs_node.value), PyCallItem::Arg(lhs)],
+            )
+        }
+        Expr::MappedScopedAttribute(_, rhs) => {
+            let rhs_node = rhs.transform_with_placeholder_guard(ctx)?;
+            aux.extend(rhs_node.pre);
+            guard_if_expr(a.call(
+                a.tl_builtin("partial"),
                 vec![
-                    a.call_arg(lhs.clone()),
-                    a.call_arg(a.literal(PyLiteral::Str(ctx.escape_ident(&rhs.0)))),
+                    PyCallItem::Arg(rhs_node.value),
+                    PyCallItem::Arg(lhs.clone()),
                 ],
-            )),
-            _ => {
-                return Err(TfErrBuilder::default()
+            ))
+        }
+        Expr::Attribute(_, rhs) => a.call(
+            a.tl_builtin("vget"),
+            vec![
+                a.call_arg(lhs),
+                a.call_arg(a.literal(PyLiteral::Str(ctx.escape_ident(&rhs.0)))),
+            ],
+        ),
+        Expr::MappedAttribute(_, rhs) => guard_if_expr(a.call(
+            a.tl_builtin("vget"),
+            vec![
+                a.call_arg(lhs.clone()),
+                a.call_arg(a.literal(PyLiteral::Str(ctx.escape_ident(&rhs.0)))),
+            ],
+        )),
+        _ => {
+            return Err(TfErrBuilder::default()
                 .message("Internal error: Postfix expressions can only be attributes, subscripts, calls, or extensions")
                 .span(expr.1)
                 .build_errs());
-            }
-        };
+        }
+    };
 
-        Ok(SPyExprWithPre {
-            value: node,
-            pre: aux,
-        })
+    Ok(SPyExprWithPre {
+        value: node,
+        pre: aux,
     })
 }
 
@@ -2064,8 +2065,8 @@ impl<'src> ListItemsExt<'src> for Vec<ListItem<'src>> {
 
         for expr in self {
             let e = match expr {
-                ListItem::Spread(expr) => expr.transform_with_deep_placeholder_guard(ctx)?,
-                ListItem::Item(expr) => expr.transform_with_deep_placeholder_guard(ctx)?,
+                ListItem::Spread(expr) => expr.transform(ctx)?,
+                ListItem::Item(expr) => expr.transform(ctx)?,
             };
             aux_stmts.extend(e.pre);
             items.push(match expr {
@@ -2203,7 +2204,7 @@ impl<'src> SExprExt<'src> for SExpr<'src> {
         let a = PyAstBuilder::new(*span);
 
         match &expr {
-            Expr::Attribute(..) | Expr::Subscript(..) | Expr::Ident(..) => {}
+            Expr::RawAttribute(..) | Expr::Subscript(..) | Expr::Ident(..) => {}
             _ => {
                 if access_ctx != PyAccessCtx::Load {
                     return Err(TfErrBuilder::default()
@@ -2309,16 +2310,16 @@ impl<'src> SExprExt<'src> for SExpr<'src> {
                 value: (PyExpr::Ident(ctx.escape_ident(&ident.0), access_ctx), *span).into(),
                 pre: PyBlock::new(),
             }),
-            Expr::Attribute(..)
-            | Expr::MappedAttribute(..)
+            Expr::RawAttribute(..)
+            | Expr::MappedRawAttribute(..)
             | Expr::Call(..)
             | Expr::MappedCall(..)
             | Expr::Subscript(..)
             | Expr::MappedSubscript(..)
-            | Expr::ScopedExtension(..)
-            | Expr::MappedThen(..)
-            | Expr::Extension(..)
-            | Expr::MappedExtension(..) => transform_postfix_expr(ctx, self, access_ctx),
+            | Expr::ScopedAttribute(..)
+            | Expr::MappedScopedAttribute(..)
+            | Expr::Attribute(..)
+            | Expr::MappedAttribute(..) => transform_postfix_expr(ctx, self, access_ctx),
             Expr::If(cond, then_block, else_block) => transform_if_expr(
                 ctx,
                 cond,
@@ -2507,127 +2508,116 @@ impl<'src> SExprExt<'src> for SExpr<'src> {
                 });
             }
             Expr::List(exprs) => {
-                return placeholder_guard(ctx, span, |ctx| {
-                    let (items, aux_stmts) = exprs.transform(ctx)?;
+                let (items, aux_stmts) = exprs.transform(ctx)?;
 
-                    return Ok(SPyExprWithPre {
-                        value: (PyExpr::List(items, PyAccessCtx::Load), *span).into(),
-                        pre: aux_stmts,
-                    });
+                return Ok(SPyExprWithPre {
+                    value: (PyExpr::List(items, PyAccessCtx::Load), *span).into(),
+                    pre: aux_stmts,
                 });
             }
             Expr::Tuple(exprs) => {
-                return placeholder_guard(ctx, span, |ctx| {
-                    let (items, aux_stmts) = exprs.transform(ctx)?;
+                let (items, aux_stmts) = exprs.transform(ctx)?;
 
-                    return Ok(SPyExprWithPre {
-                        value: (PyExpr::Tuple(items, PyAccessCtx::Load), *span).into(),
-                        pre: aux_stmts,
-                    });
+                return Ok(SPyExprWithPre {
+                    value: (PyExpr::Tuple(items, PyAccessCtx::Load), *span).into(),
+                    pre: aux_stmts,
                 });
             }
             Expr::Mapping(items) => {
-                return placeholder_guard(ctx, span, |ctx| {
-                    let mut aux_stmts = PyBlock::new();
-                    let mut dict_items = vec![];
-
-                    for item in items {
-                        match item {
-                            MappingItem::Ident(id) => {
-                                dict_items.push(PyDictItem::Item(
-                                    a.literal(PyLiteral::Str(ctx.escape_ident(&id.0))),
-                                    a.load_ident(ctx.escape_ident(&id.0)),
-                                ));
-                            }
-                            MappingItem::Item(key, value) => {
-                                let key = key.transform_with_deep_placeholder_guard(ctx)?;
-                                let value = value.transform_with_deep_placeholder_guard(ctx)?;
+                let mut aux_stmts = PyBlock::new();
+                let mut dict_items = vec![];
 
-                                aux_stmts.extend(key.pre);
-                                aux_stmts.extend(value.pre);
+                for item in items {
+                    match item {
+                        MappingItem::Ident(id) => {
+                            dict_items.push(PyDictItem::Item(
+                                a.literal(PyLiteral::Str(ctx.escape_ident(&id.0))),
+                                a.load_ident(ctx.escape_ident(&id.0)),
+                            ));
+                        }
+                        MappingItem::Item(key, value) => {
+                            let key = key.transform(ctx)?;
+                            let value = value.transform(ctx)?;
 
-                                dict_items.push(PyDictItem::Item(key.value, value.value));
-                            }
-                            MappingItem::Spread(expr) => {
-                                let e = expr.transform_with_deep_placeholder_guard(ctx)?;
-                                aux_stmts.extend(e.pre);
+                            aux_stmts.extend(key.pre);
+                            aux_stmts.extend(value.pre);
 
-                                dict_items.push(PyDictItem::Spread(e.value));
-                            }
+                            dict_items.push(PyDictItem::Item(key.value, value.value));
+                        }
+                        MappingItem::Spread(expr) => {
+                            let e = expr.transform(ctx)?;
+                            aux_stmts.extend(e.pre);
+
+                            dict_items.push(PyDictItem::Spread(e.value));
                         }
                     }
+                }
 
-                    return Ok(SPyExprWithPre {
-                        value: a.call(a.load_ident("Record"), vec![a.call_arg(a.dict(dict_items))]),
-                        pre: aux_stmts,
-                    });
+                return Ok(SPyExprWithPre {
+                    value: a.call(a.load_ident("Record"), vec![a.call_arg(a.dict(dict_items))]),
+                    pre: aux_stmts,
                 });
             }
             Expr::Slice(start, end, step) => {
-                return placeholder_guard(ctx, span, |ctx| {
-                    let start_node = start
-                        .as_ref()
-                        .map(|e| e.as_ref().transform_with_deep_placeholder_guard(ctx))
-                        .transpose()?;
-                    let end_node = end
-                        .as_ref()
-                        .map(|e| e.as_ref().transform_with_deep_placeholder_guard(ctx))
-                        .transpose()?;
-                    let step_node = step
-                        .as_ref()
-                        .map(|e| e.as_ref().transform_with_deep_placeholder_guard(ctx))
-                        .transpose()?;
-
-                    let mut aux_stmts = PyBlock::new();
-
-                    let mut get = |x: Option<SPyExprWithPre<'src>>| {
-                        let expr = if let Some(x) = x {
-                            aux_stmts.extend(x.pre);
-                            x.value
-                        } else {
-                            (PyExpr::Literal(PyLiteral::None), *span).into()
-                        };
+                let start_node = start
+                    .as_ref()
+                    .map(|e| e.as_ref().transform(ctx))
+                    .transpose()?;
+                let end_node = end
+                    .as_ref()
+                    .map(|e| e.as_ref().transform(ctx))
+                    .transpose()?;
+                let step_node = step
+                    .as_ref()
+                    .map(|e| e.as_ref().transform(ctx))
+                    .transpose()?;
+
+                let mut aux_stmts = PyBlock::new();
 
-                        PyCallItem::Arg(expr)
+                let mut get = |x: Option<SPyExprWithPre<'src>>| {
+                    let expr = if let Some(x) = x {
+                        aux_stmts.extend(x.pre);
+                        x.value
+                    } else {
+                        (PyExpr::Literal(PyLiteral::None), *span).into()
                     };
 
-                    return Ok(SPyExprWithPre {
-                        value: (
-                            PyExpr::Call(
-                                Box::new(
-                                    (PyExpr::Ident("slice".into(), PyAccessCtx::Load), *span)
-                                        .into(),
-                                ),
-                                vec![get(start_node), get(end_node), get(step_node)],
+                    PyCallItem::Arg(expr)
+                };
+
+                return Ok(SPyExprWithPre {
+                    value: (
+                        PyExpr::Call(
+                            Box::new(
+                                (PyExpr::Ident("slice".into(), PyAccessCtx::Load), *span).into(),
                             ),
-                            *span,
-                        )
-                            .into(),
-                        pre: aux_stmts,
-                    });
+                            vec![get(start_node), get(end_node), get(step_node)],
+                        ),
+                        *span,
+                    )
+                        .into(),
+                    pre: aux_stmts,
                 });
             }
             Expr::Fstr(begin, parts) => {
-                return placeholder_guard(ctx, span, |ctx| {
-                    let mut aux_stmts = PyBlock::new();
-                    let mut nodes = Vec::new();
+                let mut aux_stmts = PyBlock::new();
+                let mut nodes = Vec::new();
 
-                    nodes.push(PyFstrPart::Str(begin.0.clone().into()));
+                nodes.push(PyFstrPart::Str(begin.0.clone().into()));
 
-                    for (fmt_expr, str_part) in parts {
-                        // TODO format specifiers?
-                        let block_node = fmt_expr.0.block.transform(ctx)?;
-                        aux_stmts.extend(block_node.pre);
+                for (fmt_expr, str_part) in parts {
+                    // TODO format specifiers?
+                    let block_node = fmt_expr.0.block.transform(ctx)?;
+                    aux_stmts.extend(block_node.pre);
 
-                        nodes.push(PyFstrPart::Expr(block_node.value, None));
-                        nodes.push(PyFstrPart::Str(str_part.0.clone().into()));
-                    }
+                    nodes.push(PyFstrPart::Expr(block_node.value, None));
+                    nodes.push(PyFstrPart::Str(str_part.0.clone().into()));
+                }
 
-                    let expr = (PyExpr::Fstr(nodes), *span).into();
-                    return Ok(SPyExprWithPre {
-                        value: expr,
-                        pre: aux_stmts,
-                    });
+                let expr = (PyExpr::Fstr(nodes), *span).into();
+                return Ok(SPyExprWithPre {
+                    value: expr,
+                    pre: aux_stmts,
                 });
             }
         }

koatl-0.1.12/koatl/tests/e2e/base/placeholder.tl

@@ -1,23 +0,0 @@
-import util.assert_eq
-
-assert_eq((x => x)($)(1), 1)
-
-assert_eq(1
-    | $ + 1
-    | $ * 2
-    | $ * 5, 20)
-
-f = $ + 1
-
-assert_eq(f(2), 3)
-
-f = x => x * 2
-g = f($)
-
-assert_eq(g(3), 6)
-
-assert_eq(3 | f($), 6)
-assert_eq(f($)(3), 6)
-
-assert_eq(3 | [$, 2, 3], [3, 2, 3])
-assert_eq([$, 2, 3](3), [3, 2, 3])