koatl 0.3.9__tar.gz → 0.3.11__tar.gz

{koatl-0.3.9 → koatl-0.3.11}/Cargo.lock

@@ -190,7 +190,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "koatl"
-version = "0.3.9"
+version = "0.3.11"
 dependencies = [
  "ariadne",
  "koatl-core",
@@ -248,7 +248,7 @@ dependencies = [
 
 [[package]]
 name = "ohtli"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "anyhow",
  "clap",

{koatl-0.3.9 → koatl-0.3.11}/PKG-INFO

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

{koatl-0.3.9 → koatl-0.3.11}/koatl/Cargo.toml

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

{koatl-0.3.9 → koatl-0.3.11}/koatl/src/emit_py.rs

@@ -110,41 +110,65 @@ impl<'src> PyBlockExt<'src> for PyBlock<'src> {
 trait PyArgDefExt<'src> {
     fn emit_py<'py>(&self, ctx: &PyCtx<'py, 'src>) -> PyTlResult<PyObject>;
 }
-impl<'src> PyArgDefExt<'src> for Vec<PyArgDefItem<'src>> {
+impl<'src> PyArgDefExt<'src> for PyArgList<'src> {
     fn emit_py<'py>(&self, ctx: &PyCtx<'py, 'src>) -> PyTlResult<PyObject> {
+        let mut py_posonlyargs = Vec::new();
         let mut py_args = Vec::new();
+        let mut py_kwonlyargs = Vec::new();
         let mut py_defaults = Vec::new();
+        let mut py_kw_defaults = Vec::new();
         let mut vararg = None;
         let mut kwarg = None;
 
-        for arg in self {
-            match arg {
-                PyArgDefItem::Arg(arg_name, default) => {
-                    let arg_ast = ctx.ast_cls("arg", (arg_name.as_ref(), ctx.py.None()))?;
-                    py_args.push(arg_ast);
-                    if let Some(default_expr) = default {
-                        py_defaults.push(default_expr.emit_py(ctx)?);
-                    }
-                }
-                PyArgDefItem::ArgSpread(arg_name) => {
-                    vararg = Some(ctx.ast_cls("arg", (arg_name.as_ref(), ctx.py.None()))?);
-                }
-                PyArgDefItem::KwargSpread(arg_name) => {
-                    kwarg = Some(ctx.ast_cls("arg", (arg_name.as_ref(), ctx.py.None()))?);
-                }
+        // Process position-only arguments
+        for (arg_name, default) in &self.posonlyargs {
+            let arg_ast = ctx.ast_cls("arg", (arg_name.as_ref(), ctx.py.None()))?;
+            py_posonlyargs.push(arg_ast);
+            if let Some(default_expr) = default {
+                py_defaults.push(default_expr.emit_py(ctx)?);
+            }
+        }
+
+        // Process regular arguments
+        for (arg_name, default) in &self.args {
+            let arg_ast = ctx.ast_cls("arg", (arg_name.as_ref(), ctx.py.None()))?;
+            py_args.push(arg_ast);
+            if let Some(default_expr) = default {
+                py_defaults.push(default_expr.emit_py(ctx)?);
             }
         }
 
+        // Process *args
+        if let Some(arg_name) = &self.vararg {
+            vararg = Some(ctx.ast_cls("arg", (arg_name.as_ref(), ctx.py.None()))?);
+        }
+
+        // Process keyword-only arguments
+        for (arg_name, default) in &self.kwonlyargs {
+            let arg_ast = ctx.ast_cls("arg", (arg_name.as_ref(), ctx.py.None()))?;
+            py_kwonlyargs.push(arg_ast);
+            if let Some(default_expr) = default {
+                py_kw_defaults.push(default_expr.emit_py(ctx)?);
+            } else {
+                py_kw_defaults.push(ctx.py.None());
+            }
+        }
+
+        // Process **kwargs
+        if let Some(arg_name) = &self.kwarg {
+            kwarg = Some(ctx.ast_cls("arg", (arg_name.as_ref(), ctx.py.None()))?);
+        }
+
         ctx.ast_cls(
             "arguments",
             (
-                Vec::<PyObject>::new(), // posonlyargs
-                py_args,                // args
-                vararg,                 // vararg
-                Vec::<PyObject>::new(), // kwonlyargs
-                Vec::<PyObject>::new(), // kw_defaults
-                kwarg,                  // kwarg
-                py_defaults,            // defaults
+                py_posonlyargs, // posonlyargs
+                py_args,        // args
+                vararg,         // vararg
+                py_kwonlyargs,  // kwonlyargs
+                py_kw_defaults, // kw_defaults
+                kwarg,          // kwarg
+                py_defaults,    // defaults
             ),
         )
     }

koatl-0.3.11/koatl/tests/e2e/base/arguments.tl

@@ -0,0 +1,41 @@
+import util.assert_eq
+
+# Test *args with keyword-only default argument
+let fn = (*args, default=2) => args + (default,)
+
+assert_eq(fn(1, 3), (1, 3, 2))
+
+# Test regular arg with default and *args
+fn = (a, b=2, *args) => (a, b) + args
+
+assert_eq(fn(1, 3, 4, 5), (1, 3, 4, 5))
+assert_eq(fn(1), (1, 2))
+fn = (a, /, b, *, c=5) => (a, b, c)
+
+assert_eq(fn(1, 2), (1, 2, 5))
+assert_eq(fn(1, 2, c=10), (1, 2, 10))
+fn = (a, b=3, /, c=4) => (a, b, c)
+
+assert_eq(fn(1), (1, 3, 4))
+assert_eq(fn(1, 2), (1, 2, 4))
+assert_eq(fn(1, 2, 5), (1, 2, 5))
+fn = (a, b, *, c, d=10) => (a, b, c, d)
+
+assert_eq(fn(1, 2, c=3), (1, 2, 3, 10))
+assert_eq(fn(1, 2, c=3, d=4), (1, 2, 3, 4))
+
+# Test **kwargs
+fn = (a, **kwargs) => (a, kwargs)
+
+assert_eq(fn(1), (1, {}))
+assert_eq(fn(1, b=2, c=3), (1, {"b": 2, "c": 3}))
+fn = (a, b, /, c, *args, d, e=5, **kwargs) => (a, b, c, args, d, e, kwargs)
+
+assert_eq(fn(1, 2, 3, d=4), (1, 2, 3, (), 4, 5, {}))
+assert_eq(fn(1, 2, 3, 4, 5, d=6, e=7, f=8), (1, 2, 3, (4, 5), 6, 7, {"f": 8}))
+fn = (a, b, c, /) => (a, b, c)
+
+assert_eq(fn(1, 2, 3), (1, 2, 3))
+fn = (*, a, b) => (a, b)
+
+assert_eq(fn(a=1, b=2), (1, 2))

koatl-0.3.11/koatl/tests/fail-parse/arguments_mixed_defaults.tl

@@ -0,0 +1 @@
+let a = (b=3, c, default=2, *a) => None

koatl-0.3.11/koatl/tests/fail-parse/arguments_multiple_kwargs.tl

@@ -0,0 +1 @@
+let a = (**a, **b) => None

koatl-0.3.11/koatl/tests/fail-parse/arguments_multiple_kwonly_markers.tl

@@ -0,0 +1 @@
+let a = (*, *, default=2) => None

koatl-0.3.11/koatl/tests/fail-parse/arguments_multiple_posonly_markers.tl

@@ -0,0 +1 @@
+let a = (a, /, b, /, c) => None

koatl-0.3.11/koatl/tests/fail-parse/arguments_multiple_varargs.tl

@@ -0,0 +1 @@
+let a = (*a, *b) => None

koatl-0.3.11/koatl/tests/fail-parse/arguments_posonly_after_kwonly.tl

@@ -0,0 +1 @@
+let a = (a, *, /, default=2) => None

koatl-0.3.11/koatl/tests/fail-parse/arguments_vararg_and_kwonly_marker.tl

@@ -0,0 +1 @@
+let a = (*a, *, default=2) => None

koatl-0.3.11/koatl/tests/parse/mutual-recursion.tl

@@ -0,0 +1,2 @@
+let a = () => b()
+let b = () => a()

koatl-0.3.11/koatl/tests/test_parse_fail.py

@@ -0,0 +1,26 @@
+import pytest
+import koatl.cli
+from pathlib import Path
+
+
+def get_test_data():
+    data_dirs = [
+        Path(__file__).parent / "fail-parse",
+    ]
+
+    test_cases = []
+    for data_dir in data_dirs:
+        for file_path in data_dir.glob("*.tl"):
+            test_cases.append(pytest.param(file_path, id=str(file_path)))
+
+    return test_cases
+
+
+@pytest.mark.parametrize("test_file", get_test_data())
+def test_parse(test_file):
+    try:
+        koatl.cli.transpile_from_path(test_file, mode="script")
+    except:
+        return
+
+    raise AssertionError("Expected parse to fail but it succeeded.")

{koatl-0.3.9 → koatl-0.3.11}/koatl-core/src/ast.rs

@@ -138,6 +138,8 @@ pub enum ArgDefItem<'a, TTree: Tree> {
     Arg(TTree::Pattern, Option<TTree::Expr>),
     ArgSpread(SIdent<'a>),
     KwargSpread(SIdent<'a>),
+    PosOnlyMarker,
+    KwOnlyMarker,
 }
 
 #[derive(Debug, Clone)]

{koatl-0.3.9 → koatl-0.3.11}/koatl-core/src/lift_cst.rs

@@ -555,6 +555,8 @@ impl<'src, 'tok> Lift<ast::ArgDefItem<'src, ast::STree<'src>>>
             cst::ArgDefItem::KwargSpread { name, .. } => {
                 ast::ArgDefItem::KwargSpread(name.lift_as_ident())
             }
+            cst::ArgDefItem::PosOnlyMarker { .. } => ast::ArgDefItem::PosOnlyMarker,
+            cst::ArgDefItem::KwOnlyMarker { .. } => ast::ArgDefItem::KwOnlyMarker,
         }
     }
 }

{koatl-0.3.9 → koatl-0.3.11}/koatl-core/src/py/ast.rs

@@ -47,7 +47,7 @@ impl<'a> PyDecorators<'a> {
 #[derive(Debug, Clone)]
 pub struct PyFnDef<'a> {
     pub name: PyToken<'a>,
-    pub args: Vec<PyArgDefItem<'a>>,
+    pub args: PyArgList<'a>,
     pub body: PyBlock<'a>,
     pub decorators: PyDecorators<'a>,
     pub async_: bool,
@@ -188,10 +188,39 @@ pub enum PyCallItem<'a> {
 }
 
 #[derive(Debug, Clone)]
-pub enum PyArgDefItem<'a> {
-    Arg(PyToken<'a>, Option<SPyExpr<'a>>),
-    ArgSpread(PyToken<'a>),
-    KwargSpread(PyToken<'a>),
+pub struct PyArgList<'a> {
+    /// Position-only arguments (before `/` marker)
+    pub posonlyargs: Vec<(PyToken<'a>, Option<SPyExpr<'a>>)>,
+    /// Regular positional or keyword arguments
+    pub args: Vec<(PyToken<'a>, Option<SPyExpr<'a>>)>,
+    /// Variadic positional argument (*args)
+    pub vararg: Option<PyToken<'a>>,
+    /// Keyword-only arguments (after `*` or `*args`)
+    pub kwonlyargs: Vec<(PyToken<'a>, Option<SPyExpr<'a>>)>,
+    /// Variadic keyword argument (**kwargs)
+    pub kwarg: Option<PyToken<'a>>,
+}
+
+impl<'a> PyArgList<'a> {
+    pub fn empty() -> Self {
+        PyArgList {
+            posonlyargs: vec![],
+            args: vec![],
+            vararg: None,
+            kwonlyargs: vec![],
+            kwarg: None,
+        }
+    }
+
+    pub fn simple_args(args: Vec<(PyToken<'a>, Option<SPyExpr<'a>>)>) -> Self {
+        PyArgList {
+            posonlyargs: vec![],
+            args,
+            vararg: None,
+            kwonlyargs: vec![],
+            kwarg: None,
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -225,7 +254,7 @@ pub enum PyExpr<'a> {
     Subscript(Box<SPyExpr<'a>>, Box<SPyExpr<'a>>, PyAccessCtx),
 
     IfExpr(Box<SPyExpr<'a>>, Box<SPyExpr<'a>>, Box<SPyExpr<'a>>),
-    Lambda(Vec<PyArgDefItem<'a>>, Box<SPyExpr<'a>>),
+    Lambda(PyArgList<'a>, Box<SPyExpr<'a>>),
 
     List(Vec<PyListItem<'a>>, PyAccessCtx),
     Tuple(Vec<PyListItem<'a>>, PyAccessCtx),

{koatl-0.3.9 → koatl-0.3.11}/koatl-core/src/py/ast_builder.rs

@@ -69,7 +69,7 @@ impl PyAstBuilder {
     pub fn fn_def<'src>(
         &self,
         name: impl Into<PyToken<'src>>,
-        args: Vec<PyArgDefItem<'src>>,
+        args: PyArgList<'src>,
         body: PyBlock<'src>,
         async_: bool,
     ) -> SPyStmt<'src> {
@@ -305,11 +305,7 @@ impl PyAstBuilder {
         (PyExpr::YieldFrom(Box::new(value)), self.span).into()
     }
 
-    pub fn lambda<'src>(
-        &self,
-        args: Vec<PyArgDefItem<'src>>,
-        body: SPyExpr<'src>,
-    ) -> SPyExpr<'src> {
+    pub fn lambda<'src>(&self, args: PyArgList<'src>, body: SPyExpr<'src>) -> SPyExpr<'src> {
         (PyExpr::Lambda(args, Box::new(body)), self.span).into()
     }
 
@@ -334,23 +330,6 @@ impl PyAstBuilder {
         PyCallItem::KwargSpread(expr)
     }
 
-    // Utility builders for argument definitions
-    pub fn arg_def<'src>(
-        &self,
-        name: impl Into<PyToken<'src>>,
-        default: Option<SPyExpr<'src>>,
-    ) -> PyArgDefItem<'src> {
-        PyArgDefItem::Arg(name.into(), default)
-    }
-
-    pub fn arg_def_spread<'src>(&self, name: impl Into<PyToken<'src>>) -> PyArgDefItem<'src> {
-        PyArgDefItem::ArgSpread(name.into())
-    }
-
-    pub fn kwarg_def_spread<'src>(&self, name: impl Into<PyToken<'src>>) -> PyArgDefItem<'src> {
-        PyArgDefItem::KwargSpread(name.into())
-    }
-
     // Utility builders for tuple items
     pub fn list_item<'src>(&self, expr: SPyExpr<'src>) -> PyListItem<'src> {
         PyListItem::Item(expr)

{koatl-0.3.9 → koatl-0.3.11}/koatl-core/src/py/emit.rs

@@ -105,26 +105,85 @@ impl PyCallItem<'_> {
     }
 }
 
-impl PyArgDefItem<'_> {
+impl PyArgList<'_> {
     fn emit_to(&mut self, ctx: &mut EmitCtx) -> TlResult<()> {
-        match self {
-            PyArgDefItem::Arg(name, default) => {
-                if let Some(default) = default {
-                    ctx.emit(name);
-                    ctx.emit("=");
-                    default.emit_to(ctx, LOW_PREC)?;
-                } else {
-                    ctx.emit(name);
-                }
+        let mut first = true;
+
+        // Emit position-only arguments
+        for (name, default) in &mut self.posonlyargs {
+            if !first {
+                ctx.emit(", ");
+            }
+            first = false;
+
+            ctx.emit(name);
+            if let Some(default) = default {
+                ctx.emit("=");
+                default.emit_to(ctx, LOW_PREC)?;
+            }
+        }
+
+        // Emit position-only marker if there are position-only args
+        if !self.posonlyargs.is_empty() {
+            if !first {
+                ctx.emit(", ");
+            }
+            first = false;
+            ctx.emit("/");
+        }
+
+        // Emit regular args
+        for (name, default) in &mut self.args {
+            if !first {
+                ctx.emit(", ");
+            }
+            first = false;
+
+            ctx.emit(name);
+            if let Some(default) = default {
+                ctx.emit("=");
+                default.emit_to(ctx, LOW_PREC)?;
+            }
+        }
+
+        // Emit *args
+        if let Some(vararg) = &self.vararg {
+            if !first {
+                ctx.emit(", ");
+            }
+            first = false;
+            ctx.emit(&format!("*{}", vararg));
+        } else if !self.kwonlyargs.is_empty() {
+            // If there are keyword-only args but no *args, emit bare *
+            if !first {
+                ctx.emit(", ");
             }
-            PyArgDefItem::ArgSpread(name) => {
-                ctx.emit(&format!("*{}", name));
+            first = false;
+            ctx.emit("*");
+        }
+
+        // Emit keyword-only args
+        for (name, default) in &mut self.kwonlyargs {
+            if !first {
+                ctx.emit(", ");
             }
-            PyArgDefItem::KwargSpread(name) => {
-                ctx.emit(&format!("**{}", name));
+            first = false;
+
+            ctx.emit(name);
+            if let Some(default) = default {
+                ctx.emit("=");
+                default.emit_to(ctx, LOW_PREC)?;
             }
         }
 
+        // Emit **kwargs
+        if let Some(kwarg) = &self.kwarg {
+            if !first {
+                ctx.emit(", ");
+            }
+            ctx.emit(&format!("**{}", kwarg));
+        }
+
         Ok(())
     }
 }
@@ -546,13 +605,7 @@ impl SPyExpr<'_> {
             }
             PyExpr::Lambda(args, body) => {
                 ctx.emit("(lambda ");
-                ctx.emit("");
-                for (i, arg) in args.iter_mut().enumerate() {
-                    if i > 0 {
-                        ctx.emit(", ");
-                    }
-                    arg.emit_to(ctx)?;
-                }
+                args.emit_to(ctx)?;
                 ctx.emit(": ");
                 body.emit_to(ctx, HIGH_PREC)?;
                 ctx.emit(")");
@@ -779,12 +832,7 @@ impl SPyStmt<'_> {
                 ctx.emit("def ");
                 ctx.emit(&name);
                 ctx.emit("(");
-                for (i, arg) in args.iter_mut().enumerate() {
-                    if i > 0 {
-                        ctx.emit(", ");
-                    }
-                    arg.emit_to(ctx)?;
-                }
+                args.emit_to(ctx)?;
                 ctx.emit("):");
                 ctx.emit_endl();
                 body.emit_to(ctx, 1)?;

{koatl-0.3.9 → koatl-0.3.11}/koatl-core/src/resolve_scopes.rs

@@ -180,6 +180,8 @@ impl<'src> ResolveState<'src> {
                 DeclType::Let,
             );
 
+            self.declarations[decl].is_implicit_global = true;
+
             self.scopes[self.root_scope].locals.push(decl.clone());
 
             return Ok(decl);
@@ -329,16 +331,20 @@ impl<'src> ResolveState<'src> {
             DeclType::Let | DeclType::Const => {
                 if class || global {
                     if let Some(found) = self.scope_stack.find_decl(self, &name) {
-                        self.errors.extend(
-                            TlErrBuilder::new()
-                                .message("Cannot shadow declarations in a class or global scope")
-                                .span(name.span)
-                                .context(
-                                    "Previous declaration here",
-                                    self.declarations[found.decl].loc,
-                                )
-                                .build(),
-                        );
+                        if !self.declarations[found.decl].is_implicit_global {
+                            self.errors.extend(
+                                TlErrBuilder::new()
+                                    .message(
+                                        "Cannot shadow declarations in a class or global scope",
+                                    )
+                                    .span(name.span)
+                                    .context(
+                                        "Previous declaration here",
+                                        self.declarations[found.decl].loc,
+                                    )
+                                    .build(),
+                            );
+                        }
                     }
                 }
             }
@@ -469,6 +475,7 @@ pub struct Declaration<'src> {
     pub loc: Span,
     pub typ: Type,
 
+    pub is_implicit_global: bool,
     pub is_fn_arg: bool,
     pub is_exported: bool,
     pub is_const: bool,
@@ -498,8 +505,9 @@ impl<'src> DeclSlotMapExt<'src> for SlotMap<DeclarationKey, Declaration<'src>> {
             scope,
             loc: name.span,
             typ: Type::Unprocessed,
-            is_fn_arg: false,
 
+            is_implicit_global: false,
+            is_fn_arg: false,
             is_const: matches!(modifier, DeclType::Const),
             is_exported: matches!(modifier, DeclType::Export),
             is_import: false,
@@ -1282,6 +1290,8 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                             ArgDefItem::KwargSpread(arg)
                         }
+                        ArgDefItem::PosOnlyMarker => ArgDefItem::PosOnlyMarker,
+                        ArgDefItem::KwOnlyMarker => ArgDefItem::KwOnlyMarker,
                     })
                     .collect::<Vec<_>>();
 
@@ -1675,7 +1685,7 @@ impl<'src> SStmtExt<'src> for Indirect<SStmt<'src>> {
                         .collect::<Vec<_>>()
                         .join(".");
 
-                    let full_module = ".".repeat(tree.level) + &base_module;
+                    let full_module = ".".repeat(level) + &base_module;
 
                     match &tree.leaf.value {
                         ImportLeaf::Multi(branches) => {