koatl 0.3.19__tar.gz → 0.4.0__tar.gz

{koatl-0.3.19 → koatl-0.4.0}/Cargo.lock

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

{koatl-0.3.19 → koatl-0.4.0}/PKG-INFO

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

{koatl-0.3.19 → koatl-0.4.0}/koatl/Cargo.toml

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

{koatl-0.3.19 → koatl-0.4.0}/koatl/python/koatl/runtime/__init__.py

@@ -1,5 +1,6 @@
 import functools
 import importlib
+import builtins
 from types import SimpleNamespace
 
 from koatl.runtime.record import Record
@@ -33,6 +34,13 @@ def set_exports(package_name, globals_dict, exports, module_star_exports):
     globals_dict["__all__"] = tuple(set(globals_dict["__all__"]) | exports)
 
 
+def redirect_locals(locals_name_map, py_locals_dict):
+    new_locals = {}
+    for tl_name, py_name in locals_name_map.items():
+        new_locals[tl_name] = py_locals_dict[py_name]
+    return new_locals
+
+
 __tl__ = SimpleNamespace(
     Exception=Exception,
     slice=slice,
@@ -42,6 +50,8 @@ __tl__ = SimpleNamespace(
     record_literal=Record.from_dict_ref,
     #
     set_exports=set_exports,
+    redirect_locals=redirect_locals,
+    builtins=builtins,
     #
     vget=vget,
     vhas=vhas,

{koatl-0.3.19 → koatl-0.4.0}/koatl/src/emit_py.rs

@@ -708,11 +708,17 @@ impl<'src> PyExprExt<'src> for SPyExpr<'src> {
                         PyFstrPart::Str(s) => {
                             values.push(ctx.ast_node("Constant", (s.as_ref(),), &self.tl_span)?);
                         }
-                        PyFstrPart::Expr(expr, _format_spec) => {
+                        PyFstrPart::Expr(expr, format_spec) => {
                             let expr_ast = expr.emit_py(ctx)?;
+                            let format_spec_ast = if let Some(spec) = format_spec {
+                                spec.emit_py(ctx)?
+                            } else {
+                                ctx.py.None()
+                            };
+
                             values.push(ctx.ast_node(
                                 "FormattedValue",
-                                (expr_ast, -1, ctx.py.None()),
+                                (expr_ast, -1, format_spec_ast),
                                 &self.tl_span,
                             )?);
                         }

koatl-0.4.0/koatl/tests/e2e/base/elif.tl

@@ -0,0 +1,92 @@
+import util.assert_eq
+
+# Test basic elif
+x = 2
+let result
+if x == 1:
+    result = "one"
+elif x == 2:
+    result = "two"
+else:
+    result = "other"
+assert_eq(result, "two")
+
+# Test multiple elif clauses
+score = 75
+let grade = if score >= 90:
+    "A"
+elif score >= 80:
+    "B"
+elif score >= 70:
+    "C"
+elif score >= 60:
+    "D"
+else:
+    "F"
+assert_eq(grade, "C")
+
+# Test elif without else
+value = 5
+output = "default"
+if value < 0:
+    output = "negative"
+elif value == 0:
+    output = "zero"
+elif value > 0:
+    output = "positive"
+assert_eq(output, "positive")
+
+# Test elif with expressions
+a, b = 10, 20
+let relation
+if a > b:
+    relation = "greater"
+elif a < b:
+    relation = "less"
+elif a == b:
+    relation = "equal"
+assert_eq(relation, "less")
+
+# Test nested if with elif
+outer_val = 2
+inner_val = 3
+let result2
+if outer_val == 1:
+    result2 = "outer1"
+elif outer_val == 2:
+    if inner_val == 1:
+        result2 = "inner1"
+    elif inner_val == 2:
+        result2 = "inner2"
+    elif inner_val == 3:
+        result2 = "inner3"
+    else:
+        result2 = "inner_else"
+else:
+    result2 = "outer_else"
+assert_eq(result2, "inner3")
+
+# Test elif in expression context (as part of block expression)
+num = 15
+msg = if num < 10:
+    "small"
+elif num < 20:
+    "medium"
+else:
+    "large"
+assert_eq(msg, "medium")
+
+# Test elif with complex conditions
+x, y = 5, 11
+let result3
+if x > 10 and y > 10:
+    result3 = "both large"
+elif x > 10 or y > 10:
+    result3 = "one large"
+elif x == y:
+    result3 = "equal"
+else:
+    result3 = "both small"
+assert_eq(result3, "one large")
+
+print("All elif tests passed!")

koatl-0.4.0/koatl/tests/e2e/base/fstr.tl

@@ -0,0 +1,51 @@
+import util.assert_eq
+
+assert_eq(f"{1}", "1")
+
+x = 1
+
+fstr = f"x = {x + 1}"
+assert_eq(fstr, "x = 2")
+
+fstr = f"x = {(y => y)(x)}"
+assert_eq(fstr, "x = 1")
+
+fstr = f"={(
+    let a = 1
+    let b = 2
+    let c = 3
+    a * b * c
+)}="
+assert_eq(fstr, "=6=")
+
+assert_eq(f"{{}}", "{}")
+assert_eq(f"{{{1}}}", "{1}")
+
+assert_eq(f"""
+
+{{1}}
+{2 * 5}""", "\n\n{1}\n10")
+
+# Test format specifiers
+num = 42
+assert_eq(f"{num%d}", "42")
+assert_eq(f"{num%05d}", "00042")
+assert_eq(f"{num%>5d}", "   42")
+assert_eq(f"{num%<5d}", "42   ")
+assert_eq(f"{num%^5d}", " 42  ")
+
+pi = 3.14159
+assert_eq(f"{pi%.2f}", "3.14")
+assert_eq(f"{pi%.4f}", "3.1416")
+
+hex_num = 255
+assert_eq(f"{hex_num%x}", "ff")
+assert_eq(f"{hex_num%X}", "FF")
+assert_eq(f"{hex_num%#x}", "0xff")
+
+# Test multiple format specs in one string
+assert_eq(f"{num%05d} and {pi%.2f}", "00042 and 3.14")
+
+# Test format spec with expressions
+assert_eq(f"{1 + 1%d}", "2")
+assert_eq(f"{(10 * 5)%03d}", "050")

koatl-0.4.0/koatl/tests/e2e/base/locals.tl

@@ -0,0 +1,68 @@
+import util.assert_eq
+
+# Test __locals__ in function scope with let declarations
+test_function_locals = () =>
+    let y = 1
+    let z = 2
+    assert_eq(__locals__, {y: 1, z: 2})
+
+test_function_locals()
+
+# Test __locals__ in nested function
+test_nested = () =>
+    let outer = 1
+    let inner = () =>
+        let inner_var = 2
+        assert_eq(__locals__, {inner_var: 2})
+    inner()
+
+test_nested()
+
+# Test __locals__ with function arguments (not mangled)
+test_with_args = (arg1, arg2) =>
+    let local = 100
+    assert_eq(__locals__, {local: 100, arg1: arg1, arg2: arg2})
+
+test_with_args(10, 20)
+
+# Test __captures__ in nested function
+test_nested_captures = () =>
+    let outer_var = 1
+    let another_outer = 2
+    let inner = () =>
+        let inner_var = 3
+        outer_var, another_outer
+
+        # Should capture outer_var and another_outer but not inner_var
+        assert_eq(__captures__, {assert_eq, inner, outer_var, another_outer})
+    inner()
+
+test_nested_captures()
+
+# Test __captures__ with multiple nesting levels
+test_deep_nesting = () =>
+    let level1 = 1
+    let middle = () =>
+        let level2 = 2
+        let inner = () =>
+            let level3 = 3
+            # Should capture level1 and level2 but not level3
+            assert_eq(__captures__, {assert_eq, inner, middle, level1, level2})
+        inner()
+    middle()
+
+test_deep_nesting()
+
+test_no_captures = () =>
+    assert_eq(__captures__, {test_no_captures, assert_eq})
+
+test_no_captures()
+
+# Test __captures__ with function arguments in outer scope
+test_args_captured = (arg1, arg2) =>
+    let local_outer = 100
+    let inner = () =>
+        assert_eq(__captures__, {assert_eq, inner, arg1, arg2, local_outer})
+    inner()
+
+test_args_captured(10, 20)

{koatl-0.3.19 → koatl-0.4.0}/koatl-core/src/ast.rs

@@ -74,7 +74,7 @@ pub enum ImportLeaf<'a> {
 #[derive(Debug, Clone)]
 pub struct ImportTree<'a> {
     pub trunk: Vec<SIdent<'a>>,
-    pub leaf: Spanned<ImportLeaf<'a>>,
+    pub leaf: Indirect<Spanned<ImportLeaf<'a>>>,
 
     // number of dots prepending the trunk
     pub level: usize,

{koatl-0.3.19 → koatl-0.4.0}/koatl-core/src/ast_builder.rs

@@ -231,7 +231,7 @@ impl AstBuilder {
                 .into_iter()
                 .map(|t| t.into().spanned(self.span))
                 .collect(),
-            leaf: ImportLeaf::Star.spanned(self.span),
+            leaf: ImportLeaf::Star.spanned(self.span).indirect(),
             level,
         }
     }

{koatl-0.3.19 → koatl-0.4.0}/koatl-core/src/lift_cst.rs

@@ -208,15 +208,30 @@ impl<'src, 'tok> Lift<Indirect<ast::SExpr<'src>>> for cst::SExpr<'src, 'tok> {
                 body,
                 else_clause,
                 ..
+            } => {
+                let else_expr = else_clause.as_ref().map(|(_, expr)| expr.lift());
+                ast::Expr::If(cond.lift(), body.lift(), else_expr)
             }
-            | cst::Expr::ClassicIf {
+            cst::Expr::ClassicIf {
                 cond,
                 body,
+                elif_clauses,
                 else_clause,
                 ..
             } => {
-                let else_expr = else_clause.as_ref().map(|(_, expr)| expr.lift());
-                ast::Expr::If(cond.lift(), body.lift(), else_expr)
+                // Convert elif chain into nested if-else
+                let mut result_else = else_clause.as_ref().map(|(_, expr)| expr.lift());
+
+                // Process elif clauses in reverse order to build nested structure
+                for (_, elif_cond, elif_body) in elif_clauses.iter().rev() {
+                    let elif_body_lifted = elif_body.lift();
+                    let span = elif_body_lifted.span;
+                    let elif_expr = ast::Expr::If(elif_cond.lift(), elif_body_lifted, result_else)
+                        .spanned(span);
+                    result_else = Some(elif_expr.indirect());
+                }
+
+                ast::Expr::If(cond.lift(), body.lift(), result_else)
             }
             cst::Expr::Parenthesized { expr, .. } => return expr.lift(),
             cst::Expr::Slice {
@@ -637,7 +652,7 @@ impl<'src, 'tok> Lift<ast::ImportTree<'src>> for cst::ImportTree<cst::STree<'src
                 .iter()
                 .map(|(ident, _)| ident.lift_as_ident())
                 .collect(),
-            leaf: self.leaf.value.lift().spanned(self.leaf.span),
+            leaf: self.leaf.value.lift().spanned(self.leaf.span).indirect(),
         }
     }
 }

{koatl-0.3.19 → koatl-0.4.0}/koatl-core/src/py/ast_builder.rs

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

{koatl-0.3.19 → koatl-0.4.0}/koatl-core/src/resolve_scopes.rs

@@ -38,6 +38,7 @@ pub struct ResolveState<'src> {
     pub export_stars: Vec<SIdent<'src>>,
 
     pub resolutions: HashMap<RefHash, DeclarationKey>,
+    pub locals_scope_refs: HashMap<RefHash, ScopeKey>,
     pub patterns: HashMap<RefHash, PatternInfo>,
 
     // TODO: these should all be collapsed into the same thing...
@@ -62,7 +63,7 @@ pub struct ResolveState<'src> {
     errors: TlErrs,
 
     placeholder_stack: Vec<PlaceholderGuard>,
-    fn_stack: Vec<FnInfo>,
+    phantom_fn_stack: Vec<FnInfo>,
     scope_stack: Vec<ScopeKey>,
 }
 
@@ -99,6 +100,7 @@ impl<'src> ResolveState<'src> {
             source,
 
             resolutions: HashMap::new(),
+            locals_scope_refs: HashMap::new(),
             functions: HashMap::new(),
             patterns: HashMap::new(),
             memo_fninfo: HashMap::new(),
@@ -114,7 +116,7 @@ impl<'src> ResolveState<'src> {
             errors: TlErrs::new(),
 
             placeholder_stack: Vec::new(),
-            fn_stack: Vec::new(),
+            phantom_fn_stack: Vec::new(),
             scope_stack: Vec::new(),
         }
     }
@@ -137,14 +139,14 @@ impl<'src> ResolveState<'src> {
                 return Ok(found.decl);
             }
 
-            let Some(fn_ctx) = self.fn_stack.last_mut() else {
+            let Some(fn_ctx) = self.phantom_fn_stack.last_mut() else {
                 // This should never happen since if not fn_local, there must be at least one function context
                 return Err(simple_err("Internal error: no function context", ident.span).into());
             };
 
             fn_ctx.captures.insert(found.decl.clone().into());
 
-            for fn_ctx in self.fn_stack.iter_mut().rev().skip(1) {
+            for fn_ctx in self.phantom_fn_stack.iter_mut().rev().skip(1) {
                 if fn_ctx.decls.contains(&found.decl) {
                     break;
                 }
@@ -160,7 +162,7 @@ impl<'src> ResolveState<'src> {
         if lhs {
             if scope.is_class || scope.is_global {
                 let decl = self.declarations.insert_declaration(
-                    &mut self.fn_stack,
+                    &mut self.phantom_fn_stack,
                     ident.clone(),
                     scope_key,
                     DeclType::Let,
@@ -174,7 +176,7 @@ impl<'src> ResolveState<'src> {
 
         if !lhs {
             let decl = self.declarations.insert_declaration(
-                &mut self.fn_stack,
+                &mut self.phantom_fn_stack,
                 ident.clone(),
                 self.root_scope,
                 DeclType::Let,
@@ -227,7 +229,7 @@ impl<'src> ResolveState<'src> {
         let temp_scope_key = self.scopes.insert(dummy_scope);
 
         let ph_decl = self.declarations.insert_declaration(
-            &mut self.fn_stack,
+            &mut self.phantom_fn_stack,
             Ident("x".into()).spanned(span),
             temp_scope_key,
             DeclType::Let,
@@ -242,11 +244,11 @@ impl<'src> ResolveState<'src> {
         self.placeholder_stack
             .push(PlaceholderGuard::new(ph_decl, span));
 
-        self.fn_stack.push(FnInfo::new());
+        self.phantom_fn_stack.push(FnInfo::new());
 
         let result = f(self);
 
-        let mut ph_fn_ctx = self.fn_stack.pop().unwrap();
+        let mut ph_fn_ctx = self.phantom_fn_stack.pop().unwrap();
         let placeholder_ctx = self.placeholder_stack.pop().unwrap();
 
         if placeholder_ctx.activated {
@@ -292,7 +294,7 @@ impl<'src> ResolveState<'src> {
                 self.set_generator(span);
             }
 
-            if let Some(cur_fn_ctx) = self.fn_stack.last_mut() {
+            if let Some(cur_fn_ctx) = self.phantom_fn_stack.last_mut() {
                 cur_fn_ctx.captures.extend(ph_fn_ctx.captures);
             }
 
@@ -352,9 +354,12 @@ impl<'src> ResolveState<'src> {
 
         let key = *self.scope_stack.last().unwrap();
 
-        let decl =
-            self.declarations
-                .insert_declaration(&mut self.fn_stack, name.clone(), key, modifier);
+        let decl = self.declarations.insert_declaration(
+            &mut self.phantom_fn_stack,
+            name.clone(),
+            key,
+            modifier,
+        );
 
         if lifted {
             self.scopes[key].lifted_decls.push(decl.clone());
@@ -366,7 +371,7 @@ impl<'src> ResolveState<'src> {
     }
 
     fn set_async(&mut self, span: Span) -> () {
-        if let Some(fn_ctx) = self.fn_stack.last_mut() {
+        if let Some(fn_ctx) = self.phantom_fn_stack.last_mut() {
             fn_ctx.is_async = true;
         } else if !self.allow_top_level_await {
             self.errors.extend(simple_err(
@@ -377,7 +382,7 @@ impl<'src> ResolveState<'src> {
     }
 
     fn set_do(&mut self, span: Span) -> () {
-        if let Some(fn_ctx) = self.fn_stack.last_mut() {
+        if let Some(fn_ctx) = self.phantom_fn_stack.last_mut() {
             fn_ctx.is_do = true;
         } else {
             self.errors.extend(simple_err(
@@ -388,7 +393,7 @@ impl<'src> ResolveState<'src> {
     }
 
     fn set_generator(&mut self, span: Span) -> () {
-        if let Some(fn_ctx) = self.fn_stack.last_mut() {
+        if let Some(fn_ctx) = self.phantom_fn_stack.last_mut() {
             fn_ctx.is_generator = true;
         } else {
             self.errors.extend(simple_err(
@@ -650,7 +655,7 @@ fn error_ident_and_decl<'src>(
     let expr = Expr::Ident(ident.clone()).spanned(span).indirect();
 
     let decl = state.declarations.insert_declaration(
-        &mut state.fn_stack,
+        &mut state.phantom_fn_stack,
         ident.clone(),
         state.err_scope,
         DeclType::Let,
@@ -901,7 +906,7 @@ fn pattern_scoped<'src>(
         .iter()
         .map(|x| {
             state.declarations.insert_declaration(
-                &mut state.fn_stack,
+                &mut state.phantom_fn_stack,
                 x.clone().spanned(pattern.span),
                 scope_key,
                 DeclType::Let,
@@ -928,11 +933,11 @@ where
 {
     let fn_ctx = FnInfo::new();
 
-    state.fn_stack.push(fn_ctx);
+    state.phantom_fn_stack.push(fn_ctx);
 
     let ret = f(state);
 
-    let fn_ctx = state.fn_stack.pop().unwrap();
+    let fn_ctx = state.phantom_fn_stack.pop().unwrap();
 
     if fn_ctx.is_async {
         state.set_async(span);
@@ -989,6 +994,21 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
         let t = match self.value {
             Expr::Literal(_) => return self,
             Expr::Ident(ident) => {
+                // Check for special __locals__ identifier
+                if ident.value.0.as_ref() == "__locals__" {
+                    let expr = Expr::Ident(ident).spanned(span).indirect();
+                    // Store the current scope for __locals__
+                    let current_scope = *state.scope_stack.last().unwrap();
+                    state
+                        .locals_scope_refs
+                        .insert(expr.as_ref().into(), current_scope);
+                    return expr;
+                } else if ident.value.0.as_ref() == "__captures__" {
+                    let expr = Expr::Ident(ident).spanned(span).indirect();
+
+                    return expr;
+                }
+
                 let decl = match state.resolve(&ident, false) {
                     Ok(decl) => decl,
                     Err(errs) => {
@@ -1240,7 +1260,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                                 let cap = capture.spanned(pattern.span);
 
                                 let decl = state.declarations.insert_declaration(
-                                    &mut state.fn_stack,
+                                    &mut state.phantom_fn_stack,
                                     cap,
                                     scope,
                                     DeclType::Let,
@@ -1264,7 +1284,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                         }
                         ArgDefItem::ArgSpread(arg) => {
                             let decl = state.declarations.insert_declaration(
-                                &mut state.fn_stack,
+                                &mut state.phantom_fn_stack,
                                 arg.clone(),
                                 scope,
                                 DeclType::Let,
@@ -1276,7 +1296,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                         }
                         ArgDefItem::KwargSpread(arg) => {
                             let decl = state.declarations.insert_declaration(
-                                &mut state.fn_stack,
+                                &mut state.phantom_fn_stack,
                                 arg.clone(),
                                 scope,
                                 DeclType::Let,
@@ -1312,7 +1332,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                 state.scopes[scope].locals.extend(decls);
 
-                state.fn_stack.push(fn_info);
+                state.phantom_fn_stack.push(fn_info);
 
                 let n_scopes = state.scope_stack.len();
 
@@ -1341,7 +1361,9 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                     (n_fndef_lifted, n_classdef_lifted)
                 };
 
-                let body = state.scoped(scope, |state| body.traverse(state)).value;
+                let body = state
+                    .scoped(scope, |state| body.traverse_expecting_scope(state))
+                    .value;
 
                 {
                     // put back
@@ -1362,7 +1384,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                     }
                 }
 
-                let fn_ctx = state.fn_stack.pop().unwrap();
+                let fn_ctx = state.phantom_fn_stack.pop().unwrap();
                 let expr = Expr::Fn(items, body).spanned(span).indirect();
 
                 state.functions.insert(expr.as_ref().into(), fn_ctx);
@@ -1700,7 +1722,7 @@ impl<'src> SStmtExt<'src> for Indirect<SStmt<'src>> {
                             let scope = &mut state.scopes[scope_key];
 
                             let decl = state.declarations.insert_declaration(
-                                &mut state.fn_stack,
+                                &mut state.phantom_fn_stack,
                                 alias.clone().unwrap_or(ident.clone()),
                                 scope_key,
                                 if reexport {
@@ -1712,6 +1734,10 @@ impl<'src> SStmtExt<'src> for Indirect<SStmt<'src>> {
 
                             state.declarations[decl].is_import = true;
 
+                            state
+                                .resolutions
+                                .insert(tree.leaf.as_ref().into(), decl.clone());
+
                             scope.locals.push(decl);
                         }
                         ImportLeaf::This(alias) => {
@@ -1727,7 +1753,7 @@ impl<'src> SStmtExt<'src> for Indirect<SStmt<'src>> {
                             }
 
                             let decl = state.declarations.insert_declaration(
-                                &mut state.fn_stack,
+                                &mut state.phantom_fn_stack,
                                 alias.clone().unwrap_or(trunk_accum.last().unwrap().clone()),
                                 scope_key,
                                 if reexport {
@@ -1739,9 +1765,20 @@ impl<'src> SStmtExt<'src> for Indirect<SStmt<'src>> {
 
                             state.declarations[decl].is_import = true;
 
+                            state
+                                .resolutions
+                                .insert(tree.leaf.as_ref().into(), decl.clone());
+
                             scope.locals.push(decl);
                         }
                         ImportLeaf::Star => {
+                            if state.scope_stack.len() > 1 {
+                                state.errors.extend(simple_err(
+                                    "Wildcard imports are only allowed in the global scope",
+                                    tree.leaf.span,
+                                ));
+                            }
+
                             if reexport {
                                 state
                                     .export_stars
@@ -1777,7 +1814,7 @@ pub fn resolve_names<'src>(
         })
         .value;
 
-    if !state.fn_stack.is_empty() {
+    if !state.phantom_fn_stack.is_empty() {
         panic!("Function context stack is not empty after resolving names");
     }