koatl 0.3.17__tar.gz → 0.3.18__tar.gz

{koatl-0.3.17 → koatl-0.3.18}/Cargo.lock

@@ -190,7 +190,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "koatl"
-version = "0.3.17"
+version = "0.3.18"
 dependencies = [
  "ariadne",
  "koatl-core",

{koatl-0.3.17 → koatl-0.3.18}/PKG-INFO

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

{koatl-0.3.17 → koatl-0.3.18}/koatl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "koatl"
-version = "0.3.17"
+version = "0.3.18"
 edition = "2021"
 homepage = "https://koatl.org"
 

{koatl-0.3.17 → koatl-0.3.18}/koatl/python/koatl/std/iter.tl

@@ -260,6 +260,12 @@ export Iterable = class(Traversable, Trait):
     list = self =>
         list(self.iter)
 
+    set = self =>
+        set(self.iter)
+
+    tuple = self =>
+        tuple(self.iter)
+
     dict = self =>
         dict(self.iter)
 

{koatl-0.3.17 → koatl-0.3.18}/koatl/tests/e2e/base/placeholder.tl

@@ -34,4 +34,8 @@ assert_eq(3 | f($), 6)
 
 assert_eq(3 | [$, 2, 3], [3, 2, 3])
 f = [$, 2, 3]
-assert_eq(f(3), [3, 2, 3])
+assert_eq(f(3), [3, 2, 3])
+
+# placeholder guard regression
+
+assert_eq({}.($.__or__({1: 2}).__or__({3: 4})), {1: 2, 3: 4})

{koatl-0.3.17 → koatl-0.3.18}/koatl-core/src/ast.rs

@@ -186,15 +186,16 @@ pub enum Expr<'a, TTree: Tree> {
     Call(TTree::Expr, Vec<CallItem<'a, TTree>>),
     Subscript(TTree::Expr, Vec<ListItem<TTree>>),
     RawAttribute(TTree::Expr, SIdent<'a>),
+    ScopedAttribute(TTree::Expr, TTree::Expr),
     Attribute(TTree::Expr, SIdent<'a>),
     MaybeAttribute(TTree::Expr, SIdent<'a>),
 
     MappedCall(TTree::Expr, Vec<CallItem<'a, TTree>>),
     MappedSubscript(TTree::Expr, Vec<ListItem<TTree>>),
     MappedRawAttribute(TTree::Expr, SIdent<'a>),
+    MappedScopedAttribute(TTree::Expr, TTree::Expr),
     MappedAttribute(TTree::Expr, SIdent<'a>),
     MappedMaybeAttribute(TTree::Expr, SIdent<'a>),
-    CallNullable(TTree::Expr, TTree::Expr),
 
     Try(TTree::Expr, Vec<MatchCase<TTree>>, Option<TTree::Expr>),
     Checked(TTree::Expr, Option<TTree::Pattern>),

{koatl-0.3.17 → koatl-0.3.18}/koatl-core/src/inference.rs

@@ -235,7 +235,7 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for Indirect<SExpr<'src>> {
                 expr.traverse(ctx);
                 Type::Any
             }
-            Expr::CallNullable(expr, func) => {
+            Expr::ScopedAttribute(expr, func) | Expr::MappedScopedAttribute(expr, func) => {
                 expr.traverse(ctx);
                 func.traverse(ctx);
                 Type::Any

{koatl-0.3.17 → koatl-0.3.18}/koatl-core/src/lift_cst.rs

@@ -379,11 +379,9 @@ impl<'src, 'tok> Lift<Indirect<ast::SExpr<'src>>> for cst::SExpr<'src, 'tok> {
                 ..
             } => {
                 if question.is_some() {
-                    ast::Expr::CallNullable(expr.lift(), rhs.lift())
+                    ast::Expr::MappedScopedAttribute(expr.lift(), rhs.lift())
                 } else {
-                    let func = rhs.lift();
-                    let arg = ast::CallItem::Arg(expr.lift());
-                    ast::Expr::Call(func, vec![arg])
+                    ast::Expr::ScopedAttribute(expr.lift(), rhs.lift())
                 }
             }
             cst::Expr::Decorated {

{koatl-0.3.17 → koatl-0.3.18}/koatl-core/src/resolve_scopes.rs

@@ -1442,14 +1442,14 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                 return traversed;
             }
-            Expr::Call(a, items) => {
-                Expr::Call(a.traverse_guarded(state), traverse_call_items(state, items))
+            Expr::ScopedAttribute(expr, value) => {
+                Expr::ScopedAttribute(expr.traverse(state), value.traverse_guarded(state))
             }
-            Expr::CallNullable(expr, value) => {
+            Expr::MappedScopedAttribute(expr, value) => {
                 let (rhs, fn_ctx) =
                     with_phantom_fninfo(state, span, |state| value.traverse_guarded(state));
 
-                let traversed = Expr::CallNullable(expr.traverse(state), rhs)
+                let traversed = Expr::MappedScopedAttribute(expr.traverse(state), rhs)
                     .spanned(span)
                     .indirect();
 
@@ -1459,6 +1459,9 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                 return traversed;
             }
+            Expr::Call(a, items) => {
+                Expr::Call(a.traverse(state), traverse_call_items(state, items))
+            }
             Expr::MappedCall(a, call_items) => {
                 let (rhs, fn_ctx) = with_phantom_fninfo(state, span, |state| {
                     traverse_call_items(state, call_items)

{koatl-0.3.17 → koatl-0.3.18}/koatl-core/src/transform.rs

@@ -1425,11 +1425,13 @@ fn transform_postfix_expr<'src, 'ast>(
         Expr::RawAttribute(obj, _) => (false, obj),
         Expr::Subscript(obj, _) => (false, obj),
         Expr::Call(obj, _) => (false, obj),
+        Expr::ScopedAttribute(obj, _) => (false, obj),
         Expr::Attribute(obj, _) => (false, obj),
         Expr::MaybeAttribute(obj, _) => (false, obj),
         Expr::MappedRawAttribute(obj, _) => (true, obj),
         Expr::MappedSubscript(obj, _) => (true, obj),
         Expr::MappedCall(obj, _) => (true, obj),
+        Expr::MappedScopedAttribute(obj, _) => (true, obj),
         Expr::MappedAttribute(obj, _) => (true, obj),
         Expr::MappedMaybeAttribute(obj, _) => (true, obj),
         _ => {
@@ -1460,6 +1462,10 @@ fn transform_postfix_expr<'src, 'ast>(
                 let t = inner_pre.bind(transform_subscript_items(ctx, &list, &expr.span)?);
                 a.subscript(lhs, t, access_ctx)
             }
+            Expr::ScopedAttribute(_, rhs) | Expr::MappedScopedAttribute(_, rhs) => {
+                let t = inner_pre.bind(rhs.transform(ctx)?);
+                a.call(t, vec![PyCallItem::Arg(lhs)])
+            }
             Expr::RawAttribute(_, attr) | Expr::MappedRawAttribute(_, attr) => {
                 a.attribute(lhs, attr.value.escape(), access_ctx)
             }
@@ -2025,30 +2031,14 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
             | Expr::MappedCall(..)
             | Expr::Subscript(..)
             | Expr::MappedSubscript(..)
+            | Expr::ScopedAttribute(..)
+            | Expr::MappedScopedAttribute(..)
             | Expr::Attribute(..)
             | Expr::MappedAttribute(..)
             | Expr::MaybeAttribute(..)
             | Expr::MappedMaybeAttribute(..) => {
                 pre.bind(transform_postfix_expr(ctx, self, access_ctx)?)
             }
-            Expr::CallNullable(obj, func) => {
-                let a = PyAstBuilder::new(span);
-                let obj_transformed = pre.bind(obj.transform(ctx)?);
-                let func_transformed = pre.bind(func.transform(ctx)?);
-
-                let maparg = ctx.create_aux_var("maparg", span.start);
-
-                a.call(
-                    a.tl_builtin("op_map"),
-                    vec![
-                        a.call_arg(obj_transformed),
-                        a.call_arg(a.lambda(
-                            PyArgList::simple_args(vec![(maparg.clone().into(), None)]),
-                            a.call(func_transformed, vec![a.call_arg(a.load_ident(maparg))]),
-                        )),
-                    ],
-                )
-            }
             Expr::With(pattern, value, body) => {
                 let temp_var = ctx.create_aux_var("with", span.start);
                 let value = pre.bind(value.transform(ctx)?);

{koatl-0.3.17 → koatl-0.3.18}/python/koatl/std/iter.tl

@@ -260,6 +260,12 @@ export Iterable = class(Traversable, Trait):
     list = self =>
         list(self.iter)
 
+    set = self =>
+        set(self.iter)
+
+    tuple = self =>
+        tuple(self.iter)
+
     dict = self =>
         dict(self.iter)