snail-lang 0.5.1__tar.gz → 0.5.3__tar.gz

{snail_lang-0.5.1 → snail_lang-0.5.3}/Cargo.lock

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

{snail_lang-0.5.1 → snail_lang-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snail-lang
-Version: 0.5.1
+Version: 0.5.3
 Requires-Dist: jmespath>=1.0.1
 Requires-Dist: maturin>=1.5 ; extra == 'dev'
 Requires-Dist: pytest ; extra == 'dev'
@@ -19,6 +19,12 @@ Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 
 **Snail** is a programming language that compiles to Python, combining Python's familiarity and extensive libraries with Perl/awk-inspired syntax for quick scripts and one-liners.
 
+## AI Slop!
+
+Snail is me learning how to devlop code using LLMs. I think its neat, and
+maybe useful. I don't think this is high quality. I am going to try and LLM my
+way into something good, but its certainly not there yet.
+
 ## Installing Snail
 
 Install [uv](https://docs.astral.sh/uv/getting-started/installation/) and then run:
@@ -51,14 +57,18 @@ semicolons are optional. You can separate statements with newlines.
 
 Process files line-by-line with familiar awk semantics:
 
-```snail-awk("5\n4\n3\n2\n1\nbanana\n")
-BEGIN { total = 0 }
-/^[0-9]+/ { total = total + int($1) }
-END { print("Sum:", total); assert total == 15}
+```snail-awk("hello world\nfoo bar\n")
+/hello/ { print("matched:", $0) }
+{ print($1, "->", $2) }
 ```
 
 Built-in variables: `$0` (line), `$1`, `$2` etc (access fields), `$n` (line number), `$fn` (per-file line number), `$p` (file path), `$m` (last match).
 
+Begin/end blocks use CLI flags for setup and teardown:
+```bash
+echo -e "5\n4\n3\n2\n1" | snail --awk -b 'total = 0' -e 'print("Sum:", total)' '/^[0-9]+/ { total = total + int($1) }'
+```
+
 ### Compact Error Handling
 
 The `?` operator makes error handling terse yet expressive:
@@ -229,6 +239,13 @@ Plug 'sudonym1/snail', { 'rtp': 'extras/vim' }
 
 See [extras/vim/README.md](extras/vim/README.md) for details. Tree-sitter grammar available in `extras/tree-sitter-snail/`.
 
+## Performance
+
+Section is WIP
+
+Startup performance is benchmarked with `./benchmarks/startup.py`. On my
+machine snail adds 5 ms of overhead above the regular python3 interpreter.
+
 ## 🛠️ Building from Source
 
 ### Prerequisites

{snail_lang-0.5.1 → snail_lang-0.5.3}/README.md

@@ -7,6 +7,12 @@
 
 **Snail** is a programming language that compiles to Python, combining Python's familiarity and extensive libraries with Perl/awk-inspired syntax for quick scripts and one-liners.
 
+## AI Slop!
+
+Snail is me learning how to devlop code using LLMs. I think its neat, and
+maybe useful. I don't think this is high quality. I am going to try and LLM my
+way into something good, but its certainly not there yet.
+
 ## Installing Snail
 
 Install [uv](https://docs.astral.sh/uv/getting-started/installation/) and then run:
@@ -39,14 +45,18 @@ semicolons are optional. You can separate statements with newlines.
 
 Process files line-by-line with familiar awk semantics:
 
-```snail-awk("5\n4\n3\n2\n1\nbanana\n")
-BEGIN { total = 0 }
-/^[0-9]+/ { total = total + int($1) }
-END { print("Sum:", total); assert total == 15}
+```snail-awk("hello world\nfoo bar\n")
+/hello/ { print("matched:", $0) }
+{ print($1, "->", $2) }
 ```
 
 Built-in variables: `$0` (line), `$1`, `$2` etc (access fields), `$n` (line number), `$fn` (per-file line number), `$p` (file path), `$m` (last match).
 
+Begin/end blocks use CLI flags for setup and teardown:
+```bash
+echo -e "5\n4\n3\n2\n1" | snail --awk -b 'total = 0' -e 'print("Sum:", total)' '/^[0-9]+/ { total = total + int($1) }'
+```
+
 ### Compact Error Handling
 
 The `?` operator makes error handling terse yet expressive:
@@ -217,6 +227,13 @@ Plug 'sudonym1/snail', { 'rtp': 'extras/vim' }
 
 See [extras/vim/README.md](extras/vim/README.md) for details. Tree-sitter grammar available in `extras/tree-sitter-snail/`.
 
+## Performance
+
+Section is WIP
+
+Startup performance is benchmarked with `./benchmarks/startup.py`. On my
+machine snail adds 5 ms of overhead above the regular python3 interpreter.
+
 ## 🛠️ Building from Source
 
 ### Prerequisites

{snail_lang-0.5.1 → snail_lang-0.5.3}/crates/snail-ast/Cargo.toml

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

{snail_lang-0.5.1 → snail_lang-0.5.3}/crates/snail-ast/src/ast.rs

@@ -189,11 +189,13 @@ pub enum Expr {
     String {
         value: String,
         raw: bool,
+        bytes: bool,
         delimiter: StringDelimiter,
         span: SourceSpan,
     },
     FString {
         parts: Vec<FStringPart>,
+        bytes: bool,
         span: SourceSpan,
     },
     Bool {

{snail_lang-0.5.1 → snail_lang-0.5.3}/crates/snail-core/Cargo.toml

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

{snail_lang-0.5.1 → snail_lang-0.5.3}/crates/snail-core/src/lib.rs

@@ -34,3 +34,17 @@ pub fn compile_snail_source_with_auto_print(
         }
     }
 }
+
+/// Compile an awk program with separate begin and end code blocks.
+/// Each begin/end source is parsed as a regular Snail program.
+pub fn compile_awk_source_with_begin_end(
+    py: Python<'_>,
+    main_source: &str,
+    begin_sources: &[&str],
+    end_sources: &[&str],
+    auto_print_last: bool,
+) -> Result<PyObject, SnailError> {
+    let program = parse_awk_program_with_begin_end(main_source, begin_sources, end_sources)?;
+    let module = lower_awk_program_with_auto_print(py, &program, auto_print_last)?;
+    Ok(module)
+}

{snail_lang-0.5.1 → snail_lang-0.5.3}/crates/snail-error/Cargo.toml

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

{snail_lang-0.5.1 → snail_lang-0.5.3}/crates/snail-lower/Cargo.toml

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

{snail_lang-0.5.1 → snail_lang-0.5.3}/crates/snail-lower/src/expr.rs

@@ -4,7 +4,7 @@ use snail_ast::*;
 use snail_error::LowerError;
 
 use crate::constants::*;
-use crate::helpers::{name_expr, number_expr, regex_pattern_expr, string_expr};
+use crate::helpers::{byte_string_expr, name_expr, number_expr, regex_pattern_expr, string_expr};
 use crate::operators::{lower_binary_op, lower_bool_op, lower_compare_op, lower_unary_op};
 use crate::py_ast::{AstBuilder, py_err_to_lower};
 
@@ -441,18 +441,53 @@ pub(crate) fn lower_expr_with_exception(
         Expr::String {
             value,
             raw,
+            bytes,
             delimiter,
             span,
-        } => string_expr(builder, value, *raw, *delimiter, span),
-        Expr::FString { parts, span } => {
+        } => {
+            if *bytes {
+                byte_string_expr(builder, value, *raw, *delimiter, span)
+            } else {
+                string_expr(builder, value, *raw, *delimiter, span)
+            }
+        }
+        Expr::FString { parts, bytes, span } => {
             let values = lower_fstring_parts(builder, parts, exception_name)?;
-            builder
+            let joined = builder
                 .call_node(
                     "JoinedStr",
                     vec![PyList::new_bound(builder.py(), values).into_py(builder.py())],
                     span,
                 )
-                .map_err(py_err_to_lower)
+                .map_err(py_err_to_lower)?;
+
+            if *bytes {
+                // Wrap in .encode() call: f"...".encode()
+                let encode_attr = builder
+                    .call_node(
+                        "Attribute",
+                        vec![
+                            joined,
+                            "encode".to_string().into_py(builder.py()),
+                            builder.load_ctx().map_err(py_err_to_lower)?,
+                        ],
+                        span,
+                    )
+                    .map_err(py_err_to_lower)?;
+                builder
+                    .call_node(
+                        "Call",
+                        vec![
+                            encode_attr,
+                            PyList::empty_bound(builder.py()).into_py(builder.py()),
+                            PyList::empty_bound(builder.py()).into_py(builder.py()),
+                        ],
+                        span,
+                    )
+                    .map_err(py_err_to_lower)
+            } else {
+                Ok(joined)
+            }
         }
         Expr::Bool { value, span } => builder
             .call_node("Constant", vec![value.into_py(builder.py())], span)
@@ -1324,7 +1359,7 @@ fn substitute_placeholder(expr: &Expr, replacement: &Expr) -> Expr {
         | Expr::None { .. }
         | Expr::StructuredAccessor { .. }
         | Expr::FieldIndex { .. } => expr.clone(),
-        Expr::FString { parts, span } => Expr::FString {
+        Expr::FString { parts, bytes, span } => Expr::FString {
             parts: parts
                 .iter()
                 .map(|part| match part {
@@ -1334,6 +1369,7 @@ fn substitute_placeholder(expr: &Expr, replacement: &Expr) -> Expr {
                     }
                 })
                 .collect(),
+            bytes: *bytes,
             span: span.clone(),
         },
         Expr::Unary { op, expr, span } => Expr::Unary {

{snail_lang-0.5.1 → snail_lang-0.5.3}/crates/snail-lower/src/helpers.rs

@@ -75,6 +75,37 @@ pub(crate) fn string_expr(
     Ok(expr.into_py(builder.py()))
 }
 
+pub(crate) fn byte_string_expr(
+    builder: &AstBuilder<'_>,
+    value: &str,
+    raw: bool,
+    delimiter: StringDelimiter,
+    span: &SourceSpan,
+) -> Result<PyObject, LowerError> {
+    let rendered = match (raw, delimiter) {
+        (true, StringDelimiter::Single) => format!("rb'{}'", value),
+        (true, StringDelimiter::Double) => format!("rb\"{}\"", value),
+        (true, StringDelimiter::TripleSingle) => format!("rb'''{}'''", value),
+        (true, StringDelimiter::TripleDouble) => format!("rb\"\"\"{}\"\"\"", value),
+        (false, StringDelimiter::Single) => format!("b'{}'", value),
+        (false, StringDelimiter::Double) => format!("b\"{}\"", value),
+        (false, StringDelimiter::TripleSingle) => format!("b'''{}'''", value),
+        (false, StringDelimiter::TripleDouble) => format!("b\"\"\"{}\"\"\"", value),
+    };
+    let expr = builder
+        .py()
+        .import_bound("ast")
+        .and_then(|ast| ast.getattr("parse"))
+        .and_then(|parse| parse.call1((rendered,)))
+        .and_then(|module| module.getattr("body"))
+        .and_then(|body| body.get_item(0))
+        .and_then(|expr_stmt| expr_stmt.getattr("value"));
+
+    let expr = expr.map_err(py_err_to_lower)?;
+    set_location(&expr, span).map_err(py_err_to_lower)?;
+    Ok(expr.into_py(builder.py()))
+}
+
 pub(crate) fn number_expr(
     builder: &AstBuilder<'_>,
     value: &str,

{snail_lang-0.5.1 → snail_lang-0.5.3}/crates/snail-parser/Cargo.toml

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

{snail_lang-0.5.1 → snail_lang-0.5.3}/crates/snail-parser/src/lib.rs

@@ -12,7 +12,7 @@ mod string;
 mod util;
 
 use awk::parse_awk_rule;
-use stmt::{parse_block, parse_stmt_list};
+use stmt::parse_stmt_list;
 use util::{error_with_span, full_span, parse_error_from_pest};
 
 #[derive(Parser)]
@@ -45,47 +45,55 @@ pub fn parse_awk_program(source: &str) -> Result<AwkProgram, ParseError> {
         .ok_or_else(|| ParseError::new("missing awk program root"))?;
     let span = full_span(source);
 
-    let mut begin_blocks = Vec::new();
     let mut rules = Vec::new();
-    let mut end_blocks = Vec::new();
 
     for inner in pair.into_inner() {
         if inner.as_rule() == Rule::awk_entry_list {
             for entry in inner.into_inner() {
-                match entry.as_rule() {
-                    Rule::awk_begin => {
-                        let block = entry
-                            .into_inner()
-                            .find(|pair| pair.as_rule() == Rule::block)
-                            .ok_or_else(|| {
-                                util::error_with_span("missing BEGIN block", span.clone(), source)
-                            })?;
-                        begin_blocks.push(parse_block(block, source)?);
-                    }
-                    Rule::awk_end => {
-                        let block = entry
-                            .into_inner()
-                            .find(|pair| pair.as_rule() == Rule::block)
-                            .ok_or_else(|| {
-                                util::error_with_span("missing END block", span.clone(), source)
-                            })?;
-                        end_blocks.push(parse_block(block, source)?);
-                    }
-                    Rule::awk_rule => rules.push(parse_awk_rule(entry, source)?),
-                    _ => {}
+                if entry.as_rule() == Rule::awk_rule {
+                    rules.push(parse_awk_rule(entry, source)?);
                 }
             }
         }
     }
 
     Ok(AwkProgram {
-        begin_blocks,
+        begin_blocks: Vec::new(),
         rules,
-        end_blocks,
+        end_blocks: Vec::new(),
         span,
     })
 }
 
+/// Parses an awk program with separate begin and end code sources.
+/// Each begin/end source is parsed as a regular Snail program and its statements
+/// are injected into the resulting AwkProgram.
+pub fn parse_awk_program_with_begin_end(
+    main_source: &str,
+    begin_sources: &[&str],
+    end_sources: &[&str],
+) -> Result<AwkProgram, ParseError> {
+    let mut program = parse_awk_program(main_source)?;
+
+    // Parse each begin source as a regular program and extract statements
+    for source in begin_sources {
+        let begin_program = parse_program(source)?;
+        if !begin_program.stmts.is_empty() {
+            program.begin_blocks.push(begin_program.stmts);
+        }
+    }
+
+    // Parse each end source as a regular program and extract statements
+    for source in end_sources {
+        let end_program = parse_program(source)?;
+        if !end_program.stmts.is_empty() {
+            program.end_blocks.push(end_program.stmts);
+        }
+    }
+
+    Ok(program)
+}
+
 const AWK_ONLY_NAMES: [&str; 4] = ["$n", "$fn", "$p", "$m"];
 const AWK_ONLY_MESSAGE: &str = "awk variables are only valid in awk mode; use --awk";
 

{snail_lang-0.5.1 → snail_lang-0.5.3}/crates/snail-parser/src/snail.pest

@@ -2,11 +2,9 @@
 program = { SOI ~ stmt_sep* ~ stmt_list? ~ stmt_sep* ~ EOI }
 awk_program = { SOI ~ stmt_sep* ~ awk_entry_list? ~ stmt_sep* ~ EOI }
 
-// AWK mode: BEGIN blocks, END blocks, and pattern-action rules
+// AWK mode: pattern-action rules
 awk_entry_list = { awk_entry ~ (stmt_sep* ~ awk_entry)* ~ stmt_sep* }
-awk_entry = _{ awk_begin | awk_end | awk_rule }
-awk_begin = { "BEGIN" ~ block }
-awk_end = { "END" ~ block }
+awk_entry = _{ awk_rule }
 awk_rule = { block | awk_pattern ~ block? }
 awk_pattern = { expr }
 
@@ -223,7 +221,11 @@ injected_var = { "$fn" | "$n" | "$p" | "$m" }
 
 // Number, string, and regex literals
 number = @{ ASCII_DIGIT+ ~ ("." ~ ASCII_DIGIT+)? }
-string = @{ raw_prefix? ~ (triple_double | triple_single | double_string | single_string) }
+string = @{ string_prefix? ~ (triple_double | triple_single | double_string | single_string) }
+string_prefix = { byte_raw_prefix | raw_byte_prefix | byte_prefix | raw_prefix }
+byte_raw_prefix = { "br" }
+raw_byte_prefix = { "rb" }
+byte_prefix = { "b" }
 raw_prefix = { "r" }
 triple_double = { "\"\"\"" ~ (!"\"\"\"" ~ ANY)* ~ "\"\"\"" }
 triple_single = { "'''" ~ (!"'''" ~ ANY)* ~ "'''" }

{snail_lang-0.5.1 → snail_lang-0.5.3}/crates/snail-parser/src/string.rs

@@ -17,6 +17,7 @@ pub fn parse_string_or_fstring(pair: Pair<'_, Rule>, source: &str) -> Result<Exp
         return Ok(Expr::String {
             value: parsed.content,
             raw: true,
+            bytes: parsed.bytes,
             delimiter: parsed.delimiter,
             span,
         });
@@ -28,12 +29,17 @@ pub fn parse_string_or_fstring(pair: Pair<'_, Rule>, source: &str) -> Result<Exp
         .any(|part| matches!(part, FStringPart::Expr(_)));
     if has_expr {
         let parts = normalize_string_parts(parts, parsed.raw)?;
-        Ok(Expr::FString { parts, span })
+        Ok(Expr::FString {
+            parts,
+            bytes: parsed.bytes,
+            span,
+        })
     } else {
         let value = join_fstring_text(parts);
         Ok(Expr::String {
             value,
             raw: parsed.raw,
+            bytes: parsed.bytes,
             delimiter: parsed.delimiter,
             span,
         })
@@ -43,6 +49,7 @@ pub fn parse_string_or_fstring(pair: Pair<'_, Rule>, source: &str) -> Result<Exp
 pub struct ParsedStringLiteral {
     pub content: String,
     pub raw: bool,
+    pub bytes: bool,
     pub delimiter: StringDelimiter,
     pub content_offset: usize,
 }
@@ -50,10 +57,17 @@ pub struct ParsedStringLiteral {
 pub fn parse_string_literal(pair: Pair<'_, Rule>) -> Result<ParsedStringLiteral, ParseError> {
     let value = pair.as_str();
     let span = pair.as_span();
-    let (raw, rest, prefix_len) = if let Some(stripped) = value.strip_prefix('r') {
-        (true, stripped, 1usize)
+    // Parse prefix - check longer prefixes first
+    let (raw, bytes, rest, prefix_len) = if let Some(stripped) = value.strip_prefix("br") {
+        (true, true, stripped, 2usize)
+    } else if let Some(stripped) = value.strip_prefix("rb") {
+        (true, true, stripped, 2usize)
+    } else if let Some(stripped) = value.strip_prefix('b') {
+        (false, true, stripped, 1usize)
+    } else if let Some(stripped) = value.strip_prefix('r') {
+        (true, false, stripped, 1usize)
     } else {
-        (false, value, 0usize)
+        (false, false, value, 0usize)
     };
     let (delimiter, open, close) = if rest.starts_with("\"\"\"") {
         (StringDelimiter::TripleDouble, "\"\"\"", "\"\"\"")
@@ -73,6 +87,7 @@ pub fn parse_string_literal(pair: Pair<'_, Rule>) -> Result<ParsedStringLiteral,
     Ok(ParsedStringLiteral {
         content: content.to_string(),
         raw,
+        bytes,
         delimiter,
         content_offset,
     })
@@ -166,15 +181,29 @@ pub fn find_fstring_expr_end(content: &str, start: usize) -> Option<usize> {
     let mut brace = 0usize;
     while i < bytes.len() {
         match bytes[i] {
-            b'r' => {
-                if let Some(next) = bytes.get(i + 1)
-                    && (*next == b'\'' || *next == b'"')
-                {
-                    if let Some(end) = skip_string_literal(bytes, i) {
-                        i = end;
-                        continue;
-                    } else {
-                        return None;
+            b'r' | b'b' => {
+                // Check for string prefix combinations: r, b, rb, br
+                if let Some(next) = bytes.get(i + 1) {
+                    if *next == b'\'' || *next == b'"' {
+                        // r"..." or b"..."
+                        if let Some(end) = skip_string_literal(bytes, i) {
+                            i = end;
+                            continue;
+                        } else {
+                            return None;
+                        }
+                    } else if (*next == b'r' || *next == b'b') && bytes[i] != *next {
+                        // Could be rb"..." or br"..."
+                        if let Some(third) = bytes.get(i + 2)
+                            && (*third == b'\'' || *third == b'"')
+                        {
+                            if let Some(end) = skip_string_literal(bytes, i) {
+                                i = end;
+                                continue;
+                            } else {
+                                return None;
+                            }
+                        }
                     }
                 }
                 i += 1;
@@ -221,7 +250,14 @@ pub fn find_fstring_expr_end(content: &str, start: usize) -> Option<usize> {
 
 pub fn skip_string_literal(bytes: &[u8], start: usize) -> Option<usize> {
     let mut i = start;
-    let raw = if bytes.get(i) == Some(&b'r') {
+    // Handle prefixes: br, rb, b, r (check longer prefixes first)
+    let raw = if bytes.get(i..i + 2) == Some(b"br") || bytes.get(i..i + 2) == Some(b"rb") {
+        i += 2;
+        true
+    } else if bytes.get(i) == Some(&b'b') {
+        i += 1;
+        false
+    } else if bytes.get(i) == Some(&b'r') {
         i += 1;
         true
     } else {
@@ -327,7 +363,7 @@ pub fn shift_expr_spans(expr: &mut Expr, offset: usize, source: &str) {
         | Expr::Slice { span, .. } => {
             *span = shift_span(span, offset, source);
         }
-        Expr::FString { parts, span } => {
+        Expr::FString { parts, span, .. } => {
             for part in parts {
                 if let FStringPart::Expr(expr) = part {
                     shift_expr_spans(expr, offset, source);

{snail_lang-0.5.1 → snail_lang-0.5.3}/crates/snail-parser/tests/common.rs

@@ -84,6 +84,33 @@ pub fn expect_string_contains(expr: &Expr, snippet: &str, raw: bool, delimiter:
     }
 }
 
+pub fn expect_byte_string(expr: &Expr, expected: &str, raw: bool, delimiter: StringDelimiter) {
+    match expr {
+        Expr::String {
+            value,
+            raw: is_raw,
+            bytes,
+            delimiter: actual_delimiter,
+            ..
+        } => {
+            assert_eq!(value, expected);
+            assert_eq!(*is_raw, raw);
+            assert!(*bytes, "Expected byte string (bytes=true)");
+            assert_eq!(*actual_delimiter, delimiter);
+        }
+        other => panic!("Expected byte string, got {other:?}"),
+    }
+}
+
+pub fn expect_byte_fstring(expr: &Expr) {
+    match expr {
+        Expr::FString { bytes, .. } => {
+            assert!(*bytes, "Expected byte f-string (bytes=true)");
+        }
+        other => panic!("Expected byte f-string, got {other:?}"),
+    }
+}
+
 pub fn expect_span_start(span: &SourceSpan, line: usize, column: usize) {
     assert_eq!(span.start.line, line);
     assert_eq!(span.start.column, column);