Rollup merge of #42730 - VBChunguk:boxed-wild-pattern, r=eddyb

Use T as the subpattern type of Box<T>

The subpattern type of boxes being nil does not make sense because of box patterns. They should have their inner type as the subpattern type.

Fixes #42679, which describes ICE caused by the bug.

2 files changed, 51 insertions, 15 deletions

diff --git a/src/librustc_const_eval/_match.rs b/src/librustc_const_eval/_match.rs
index c1dc5f5f7a2..98d90188312 100644
--- a/src/librustc_const_eval/_match.rs
+++ b/src/librustc_const_eval/_match.rs
@@ -774,21 +774,26 @@ fn constructor_sub_pattern_tys<'a, 'tcx: 'a>(cx: &MatchCheckCtxt<'a, 'tcx>,
         },
         ty::TyRef(_, ref ty_and_mut) => vec![ty_and_mut.ty],
         ty::TyAdt(adt, substs) => {
-            adt.variants[ctor.variant_index_for_adt(adt)].fields.iter().map(|field| {
-                let is_visible = adt.is_enum()
-                    || field.vis.is_accessible_from(cx.module, cx.tcx);
-                if is_visible {
-                    field.ty(cx.tcx, substs)
-                } else {
-                    // Treat all non-visible fields as nil. They
-                    // can't appear in any other pattern from
-                    // this match (because they are private),
-                    // so their type does not matter - but
-                    // we don't want to know they are
-                    // uninhabited.
-                    cx.tcx.mk_nil()
-                }
-            }).collect()
+            if adt.is_box() {
+                // Use T as the sub pattern type of Box<T>.
+                vec![substs[0].as_type().unwrap()]
+            } else {
+                adt.variants[ctor.variant_index_for_adt(adt)].fields.iter().map(|field| {
+                    let is_visible = adt.is_enum()
+                        || field.vis.is_accessible_from(cx.module, cx.tcx);
+                    if is_visible {
+                        field.ty(cx.tcx, substs)
+                    } else {
+                        // Treat all non-visible fields as nil. They
+                        // can't appear in any other pattern from
+                        // this match (because they are private),
+                        // so their type does not matter - but
+                        // we don't want to know they are
+                        // uninhabited.
+                        cx.tcx.mk_nil()
+                    }
+                }).collect()
+            }
         }
         _ => vec![],
     }
diff --git a/src/test/run-pass/issue-42679.rs b/src/test/run-pass/issue-42679.rs
new file mode 100644
index 00000000000..312835225ed
--- /dev/null
+++ b/src/test/run-pass/issue-42679.rs
@@ -0,0 +1,31 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(box_syntax)]
+#![feature(box_patterns)]
+
+#[derive(Debug, PartialEq)]
+enum Test {
+    Foo(usize),
+    Bar(isize),
+}
+
+fn main() {
+    let a = box Test::Foo(10);
+    let b = box Test::Bar(-20);
+    match (a, b) {
+        (_, box Test::Foo(_)) => unreachable!(),
+        (box Test::Foo(x), b) => {
+            assert_eq!(x, 10);
+            assert_eq!(b, box Test::Bar(-20));
+        },
+        _ => unreachable!(),
+    }
+}