Don't type error on variant type check fail

crates/rune/src/runtime/vm.rs

@@ -2628,7 +2628,10 @@ impl Vm {
                 }
                 Repr::Any(any) => match enum_hash {
                     Result::<Value, Value>::HASH => {
-                        let result = vm_try!(any.borrow_ref::<Result<Value, Value>>());
+                        let Some(result) = vm_try!(any.try_borrow_ref::<Result<Value, Value>>())
+                        else {
+                            break 'out false;
+                        };
 
                         break 'out match (&*result, variant_hash) {
                             (Ok(..), hash!(::std::result::Result::Ok)) => true,
@@ -2637,7 +2640,9 @@ impl Vm {
                         };
                     }
                     Option::<Value>::HASH => {
-                        let option = vm_try!(any.borrow_ref::<Option<Value>>());
+                        let Some(option) = vm_try!(any.try_borrow_ref::<Option<Value>>()) else {
+                            break 'out false;
+                        };
 
                         break 'out match (&*option, variant_hash) {
                             (None, hash!(::std::option::Option::None)) => true,

crates/rune/tests/matching.rn

@@ -214,3 +214,40 @@ fn match_extraction_struct() {
 
     assert_eq!(inner(v), 42);
 }
+
+/// This tests that matching against a built-in type with a value which is not
+/// the same type does not error due to a type mismatch.
+#[test]
+fn match_builtin_non_err() {
+    let outcome = match 42 {
+        Some(42) => false,
+        42 => true,
+        _ => false,
+    };
+
+    assert!(outcome, "built-in Option::Some should match");
+
+    let outcome = match 42 {
+        None => false,
+        42 => true,
+        _ => false,
+    };
+
+    assert!(outcome, "built-in Option::None should match");
+
+    let outcome = match 42 {
+        Ok(42) => false,
+        42 => true,
+        _ => false,
+    };
+
+    assert!(outcome, "built-in Result::Ok should match");
+
+    let outcome = match 42 {
+        Err(42) => false,
+        42 => true,
+        _ => false,
+    };
+
+    assert!(outcome, "built-in Result::Err should match");
+}