Merge pull request #707 from wado-lang/claude/add-pipe-pattern-matching-WcOXD

Add support for or-patterns in match expressions

Author: gfx

docs/cheatsheet.md

@@ -682,6 +682,21 @@ let result = match opt {
     None => 0,
 };
 
+// Or patterns
+match color {
+    Red | Blue => "cool",
+    Green => "warm",
+}
+
+// Or patterns with bindings (all alternatives must bind the same names)
+match expr {
+    Num(n) | Neg(n) => use(n),
+    Zero => 0,
+}
+
+// Or patterns in matches operator
+if shape matches { Circle(_) | Square(_) } { ... }
+
 // Match with guard
 let label = match value {
     Some(x) && x > 100 => "large",

docs/spec.md

@@ -652,6 +652,33 @@ match customer {
 }
 ```
 
+**Or Patterns:**
+
+Or patterns match if any alternative matches. All alternatives must bind the same names with the same types:
+
+```wado
+// Enum or-patterns
+match color {
+    Red | Blue => "cool",
+    Green => "warm",
+}
+
+// Variant or-patterns with bindings
+match expr {
+    Num(n) | Neg(n) => use(n),
+    Zero => 0,
+}
+
+// Literal or-patterns
+match n {
+    1 | 2 | 3 => "low",
+    _ => "high",
+}
+
+// Or patterns in matches operator
+if shape matches { Circle(_) | Square(_) } { ... }
+```
+
 **Nested Sub-Patterns in Tuple/Struct Destructuring:**
 
 Tuple and struct patterns support literal, variant, and enum sub-patterns. These are lowered into guard conditions with appropriate checks:

wado-compiler/src/ast.rs

@@ -1045,6 +1045,8 @@ pub enum Pattern {
         has_rest: bool,
         span: Span,
     },
+    /// Or pattern: `Red | Blue` or `Some(x) | Other(x)`
+    Or(Vec<Pattern>),
 }
 
 #[derive(Debug, Clone)]

wado-compiler/src/bind.rs

@@ -548,6 +548,12 @@ impl<'a, H: CompilerHost> Binder<'a, H> {
                 }
             }
             crate::ast::Pattern::Literal(_) | crate::ast::Pattern::Variant { .. } => {}
+            crate::ast::Pattern::Or(alternatives) => {
+                // Bind variables from the first alternative (all alternatives must bind the same names)
+                if let Some(first) = alternatives.first() {
+                    self.bind_let_pattern_uninit(first, is_mut, is_reactive, span)?;
+                }
+            }
         }
         Ok(())
     }
@@ -577,6 +583,11 @@ impl<'a, H: CompilerHost> Binder<'a, H> {
                     self.bind_let_pattern(&field.pattern, is_mut, is_reactive, span)?;
                 }
             }
+            crate::ast::Pattern::Or(alternatives) => {
+                if let Some(first) = alternatives.first() {
+                    self.bind_let_pattern(first, is_mut, is_reactive, span)?;
+                }
+            }
             crate::ast::Pattern::Literal(_) | crate::ast::Pattern::Variant { .. } => {
                 // Literal and variant patterns are not valid in let statements
                 // This would be caught by the type checker
@@ -1051,6 +1062,12 @@ impl<'a, H: CompilerHost> Binder<'a, H> {
             crate::ast::Pattern::Literal(_) | crate::ast::Pattern::Wildcard => {
                 // No variables introduced
             }
+            crate::ast::Pattern::Or(alternatives) => {
+                // Bind variables from the first alternative (all alternatives must bind the same names)
+                if let Some(first) = alternatives.first() {
+                    self.bind_pattern(first, span)?;
+                }
+            }
         }
         Ok(())
     }

wado-compiler/src/desugar.rs

@@ -285,6 +285,9 @@ fn desugar_pattern(p: &Pattern) -> Pattern {
             has_rest: *has_rest,
             span: *span,
         },
+        Pattern::Or(alternatives) => {
+            Pattern::Or(alternatives.iter().map(desugar_pattern).collect())
+        }
     }
 }
 

wado-compiler/src/lower/closure.rs

@@ -1619,6 +1619,12 @@ impl ClosureLowerer {
                     .collect(),
                 has_rest: *has_rest,
             },
+            TirPattern::Or(alternatives) => TirPattern::Or(
+                alternatives
+                    .iter()
+                    .map(|p| self.transform_closure_body_pattern(p))
+                    .collect(),
+            ),
         }
     }
 

wado-compiler/src/lower/globals.rs

@@ -585,6 +585,11 @@ fn renumber_locals_in_pattern(pattern: &mut TirPattern, offset: u32) {
             }
         }
         TirPattern::Wildcard | TirPattern::Literal(_) | TirPattern::Enum { .. } => {}
+        TirPattern::Or(alternatives) => {
+            for p in alternatives {
+                renumber_locals_in_pattern(p, offset);
+            }
+        }
     }
 }
 

wado-compiler/src/lower/pattern.rs

@@ -1270,6 +1270,12 @@ impl<'a> PatternLowerer<'a> {
                 // Literal/Enum patterns don't bind anything, just evaluate for side effects
                 out.push(TirStmt::new(TirStmtKind::Expr(value), span));
             }
+            TirPattern::Or(alternatives) => {
+                // Or patterns in let-destructure: use first alternative's bindings
+                if let Some(first) = alternatives.first() {
+                    self.lower_pattern_to_lets(first, is_mut, value, span, out, type_table);
+                }
+            }
         }
     }
 
@@ -1522,6 +1528,12 @@ impl<'a> PatternLowerer<'a> {
                 // Just evaluate for side effects (no bindings)
                 out.push(TirStmt::new(TirStmtKind::Expr(value), span));
             }
+            TirPattern::Or(alternatives) => {
+                // Or patterns in lets: use first alternative's bindings
+                if let Some(first) = alternatives.first() {
+                    self.lower_pattern_to_lets(first, is_mut, value, span, out, type_table);
+                }
+            }
         }
     }
 
@@ -2058,6 +2070,42 @@ impl<'a> PatternLowerer<'a> {
                     binding_stmts,
                 )
             }
+            TirPattern::Or(alternatives) => {
+                // Or pattern: combine conditions with logical OR, use first alternative's bindings
+                let mut or_conditions: Vec<TirExpr> = Vec::new();
+                for alt in alternatives {
+                    let (cond, _) = self.pattern_to_condition_and_bindings(
+                        alt,
+                        scrutinee.clone(),
+                        span,
+                        type_table,
+                    );
+                    or_conditions.push(cond);
+                }
+                // Emit bindings from the first alternative (all alternatives bind the same names)
+                if let Some(first) = alternatives.first() {
+                    let (_, first_bindings) =
+                        self.pattern_to_condition_and_bindings(first, scrutinee, span, type_table);
+                    binding_stmts.extend(first_bindings);
+                }
+                let combined = or_conditions
+                    .into_iter()
+                    .reduce(|acc, cond| {
+                        TirExpr::new(
+                            TirExprKind::Binary {
+                                op: TirBinaryOp::Or,
+                                left: Box::new(acc),
+                                right: Box::new(cond),
+                            },
+                            TypeTable::BOOL,
+                            span,
+                        )
+                    })
+                    .unwrap_or_else(|| {
+                        TirExpr::new(TirExprKind::BoolLiteral(false), TypeTable::BOOL, span)
+                    });
+                (combined, binding_stmts)
+            }
         }
     }
 
@@ -2091,6 +2139,24 @@ impl<'a> PatternLowerer<'a> {
                     self.lower_expr(&mut arm.body, type_table);
                 }
 
+                // Expand or-patterns: `A | B => body` becomes `A => body, B => body`
+                let mut expanded_arms = Vec::new();
+                for arm in arms.drain(..) {
+                    if let TirPattern::Or(alternatives) = arm.pattern {
+                        for alt in alternatives {
+                            expanded_arms.push(TirMatchArm {
+                                pattern: alt,
+                                guard: arm.guard.clone(),
+                                body: arm.body.clone(),
+                                span: arm.span,
+                            });
+                        }
+                    } else {
+                        expanded_arms.push(arm);
+                    }
+                }
+                *arms = expanded_arms;
+
                 // Match ergonomics: insert deref if scrutinee is Ref/MutRef
                 while let ResolvedType::Ref(inner) | ResolvedType::MutRef(inner) =
                     type_table.get(scrutinee.type_id)

wado-compiler/src/monomorphize/substitute.rs

@@ -388,6 +388,11 @@ impl Monomorphizer {
                     self.substitute_types_in_pattern(&mut field.pattern, substitution, type_table);
                 }
             }
+            TirPattern::Or(alternatives) => {
+                for p in alternatives {
+                    self.substitute_types_in_pattern(p, substitution, type_table);
+                }
+            }
         }
     }
 }

wado-compiler/src/optimize/dce.rs

@@ -1653,6 +1653,11 @@ fn collect_types_from_pattern(
                 collect_types_from_pattern(&field.pattern, type_table, reachable);
             }
         }
+        TirPattern::Or(alternatives) => {
+            for p in alternatives {
+                collect_types_from_pattern(p, type_table, reachable);
+            }
+        }
     }
 }