koatl 0.1.35__tar.gz → 0.1.36__tar.gz

{koatl-0.1.35 → koatl-0.1.36}/Cargo.lock

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

{koatl-0.1.35 → koatl-0.1.36}/PKG-INFO

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

{koatl-0.1.35 → koatl-0.1.36}/koatl/Cargo.toml

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

{koatl-0.1.35 → koatl-0.1.36/koatl}/python/koatl/prelude/iterable.tl

@@ -11,6 +11,16 @@ export Iterable = Extension.trait& class(Traversable, Trait):
             next(it, None)
         it
 
+    skip_while = (self, f) =>
+        let it = self.iter
+        while True:
+            try:
+                let value = next(it)
+                if not f(value):
+                    return Iterable.chain([value], it)
+            except StopIteration():
+                return it
+
     take = (self, n) =>
         let impl = () =>
             let it = self.iter
@@ -70,7 +80,7 @@ export Iterable = Extension.trait& class(Traversable, Trait):
 
     reverse = self => reversed(list(self.iter))
 
-    sort = (self, key=None, reverse=False) =>
+    sorted = (self, key=None, reverse=False) =>
         sorted(self.iter, key=key, reverse=reverse)
 
     copy = self => itertools.tee(self.iter)
@@ -99,19 +109,19 @@ export Iterable = Extension.trait& class(Traversable, Trait):
             acc[i] = value
         acc
 
-    group_by = (self, f) =>
+    group_by = (self, f=None) =>
         let acc = dict()
         for i in self:
-            let key = f(i)
+            let key = f === None then i else f(i)
             if not acc.__contains__(key):
                 acc[key] = []
             acc[key].append(i)
         acc
 
-    count_by = (self, f) =>
+    count_by = (self, f=None) =>
         let acc = dict()
         for i in self:
-            let key = f(i)
+            let key = f === None then i else f(i)
             if not acc.__contains__(key):
                 acc[key] = 0
             acc[key] += 1

{koatl-0.1.35 → koatl-0.1.36}/koatl-core/src/resolve_scopes.rs

@@ -142,6 +142,10 @@ impl<'src> ResolveState<'src> {
             fn_ctx.captures.insert(found.decl.clone().into());
 
             for fn_ctx in self.fn_stack.iter_mut().rev().skip(1) {
+                if fn_ctx.decls.contains(&found.decl) {
+                    break;
+                }
+
                 fn_ctx.indirect_captures.insert(found.decl.clone().into());
             }
 
@@ -152,9 +156,12 @@ impl<'src> ResolveState<'src> {
 
         if lhs {
             if scope.is_class || scope.is_global {
-                let decl =
-                    self.declarations
-                        .insert_declaration(ident.clone(), scope_key, DeclType::Let);
+                let decl = self.declarations.insert_declaration(
+                    &mut self.fn_stack,
+                    ident.clone(),
+                    scope_key,
+                    DeclType::Let,
+                );
 
                 scope.locals.push(decl.clone());
 
@@ -163,9 +170,12 @@ impl<'src> ResolveState<'src> {
         }
 
         if !lhs {
-            let decl =
-                self.declarations
-                    .insert_declaration(ident.clone(), self.root_scope, DeclType::Let);
+            let decl = self.declarations.insert_declaration(
+                &mut self.fn_stack,
+                ident.clone(),
+                self.root_scope,
+                DeclType::Let,
+            );
 
             self.scopes[self.root_scope].locals.push(decl.clone());
 
@@ -212,6 +222,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,
             Ident("x".into()).spanned(span),
             temp_scope_key,
             DeclType::Let,
@@ -332,9 +343,9 @@ impl<'src> ResolveState<'src> {
 
         let key = *self.scope_stack.last().unwrap();
 
-        let decl = self
-            .declarations
-            .insert_declaration(name.clone(), key, modifier);
+        let decl =
+            self.declarations
+                .insert_declaration(&mut self.fn_stack, name.clone(), key, modifier);
 
         if lifted {
             self.scopes[key].lifted_decls.push(decl.clone());
@@ -415,6 +426,8 @@ pub struct FnInfo {
     pub is_memo: bool,
     pub is_mapped_rhs: bool,
 
+    pub decls: Vec<DeclarationKey>,
+
     pub arg_names: Vec<DeclarationKey>,
 
     /**
@@ -439,6 +452,7 @@ impl FnInfo {
             is_memo: false,
             is_mapped_rhs: false,
             arg_names: Vec::new(),
+            decls: Vec::new(),
             captures: HashSet::new(),
             indirect_captures: HashSet::new(),
         }
@@ -461,6 +475,7 @@ pub struct Declaration<'src> {
 trait DeclSlotMapExt<'src> {
     fn insert_declaration(
         &mut self,
+        fn_stack: &mut Vec<FnInfo>,
         name: SIdent<'src>,
         scope: ScopeKey,
         modifier: DeclType,
@@ -470,6 +485,7 @@ trait DeclSlotMapExt<'src> {
 impl<'src> DeclSlotMapExt<'src> for SlotMap<DeclarationKey, Declaration<'src>> {
     fn insert_declaration(
         &mut self,
+        fn_stack: &mut Vec<FnInfo>,
         name: SIdent<'src>,
         scope: ScopeKey,
         modifier: DeclType,
@@ -486,7 +502,15 @@ impl<'src> DeclSlotMapExt<'src> for SlotMap<DeclarationKey, Declaration<'src>> {
             is_import: false,
         };
 
-        self.insert(decl)
+        let key = self.insert(decl);
+
+        if let Some(fnctx) = fn_stack.last_mut() {
+            if matches!(modifier, DeclType::Let | DeclType::Const) {
+                fnctx.decls.push(key);
+            }
+        }
+
+        key
     }
 }
 
@@ -614,9 +638,12 @@ fn error_ident_and_decl<'src>(
     let ident = Ident("_".into()).spanned(span);
     let expr = Expr::Ident(ident.clone()).spanned(span).indirect();
 
-    let decl = state
-        .declarations
-        .insert_declaration(ident.clone(), state.err_scope, DeclType::Let);
+    let decl = state.declarations.insert_declaration(
+        &mut state.fn_stack,
+        ident.clone(),
+        state.err_scope,
+        DeclType::Let,
+    );
 
     state.resolutions.insert(expr.as_ref().into(), decl);
 
@@ -861,6 +888,7 @@ fn pattern_scoped<'src>(
         .iter()
         .map(|x| {
             state.declarations.insert_declaration(
+                &mut state.fn_stack,
                 x.clone().spanned(pattern.span),
                 scope_key,
                 DeclType::Let,
@@ -1187,6 +1215,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,
                                     cap,
                                     scope,
                                     DeclType::Let,
@@ -1210,6 +1239,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                         }
                         ArgDefItem::ArgSpread(arg) => {
                             let decl = state.declarations.insert_declaration(
+                                &mut state.fn_stack,
                                 arg.clone(),
                                 scope,
                                 DeclType::Let,
@@ -1221,6 +1251,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                         }
                         ArgDefItem::KwargSpread(arg) => {
                             let decl = state.declarations.insert_declaration(
+                                &mut state.fn_stack,
                                 arg.clone(),
                                 scope,
                                 DeclType::Let,
@@ -1432,7 +1463,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                             MappingItem::Item(key.traverse(state), value.traverse(state))
                         }
                         MappingItem::Spread(i) => MappingItem::Spread(i.traverse(state)),
-                        MappingItem::Ident(i) => MappingItem::Ident(i),
+                        MappingItem::Ident(i) => MappingItem::Ident(i.traverse(state)),
                     })
                     .collect::<Vec<_>>(),
             ),
@@ -1640,6 +1671,7 @@ impl<'src> SStmtExt<'src> for Indirect<SStmt<'src>> {
                     ImportList::Leaves(imports) => {
                         for (ident, as_name) in imports {
                             let decl = state.declarations.insert_declaration(
+                                &mut state.fn_stack,
                                 as_name.clone().unwrap_or(ident.clone()),
                                 scope_key,
                                 if import_stmt.reexport {

{koatl-0.1.35 → koatl-0.1.36}/koatl-core/src/transform.rs

@@ -2019,9 +2019,10 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
                 for capture in deps_set {
                     let decl = &ctx.declarations[*capture];
                     let decl_scope = &ctx.scopes[decl.scope];
+                    let py_name = ctx.decl_py_ident(*capture)?;
 
                     if !decl_scope.is_global {
-                        nonglobal_deps.push(decl.name.0.clone());
+                        nonglobal_deps.push(py_name.clone());
                     }
                 }
 

{koatl-0.1.35/koatl → koatl-0.1.36}/python/koatl/prelude/iterable.tl

@@ -11,6 +11,16 @@ export Iterable = Extension.trait& class(Traversable, Trait):
             next(it, None)
         it
 
+    skip_while = (self, f) =>
+        let it = self.iter
+        while True:
+            try:
+                let value = next(it)
+                if not f(value):
+                    return Iterable.chain([value], it)
+            except StopIteration():
+                return it
+
     take = (self, n) =>
         let impl = () =>
             let it = self.iter
@@ -70,7 +80,7 @@ export Iterable = Extension.trait& class(Traversable, Trait):
 
     reverse = self => reversed(list(self.iter))
 
-    sort = (self, key=None, reverse=False) =>
+    sorted = (self, key=None, reverse=False) =>
         sorted(self.iter, key=key, reverse=reverse)
 
     copy = self => itertools.tee(self.iter)
@@ -99,19 +109,19 @@ export Iterable = Extension.trait& class(Traversable, Trait):
             acc[i] = value
         acc
 
-    group_by = (self, f) =>
+    group_by = (self, f=None) =>
         let acc = dict()
         for i in self:
-            let key = f(i)
+            let key = f === None then i else f(i)
             if not acc.__contains__(key):
                 acc[key] = []
             acc[key].append(i)
         acc
 
-    count_by = (self, f) =>
+    count_by = (self, f=None) =>
         let acc = dict()
         for i in self:
-            let key = f(i)
+            let key = f === None then i else f(i)
             if not acc.__contains__(key):
                 acc[key] = 0
             acc[key] += 1