koatl 0.1.15__tar.gz → 0.1.17__tar.gz

{koatl-0.1.15 → koatl-0.1.17}/Cargo.lock

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

{koatl-0.1.15 → koatl-0.1.17}/PKG-INFO

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

{koatl-0.1.15 → koatl-0.1.17}/koatl/Cargo.toml

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

{koatl-0.1.15 → koatl-0.1.17}/koatl/python/koatl/runtime/__init__.py

@@ -22,6 +22,7 @@ from .helpers import *
 
 
 __tl__ = SimpleNamespace(
+    Exception=Exception,
     slice=slice,
     vget=virtual.vget,
     vhas=virtual.vhas,

{koatl-0.1.15 → koatl-0.1.17}/koatl/tests/e2e/base/fstr.tl

@@ -11,9 +11,9 @@ fstr = f"x = {(y => y)(x)}"
 assert_eq(fstr, "x = 1")
 
 fstr = f"={
-    a = 1
-    b = 2
-    c = 3
+    let a = 1
+    let b = 2
+    let c = 3
     a * b * c
 }="
 assert_eq(fstr, "=6=")

{koatl-0.1.15 → koatl-0.1.17}/koatl/tests/e2e/base/match.tl

@@ -71,6 +71,19 @@ assert_eq(
 
 x = 1
 assert_eq([1, 2, 3] matches [1, 2, 3], True)
-assert_eq([1, 2, 3] matches [.x, y, 3], True)
+assert_eq([1, 2, 3] matches [.x, _, 3], True)
 
-assert_eq(try 1 matches 1, True)
+assert_eq(try 1 matches 1, True)
+
+f = () =>
+    if [1, 2, 3] matches [1, 2, x]:
+        assert_eq(x, 3)
+    else:
+        assert False
+
+    if [1, 2, 3] matches not [1, 2, x]:
+        raise
+    else:
+        assert_eq(x, 3)
+
+f()

koatl-0.1.17/koatl/tests/e2e/base/scopes.tl

@@ -0,0 +1,92 @@
+import util.assert_eq
+
+#-
+Note: many of the tests in this file are inside temporary functions;
+this is because the global scope is special in Python.
+-#
+
+
+
+# Scope variables shouldn't escape
+
+test = 1
+if True:
+    test = 2
+    assert_eq(test, 2)
+    let test = 3
+    assert_eq(test, 3)
+    test = 4
+    assert_eq(test, 4)
+assert_eq(test, 2)
+
+# Nested scopes should identify captures properly
+
+test = 1
+f = () =>
+    test = 2
+    let g = () =>
+        test = 3
+    g()
+    assert_eq(test, 3)
+f()
+assert_eq(test, 3)
+
+# ...but should also not leak variables
+
+test = 1
+f = () =>
+    test = 2
+    let g = () =>
+        let test = 3
+    g()
+    assert_eq(test, 2)
+f()
+assert_eq(test, 2)
+
+# Arguments should shadow all other variables
+
+test = 0
+f = test =>
+    test = 1
+    assert_eq(test, 1)
+f(1)
+assert_eq(test, 0)
+
+# Assignment lhs should be lifted into function body scope
+
+f = () =>
+    let g = 1
+    let g = () => g = 2
+    g()
+    assert_eq(g, 2)
+f()
+
+# Recursion should work
+
+a = () =>
+    let fib = n => n < 2 then 1 else fib(n - 1) + fib(n - 2)
+    assert_eq(fib(5), 8)
+a()
+
+# Classes should work
+
+f = () =>
+    let A = class:
+        B = 2
+
+        f = (self, x=B) =>
+            x
+
+    assert_eq(A.B, 2)
+    assert_eq(A().f(), 2)
+f()
+
+f = () =>
+    let A = class:
+        f = self =>
+            # this should now resolve to the class itself
+            A = 2
+
+    A().f()
+    assert_eq(A, 2)
+f()

koatl-0.1.17/koatl/tests/parse/block-comments.tl

@@ -0,0 +1 @@
+a = #- 81937 (*A&F(*& #- asdf -##( *&U*( -# 3

{koatl-0.1.15 → koatl-0.1.17}/koatl-core/parser/src/ast.rs

@@ -83,7 +83,7 @@ pub enum DeclType {
 pub enum Stmt<'a> {
     Module,
     Decl(Vec<SIdent<'a>>, DeclType),
-    Assign(SExpr<'a>, SExpr<'a>, Option<DeclType>),
+    Assign(Indirect<SExpr<'a>>, Indirect<SExpr<'a>>, Option<DeclType>),
     Expr(SExpr<'a>),
 
     Return(SExpr<'a>),

{koatl-0.1.15 → koatl-0.1.17}/koatl-core/parser/src/parser.rs

@@ -1203,7 +1203,7 @@ where
         nary_tuple.clone(),
         symbol("=").ignore_then(nary_tuple.clone()),
     ))
-    .map(|(decl, lhs, rhs)| Stmt::Assign(lhs, rhs, decl))
+    .map(|(decl, lhs, rhs)| Stmt::Assign(lhs.into(), rhs.into(), decl))
     .boxed();
 
     let inline_assign_stmt = group((
@@ -1211,7 +1211,7 @@ where
         expr.clone(),
         symbol("=").ignore_then(expr.clone()),
     ))
-    .map(|(decl, lhs, rhs)| Stmt::Assign(lhs, rhs, decl))
+    .map(|(decl, lhs, rhs)| Stmt::Assign(lhs.into(), rhs.into(), decl))
     .boxed();
 
     let expr_stmt = nary_tuple.clone().map(Stmt::Expr).boxed();

{koatl-0.1.15 → koatl-0.1.17}/koatl-core/parser/src/util.rs

@@ -21,17 +21,24 @@ impl AstBuilder {
         (Stmt::Expr(expr), self.span)
     }
 
-    pub fn assign<'src>(&self, target: SExpr<'src>, value: SExpr<'src>) -> SStmt<'src> {
-        (Stmt::Assign(target, value, None), self.span)
+    pub fn assign<'src>(
+        &self,
+        target: impl Into<Indirect<SExpr<'src>>>,
+        value: impl Into<Indirect<SExpr<'src>>>,
+    ) -> SStmt<'src> {
+        (Stmt::Assign(target.into(), value.into(), None), self.span)
     }
 
     pub fn assign_modified<'src>(
         &self,
-        target: SExpr<'src>,
-        value: SExpr<'src>,
+        target: impl Into<Indirect<SExpr<'src>>>,
+        value: impl Into<Indirect<SExpr<'src>>>,
         modifier: DeclType,
     ) -> SStmt<'src> {
-        (Stmt::Assign(target, value, Some(modifier)), self.span)
+        (
+            Stmt::Assign(target.into(), value.into(), Some(modifier)),
+            self.span,
+        )
     }
 
     pub fn return_<'src>(&self, expr: SExpr<'src>) -> SStmt<'src> {

{koatl-0.1.15 → koatl-0.1.17}/koatl-core/src/py/util.rs

@@ -233,6 +233,10 @@ impl PyAstBuilder {
         self.attribute(self.load_ident("__tl__"), name, PyAccessCtx::Load)
     }
 
+    pub fn py_builtin<'src>(&self, name: &'static str) -> SPyExpr<'src> {
+        self.attribute(self.load_ident("__builtins__"), name, PyAccessCtx::Load)
+    }
+
     pub fn subscript<'src>(
         &self,
         value: SPyExpr<'src>,