Fix nightly syntax combo gate

Author: a19q3

Cargo.toml

@@ -16,6 +16,8 @@ exclude = [
     ".rustfmt.toml",
     ".github/",
     "A2_TYPE_RESOLUTION_AUDIT.md",
+    "BRANCHES.md",
+    "README_REVIEW.md",
     "RUST_COMPARATIVE_AUDIT.md",
     "SECURITY_AUDIT_SEMANTIC.md",
     "cellscript-*.png",

src/fmt/mod.rs

@@ -549,26 +549,14 @@ impl Formatter {
                 let fields = preserve.fields.join("\n");
                 format!("preserve {} from {} {{\n{}\n}}", preserve.output_name, preserve.input_name, fields)
             }
-            Expr::Block(stmts) => {
-                let inner = stmts
-                    .iter()
-                    .map(|stmt| {
-                        let mut formatter = Formatter::new(self.config.clone());
-                        formatter.indent_level = 0;
-                        formatter.format_stmt(stmt);
-                        formatter.output.trim().to_string()
-                    })
-                    .collect::<Vec<_>>()
-                    .join(" ");
-                format!("{{ {} }}", inner)
-            }
+            Expr::Block(stmts) => format!("{{ {} }}", self.format_expr_block_body(stmts)),
             Expr::Tuple(items) => format!("({})", items.iter().map(|item| self.format_expr(item)).collect::<Vec<_>>().join(", ")),
             Expr::Array(items) => format!("[{}]", items.iter().map(|item| self.format_expr(item)).collect::<Vec<_>>().join(", ")),
             Expr::If(if_expr) => format!(
                 "if {} {{ {} }} else {{ {} }}",
                 self.format_expr(&if_expr.condition),
-                self.format_expr(&if_expr.then_branch),
-                self.format_expr(&if_expr.else_branch)
+                self.format_branch_expr_body(&if_expr.then_branch),
+                self.format_branch_expr_body(&if_expr.else_branch)
             ),
             Expr::Cast(cast) => format!("{} as {}", self.format_expr(&cast.expr), format_type(&cast.ty)),
             Expr::Range(range) => format!("{}..{}", self.format_expr(&range.start), self.format_expr(&range.end)),
@@ -599,6 +587,26 @@ impl Formatter {
         }
     }
 
+    fn format_branch_expr_body(&self, expr: &Expr) -> String {
+        match expr {
+            Expr::Block(stmts) => self.format_expr_block_body(stmts),
+            expr => self.format_expr(expr),
+        }
+    }
+
+    fn format_expr_block_body(&self, stmts: &[Stmt]) -> String {
+        stmts
+            .iter()
+            .map(|stmt| {
+                let mut formatter = Formatter::new(self.config.clone());
+                formatter.indent_level = 0;
+                formatter.format_stmt(stmt);
+                formatter.output.trim().to_string()
+            })
+            .collect::<Vec<_>>()
+            .join(" ")
+    }
+
     fn format_field_initializer(&self, name: &str, value: &Expr) -> String {
         if matches!(value, Expr::Identifier(identifier) if identifier == name) {
             name.to_string()
@@ -867,6 +875,28 @@ where
         assert!(formatted.contains("create token = Token { amount, symbol }"), "unexpected formatted source:\n{}", formatted);
     }
 
+    #[test]
+    fn format_if_expression_branch_blocks_are_idempotent() {
+        let source = r#"
+module demo
+
+action choose(flag: bool) -> u64
+where
+    let pair = if flag { (1, 2) } else { (3, 4) }
+    return pair.0
+"#;
+        let tokens = lexer::lex(source).unwrap();
+        let module = parser::parse(&tokens).unwrap();
+        let formatted = format_default(&module).unwrap();
+        let tokens2 = lexer::lex(&formatted).unwrap();
+        let module2 = parser::parse(&tokens2).unwrap();
+        let formatted2 = format_default(&module2).unwrap();
+
+        assert_eq!(formatted, formatted2);
+        assert!(formatted.contains("let pair = if flag { (1, 2) } else { (3, 4) }"), "unexpected formatted source:\n{}", formatted);
+        assert!(!formatted.contains("{{"), "unexpected formatted source:\n{}", formatted);
+    }
+
     #[test]
     fn format_uses_canonical_assert_and_no_const_semicolon() {
         let source = r#"

src/ir/mod.rs

@@ -1961,10 +1961,10 @@ impl IrGenerator {
                 self.record_error("string literals are only supported in metadata positions such as assert messages", Span::default());
                 LoweredExpr { operand: IrOperand::Const(IrConst::U64(0)), current: Some(current) }
             }
-            Expr::ByteString(_) => {
-                self.record_error("byte string literals require an explicit lowered byte-array context", Span::default());
-                LoweredExpr { operand: IrOperand::Const(IrConst::U64(0)), current: Some(current) }
-            }
+            Expr::ByteString(bytes) => LoweredExpr {
+                operand: IrOperand::Const(IrConst::Array(bytes.iter().copied().map(IrConst::U8).collect())),
+                current: Some(current),
+            },
             Expr::Range(_) => {
                 self.record_error("range expressions are only supported as for-loop iterables", Span::default());
                 LoweredExpr { operand: IrOperand::Const(IrConst::U64(0)), current: Some(current) }
@@ -2013,7 +2013,7 @@ impl IrGenerator {
             IrConst::Bool(_) => IrType::Bool,
             IrConst::Address(_) => IrType::Address,
             IrConst::Hash(_) => IrType::Hash,
-            IrConst::Array(_) => IrType::Array(Box::new(IrType::U8), 0),
+            IrConst::Array(items) => IrType::Array(Box::new(IrType::U8), items.len()),
         }
     }
 
@@ -6208,6 +6208,40 @@ where
         );
     }
 
+    #[test]
+    fn byte_string_literal_lowers_to_fixed_array_const() {
+        let source = r#"
+module test
+
+action symbol() -> [u8; 4]
+where
+    return b"TEST"
+"#;
+        let ir = parse_and_lower(source);
+        let action = ir
+            .items
+            .iter()
+            .find_map(|item| match item {
+                IrItem::Action(a) if a.name == "symbol" => Some(a),
+                _ => None,
+            })
+            .expect("expected symbol action");
+        let bytes = action.body.blocks.iter().find_map(|block| match &block.terminator {
+            IrTerminator::Return(Some(IrOperand::Const(IrConst::Array(items)))) => Some(items),
+            _ => None,
+        });
+
+        let bytes = bytes.expect("expected byte string return to lower to a fixed array const");
+        let lowered = bytes
+            .iter()
+            .map(|byte| match byte {
+                IrConst::U8(byte) => *byte,
+                other => panic!("expected fixed byte const, got {:?}", other),
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(lowered, b"TEST");
+    }
+
     #[test]
     fn stdlib_transfer_lowers_to_single_consumed_input_and_locked_output() {
         let source = r#"

src/repl.rs

@@ -63,12 +63,12 @@ impl Repl {
         println!(
             "{}",
             r#"
-   ____     _       _   _           _   
-  / ___|__| | ___ | |_| |__   ___ | |_ 
+   ____     _       _   _           _
+  / ___|__| | ___ | |_| |__   ___ | |_
  | |   / _` |/ _ \| __| '_ \ / _ \| __|
- | |__| (_| | (_) | |_| | | | (_) | |_ 
+ | |__| (_| | (_) | |_| | | | (_) | |_
   \____\__,_|\___/ \__|_| |_|\___/ \__|
-                                       
+
         CellScript Interactive Shell
               Version 0.1.0
 "#

src/types/mod.rs

@@ -2659,7 +2659,7 @@ impl<'a> TypeChecker<'a> {
             Expr::Integer(_) => Ok(Type::U64),
             Expr::Bool(_) => Ok(Type::Bool),
             Expr::String(_) => Ok(Type::Named("String".to_string())),
-            Expr::ByteString(_) => Ok(Type::Array(Box::new(Type::U8), 0)),
+            Expr::ByteString(bytes) => Ok(Type::Array(Box::new(Type::U8), bytes.len())),
             Expr::Identifier(name) => {
                 if let Some(ty) = env.lookup(name).cloned() {
                     Ok(ty)
@@ -3334,9 +3334,15 @@ impl<'a> TypeChecker<'a> {
 
         for arm in &match_expr.arms {
             if arm.pattern == "_" {
+                if has_wildcard {
+                    return Err(CompileError::new("duplicate wildcard match arm", arm.span));
+                }
                 has_wildcard = true;
                 continue;
             }
+            if has_wildcard {
+                return Err(CompileError::new("wildcard pattern '_' must be the last match arm", arm.span));
+            }
             let Some(variant) = match_pattern_variant(enum_name, &arm.pattern) else {
                 return Err(CompileError::new(
                     format!("match pattern '{}' does not match enum '{}'", arm.pattern, enum_name),
@@ -6275,6 +6281,45 @@ where
         assert!(err.message.contains("require block contains assignment"), "unexpected error: {}", err.message);
     }
 
+    #[test]
+    fn byte_string_literal_infers_exact_fixed_array_length() {
+        let module = source_module(
+            r#"
+module test
+
+action symbol() -> [u8; 4]
+where
+    return b"TEST"
+"#,
+        );
+
+        check(&module).unwrap();
+    }
+
+    #[test]
+    fn match_wildcard_arm_must_be_last() {
+        let module = source_module(
+            r#"
+module test
+
+enum Flag {
+    Off,
+    On,
+}
+
+action bad(flag: Flag) -> u64
+where
+    return match flag {
+        _ => { 1 },
+        Flag::Off => { 2 },
+    }
+"#,
+        );
+
+        let err = check(&module).unwrap_err();
+        assert!(err.message.contains("wildcard pattern '_' must be the last match arm"), "unexpected error: {}", err.message);
+    }
+
     #[test]
     fn stdlib_claim_rejects_non_receipt_input() {
         let module = source_module(