snail-lang 0.7.5__tar.gz → 0.7.6__tar.gz

{snail_lang-0.7.5 → snail_lang-0.7.6}/Cargo.lock

@@ -312,25 +312,25 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "snail-ast"
-version = "0.7.5"
+version = "0.7.6"
 
 [[package]]
 name = "snail-error"
-version = "0.7.5"
+version = "0.7.6"
 dependencies = [
  "snail-ast",
 ]
 
 [[package]]
 name = "snail-lower"
-version = "0.7.5"
+version = "0.7.6"
 dependencies = [
  "snail-python",
 ]
 
 [[package]]
 name = "snail-parser"
-version = "0.7.5"
+version = "0.7.6"
 dependencies = [
  "pest",
  "pest_derive",
@@ -340,7 +340,7 @@ dependencies = [
 
 [[package]]
 name = "snail-python"
-version = "0.7.5"
+version = "0.7.6"
 dependencies = [
  "pyo3",
  "snail-ast",

{snail_lang-0.7.5 → snail_lang-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snail-lang
-Version: 0.7.5
+Version: 0.7.6
 Requires-Dist: astunparse>=1.6.3 ; python_full_version < '3.9'
 Requires-Dist: jmespath>=1.0.1
 Requires-Dist: maturin>=1.5 ; extra == 'dev'

{snail_lang-0.7.5 → snail_lang-0.7.6}/crates/snail-ast/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-ast"
-version = "0.7.5"
+version = "0.7.6"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.7.5 → snail_lang-0.7.6}/crates/snail-error/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-error"
-version = "0.7.5"
+version = "0.7.6"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.7.5 → snail_lang-0.7.6}/crates/snail-parser/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-parser"
-version = "0.7.5"
+version = "0.7.6"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.7.5 → snail_lang-0.7.6}/crates/snail-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-python"
-version = "0.7.5"
+version = "0.7.6"
 edition.workspace = true
 build = "build.rs"
 

{snail_lang-0.7.5 → snail_lang-0.7.6}/crates/snail-python/src/lower/desugar.rs

@@ -553,26 +553,18 @@ impl LambdaHoister {
                 span: span.clone(),
             },
             Expr::Lambda { params, body, span } => {
-                if lambda_requires_def(params, body) {
-                    let params = self.desugar_params(params, prelude);
-                    let body = ensure_lambda_return(self.desugar_block(body));
-                    let name = self.next_lambda_name();
-                    prelude.push(Stmt::Def {
-                        name: name.clone(),
-                        params,
-                        body,
-                        span: span.clone(),
-                    });
-                    Expr::Name {
-                        name,
-                        span: span.clone(),
-                    }
-                } else {
-                    Expr::Lambda {
-                        params: params.clone(),
-                        body: body.clone(),
-                        span: span.clone(),
-                    }
+                let params = self.desugar_params(params, prelude);
+                let body = self.desugar_block(body);
+                let name = self.next_lambda_name();
+                prelude.push(Stmt::Def {
+                    name: name.clone(),
+                    params,
+                    body,
+                    span: span.clone(),
+                });
+                Expr::Name {
+                    name,
+                    span: span.clone(),
                 }
             }
             Expr::Compound { expressions, span } => Expr::Compound {
@@ -717,190 +709,3 @@ impl LambdaHoister {
         }
     }
 }
-
-fn lambda_requires_def(params: &[Parameter], body: &[Stmt]) -> bool {
-    if body.iter().any(|stmt| !matches!(stmt, Stmt::Expr { .. })) {
-        return true;
-    }
-
-    for param in params {
-        if let Parameter::Regular { default, .. } = param
-            && let Some(default) = default
-            && expr_contains_complex_lambda(default)
-        {
-            return true;
-        }
-    }
-
-    for stmt in body {
-        if let Stmt::Expr { value, .. } = stmt
-            && expr_contains_complex_lambda(value)
-        {
-            return true;
-        }
-    }
-
-    false
-}
-
-fn expr_contains_complex_lambda(expr: &Expr) -> bool {
-    match expr {
-        Expr::Yield { value, .. } => value
-            .as_ref()
-            .is_some_and(|expr| expr_contains_complex_lambda(expr)),
-        Expr::YieldFrom { expr, .. } => expr_contains_complex_lambda(expr),
-        Expr::Lambda { params, body, .. } => lambda_requires_def(params, body),
-        Expr::Unary { expr, .. } => expr_contains_complex_lambda(expr),
-        Expr::Binary { left, right, .. } => {
-            expr_contains_complex_lambda(left) || expr_contains_complex_lambda(right)
-        }
-        Expr::AugAssign { target, value, .. } => {
-            assign_target_contains_complex_lambda(target) || expr_contains_complex_lambda(value)
-        }
-        Expr::PrefixIncr { target, .. } | Expr::PostfixIncr { target, .. } => {
-            assign_target_contains_complex_lambda(target)
-        }
-        Expr::Compare {
-            left, comparators, ..
-        } => {
-            if expr_contains_complex_lambda(left) {
-                return true;
-            }
-            comparators.iter().any(expr_contains_complex_lambda)
-        }
-        Expr::IfExpr {
-            test, body, orelse, ..
-        } => {
-            expr_contains_complex_lambda(test)
-                || expr_contains_complex_lambda(body)
-                || expr_contains_complex_lambda(orelse)
-        }
-        Expr::TryExpr { expr, fallback, .. } => {
-            expr_contains_complex_lambda(expr)
-                || fallback
-                    .as_ref()
-                    .is_some_and(|expr| expr_contains_complex_lambda(expr))
-        }
-        Expr::Compound { expressions, .. } => expressions.iter().any(expr_contains_complex_lambda),
-        Expr::Regex { pattern, .. } => regex_pattern_contains_complex_lambda(pattern),
-        Expr::RegexMatch { value, pattern, .. } => {
-            expr_contains_complex_lambda(value) || regex_pattern_contains_complex_lambda(pattern)
-        }
-        Expr::Subprocess { parts, .. } => parts.iter().any(|part| match part {
-            SubprocessPart::Expr(expr) => expr_contains_complex_lambda(expr),
-            SubprocessPart::Text(_) => false,
-        }),
-        Expr::Call { func, args, .. } => {
-            if expr_contains_complex_lambda(func) {
-                return true;
-            }
-            args.iter().any(|arg| match arg {
-                Argument::Positional { value, .. }
-                | Argument::Keyword { value, .. }
-                | Argument::Star { value, .. }
-                | Argument::KwStar { value, .. } => expr_contains_complex_lambda(value),
-            })
-        }
-        Expr::Attribute { value, .. } => expr_contains_complex_lambda(value),
-        Expr::Index { value, index, .. } => {
-            expr_contains_complex_lambda(value) || expr_contains_complex_lambda(index)
-        }
-        Expr::Paren { expr, .. } => expr_contains_complex_lambda(expr),
-        Expr::List { elements, .. } | Expr::Tuple { elements, .. } => {
-            elements.iter().any(expr_contains_complex_lambda)
-        }
-        Expr::Set { elements, .. } => elements.iter().any(expr_contains_complex_lambda),
-        Expr::Dict { entries, .. } => entries.iter().any(|(key, value)| {
-            expr_contains_complex_lambda(key) || expr_contains_complex_lambda(value)
-        }),
-        Expr::Slice { start, end, .. } => {
-            start
-                .as_ref()
-                .is_some_and(|expr| expr_contains_complex_lambda(expr))
-                || end
-                    .as_ref()
-                    .is_some_and(|expr| expr_contains_complex_lambda(expr))
-        }
-        Expr::ListComp {
-            element, iter, ifs, ..
-        } => {
-            expr_contains_complex_lambda(element)
-                || expr_contains_complex_lambda(iter)
-                || ifs.iter().any(expr_contains_complex_lambda)
-        }
-        Expr::DictComp {
-            key,
-            value,
-            iter,
-            ifs,
-            ..
-        } => {
-            expr_contains_complex_lambda(key)
-                || expr_contains_complex_lambda(value)
-                || expr_contains_complex_lambda(iter)
-                || ifs.iter().any(expr_contains_complex_lambda)
-        }
-        Expr::FString { parts, .. } => parts.iter().any(fstring_part_contains_complex_lambda),
-        Expr::Name { .. }
-        | Expr::Placeholder { .. }
-        | Expr::Number { .. }
-        | Expr::String { .. }
-        | Expr::Bool { .. }
-        | Expr::None { .. }
-        | Expr::StructuredAccessor { .. }
-        | Expr::FieldIndex { .. } => false,
-    }
-}
-
-fn assign_target_contains_complex_lambda(target: &AssignTarget) -> bool {
-    match target {
-        AssignTarget::Name { .. } => false,
-        AssignTarget::Attribute { value, .. } => expr_contains_complex_lambda(value),
-        AssignTarget::Index { value, index, .. } => {
-            expr_contains_complex_lambda(value) || expr_contains_complex_lambda(index)
-        }
-        AssignTarget::Starred { target, .. } => assign_target_contains_complex_lambda(target),
-        AssignTarget::Tuple { elements, .. } | AssignTarget::List { elements, .. } => {
-            elements.iter().any(assign_target_contains_complex_lambda)
-        }
-    }
-}
-
-fn regex_pattern_contains_complex_lambda(pattern: &RegexPattern) -> bool {
-    match pattern {
-        RegexPattern::Literal(_) => false,
-        RegexPattern::Interpolated(parts) => parts.iter().any(fstring_part_contains_complex_lambda),
-    }
-}
-
-fn fstring_part_contains_complex_lambda(part: &FStringPart) -> bool {
-    match part {
-        FStringPart::Text(_) => false,
-        FStringPart::Expr(expr) => fstring_expr_contains_complex_lambda(expr),
-    }
-}
-
-fn fstring_expr_contains_complex_lambda(expr: &FStringExpr) -> bool {
-    if expr_contains_complex_lambda(expr.expr.as_ref()) {
-        return true;
-    }
-    expr.format_spec
-        .as_ref()
-        .is_some_and(|parts| parts.iter().any(fstring_part_contains_complex_lambda))
-}
-
-fn ensure_lambda_return(mut body: Vec<Stmt>) -> Vec<Stmt> {
-    let Some(last) = body.pop() else {
-        return body;
-    };
-    match last {
-        Stmt::Expr { value, span, .. } => {
-            body.push(Stmt::Return {
-                value: Some(value),
-                span,
-            });
-        }
-        other => body.push(other),
-    }
-    body
-}

{snail_lang-0.7.5 → snail_lang-0.7.6}/crates/snail-python/src/lower/expr.rs

@@ -10,7 +10,6 @@ use super::operators::{
     lower_unary_op,
 };
 use super::py_ast::{AstBuilder, py_err_to_lower};
-use super::stmt::lower_parameters;
 
 pub(crate) fn lower_expr(builder: &AstBuilder<'_>, expr: &Expr) -> Result<PyObject, LowerError> {
     lower_expr_with_exception(builder, expr, None)
@@ -782,9 +781,9 @@ pub(crate) fn lower_expr_with_exception(
                 .call_node("YieldFrom", vec![value], span)
                 .map_err(py_err_to_lower)
         }
-        Expr::Lambda { params, body, span } => {
-            lower_lambda_expr(builder, params, body, span, exception_name)
-        }
+        Expr::Lambda { .. } => Err(LowerError::new(
+            "def expressions should be desugared before lowering",
+        )),
         Expr::Compound { expressions, span } => {
             let mut lowered = Vec::new();
             for expr in expressions {
@@ -1431,83 +1430,6 @@ fn lower_subprocess_parts(
     Ok(lowered_parts)
 }
 
-fn lower_lambda_expr(
-    builder: &AstBuilder<'_>,
-    params: &[Parameter],
-    body: &[Stmt],
-    span: &SourceSpan,
-    exception_name: Option<&str>,
-) -> Result<PyObject, LowerError> {
-    let args = lower_parameters(builder, params, exception_name)?;
-    let body_expr = lower_lambda_body_expr(builder, body, span, exception_name)?;
-    builder
-        .call_node("Lambda", vec![args, body_expr], span)
-        .map_err(py_err_to_lower)
-}
-
-fn lower_lambda_body_expr(
-    builder: &AstBuilder<'_>,
-    body: &[Stmt],
-    span: &SourceSpan,
-    exception_name: Option<&str>,
-) -> Result<PyObject, LowerError> {
-    let mut lowered = Vec::new();
-    for stmt in body {
-        match stmt {
-            Stmt::Expr { value, .. } => {
-                lowered.push(lower_expr_with_exception(builder, value, exception_name)?);
-            }
-            _ => {
-                return Err(LowerError::new(
-                    "def expression bodies must contain only expression statements",
-                ));
-            }
-        }
-    }
-
-    if lowered.is_empty() {
-        return builder
-            .call_node(
-                "Constant",
-                vec![builder.py().None().into_py(builder.py())],
-                span,
-            )
-            .map_err(py_err_to_lower);
-    }
-
-    if lowered.len() == 1 {
-        return Ok(lowered.pop().unwrap());
-    }
-
-    let tuple_expr = builder
-        .call_node(
-            "Tuple",
-            vec![
-                PyList::new_bound(builder.py(), lowered).into_py(builder.py()),
-                builder.load_ctx().map_err(py_err_to_lower)?,
-            ],
-            span,
-        )
-        .map_err(py_err_to_lower)?;
-    let index_expr = builder
-        .call_node(
-            "UnaryOp",
-            vec![
-                lower_unary_op(builder, UnaryOp::Minus)?,
-                number_expr(builder, "1", span)?,
-            ],
-            span,
-        )
-        .map_err(py_err_to_lower)?;
-    subscript_expr(
-        builder,
-        tuple_expr,
-        index_expr,
-        builder.load_ctx().map_err(py_err_to_lower)?,
-        span,
-    )
-}
-
 fn lower_call_arguments(
     builder: &AstBuilder<'_>,
     args: &[Argument],

{snail_lang-0.7.5 → snail_lang-0.7.6}/crates/snail-python/src/lower/validate.rs

@@ -269,8 +269,8 @@ fn check_expr(expr: &Expr, in_function: bool) -> Result<(), LowerError> {
             for param in params {
                 check_param(param)?;
             }
-            // Lambdas lower to Python lambdas; disallow yield in their bodies.
-            check_stmts(body, false)?;
+            // Anonymous defs are hoisted to defs; allow yield in their bodies.
+            check_stmts(body, true)?;
         }
         Expr::Compound { expressions, .. } => {
             for expr in expressions {

{snail_lang-0.7.5 → snail_lang-0.7.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "snail-lang"
-version = "0.7.5"
+version = "0.7.6"
 description = "Snail programming language interpreter"
 readme = "README.md"
 requires-python = ">=3.8"