Track moves through short-circuit expressions

Author: olwang

src/checks/body.rs

@@ -198,6 +198,10 @@ fn apply_expr_effects(expr: &HirExpr, state: &mut BodyState) {
             state.apply_move_events(events);
             apply_expr_effects(value, state);
         }
+        HirExpr::Binary { left, right, .. } => {
+            apply_expr_effects(left, state);
+            apply_expr_effects(right, state);
+        }
         HirExpr::Field { base, .. } => apply_expr_effects(base, state),
         HirExpr::Closure { .. }
         | HirExpr::Ident { .. }
@@ -444,6 +448,10 @@ fn check_resource_pool_lease_expr(
         HirExpr::Effect { value, .. } | HirExpr::Manage { value, .. } => {
             check_resource_pool_lease_expr(analyzer, value, within_with_resource);
         }
+        HirExpr::Binary { left, right, .. } => {
+            check_resource_pool_lease_expr(analyzer, left, within_with_resource);
+            check_resource_pool_lease_expr(analyzer, right, within_with_resource);
+        }
         HirExpr::Field { base, .. } => {
             check_resource_pool_lease_expr(analyzer, base, within_with_resource);
         }

src/checks/calls.rs

@@ -79,6 +79,10 @@ fn check_expr(analyzer: &mut Analyzer<'_>, expr: &HirExpr) {
         HirExpr::Effect { value, .. } | HirExpr::Manage { value, .. } => {
             check_expr(analyzer, value);
         }
+        HirExpr::Binary { left, right, .. } => {
+            check_expr(analyzer, left);
+            check_expr(analyzer, right);
+        }
         HirExpr::Field { base, .. } => check_expr(analyzer, base),
         HirExpr::Closure { body, .. } => check_block(analyzer, body),
         HirExpr::Ident { .. }
@@ -287,6 +291,7 @@ fn hir_expr_span(expr: &HirExpr) -> &Span {
         HirExpr::Ident { span, .. }
         | HirExpr::Number { span, .. }
         | HirExpr::String { span, .. }
+        | HirExpr::Binary { span, .. }
         | HirExpr::Field { span, .. }
         | HirExpr::Call { span, .. }
         | HirExpr::Effect { span, .. }

src/checks/local.rs

@@ -358,6 +358,10 @@ fn collect_expr_take_handle_fields(expr: &HirExpr, fields: &mut Vec<TakeHandleFi
         HirExpr::Effect { value, .. } | HirExpr::Manage { value, .. } => {
             collect_expr_take_handle_fields(value, fields);
         }
+        HirExpr::Binary { left, right, .. } => {
+            collect_expr_take_handle_fields(left, fields);
+            collect_expr_take_handle_fields(right, fields);
+        }
         HirExpr::Field { base, .. } => collect_expr_take_handle_fields(base, fields),
         HirExpr::Call { args, .. } => {
             for arg in args {
@@ -585,6 +589,10 @@ fn collect_ordered_moved_uses_from_expr(
             collect_ordered_moved_uses_from_expr(value, state, moved_uses);
             state.apply_move_events(events);
         }
+        HirExpr::Binary { left, right, .. } => {
+            collect_ordered_moved_uses_from_expr(left, state, moved_uses);
+            collect_ordered_moved_uses_from_expr(right, state, moved_uses);
+        }
         HirExpr::Field { base, .. } => {
             collect_ordered_moved_uses_from_expr(base, state, moved_uses);
         }
@@ -714,6 +722,10 @@ fn collect_retained_closure_captures_from_expr(
         HirExpr::Effect { value, .. } | HirExpr::Manage { value, .. } => {
             collect_retained_closure_captures_from_expr(value, state, captures);
         }
+        HirExpr::Binary { left, right, .. } => {
+            collect_retained_closure_captures_from_expr(left, state, captures);
+            collect_retained_closure_captures_from_expr(right, state, captures);
+        }
         HirExpr::Field { base, .. } => {
             collect_retained_closure_captures_from_expr(base, state, captures);
         }
@@ -737,6 +749,7 @@ fn retained_closure_arg(expr: &HirExpr) -> Option<(&HirBlock, &Span)> {
         } => retained_closure_arg(value),
         HirExpr::Effect { .. }
         | HirExpr::Manage { .. }
+        | HirExpr::Binary { .. }
         | HirExpr::Ident { .. }
         | HirExpr::Number { .. }
         | HirExpr::String { .. }
@@ -767,6 +780,7 @@ fn hir_expr_span(expr: &HirExpr) -> &Span {
         HirExpr::Ident { span, .. }
         | HirExpr::Number { span, .. }
         | HirExpr::String { span, .. }
+        | HirExpr::Binary { span, .. }
         | HirExpr::Field { span, .. }
         | HirExpr::Call { span, .. }
         | HirExpr::Effect { span, .. }
@@ -854,6 +868,10 @@ fn collect_expr_resource_escapes(
         HirExpr::Effect { value, .. } | HirExpr::Manage { value, .. } => {
             collect_expr_resource_escapes(value, escapes_by_with_span);
         }
+        HirExpr::Binary { left, right, .. } => {
+            collect_expr_resource_escapes(left, escapes_by_with_span);
+            collect_expr_resource_escapes(right, escapes_by_with_span);
+        }
         HirExpr::Field { base, .. } => collect_expr_resource_escapes(base, escapes_by_with_span),
         HirExpr::Closure { body, .. } => collect_block_resource_escapes(body, escapes_by_with_span),
         HirExpr::Ident { .. }
@@ -953,6 +971,10 @@ fn collect_resource_escapes_in_expr(
             }
         }
         HirExpr::Effect { value, .. } => collect_resource_escapes_in_expr(binding, value, escapes),
+        HirExpr::Binary { left, right, .. } => {
+            collect_resource_escapes_in_expr(binding, left, escapes);
+            collect_resource_escapes_in_expr(binding, right, escapes);
+        }
         HirExpr::Field { base, .. } => collect_resource_escapes_in_expr(binding, base, escapes),
         HirExpr::Closure { body, .. } => collect_resource_escapes_in_block(binding, body, escapes),
         HirExpr::Ident { .. }
@@ -1065,6 +1087,10 @@ fn collect_expr_managed_closure_uses(
         HirExpr::Effect { value, .. } | HirExpr::Manage { value, .. } => {
             collect_expr_managed_closure_uses(value, closures);
         }
+        HirExpr::Binary { left, right, .. } => {
+            collect_expr_managed_closure_uses(left, closures);
+            collect_expr_managed_closure_uses(right, closures);
+        }
         HirExpr::Field { base, .. } => collect_expr_managed_closure_uses(base, closures),
         HirExpr::Closure { body, .. } => collect_block_managed_closure_uses(body, closures),
         HirExpr::Ident { .. }
@@ -1177,6 +1203,10 @@ fn collect_hir_expr_effect_events(expr: &HirExpr, events: &mut Vec<HirEffectEven
             events.extend(expr_events.iter().cloned());
             collect_hir_expr_effect_events(value, events);
         }
+        HirExpr::Binary { left, right, .. } => {
+            collect_hir_expr_effect_events(left, events);
+            collect_hir_expr_effect_events(right, events);
+        }
         HirExpr::Field { base, .. } => collect_hir_expr_effect_events(base, events),
         HirExpr::Closure { .. }
         | HirExpr::Ident { .. }
@@ -1198,6 +1228,10 @@ fn collect_hir_expr_idents(expr: &HirExpr, uses: &mut Vec<(String, Span)>) {
         HirExpr::Effect { value, .. } | HirExpr::Manage { value, .. } => {
             collect_hir_expr_idents(value, uses);
         }
+        HirExpr::Binary { left, right, .. } => {
+            collect_hir_expr_idents(left, uses);
+            collect_hir_expr_idents(right, uses);
+        }
         HirExpr::Closure { body, .. } => collect_hir_block_idents(body, uses),
         HirExpr::Number { .. } | HirExpr::String { .. } | HirExpr::Unknown(_) => {}
     }
@@ -1596,6 +1630,7 @@ fn local_flow_step_binding(statement: &HirStmt) -> Option<LocalFlowBinding> {
                 HirExpr::Ident { name, span, .. } => Some((name.clone(), span.clone())),
                 HirExpr::Number { .. }
                 | HirExpr::String { .. }
+                | HirExpr::Binary { .. }
                 | HirExpr::Field { .. }
                 | HirExpr::Call { .. }
                 | HirExpr::Effect { .. }
@@ -1641,6 +1676,7 @@ fn hir_expr_type_name(expr: &HirExpr) -> Option<&str> {
         | HirExpr::Effect { type_name, .. }
         | HirExpr::Manage { type_name, .. } => type_name.as_deref(),
         HirExpr::Field { access, .. } => access.type_name.as_deref(),
+        HirExpr::Binary { .. } => None,
         HirExpr::Number { .. }
         | HirExpr::String { .. }
         | HirExpr::Closure { .. }

src/hir.rs

@@ -2,8 +2,8 @@ use std::collections::{HashMap, HashSet};
 
 use crate::diagnostic::Span;
 use crate::syntax::ast::{
-    Block, CallArg, Callee, DataEffect, EffectDecl, Expr, FieldDecl, FunctionDecl, Item, LetKind,
-    Param, Program as SyntaxProgram, Stmt, TypeDecl, TypeKind, TypeRef,
+    BinaryOp, Block, CallArg, Callee, DataEffect, EffectDecl, Expr, FieldDecl, FunctionDecl, Item,
+    LetKind, Param, Program as SyntaxProgram, Stmt, TypeDecl, TypeKind, TypeRef,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -234,6 +234,12 @@ pub enum HirExpr {
         value: String,
         span: Span,
     },
+    Binary {
+        op: BinaryOp,
+        left: Box<HirExpr>,
+        right: Box<HirExpr>,
+        span: Span,
+    },
     Field {
         base: Box<HirExpr>,
         name: String,
@@ -712,6 +718,17 @@ fn lower_hir_expr(
             value: value.clone(),
             span: span.clone(),
         },
+        Expr::Binary {
+            op,
+            left,
+            right,
+            span,
+        } => HirExpr::Binary {
+            op: *op,
+            left: Box::new(lower_hir_expr(hir, function_name, left, value_types)),
+            right: Box::new(lower_hir_expr(hir, function_name, right, value_types)),
+            span: span.clone(),
+        },
         Expr::Field { base, name, span } => {
             let base_type = infer_hir_expr_type(hir, base, value_types);
             let field = base_type
@@ -950,6 +967,10 @@ fn collect_body_facts_in_expr(
     facts: &mut BodyFacts,
 ) {
     match expr {
+        Expr::Binary { left, right, .. } => {
+            collect_body_facts_in_expr(hir, function_name, left, value_types, facts);
+            collect_body_facts_in_expr(hir, function_name, right, value_types, facts);
+        }
         Expr::Call { callee, args, span } => {
             let resolution = hir.resolve_call(callee);
             if is_resource_pool_callee(callee) {
@@ -1108,6 +1129,7 @@ fn infer_hir_expr_type(
 ) -> Option<String> {
     match expr {
         Expr::Ident(name, _) => value_types.get(name).cloned(),
+        Expr::Binary { .. } => None,
         Expr::Effect { value, .. } | Expr::Manage { value, .. } => {
             infer_hir_expr_type(hir, value, value_types)
         }
@@ -1165,6 +1187,7 @@ fn resource_pool_arg_type(expr: &Expr, value_types: &HashMap<String, String>) ->
             return resource_pool_namespace_arg(callee).map(|resource| resource.to_string());
         }
         Expr::Field { .. }
+        | Expr::Binary { .. }
         | Expr::Closure { .. }
         | Expr::Number(_, _)
         | Expr::String(_, _)
@@ -1221,6 +1244,7 @@ fn classify_return_expr(hir: &Hir, expr: &Expr) -> HirReturnProof {
         },
         Expr::Effect { value, .. } | Expr::Manage { value, .. } => classify_return_expr(hir, value),
         Expr::Field { .. }
+        | Expr::Binary { .. }
         | Expr::Closure { .. }
         | Expr::Number(_, _)
         | Expr::String(_, _)

src/lexer.rs

@@ -71,7 +71,7 @@ impl Lexer<'_> {
                 '-' if self.peek_next() == Some('>') => self.push_two("->"),
                 '=' if self.peek_next() == Some('>') => self.push_two("=>"),
                 ':' | ',' | '.' | '(' | ')' | '{' | '}' | '<' | '>' | '[' | ']' | '?' | '|'
-                | '+' | '-' | '*' | '/' | '=' | ';' => self.push_one(),
+                | '&' | '+' | '-' | '*' | '/' | '=' | ';' => self.push_one(),
                 _ => self.push_one(),
             }
         }
@@ -187,6 +187,7 @@ impl Lexer<'_> {
             ']' => "]",
             '?' => "?",
             '|' => "|",
+            '&' => "&",
             '+' => "+",
             '-' => "-",
             '*' => "*",

src/review.rs

@@ -655,6 +655,10 @@ fn collect_boundary_expr(expr: &Expr, path: &str, boundary: &mut BoundarySig) {
                 collect_boundary_expr(value, &arg_path, boundary);
             }
         }
+        Expr::Binary { left, right, .. } => {
+            collect_boundary_expr(left, &format!("{path}.left"), boundary);
+            collect_boundary_expr(right, &format!("{path}.right"), boundary);
+        }
         Expr::Field { base, .. } => collect_boundary_expr(base, path, boundary),
         Expr::Closure { body, .. } => {
             collect_boundary_block(body, &format!("{path}.closure"), boundary)
@@ -682,6 +686,7 @@ fn boundary_expr_subject(expr: &Expr) -> Option<String> {
         Expr::Effect { value, .. } | Expr::Manage { value, .. } => boundary_expr_subject(value),
         Expr::Field { name, .. } => Some(format!(".{name}")),
         Expr::Call { .. }
+        | Expr::Binary { .. }
         | Expr::Closure { .. }
         | Expr::Number(_, _)
         | Expr::String(_, _)

src/syntax/ast.rs

@@ -147,6 +147,12 @@ pub enum Expr {
     Ident(String, Span),
     Number(String, Span),
     String(String, Span),
+    Binary {
+        op: BinaryOp,
+        left: Box<Expr>,
+        right: Box<Expr>,
+        span: Span,
+    },
     Field {
         base: Box<Expr>,
         name: String,
@@ -173,6 +179,12 @@ pub enum Expr {
     Unknown(Span),
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BinaryOp {
+    LogicalAnd,
+    LogicalOr,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Callee {
     Name(String),
@@ -192,6 +204,7 @@ impl Expr {
             Self::Ident(_, span)
             | Self::Number(_, span)
             | Self::String(_, span)
+            | Self::Binary { span, .. }
             | Self::Field { span, .. }
             | Self::Call { span, .. }
             | Self::Effect { span, .. }

src/syntax/parser.rs

@@ -1,8 +1,8 @@
 use crate::lexer::{Token, TokenKind, lex};
 use crate::syntax::ast::{
-    Block, CallArg, Callee, DataEffect, EffectDecl, Expr, FieldDecl, FileMode, FunctionDecl,
-    IfStmt, Item, LetKind, LetStmt, LoopStmt, Param, Program, ReturnStmt, Stmt, TypeDecl, TypeKind,
-    TypeRef, WithStmt,
+    BinaryOp, Block, CallArg, Callee, DataEffect, EffectDecl, Expr, FieldDecl, FileMode,
+    FunctionDecl, IfStmt, Item, LetKind, LetStmt, LoopStmt, Param, Program, ReturnStmt, Stmt,
+    TypeDecl, TypeKind, TypeRef, WithStmt,
 };
 
 pub fn parse_source(file: &str, source: &str) -> Program {
@@ -526,6 +526,10 @@ fn parse_expr(tokens: &[Token], start: usize, end: usize) -> Option<Expr> {
         });
     }
 
+    if let Some(binary) = parse_binary_expr(tokens, start, end) {
+        return Some(binary);
+    }
+
     if let Some(effect) = parse_data_effect(tokens.get(start)) {
         let value_start = start + 1;
         let value = if tokens
@@ -583,6 +587,59 @@ 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, "&", "&"))
+        .and_then(|(operator, op)| {
+            let left = parse_expr(tokens, start, operator)?;
+            let right = parse_expr(tokens, operator + 2, end)?;
+            Some(Expr::Binary {
+                op,
+                left: Box::new(left),
+                right: Box::new(right),
+                span: tokens[operator].span.clone(),
+            })
+        })
+}
+
+fn find_top_level_binary_operator(
+    tokens: &[Token],
+    start: usize,
+    end: usize,
+    first: &str,
+    second: &str,
+) -> Option<(usize, BinaryOp)> {
+    let mut depth = 0usize;
+    for index in (start..end.saturating_sub(1)).rev() {
+        let token = &tokens[index];
+        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(first)
+            && tokens
+                .get(index + 1)
+                .is_some_and(|token| token.symbol(second))
+        {
+            if first == "|" && tokens.get(index + 2).is_some_and(|token| token.symbol("{")) {
+                continue;
+            }
+            let op = if first == "|" {
+                BinaryOp::LogicalOr
+            } else {
+                BinaryOp::LogicalAnd
+            };
+            return Some((index, op));
+        }
+    }
+    None
+}
+
 fn parse_call_expr(tokens: &[Token], start: usize, end: usize) -> Option<Expr> {
     let open = find_call_open(tokens, start, end)?;
     let callee = parse_callee(tokens, start, open)?;