add unstable flags and move arith ops to it

Author: stringhandler

examples/infix_operators.simf

@@ -12,25 +12,26 @@ fn main() {
     let a: u8 = 20;
     let b: u8 = 6;
 
+    // run `simc` with `-Z infix_arithmetic_operators` to allow these.
     // Addition: u8 + u8 → u8, panics on overflow
-    let sum: u8 = a + b;
-    assert!(jet::eq_8(sum, 26));
+    // let sum: u8 = a + b;
+    // assert!(jet::eq_8(sum, 26));
 
     // Subtraction: u8 - u8 → u8, panics on underflow
-    let diff: u8 = a - b;
-    assert!(jet::eq_8(diff, 14));
+    // let diff: u8 = a - b;
+    // assert!(jet::eq_8(diff, 14));
 
     // Multiplication: u8 * u8 → u16 (full precision, no overflow possible)
-    let product: u16 = a * b;
-    assert!(jet::eq_16(product, 120));
+    // let product: u16 = a * b;
+    // assert!(jet::eq_16(product, 120));
 
     // Division: u8 / u8 → u8, panics if divisor is zero
-    let quotient: u8 = a / b;
-    assert!(jet::eq_8(quotient, 3));
+    // let quotient: u8 = a / b;
+    // assert!(jet::eq_8(quotient, 3));
 
     // Modulo: u8 % u8 → u8, panics if divisor is zero
-    let remainder: u8 = a % b;
-    assert!(jet::eq_8(remainder, 2));
+    // let remainder: u8 = a % b;
+    // assert!(jet::eq_8(remainder, 2));
 
     // Equality: u8 == u8 → bool
     assert!(a == a);   // 20 == 20 is true

src/lib.rs

@@ -17,6 +17,7 @@ mod serde;
 pub mod str;
 pub mod tracker;
 pub mod types;
+pub mod unstable_flags;
 pub mod value;
 mod witness;
 
@@ -34,6 +35,7 @@ use crate::debug::DebugSymbols;
 use crate::error::{ErrorCollector, WithFile};
 use crate::parse::ParseFromStrWithErrors;
 pub use crate::types::ResolvedType;
+pub use crate::unstable_flags::{UnstableFlags, with_flags};
 pub use crate::value::Value;
 pub use crate::witness::{Arguments, Parameters, WitnessTypes, WitnessValues};
 
@@ -53,10 +55,17 @@ impl TemplateProgram {
     /// ## Errors
     ///
     /// The string is not a valid SimplicityHL program.
-    pub fn new<Str: Into<Arc<str>>>(s: Str, deny_all_warnings: bool) -> Result<Self, String> {
+    pub fn new<Str: Into<Arc<str>>>(
+        s: Str,
+        deny_all_warnings: bool,
+        flags: UnstableFlags,
+    ) -> Result<Self, String> {
         let file = s.into();
         let mut error_handler = ErrorCollector::new(Arc::clone(&file));
-        let parse_program = parse::Program::parse_from_str_with_errors(&file, &mut error_handler);
+        let parse_program =
+            with_flags(flags, || {
+                parse::Program::parse_from_str_with_errors(&file, &mut error_handler)
+            });
         if let Some(program) = parse_program {
             let (ast_program, warnings) =
                 ast::Program::analyze(&program).with_file(Arc::clone(&file))?;
@@ -199,8 +208,9 @@ impl CompiledProgram {
         arguments: Arguments,
         include_debug_symbols: bool,
         deny_all_warnings: bool,
+        flags: UnstableFlags,
     ) -> Result<Self, String> {
-        TemplateProgram::new(s, deny_all_warnings)
+        TemplateProgram::new(s, deny_all_warnings, flags)
             .and_then(|template| template.instantiate(arguments, include_debug_symbols))
     }
 
@@ -285,9 +295,10 @@ impl SatisfiedProgram {
         witness_values: WitnessValues,
         include_debug_symbols: bool,
         deny_all_warnings: bool,
+        flags: UnstableFlags,
     ) -> Result<Self, String> {
         let compiled =
-            CompiledProgram::new(s, arguments, include_debug_symbols, deny_all_warnings)?;
+            CompiledProgram::new(s, arguments, include_debug_symbols, deny_all_warnings, flags)?;
         compiled.satisfy(witness_values)
     }
 
@@ -390,7 +401,11 @@ pub(crate) mod tests {
         }
 
         pub fn template_text(program_text: Cow<str>) -> Self {
-            let program = match TemplateProgram::new(program_text.as_ref()) {
+            Self::template_text_with_flags(program_text, UnstableFlags::new())
+        }
+
+        pub fn template_text_with_flags(program_text: Cow<str>, flags: UnstableFlags) -> Self {
+            let program = match TemplateProgram::new(program_text.as_ref(), false, flags) {
                 Ok(x) => x,
                 Err(error) => panic!("{error}"),
             };
@@ -731,6 +746,8 @@ fn main() {
             Arguments::default(),
             WitnessValues::default(),
             false,
+            false,
+            UnstableFlags::new(),
         ) {
             Ok(_) => panic!("Accepted faulty program"),
             Err(error) => {
@@ -780,7 +797,13 @@ fn main() {
             .assert_run_success();
     }
 
-    // --- infix operator integration tests ---
+    // --- infix operator integration tests (require -Z infix_arithmetic_operators) ---
+
+    fn arith_flags() -> UnstableFlags {
+        let mut f = UnstableFlags::new();
+        f.enable(crate::unstable_flags::UnstableFlag::InfixArithmeticOperators);
+        f
+    }
 
     #[test]
     fn infix_op_add_u8() {
@@ -790,7 +813,8 @@ fn main() {
     let (_, sum): (bool, u8) = a + b;
     assert!(jet::eq_8(sum, 19));
 }"#;
-        TestCase::program_text(Cow::Borrowed(prog))
+        TestCase::template_text_with_flags(Cow::Borrowed(prog), arith_flags())
+            .with_arguments(Arguments::default())
             .with_witness_values(WitnessValues::default())
             .assert_run_success();
     }
@@ -803,7 +827,8 @@ fn main() {
     let (_, diff): (bool, u8) = a - b;
     assert!(jet::eq_8(diff, 13));
 }"#;
-        TestCase::program_text(Cow::Borrowed(prog))
+        TestCase::template_text_with_flags(Cow::Borrowed(prog), arith_flags())
+            .with_arguments(Arguments::default())
             .with_witness_values(WitnessValues::default())
             .assert_run_success();
     }
@@ -816,7 +841,8 @@ fn main() {
     let product: u16 = a * b;
     assert!(jet::eq_16(product, 42));
 }"#;
-        TestCase::program_text(Cow::Borrowed(prog))
+        TestCase::template_text_with_flags(Cow::Borrowed(prog), arith_flags())
+            .with_arguments(Arguments::default())
             .with_witness_values(WitnessValues::default())
             .assert_run_success();
     }
@@ -829,7 +855,8 @@ fn main() {
     let quotient: u8 = a / b;
     assert!(jet::eq_8(quotient, 5));
 }"#;
-        TestCase::program_text(Cow::Borrowed(prog))
+        TestCase::template_text_with_flags(Cow::Borrowed(prog), arith_flags())
+            .with_arguments(Arguments::default())
             .with_witness_values(WitnessValues::default())
             .assert_run_success();
     }
@@ -842,7 +869,8 @@ fn main() {
     let remainder: u8 = a % b;
     assert!(jet::eq_8(remainder, 2));
 }"#;
-        TestCase::program_text(Cow::Borrowed(prog))
+        TestCase::template_text_with_flags(Cow::Borrowed(prog), arith_flags())
+            .with_arguments(Arguments::default())
             .with_witness_values(WitnessValues::default())
             .assert_run_success();
     }
@@ -856,7 +884,14 @@ fn main() {
     let sum: u8 = a + b;
     assert!(jet::eq_8(sum, 3));
 }"#;
-        match SatisfiedProgram::new(prog, Arguments::default(), WitnessValues::default(), false) {
+        match SatisfiedProgram::new(
+            prog,
+            Arguments::default(),
+            WitnessValues::default(),
+            false,
+            false,
+            arith_flags(),
+        ) {
             Ok(_) => panic!("Expected type error for `+` with plain u8 output"),
             Err(error) => assert!(
                 error.contains("Expected expression of type"),

src/main.rs

@@ -2,7 +2,8 @@ use base64::display::Base64Display;
 use base64::engine::general_purpose::STANDARD;
 use clap::{Arg, ArgAction, Command};
 
-use simplicityhl::{AbiMeta, TemplateProgram};
+use simplicityhl::{AbiMeta, TemplateProgram, UnstableFlags};
+use simplicityhl::unstable_flags::UnstableFlag;
 use std::{env, fmt};
 
 #[cfg_attr(feature = "serde", derive(serde::Serialize))]
@@ -89,6 +90,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                     .action(ArgAction::SetTrue)
                     .help("Treat warnings as errors"),
             )
+            .arg(
+                Arg::new("unstable_flags")
+                    .short('Z')
+                    .value_name("FLAG")
+                    .action(ArgAction::Append)
+                    .help(
+                        "Enable an unstable feature flag (can be passed multiple times). \
+                         Known flags: infix_arithmetic_operators",
+                    ),
+            )
     };
 
     let matches = command.get_matches();
@@ -120,7 +131,22 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     };
 
     let deny_warnings = matches.get_flag("deny_warnings");
-    let template = match TemplateProgram::new(prog_text, deny_warnings) {
+
+    let mut flags = UnstableFlags::new();
+    for flag_str in matches
+        .get_many::<String>("unstable_flags")
+        .unwrap_or_default()
+    {
+        match flag_str.parse::<UnstableFlag>() {
+            Ok(flag) => flags.enable(flag),
+            Err(e) => {
+                eprintln!("error: {e}");
+                std::process::exit(1);
+            }
+        }
+    }
+
+    let template = match TemplateProgram::new(prog_text, deny_warnings, flags) {
         Ok(t) => t,
         Err(e) => {
             eprintln!("{}", e);

src/parse.rs

@@ -1706,11 +1706,11 @@ impl SingleExpression {
             .map(|es| SingleExpressionInner::Expression(Arc::from(es)));
 
         let op = select! {
-            Token::Plus => InfixOp::Add,
-            Token::Minus => InfixOp::Sub,
-            Token::Star => InfixOp::Mul,
-            Token::Slash => InfixOp::Div,
-            Token::Percent => InfixOp::Rem,
+            Token::Plus if crate::unstable_flags::is_enabled(crate::unstable_flags::UnstableFlag::InfixArithmeticOperators) => InfixOp::Add,
+            Token::Minus if crate::unstable_flags::is_enabled(crate::unstable_flags::UnstableFlag::InfixArithmeticOperators) => InfixOp::Sub,
+            Token::Star if crate::unstable_flags::is_enabled(crate::unstable_flags::UnstableFlag::InfixArithmeticOperators) => InfixOp::Mul,
+            Token::Slash if crate::unstable_flags::is_enabled(crate::unstable_flags::UnstableFlag::InfixArithmeticOperators) => InfixOp::Div,
+            Token::Percent if crate::unstable_flags::is_enabled(crate::unstable_flags::UnstableFlag::InfixArithmeticOperators) => InfixOp::Rem,
             Token::EqEq => InfixOp::Eq,
             Token::BangEq => InfixOp::Ne,
             Token::LAngle => InfixOp::Lt,

src/tracker.rs

@@ -472,7 +472,7 @@ mod tests {
 
     #[test]
     fn test_debug_and_jet_tracing() {
-        let program = TemplateProgram::new(TEST_PROGRAM).unwrap();
+        let program = TemplateProgram::new(TEST_PROGRAM, false, crate::UnstableFlags::new()).unwrap();
         let program = program.instantiate(Arguments::default(), true).unwrap();
         let satisfied = program.satisfy(WitnessValues::default()).unwrap();
 
@@ -541,7 +541,7 @@ mod tests {
     fn test_arith_jet_trace_regression() {
         let env = create_test_env();
 
-        let program = TemplateProgram::new(TEST_ARITHMETIC_JETS).unwrap();
+        let program = TemplateProgram::new(TEST_ARITHMETIC_JETS, false, crate::UnstableFlags::new()).unwrap();
         let program = program.instantiate(Arguments::default(), true).unwrap();
         let satisfied = program.satisfy(WitnessValues::default()).unwrap();