add and, or and xor

Author: stringhandler

examples/infix_operators.simf

@@ -1,12 +1,15 @@
 /*
  * INFIX OPERATORS
  *
- * Demonstrates all infix operators: +, -, *, /, %, ==, !=, <, <=, >, >=
+ * Demonstrates all infix operators: +, -, *, /, %, &, |, ^, ==, !=, <, <=, >, >=
  *
  * Addition and subtraction panic at runtime on overflow/underflow.
  * Multiplication returns a type twice the width of the operands (no overflow).
  * Division and modulo return the same type as the operands.
+ * Bitwise operators return the same type as the operands.
  * Comparison operators return bool.
+ *
+ * Arithmetic operators require: simc -Z infix_arithmetic_operators
  */
 fn main() {
     let a: u8 = 20;
@@ -33,6 +36,18 @@ fn main() {
     // let remainder: u8 = a % b;
     // assert!(jet::eq_8(remainder, 2));
 
+    // Bitwise AND: u8 & u8 → u8
+    let and: u8 = a & b;
+    assert!(jet::eq_8(and, 4));   // 0b00010100 & 0b00000110 = 0b00000100
+
+    // Bitwise OR: u8 | u8 → u8
+    let or: u8 = a | b;
+    assert!(jet::eq_8(or, 22));   // 0b00010100 | 0b00000110 = 0b00010110
+
+    // Bitwise XOR: u8 ^ u8 → u8
+    let xor: u8 = a ^ b;
+    assert!(jet::eq_8(xor, 18));  // 0b00010100 ^ 0b00000110 = 0b00010010
+
     // Equality: u8 == u8 → bool
     assert!(a == a);   // 20 == 20 is true
     assert!(a != b);   // 20 != 6 is true

src/ast.rs

@@ -1133,6 +1133,44 @@ fn determine_comparison_op_jet(
 /// | `*`      | `u(2N)`     | `MultiplyN` | `uN`       | no              |
 /// | `/`      | `uN`        | `DivideN`   | `uN`       | no              |
 /// | `%`      | `uN`        | `ModuloN`   | `uN`       | no              |
+/// Maps a bitwise infix operator and operand type to the corresponding Simplicity jet.
+///
+/// | Operator | Output type | Jet    | Input type |
+/// |----------|-------------|--------|------------|
+/// | `&`      | `uN`        | `AndN` | `uN`       |
+/// | `\|`     | `uN`        | `OrN`  | `uN`       |
+/// | `^`      | `uN`        | `XorN` | `uN`       |
+fn determine_infix_bitwise_op_jet(
+    op: &parse::InfixOp,
+    ty: &ResolvedType,
+) -> Result<Elements, Error> {
+    use parse::InfixOp::*;
+    use UIntType::*;
+
+    let uint_ty = ty
+        .as_integer()
+        .ok_or_else(|| Error::ExpressionUnexpectedType(ty.clone()))?;
+
+    match (op, uint_ty) {
+        (BitAnd, U1) => Ok(Elements::And1),
+        (BitAnd, U8) => Ok(Elements::And8),
+        (BitAnd, U16) => Ok(Elements::And16),
+        (BitAnd, U32) => Ok(Elements::And32),
+        (BitAnd, U64) => Ok(Elements::And64),
+        (BitOr, U1) => Ok(Elements::Or1),
+        (BitOr, U8) => Ok(Elements::Or8),
+        (BitOr, U16) => Ok(Elements::Or16),
+        (BitOr, U32) => Ok(Elements::Or32),
+        (BitOr, U64) => Ok(Elements::Or64),
+        (BitXor, U1) => Ok(Elements::Xor1),
+        (BitXor, U8) => Ok(Elements::Xor8),
+        (BitXor, U16) => Ok(Elements::Xor16),
+        (BitXor, U32) => Ok(Elements::Xor32),
+        (BitXor, U64) => Ok(Elements::Xor64),
+        _ => Err(Error::ExpressionUnexpectedType(ty.clone())),
+    }
+}
+
 fn determine_infix_arith_op_jet(
     op: &parse::InfixOp,
     ty: &ResolvedType,
@@ -1411,6 +1449,29 @@ impl AbstractSyntaxTree for SingleExpression {
                             lhs_warnings,
                         )
                     }
+                    BitAnd | BitOr | BitXor => {
+                        // Bitwise operators: same input and output type, no carry or overflow
+                        let jet =
+                            determine_infix_bitwise_op_jet(binary.op(), ty).with_span(from)?;
+                        let (lhs, mut lhs_warnings) =
+                            Expression::analyze(binary.lhs(), ty, scope)?;
+                        let (rhs, mut rhs_warnings) =
+                            Expression::analyze(binary.rhs(), ty, scope)?;
+                        lhs_warnings.append(&mut rhs_warnings);
+                        scope.track_call(from, TrackedCallName::Jet);
+                        (
+                            SingleExpressionInner::BinaryOp {
+                                jet,
+                                lhs: Arc::new(lhs),
+                                rhs: Arc::new(rhs),
+                                assert_no_carry: false,
+                                swap_args: false,
+                                negate_result: false,
+                                check_nonzero_divisor: false,
+                            },
+                            lhs_warnings,
+                        )
+                    }
                     Add | Sub | Mul | Div | Rem => {
                         // Arithmetic operators
                         let (jet, arg_ty, assert_no_carry) =

src/lexer.rs

@@ -59,6 +59,12 @@ pub enum Token<'src> {
     Slash,
     /// `%`
     Percent,
+    /// `&`
+    Ampersand,
+    /// `|`
+    Pipe,
+    /// `^`
+    Caret,
     /// `==`
     EqEq,
     /// `!=`
@@ -124,6 +130,9 @@ impl<'src> fmt::Display for Token<'src> {
             Token::Star => write!(f, "*"),
             Token::Slash => write!(f, "/"),
             Token::Percent => write!(f, "%"),
+            Token::Ampersand => write!(f, "&"),
+            Token::Pipe => write!(f, "|"),
+            Token::Caret => write!(f, "^"),
             Token::EqEq => write!(f, "=="),
             Token::BangEq => write!(f, "!="),
             Token::LtEq => write!(f, "<="),
@@ -226,6 +235,9 @@ pub fn lexer<'src>(
         just("*").to(Token::Star),
         just("/").to(Token::Slash),
         just("%").to(Token::Percent),
+        just("&").to(Token::Ampersand),
+        just("|").to(Token::Pipe),
+        just("^").to(Token::Caret),
     ));
 
     let comment = just("//")

src/parse.rs

@@ -316,6 +316,12 @@ pub enum InfixOp {
     Div,
     /// `%`
     Rem,
+    /// `&`
+    BitAnd,
+    /// `|`
+    BitOr,
+    /// `^`
+    BitXor,
     /// `==`
     Eq,
     /// `!=`
@@ -338,6 +344,9 @@ impl fmt::Display for InfixOp {
             InfixOp::Mul => write!(f, "*"),
             InfixOp::Div => write!(f, "/"),
             InfixOp::Rem => write!(f, "%"),
+            InfixOp::BitAnd => write!(f, "&"),
+            InfixOp::BitOr => write!(f, "|"),
+            InfixOp::BitXor => write!(f, "^"),
             InfixOp::Eq => write!(f, "=="),
             InfixOp::Ne => write!(f, "!="),
             InfixOp::Lt => write!(f, "<"),
@@ -1711,6 +1720,9 @@ impl SingleExpression {
             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::Ampersand => InfixOp::BitAnd,
+            Token::Pipe => InfixOp::BitOr,
+            Token::Caret => InfixOp::BitXor,
             Token::EqEq => InfixOp::Eq,
             Token::BangEq => InfixOp::Ne,
             Token::LAngle => InfixOp::Lt,

src/unstable_flags.rs

@@ -12,6 +12,9 @@ use std::str::FromStr;
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum UnstableFlag {
     /// Enable infix arithmetic operators: `+`, `-`, `*`, `/`, `%`.
+    ///
+    /// These operators have side effects (overflow/underflow panics for `+`/`-`,
+    /// division-by-zero panics for `/`/`%`) and so are opt-in.
     InfixArithmeticOperators,
     // ^^^ Add new flags here. Each flag needs:
     //   1. A variant in this enum