Improve pattern matching MIR lowering

Author: HKalbasi

crates/hir-def/src/body/lower.rs

@@ -1030,9 +1030,16 @@ impl ExprCollector<'_> {
                         .collect(),
                 }
             }
-            ast::Pat::LiteralPat(lit) => {
+            ast::Pat::LiteralPat(lit) => 'b: {
                 if let Some(ast_lit) = lit.literal() {
-                    let expr = Expr::Literal(ast_lit.kind().into());
+                    let mut hir_lit: Literal = ast_lit.kind().into();
+                    if lit.minus_token().is_some() {
+                        let Some(h) = hir_lit.negate() else {
+                            break 'b Pat::Missing;
+                        };
+                        hir_lit = h;
+                    }
+                    let expr = Expr::Literal(hir_lit);
                     let expr_ptr = AstPtr::new(&ast::Expr::Literal(ast_lit));
                     let expr_id = self.alloc_expr(expr, expr_ptr);
                     Pat::Lit(expr_id)
@@ -1144,11 +1151,11 @@ impl From<ast::LiteralKind> for Literal {
                         FloatTypeWrapper::new(lit.float_value().unwrap_or(Default::default())),
                         builtin,
                     )
-                } else if let builtin @ Some(_) = lit.suffix().and_then(BuiltinInt::from_suffix) {
-                    Literal::Int(lit.value().unwrap_or(0) as i128, builtin)
-                } else {
-                    let builtin = lit.suffix().and_then(BuiltinUint::from_suffix);
+                } else if let builtin @ Some(_) = lit.suffix().and_then(BuiltinUint::from_suffix) {
                     Literal::Uint(lit.value().unwrap_or(0), builtin)
+                } else {
+                    let builtin = lit.suffix().and_then(BuiltinInt::from_suffix);
+                    Literal::Int(lit.value().unwrap_or(0) as i128, builtin)
                 }
             }
             LiteralKind::FloatNumber(lit) => {

crates/hir-def/src/expr.rs

@@ -92,6 +92,16 @@ pub enum Literal {
     Float(FloatTypeWrapper, Option<BuiltinFloat>),
 }
 
+impl Literal {
+    pub fn negate(self) -> Option<Self> {
+        if let Literal::Int(i, k) = self {
+            Some(Literal::Int(-i, k))
+        } else {
+            None
+        }
+    }
+}
+
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Expr {
     /// This is produced if the syntax tree does not have a required expression piece.

crates/hir-ty/src/consteval/tests.rs

@@ -685,6 +685,36 @@ fn path_pattern_matching() {
     );
 }
 
+#[test]
+fn pattern_matching_literal() {
+    check_number(
+        r#"
+    const fn f(x: i32) -> i32 {
+        match x {
+            -1 => 1,
+            1 => 10,
+            _ => 100,
+        }
+    }
+    const GOAL: i32 = f(-1) + f(1) + f(0) + f(-5);
+        "#,
+        211
+    );
+    check_number(
+        r#"
+    const fn f(x: &str) -> u8 {
+        match x {
+            "foo" => 1,
+            "bar" => 10,
+            _ => 100,
+        }
+    }
+    const GOAL: u8 = f("foo") + f("bar");
+        "#,
+        11
+    );
+}
+
 #[test]
 fn pattern_matching_ergonomics() {
     check_number(
@@ -698,6 +728,16 @@ fn pattern_matching_ergonomics() {
         "#,
         5,
     );
+    check_number(
+        r#"
+    const GOAL: u8 = {
+        let a = &(2, 3);
+        let &(x, y) = a;
+        x + y
+    };
+        "#,
+        5,
+    );
 }
 
 #[test]
@@ -781,6 +821,33 @@ fn function_param_patterns() {
     );
 }
 
+#[test]
+fn match_guards() {
+    check_number(
+        r#"
+    //- minicore: option, eq
+    impl<T: PartialEq> PartialEq for Option<T> {
+        fn eq(&self, other: &Rhs) -> bool {
+            match (self, other) {
+                (Some(x), Some(y)) => x == y,
+                (None, None) => true,
+                _ => false,
+            }
+        }
+    }
+    fn f(x: Option<i32>) -> i32 {
+        match x {
+            y if y == Some(42) => 42000,
+            Some(y) => y,
+            None => 10
+        }
+    }
+    const GOAL: i32 = f(Some(42)) + f(Some(2)) + f(None);
+        "#,
+        42012,
+    );
+}
+
 #[test]
 fn options() {
     check_number(
@@ -983,6 +1050,51 @@ fn function_pointer() {
     );
 }
 
+#[test]
+fn enum_variant_as_function() {
+    check_number(
+        r#"
+    //- minicore: option
+    const GOAL: u8 = {
+        let f = Some;
+        f(3).unwrap_or(2)
+    };
+        "#,
+        3,
+    );
+    check_number(
+        r#"
+    //- minicore: option
+    const GOAL: u8 = {
+        let f: fn(u8) -> Option<u8> = Some;
+        f(3).unwrap_or(2)
+    };
+        "#,
+        3,
+    );
+    check_number(
+        r#"
+    //- minicore: coerce_unsized, index, slice
+    enum Foo {
+        Add2(u8),
+        Mult3(u8),
+    }
+    use Foo::*;
+    const fn f(x: Foo) -> u8 {
+        match x {
+            Add2(x) => x + 2,
+            Mult3(x) => x * 3,
+        }
+    }
+    const GOAL: u8 = {
+        let x = [Add2, Mult3];
+        f(x[0](1)) + f(x[1](5))
+    };
+        "#,
+        18,
+    );
+}
+
 #[test]
 fn function_traits() {
     check_number(

crates/hir-ty/src/mir/eval.rs

@@ -423,6 +423,7 @@ impl Evaluator<'_> {
         args: impl Iterator<Item = Vec<u8>>,
         subst: Substitution,
     ) -> Result<Vec<u8>> {
+        dbg!(body.dbg(self.db));
         if let Some(x) = self.stack_depth_limit.checked_sub(1) {
             self.stack_depth_limit = x;
         } else {
@@ -581,7 +582,14 @@ impl Evaluator<'_> {
                 let mut ty = self.operand_ty(lhs, locals)?;
                 while let TyKind::Ref(_, _, z) = ty.kind(Interner) {
                     ty = z.clone();
-                    let size = self.size_of_sized(&ty, locals, "operand of binary op")?;
+                    let size = if ty.kind(Interner) == &TyKind::Str {
+                        let ns = from_bytes!(usize, &lc[self.ptr_size()..self.ptr_size() * 2]);
+                        lc = &lc[..self.ptr_size()];
+                        rc = &rc[..self.ptr_size()];
+                        ns
+                    } else {
+                        self.size_of_sized(&ty, locals, "operand of binary op")?
+                    };
                     lc = self.read_memory(Address::from_bytes(lc)?, size)?;
                     rc = self.read_memory(Address::from_bytes(rc)?, size)?;
                 }