Support builtin int addition operator

Author: olwang

core/prototype/builtins.rssi

@@ -15,8 +15,6 @@ pub fn Csv.read_into(
 
 pub fn Csv.parse_row(buffer: read RowBuffer) -> Result<fresh Row, CsvError>
 
-pub fn Int.add(left: Int, right: Int) -> Int
-
 pub fn List.consume(list: take List) -> Unit
 
 pub fn Buffer.consume(buffer: take Buffer) -> Unit

examples/int_add.rss

@@ -0,0 +1,5 @@
+fn main() -> Unit {
+    let _ = 20 + 22
+    Log.write(message: read "int add ran")
+    return Unit
+}

src/rust_lower.rs

@@ -666,14 +666,11 @@ impl<'a> RustLowerer<'a> {
                 op, left, right, ..
             } => {
                 let op = match op {
+                    BinaryOp::Add => "+",
                     BinaryOp::LogicalAnd => "&&",
                     BinaryOp::LogicalOr => "||",
                 };
-                format!(
-                    "({} {op} {})",
-                    self.lower_expr(left),
-                    self.lower_expr(right)
-                )
+                format!("{} {op} {}", self.lower_expr(left), self.lower_expr(right))
             }
             Expr::Field { base, name, .. } => {
                 format!("{}.{}", self.lower_expr(base), rust_ident(name))
@@ -1044,21 +1041,25 @@ fn is_string_concat_callee(callee: &Callee) -> bool {
 }
 
 fn lower_string_concat_call(lowerer: &mut RustLowerer<'_>, args: &[CallArg]) -> String {
-    let left = args
-        .iter()
-        .find(|arg| arg.name.as_deref() == Some("left"))
-        .or_else(|| args.first())
-        .map(|arg| lowerer.lower_expr(&arg.value))
-        .unwrap_or_else(|| "\"\".to_string()".to_string());
-    let right = args
-        .iter()
-        .find(|arg| arg.name.as_deref() == Some("right"))
-        .or_else(|| args.get(1))
-        .map(|arg| lowerer.lower_expr(&arg.value))
-        .unwrap_or_else(|| "\"\".to_string()".to_string());
+    let left = lower_call_arg(lowerer, args, "left", 0, "\"\".to_string()");
+    let right = lower_call_arg(lowerer, args, "right", 1, "\"\".to_string()");
     format!("format!(\"{{}}{{}}\", {left}, {right})")
 }
 
+fn lower_call_arg(
+    lowerer: &mut RustLowerer<'_>,
+    args: &[CallArg],
+    name: &str,
+    index: usize,
+    default: &str,
+) -> String {
+    args.iter()
+        .find(|arg| arg.name.as_deref() == Some(name))
+        .or_else(|| args.get(index))
+        .map(|arg| lowerer.lower_expr(&arg.value))
+        .unwrap_or_else(|| default.to_string())
+}
+
 fn is_resource_pool_borrow_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "ResourcePool" && name == "borrow")
 }

src/syntax/ast.rs

@@ -223,6 +223,7 @@ pub enum Expr {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BinaryOp {
+    Add,
     LogicalAnd,
     LogicalOr,
 }

src/syntax/parser.rs

@@ -738,9 +738,15 @@ fn parse_expr(tokens: &[Token], start: usize, end: usize) -> Option<Expr> {
 fn parse_binary_expr(tokens: &[Token], start: usize, end: usize) -> Option<Expr> {
     find_top_level_binary_operator(tokens, start, end, "|", "|")
         .or_else(|| find_top_level_binary_operator(tokens, start, end, "&", "&"))
+        .or_else(|| find_top_level_single_binary_operator(tokens, start, end, "+", BinaryOp::Add))
         .and_then(|(operator, op)| {
             let left = parse_expr(tokens, start, operator)?;
-            let right = parse_expr(tokens, operator + 2, end)?;
+            let right_start = if matches!(op, BinaryOp::Add) {
+                operator + 1
+            } else {
+                operator + 2
+            };
+            let right = parse_expr(tokens, right_start, end)?;
             Some(Expr::Binary {
                 op,
                 left: Box::new(left),
@@ -750,6 +756,31 @@ fn parse_binary_expr(tokens: &[Token], start: usize, end: usize) -> Option<Expr>
         })
 }
 
+fn find_top_level_single_binary_operator(
+    tokens: &[Token],
+    start: usize,
+    end: usize,
+    symbol: &str,
+    op: BinaryOp,
+) -> Option<(usize, BinaryOp)> {
+    let mut depth = 0usize;
+    let mut found = None;
+    for (index, token) in tokens.iter().enumerate().take(end).skip(start) {
+        if token.symbol("(") || token.symbol("{") || token.symbol("[") || token.symbol("<") {
+            depth += 1;
+            continue;
+        }
+        if token.symbol(")") || token.symbol("}") || token.symbol("]") || token.symbol(">") {
+            depth = depth.saturating_sub(1);
+            continue;
+        }
+        if depth == 0 && token.symbol(symbol) {
+            found = Some((index, op));
+        }
+    }
+    found
+}
+
 fn find_trailing_top_level_question(tokens: &[Token], start: usize, end: usize) -> Option<usize> {
     if end <= start || !tokens.get(end - 1).is_some_and(|token| token.symbol("?")) {
         return None;

tests/checker.rs

@@ -312,6 +312,19 @@ fn main() -> Unit {
     assert!(rust.contains("rsscript_runtime::log_write(&message);"));
 }
 
+#[test]
+fn rust_lowering_maps_int_add_to_rust_std_expression() {
+    let source = r#"
+fn main() -> Unit {
+    let value = 20 + 22
+    return Unit
+}
+"#;
+    let rust = lower_source_to_rust("int.rss", source).expect("source should lower");
+
+    assert!(rust.contains("let value = 20 + 22;"));
+}
+
 #[test]
 fn rust_lowering_maps_try_operator_to_rust_result_propagation() {
     let source = r#"

tests/fixtures/pass/csv-stream-local-buffer.rss

@@ -11,7 +11,7 @@ fn sum_csv(path: read Path) -> Result<Int, CsvError> {
     with File.open_read(path: read path) as file {
         Csv.read_into(file: mut file, buffer: mut buffer)?
         let row = Csv.parse_row(buffer: read buffer)?
-        Int.add(left: total, right: row.amount)
+        total + row.amount
     }
 
     return Ok(total)