snail-lang 0.3.7__tar.gz → 0.3.8__tar.gz

{snail_lang-0.3.7 → snail_lang-0.3.8}/Cargo.lock

@@ -485,11 +485,11 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "snail-ast"
-version = "0.3.7"
+version = "0.3.8"
 
 [[package]]
 name = "snail-core"
-version = "0.3.7"
+version = "0.3.8"
 dependencies = [
  "pyo3",
  "snail-ast",
@@ -500,14 +500,14 @@ dependencies = [
 
 [[package]]
 name = "snail-error"
-version = "0.3.7"
+version = "0.3.8"
 dependencies = [
  "snail-ast",
 ]
 
 [[package]]
 name = "snail-lower"
-version = "0.3.7"
+version = "0.3.8"
 dependencies = [
  "pyo3",
  "snail-ast",
@@ -516,7 +516,7 @@ dependencies = [
 
 [[package]]
 name = "snail-parser"
-version = "0.3.7"
+version = "0.3.8"
 dependencies = [
  "pest",
  "pest_derive",
@@ -526,7 +526,7 @@ dependencies = [
 
 [[package]]
 name = "snail-proptest"
-version = "0.3.7"
+version = "0.3.8"
 dependencies = [
  "proptest",
  "pyo3",
@@ -540,7 +540,7 @@ dependencies = [
 
 [[package]]
 name = "snail-python"
-version = "0.3.7"
+version = "0.3.8"
 dependencies = [
  "pyo3",
  "snail-core",

{snail_lang-0.3.7 → snail_lang-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snail-lang
-Version: 0.3.7
+Version: 0.3.8
 Requires-Dist: maturin>=1.5 ; extra == 'dev'
 Requires-Dist: pytest ; extra == 'dev'
 Provides-Extra: dev

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-ast/Cargo.toml

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

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-ast/src/ast.rs

@@ -265,10 +265,6 @@ pub enum Expr {
         entries: Vec<(Expr, Expr)>,
         span: SourceSpan,
     },
-    Set {
-        elements: Vec<Expr>,
-        span: SourceSpan,
-    },
     Slice {
         start: Option<Box<Expr>>,
         end: Option<Box<Expr>>,

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-core"
-version = "0.3.7"
+version = "0.3.8"
 edition.workspace = true
 readme = "README.md"
 

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-error/Cargo.toml

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

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-lower/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-lower"
-version = "0.3.7"
+version = "0.3.8"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-lower/src/expr.rs

@@ -612,6 +612,34 @@ pub(crate) fn lower_expr_with_exception(
         }
         Expr::Attribute { value, attr, span } => {
             let value = lower_expr_with_exception(builder, value, exception_name)?;
+            if attr.chars().all(|ch| ch.is_ascii_digit()) {
+                let group_index = attr
+                    .parse::<i32>()
+                    .map_err(|_| LowerError::new(format!("Invalid match group index: .{attr}")))?;
+                let group_attr = builder
+                    .call_node(
+                        "Attribute",
+                        vec![
+                            value,
+                            "group".into_py(builder.py()),
+                            builder.load_ctx().map_err(py_err_to_lower)?,
+                        ],
+                        span,
+                    )
+                    .map_err(py_err_to_lower)?;
+                let index_expr = number_expr(builder, &group_index.to_string(), span)?;
+                return builder
+                    .call_node(
+                        "Call",
+                        vec![
+                            group_attr,
+                            PyList::new_bound(builder.py(), vec![index_expr]).into_py(builder.py()),
+                            PyList::empty_bound(builder.py()).into_py(builder.py()),
+                        ],
+                        span,
+                    )
+                    .map_err(py_err_to_lower);
+            }
             builder
                 .call_node(
                     "Attribute",
@@ -686,19 +714,6 @@ pub(crate) fn lower_expr_with_exception(
                 )
                 .map_err(py_err_to_lower)
         }
-        Expr::Set { elements, span } => {
-            let mut lowered = Vec::with_capacity(elements.len());
-            for element in elements {
-                lowered.push(lower_expr_with_exception(builder, element, exception_name)?);
-            }
-            builder
-                .call_node(
-                    "Set",
-                    vec![PyList::new_bound(builder.py(), lowered).into_py(builder.py())],
-                    span,
-                )
-                .map_err(py_err_to_lower)
-        }
         Expr::ListComp {
             element,
             target,
@@ -1031,7 +1046,7 @@ fn count_placeholders(expr: &Expr, info: &mut PlaceholderInfo) {
             count_placeholders(index, info);
         }
         Expr::Paren { expr, .. } => count_placeholders(expr, info),
-        Expr::List { elements, .. } | Expr::Tuple { elements, .. } | Expr::Set { elements, .. } => {
+        Expr::List { elements, .. } | Expr::Tuple { elements, .. } => {
             for expr in elements {
                 count_placeholders(expr, info);
             }
@@ -1262,13 +1277,6 @@ fn substitute_placeholder(expr: &Expr, replacement: &Expr) -> Expr {
                 .collect(),
             span: span.clone(),
         },
-        Expr::Set { elements, span } => Expr::Set {
-            elements: elements
-                .iter()
-                .map(|expr| substitute_placeholder(expr, replacement))
-                .collect(),
-            span: span.clone(),
-        },
         Expr::Slice { start, end, span } => Expr::Slice {
             start: start
                 .as_ref()

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-parser/Cargo.toml

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

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-parser/src/expr.rs

@@ -5,8 +5,8 @@ use snail_error::ParseError;
 use crate::Rule;
 use crate::literal::{
     parse_dict_comp, parse_dict_literal, parse_list_comp, parse_list_literal, parse_literal,
-    parse_regex_literal, parse_set_literal, parse_slice, parse_structured_accessor,
-    parse_subprocess, parse_tuple_literal,
+    parse_regex_literal, parse_slice, parse_structured_accessor, parse_subprocess,
+    parse_tuple_literal,
 };
 use crate::util::{error_with_span, expr_span, merge_span, span_from_pair};
 
@@ -57,7 +57,6 @@ pub fn parse_expr_pair(pair: Pair<'_, Rule>, source: &str) -> Result<Expr, Parse
         Rule::list_literal => parse_list_literal(pair, source),
         Rule::dict_literal => parse_dict_literal(pair, source),
         Rule::tuple_literal => parse_tuple_literal(pair, source),
-        Rule::set_literal => parse_set_literal(pair, source),
         Rule::list_comp => parse_list_comp(pair, source),
         Rule::dict_comp => parse_dict_comp(pair, source),
         Rule::regex => parse_regex_literal(pair, source),
@@ -586,7 +585,6 @@ fn parse_atom(pair: Pair<'_, Rule>, source: &str) -> Result<Expr, ParseError> {
         Rule::list_literal => parse_list_literal(inner_pair, source),
         Rule::dict_literal => parse_dict_literal(inner_pair, source),
         Rule::tuple_literal => parse_tuple_literal(inner_pair, source),
-        Rule::set_literal => parse_set_literal(inner_pair, source),
         Rule::list_comp => parse_list_comp(inner_pair, source),
         Rule::dict_comp => parse_dict_comp(inner_pair, source),
         Rule::regex => parse_regex_literal(inner_pair, source),

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-parser/src/lib.rs

@@ -355,7 +355,7 @@ fn validate_expr(expr: &Expr, source: &str) -> Result<(), ParseError> {
         Expr::Paren { expr, .. } => {
             validate_expr(expr, source)?;
         }
-        Expr::List { elements, .. } | Expr::Tuple { elements, .. } | Expr::Set { elements, .. } => {
+        Expr::List { elements, .. } | Expr::Tuple { elements, .. } => {
             for expr in elements {
                 validate_expr(expr, source)?;
             }

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-parser/src/literal.rs

@@ -45,17 +45,6 @@ pub fn parse_tuple_literal(pair: Pair<'_, Rule>, source: &str) -> Result<Expr, P
     Ok(Expr::Tuple { elements, span })
 }
 
-pub fn parse_set_literal(pair: Pair<'_, Rule>, source: &str) -> Result<Expr, ParseError> {
-    let span = span_from_pair(&pair, source);
-    let mut elements = Vec::new();
-    for inner in pair.into_inner() {
-        if inner.as_rule() == Rule::expr {
-            elements.push(crate::expr::parse_expr_pair(inner, source)?);
-        }
-    }
-    Ok(Expr::Set { elements, span })
-}
-
 pub fn parse_list_literal(pair: Pair<'_, Rule>, source: &str) -> Result<Expr, ParseError> {
     let span = span_from_pair(&pair, source);
     let mut elements = Vec::new();

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-parser/src/snail.pest

@@ -11,7 +11,11 @@ awk_rule = { block | awk_pattern ~ block? }
 awk_pattern = { expr }
 
 // Statements: separated by semicolons or newlines
-stmt_list = { stmt ~ (stmt_sep ~ stmt)* ~ stmt_sep? }
+// Compound statements (ending with }) don't need trailing separators
+// Simple statements need separators unless they're the last statement
+stmt_list = { stmt_item* ~ final_stmt? }
+stmt_item = _{ compound_stmt ~ stmt_sep* | simple_stmt ~ stmt_sep+ }
+final_stmt = _{ compound_stmt | simple_stmt }
 stmt_sep = _{ ";" ~ NEWLINE* | NEWLINE+ }
 
 stmt = _{ compound_stmt | simple_stmt }
@@ -136,7 +140,8 @@ star_arg = { "*" ~ expr }
 kw_star_arg = { "**" ~ expr }
 
 // Attribute access and indexing/slicing
-attribute = { "." ~ identifier }
+attribute = { "." ~ (identifier | attribute_index) }
+attribute_index = @{ ASCII_DIGIT+ }
 index = { "[" ~ slice ~ "]" }
 slice = { slice_expr | expr }
 slice_expr = { slice_start? ~ ":" ~ slice_end? }
@@ -158,7 +163,6 @@ atom = _{
   | list_literal
   | dict_comp
   | dict_literal
-  | set_literal
   | tuple_literal
   | compound_expr
   | "(" ~ expr ~ ")"
@@ -188,7 +192,6 @@ list_comp = { "[" ~ expr ~ comp_for ~ "]" }
 list_literal = { "[" ~ (expr ~ ("," ~ expr)*)? ~ "]" }
 dict_comp = { "{" ~ expr ~ ":" ~ expr ~ comp_for ~ "}" }
 dict_literal = { "{" ~ (dict_entry ~ ("," ~ dict_entry)*)? ~ "}" }
-set_literal = { "{" ~ expr ~ ("," ~ expr)* ~ ","? ~ "}" }
 dict_entry = { expr ~ ":" ~ expr }
 
 // Comprehension clauses

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-parser/src/string.rs

@@ -324,7 +324,6 @@ pub fn shift_expr_spans(expr: &mut Expr, offset: usize, source: &str) {
         | Expr::List { span, .. }
         | Expr::Tuple { span, .. }
         | Expr::Dict { span, .. }
-        | Expr::Set { span, .. }
         | Expr::Slice { span, .. } => {
             *span = shift_span(span, offset, source);
         }

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-parser/src/util.rs

@@ -162,7 +162,6 @@ pub fn expr_span(expr: &snail_ast::Expr) -> &SourceSpan {
         | snail_ast::Expr::List { span, .. }
         | snail_ast::Expr::Tuple { span, .. }
         | snail_ast::Expr::Dict { span, .. }
-        | snail_ast::Expr::Set { span, .. }
         | snail_ast::Expr::ListComp { span, .. }
         | snail_ast::Expr::DictComp { span, .. }
         | snail_ast::Expr::Slice { span, .. } => span,

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-parser/tests/parser.rs

@@ -632,3 +632,107 @@ fn parses_ternary_with_is_not_operator() {
         other => panic!("Expected assignment, got {:?}", other),
     }
 }
+
+// Tests for compound statement separator behavior (no semicolon needed after })
+
+#[test]
+fn parses_if_followed_by_stmt_without_separator() {
+    // if statement followed by expression without semicolon
+    let source = "if x { y = 1 } z";
+    let program = parse_ok(source);
+    assert_eq!(program.stmts.len(), 2);
+    assert!(matches!(&program.stmts[0], Stmt::If { .. }));
+    assert!(matches!(&program.stmts[1], Stmt::Expr { .. }));
+}
+
+#[test]
+fn parses_while_followed_by_stmt_without_separator() {
+    let source = "while x { y = 1 } z";
+    let program = parse_ok(source);
+    assert_eq!(program.stmts.len(), 2);
+    assert!(matches!(&program.stmts[0], Stmt::While { .. }));
+    assert!(matches!(&program.stmts[1], Stmt::Expr { .. }));
+}
+
+#[test]
+fn parses_for_followed_by_stmt_without_separator() {
+    let source = "for i in x { y = 1 } z";
+    let program = parse_ok(source);
+    assert_eq!(program.stmts.len(), 2);
+    assert!(matches!(&program.stmts[0], Stmt::For { .. }));
+    assert!(matches!(&program.stmts[1], Stmt::Expr { .. }));
+}
+
+#[test]
+fn parses_def_followed_by_stmt_without_separator() {
+    let source = "def f() { pass } f()";
+    let program = parse_ok(source);
+    assert_eq!(program.stmts.len(), 2);
+    assert!(matches!(&program.stmts[0], Stmt::Def { .. }));
+    assert!(matches!(&program.stmts[1], Stmt::Expr { .. }));
+}
+
+#[test]
+fn parses_class_followed_by_stmt_without_separator() {
+    let source = "class C { pass } C()";
+    let program = parse_ok(source);
+    assert_eq!(program.stmts.len(), 2);
+    assert!(matches!(&program.stmts[0], Stmt::Class { .. }));
+    assert!(matches!(&program.stmts[1], Stmt::Expr { .. }));
+}
+
+#[test]
+fn parses_try_followed_by_stmt_without_separator() {
+    // Note: using explicit exception type since bare `except { }` is ambiguous with set literals
+    let source = "try { x } except Exception { y } z";
+    let program = parse_ok(source);
+    assert_eq!(program.stmts.len(), 2);
+    assert!(matches!(&program.stmts[0], Stmt::Try { .. }));
+    assert!(matches!(&program.stmts[1], Stmt::Expr { .. }));
+}
+
+#[test]
+fn parses_with_followed_by_stmt_without_separator() {
+    let source = "with x { y } z";
+    let program = parse_ok(source);
+    assert_eq!(program.stmts.len(), 2);
+    assert!(matches!(&program.stmts[0], Stmt::With { .. }));
+    assert!(matches!(&program.stmts[1], Stmt::Expr { .. }));
+}
+
+#[test]
+fn parses_nested_compound_stmts_without_separators() {
+    let source = "if a { if b { c } d } e";
+    let program = parse_ok(source);
+    assert_eq!(program.stmts.len(), 2);
+    assert!(matches!(&program.stmts[0], Stmt::If { .. }));
+    assert!(matches!(&program.stmts[1], Stmt::Expr { .. }));
+}
+
+#[test]
+fn parses_mixed_compound_and_simple_stmts() {
+    let source = "a = 1; if b { c = 2 } d = 3; e = 4";
+    let program = parse_ok(source);
+    assert_eq!(program.stmts.len(), 4);
+    assert!(matches!(&program.stmts[0], Stmt::Assign { .. }));
+    assert!(matches!(&program.stmts[1], Stmt::If { .. }));
+    assert!(matches!(&program.stmts[2], Stmt::Assign { .. }));
+    assert!(matches!(&program.stmts[3], Stmt::Assign { .. }));
+}
+
+#[test]
+fn parses_consecutive_compound_stmts_without_separators() {
+    let source = "if a { b } if c { d } while e { f }";
+    let program = parse_ok(source);
+    assert_eq!(program.stmts.len(), 3);
+    assert!(matches!(&program.stmts[0], Stmt::If { .. }));
+    assert!(matches!(&program.stmts[1], Stmt::If { .. }));
+    assert!(matches!(&program.stmts[2], Stmt::While { .. }));
+}
+
+#[test]
+fn simple_stmt_still_requires_separator() {
+    // Two simple statements without separator should fail
+    let source = "a b";
+    parse_err(source);
+}

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-parser/tests/statements.rs

@@ -183,10 +183,10 @@ fn parses_assert_and_del() {
 }
 
 #[test]
-fn parses_tuples_sets_and_slices() {
-    let source = "items = [1, 2, 3, 4]\npair = (1, 2)\nsingle = (1,)\nempty = ()\nflags = {True, False}\nmid = items[1:3]\nhead = items[:2]\ntail = items[2:]\n";
+fn parses_tuples_and_slices() {
+    let source = "items = [1, 2, 3, 4]\npair = (1, 2)\nsingle = (1,)\nempty = ()\nmid = items[1:3]\nhead = items[:2]\ntail = items[2:]\n";
     let program = parse_ok(source);
-    assert_eq!(program.stmts.len(), 8);
+    assert_eq!(program.stmts.len(), 7);
 
     let (_, value) = expect_assign(&program.stmts[0]);
     match value {
@@ -213,18 +213,6 @@ fn parses_tuples_sets_and_slices() {
     }
 
     let (_, value) = expect_assign(&program.stmts[4]);
-    match value {
-        Expr::Set { elements, .. } => {
-            assert_eq!(elements.len(), 2);
-            match &elements[0] {
-                Expr::Bool { value, .. } => assert!(*value),
-                other => panic!("Expected True, got {other:?}"),
-            }
-        }
-        other => panic!("Expected set, got {other:?}"),
-    }
-
-    let (_, value) = expect_assign(&program.stmts[5]);
     match value {
         Expr::Index { value, index, .. } => {
             expect_name(value.as_ref(), "items");
@@ -239,7 +227,7 @@ fn parses_tuples_sets_and_slices() {
         other => panic!("Expected index, got {other:?}"),
     }
 
-    let (_, value) = expect_assign(&program.stmts[6]);
+    let (_, value) = expect_assign(&program.stmts[5]);
     match value {
         Expr::Index { index, .. } => match index.as_ref() {
             Expr::Slice { start, end, .. } => {
@@ -251,7 +239,7 @@ fn parses_tuples_sets_and_slices() {
         other => panic!("Expected index, got {other:?}"),
     }
 
-    let (_, value) = expect_assign(&program.stmts[7]);
+    let (_, value) = expect_assign(&program.stmts[6]);
     match value {
         Expr::Index { index, .. } => match index.as_ref() {
             Expr::Slice { start, end, .. } => {

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-parser/tests/syntax_expressions.rs

@@ -367,3 +367,17 @@ fn parses_call_attribute_index_chain() {
         other => panic!("Expected index access, got {other:?}"),
     }
 }
+
+#[test]
+fn parses_numeric_attribute_access() {
+    let program = parse_ok("value = match.1");
+    let (_, value) = expect_assign(&program.stmts[0]);
+
+    match value {
+        Expr::Attribute { value, attr, .. } => {
+            expect_name(value.as_ref(), "match");
+            assert_eq!(attr, "1");
+        }
+        other => panic!("Expected attribute access, got {other:?}"),
+    }
+}

{snail_lang-0.3.7 → snail_lang-0.3.8}/crates/snail-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-python"
-version = "0.3.7"
+version = "0.3.8"
 edition.workspace = true
 
 [lib]

{snail_lang-0.3.7 → snail_lang-0.3.8}/pyproject.toml

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

{snail_lang-0.3.7 → snail_lang-0.3.8}/python/snail/runtime/compact_try.py

@@ -9,5 +9,5 @@ def compact_try(expr_fn, fallback_fn=None):
             fallback_member = getattr(exc, "__fallback__", None)
             if callable(fallback_member):
                 return fallback_member()
-            return exc
+            return None
         return fallback_fn(exc)