Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

compiler crash on innocent-looking match #46964

Closed
idubrov opened this issue Dec 23, 2017 · 2 comments · Fixed by #47001
Closed

compiler crash on innocent-looking match #46964

idubrov opened this issue Dec 23, 2017 · 2 comments · Fixed by #47001
Labels
I-ICE Issue: The compiler panicked, giving an Internal Compilation Error (ICE) ❄️

Comments

@idubrov
Copy link

idubrov commented Dec 23, 2017

the compiler unexpectedly panicked. this is a bug.

I tried this code (hyper = "0.11.9"):

extern crate hyper;

pub fn crash(mime: &hyper::mime::Mime) -> bool {
  match (mime.subtype(), mime.suffix()) {
    (_, Some(hyper::mime::JSON)) => true,
    (hyper::mime::JSON, None) => true,
    _ => false,
  }
}

I expected to see this happen: code compiles (two top branches are incompatible)

Instead, this happened: compiler crashed; re-ordering two top branches fixes the issue

Meta

rustc --version --verbose:

rustc 1.24.0-nightly (5165ee9e2 2017-12-22)
binary: rustc
commit-hash: 5165ee9e209e0e70d89946ccbb7e90b9c0c3a7ac
commit-date: 2017-12-22
host: x86_64-apple-darwin
release: 1.24.0-nightly
LLVM version: 4.0

Backtrace:

error: internal compiler error: unexpected panic

note: the compiler unexpectedly panicked. this is a bug.

note: we would appreciate a bug report: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports

note: rustc 1.24.0-nightly (5165ee9e2 2017-12-22) running on x86_64-apple-darwin

note: run with `RUST_BACKTRACE=1` for a backtrace

thread 'rustc' panicked at 'assertion failed: rows.iter().all(|r| r.len() == v.len())', src/librustc_const_eval/_match.rs:596:4
stack backtrace:
   0:        0x11385781b - std::sys::unix::backtrace::tracing::imp::unwind_backtrace::h6748dc16a2d8df2e
   1:        0x113866fae - std::sys_common::backtrace::print::hc1ecb1e5559e6c33
   2:        0x113861410 - std::panicking::default_hook::{{closure}}::hb04e69910a65792e
   3:        0x11386110a - std::panicking::default_hook::h1ca336fe29972357
   4:        0x113861876 - std::panicking::rust_panic_with_hook::h02eae9f31985336e
   5:        0x1116feba1 - std::panicking::begin_panic::h0170dac5d8645b28
   6:        0x1116f50fa - rustc_const_eval::_match::is_useful::h23e3cdc562cbb328
   7:        0x1116f62b2 - rustc_const_eval::_match::is_useful_specialized::h3f912ded1cb5a78e
   8:        0x1116e6b7c - <core::iter::Map<I, F> as core::iter::iterator::Iterator>::try_fold::h8379d8eb0a7a9f77
   9:        0x1116f5320 - rustc_const_eval::_match::is_useful::h23e3cdc562cbb328
  10:        0x1116f62b2 - rustc_const_eval::_match::is_useful_specialized::h3f912ded1cb5a78e
  11:        0x1116e6b7c - <core::iter::Map<I, F> as core::iter::iterator::Iterator>::try_fold::h8379d8eb0a7a9f77
  12:        0x1116f5320 - rustc_const_eval::_match::is_useful::h23e3cdc562cbb328
  13:        0x1116f62b2 - rustc_const_eval::_match::is_useful_specialized::h3f912ded1cb5a78e
  14:        0x1116e6b7c - <core::iter::Map<I, F> as core::iter::iterator::Iterator>::try_fold::h8379d8eb0a7a9f77
  15:        0x1116f5320 - rustc_const_eval::_match::is_useful::h23e3cdc562cbb328
  16:        0x1116fcc67 - rustc_const_eval::check_match::check_arms::hf0b2a24697c406ea
  17:        0x1116f4302 - rustc_const_eval::_match::MatchCheckCtxt::create_and_enter::h8ecb2ffcfac97c79
  18:        0x1116fc6f5 - <rustc_const_eval::check_match::MatchVisitor<'a, 'tcx> as rustc::hir::intravisit::Visitor<'tcx>>::visit_expr::h5dc4813f83674f01
  19:        0x1116fc4ee - <rustc_const_eval::check_match::MatchVisitor<'a, 'tcx> as rustc::hir::intravisit::Visitor<'tcx>>::visit_expr::h5dc4813f83674f01
  20:        0x1116fc860 - <rustc_const_eval::check_match::MatchVisitor<'a, 'tcx> as rustc::hir::intravisit::Visitor<'tcx>>::visit_body::h8627b10027254cdf
  21:        0x1116ff24d - rustc::session::Session::track_errors::he6d05d19e503027d
  22:        0x1116fc2a8 - rustc_const_eval::check_match::check_match::h581d60f966dd70ec
  23:        0x112015dee - rustc::dep_graph::graph::DepGraph::with_task_impl::he4debb199688f723
  24:        0x111d3054a - rustc_errors::Handler::track_diagnostics::he3d49a14b2f2a05b
  25:        0x111c209f0 - rustc::ty::maps::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx, 'tcx>>::cycle_check::h3e96520081b37b2e
  26:        0x11208ad8e - rustc::ty::maps::<impl rustc::ty::maps::queries::check_match<'tcx>>::force::h9b0cabeb54488ef9
  27:        0x11208b46a - rustc::ty::maps::<impl rustc::ty::maps::queries::check_match<'tcx>>::try_get::h168429d15c730e8b
  28:        0x111ec85e0 - rustc::ty::maps::TyCtxtAt::check_match::h1e0137c83b27f485
  29:        0x111c721b3 - rustc::ty::maps::<impl rustc::ty::context::TyCtxt<'a, 'tcx, 'lcx>>::check_match::h395b3ef7e5d51eb3
  30:        0x1116fc029 - rustc::hir::intravisit::Visitor::visit_nested_body::hc3711ac4cbc2ecf6
  31:        0x11170dedf - rustc::hir::Crate::visit_all_item_likes::hafcfad702b50d9ac
  32:        0x1116fc1cf - rustc_const_eval::check_match::check_crate::hfadb55aaa16d50c3
  33:        0x10d3ccbc6 - <std::thread::local::LocalKey<T>>::with::h0f69a10298329fdf
  34:        0x10d3cf7cc - <std::thread::local::LocalKey<T>>::with::hb51817b52c5d173a
  35:        0x10d41c95e - rustc::ty::context::TyCtxt::create_and_enter::h0fc228efc283eb64
  36:        0x10d396952 - rustc_driver::driver::compile_input::h82abb659e9ffafec
  37:        0x10d3f9d6d - rustc_driver::run_compiler::h4102658971d5220d
  38:        0x10d351d31 - std::sys_common::backtrace::__rust_begin_short_backtrace::ha73cd560ba1185a4
  39:        0x1138913ae - __rust_maybe_catch_panic
  40:        0x10d32b84d - <F as alloc::boxed::FnBox<A>>::call_box::h4a09b2de7d586e97
  41:        0x113850247 - std::sys_common::thread::start_thread::h4cededf2a7a0e7f8
  42:        0x11386a688 - std::sys::unix::thread::Thread::new::thread_start::hc0d8e233205f2988
  43:     0x7fff995e293a - _pthread_body
  44:     0x7fff995e2886 - _pthread_start
@sfackler sfackler added the I-ICE Issue: The compiler panicked, giving an Internal Compilation Error (ICE) ❄️ label Dec 23, 2017
@idubrov
Copy link
Author

idubrov commented Dec 23, 2017

Slightly simplified version (it's not valid Rust code -- not all patterns are covered -- but it crashes the compiler):

extern crate hyper;

use hyper::mime::Name;
use hyper::mime::JSON;

pub fn crash(subtype: Name, suffix: Option<Name>) -> bool {
  match (subtype, suffix) {
    (_, Some(_)) => true,
    (JSON, None) => true,
  }
}

Backtrace with debug logging from rustc (RUST_BACKTRACE=full RUST_LOG=rustc_const_eval):

TRACE:rustc_const_eval::eval: eval_const_expr_partial: expr(25: true)
TRACE:rustc_const_eval::eval: eval_const_expr_partial: expr(29: true)
DEBUG:rustc_const_eval::pattern: expr=expr(3890: Name{source: "json", insensitive: true,}) pat_ty=hyper::<unnamed>::Name<'static> pat_id=27
DEBUG:rustc_const_eval::pattern: expr=expr(3888: "json") pat_ty=&'static str pat_id=27
TRACE:rustc_const_eval::eval: eval_const_expr_partial: expr(3888: "json")
DEBUG:rustc_const_eval::pattern: expr=expr(3889: true) pat_ty=bool pat_id=27
TRACE:rustc_const_eval::eval: eval_const_expr_partial: expr(3889: true)
DEBUG:rustc_const_eval::_match: is_useful(
+
, [Pattern { ty: (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>), span: src/lib.rs:8:5: 8:17, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild } }, FieldPattern { field: field[1], pattern: Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } } }] } }])
DEBUG:rustc_const_eval::_match: is_useful_expand_first_col: pcx=PatternContext { ty: (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>), max_slice_length: 1 }, expanding Pattern { ty: (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>), span: src/lib.rs:8:5: 8:17, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild } }, FieldPattern { field: field[1], pattern: Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } } }] } }
DEBUG:rustc_const_eval::_match: is_useful - expanding constructors: [Single]
DEBUG:rustc_const_eval::_match: is_useful_specialized([Pattern { ty: (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>), span: src/lib.rs:8:5: 8:17, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild } }, FieldPattern { field: field[1], pattern: Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } } }] } }], Single, (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>))
DEBUG:rustc_const_eval::_match: constructor_sub_pattern_tys(Single, (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>))
DEBUG:rustc_const_eval::_match: patterns_for_variant([FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild } }, FieldPattern { field: field[1], pattern: Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } } }], [Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:1:1: 1:1, kind: Wild }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:1:1: 1:1, kind: Wild }]) = [Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } }]
DEBUG:rustc_const_eval::_match: specialize(Pattern { ty: (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>), span: src/lib.rs:8:5: 8:17, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild } }, FieldPattern { field: field[1], pattern: Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } } }] } }, [Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:1:1: 1:1, kind: Wild }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:1:1: 1:1, kind: Wild }]) = Some([Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } }])
DEBUG:rustc_const_eval::_match: is_useful(
+
, [Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } }])
DEBUG:rustc_const_eval::_match: is_useful_expand_first_col: pcx=PatternContext { ty: hyper::<unnamed>::Name<'<empty>>, max_slice_length: 1 }, expanding Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild }
DEBUG:rustc_const_eval::_match: is_useful - expanding wildcard
DEBUG:rustc_const_eval::_match: used_ctors = []
DEBUG:rustc_const_eval::_match: all_constructors(hyper::<unnamed>::Name<'<empty>>)
DEBUG:rustc_const_eval::_match: all_ctors = [Single]
DEBUG:rustc_const_eval::_match: missing_ctors=[Single] is_privately_empty=false is_declared_nonexhaustive=false
DEBUG:rustc_const_eval::_match: is_useful(
+
, [Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } }])
DEBUG:rustc_const_eval::_match: is_useful_expand_first_col: pcx=PatternContext { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, max_slice_length: 1 }, expanding Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } }
DEBUG:rustc_const_eval::_match: is_useful - expanding constructors: [Variant(DefId(2/1:12166 ~ core[1805]::option[0]::Option[0]::Some[0]))]
DEBUG:rustc_const_eval::_match: is_useful_specialized([Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } }], Variant(DefId(2/1:12166 ~ core[1805]::option[0]::Option[0]::Some[0])), std::option::Option<hyper::<unnamed>::Name<'<empty>>>)
DEBUG:rustc_const_eval::_match: constructor_sub_pattern_tys(Variant(DefId(2/1:12166 ~ core[1805]::option[0]::Option[0]::Some[0])), std::option::Option<hyper::<unnamed>::Name<'<empty>>>)
DEBUG:rustc_const_eval::_match: patterns_for_variant([FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }], [Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:1:1: 1:1, kind: Wild }]) = [Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild }]
DEBUG:rustc_const_eval::_match: specialize(Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } }, [Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:1:1: 1:1, kind: Wild }]) = Some([Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild }])
DEBUG:rustc_const_eval::_match: is_useful(
+
, [Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild }])
DEBUG:rustc_const_eval::_match: is_useful_expand_first_col: pcx=PatternContext { ty: hyper::<unnamed>::Name<'<empty>>, max_slice_length: 1 }, expanding Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild }
DEBUG:rustc_const_eval::_match: is_useful - expanding wildcard
DEBUG:rustc_const_eval::_match: used_ctors = []
DEBUG:rustc_const_eval::_match: all_constructors(hyper::<unnamed>::Name<'<empty>>)
DEBUG:rustc_const_eval::_match: all_ctors = [Single]
DEBUG:rustc_const_eval::_match: missing_ctors=[Single] is_privately_empty=false is_declared_nonexhaustive=false
DEBUG:rustc_const_eval::_match: is_useful(
+
, [])
DEBUG:rustc_const_eval::_match: is_useful(
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Pattern { ty: (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>), span: src/lib.rs:8:5: 8:17, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild } }, FieldPattern { field: field[1], pattern: Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } } }] } } +
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
, [Pattern { ty: (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>), span: src/lib.rs:9:5: 9:17, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'static>, span: src/lib.rs:9:6: 9:10, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } } }, FieldPattern { field: field[1], pattern: Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } } }] } } }, FieldPattern { field: field[1], pattern: Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:9:12: 9:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 0, subpatterns: [] } } }] } }])
DEBUG:rustc_const_eval::_match: is_useful_expand_first_col: pcx=PatternContext { ty: (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>), max_slice_length: 1 }, expanding Pattern { ty: (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>), span: src/lib.rs:9:5: 9:17, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'static>, span: src/lib.rs:9:6: 9:10, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } } }, FieldPattern { field: field[1], pattern: Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } } }] } } }, FieldPattern { field: field[1], pattern: Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:9:12: 9:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 0, subpatterns: [] } } }] } }
DEBUG:rustc_const_eval::_match: is_useful - expanding constructors: [Single]
DEBUG:rustc_const_eval::_match: is_useful_specialized([Pattern { ty: (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>), span: src/lib.rs:9:5: 9:17, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'static>, span: src/lib.rs:9:6: 9:10, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } } }, FieldPattern { field: field[1], pattern: Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } } }] } } }, FieldPattern { field: field[1], pattern: Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:9:12: 9:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 0, subpatterns: [] } } }] } }], Single, (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>))
DEBUG:rustc_const_eval::_match: constructor_sub_pattern_tys(Single, (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>))
DEBUG:rustc_const_eval::_match: patterns_for_variant([FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild } }, FieldPattern { field: field[1], pattern: Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } } }], [Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:1:1: 1:1, kind: Wild }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:1:1: 1:1, kind: Wild }]) = [Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } }]
DEBUG:rustc_const_eval::_match: specialize(Pattern { ty: (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>), span: src/lib.rs:8:5: 8:17, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild } }, FieldPattern { field: field[1], pattern: Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } } }] } }, [Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:1:1: 1:1, kind: Wild }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:1:1: 1:1, kind: Wild }]) = Some([Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } }])
DEBUG:rustc_const_eval::_match: patterns_for_variant([FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'static>, span: src/lib.rs:9:6: 9:10, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } } }, FieldPattern { field: field[1], pattern: Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } } }] } } }, FieldPattern { field: field[1], pattern: Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:9:12: 9:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 0, subpatterns: [] } } }], [Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:1:1: 1:1, kind: Wild }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:1:1: 1:1, kind: Wild }]) = [Pattern { ty: hyper::<unnamed>::Name<'static>, span: src/lib.rs:9:6: 9:10, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } } }, FieldPattern { field: field[1], pattern: Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } } }] } }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:9:12: 9:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 0, subpatterns: [] } }]
DEBUG:rustc_const_eval::_match: specialize(Pattern { ty: (hyper::<unnamed>::Name<'<empty>>, std::option::Option<hyper::<unnamed>::Name<'<empty>>>), span: src/lib.rs:9:5: 9:17, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'static>, span: src/lib.rs:9:6: 9:10, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } } }, FieldPattern { field: field[1], pattern: Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } } }] } } }, FieldPattern { field: field[1], pattern: Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:9:12: 9:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 0, subpatterns: [] } } }] } }, [Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:1:1: 1:1, kind: Wild }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:1:1: 1:1, kind: Wild }]) = Some([Pattern { ty: hyper::<unnamed>::Name<'static>, span: src/lib.rs:9:6: 9:10, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } } }, FieldPattern { field: field[1], pattern: Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } } }] } }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:9:12: 9:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 0, subpatterns: [] } }])
DEBUG:rustc_const_eval::_match: is_useful(
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild } + Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } } +
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
, [Pattern { ty: hyper::<unnamed>::Name<'static>, span: src/lib.rs:9:6: 9:10, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } } }, FieldPattern { field: field[1], pattern: Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } } }] } }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:9:12: 9:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 0, subpatterns: [] } }])
DEBUG:rustc_const_eval::_match: is_useful_expand_first_col: pcx=PatternContext { ty: hyper::<unnamed>::Name<'<empty>>, max_slice_length: 1 }, expanding Pattern { ty: hyper::<unnamed>::Name<'static>, span: src/lib.rs:9:6: 9:10, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } } }, FieldPattern { field: field[1], pattern: Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } } }] } }
DEBUG:rustc_const_eval::_match: is_useful - expanding constructors: [Single]
DEBUG:rustc_const_eval::_match: is_useful_specialized([Pattern { ty: hyper::<unnamed>::Name<'static>, span: src/lib.rs:9:6: 9:10, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } } }, FieldPattern { field: field[1], pattern: Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } } }] } }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:9:12: 9:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 0, subpatterns: [] } }], Single, hyper::<unnamed>::Name<'<empty>>)
DEBUG:rustc_const_eval::_match: constructor_sub_pattern_tys(Single, hyper::<unnamed>::Name<'<empty>>)
DEBUG:rustc_const_eval::_match: specialize(Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:6: 8:7, kind: Wild }, [Pattern { ty: (), span: src/lib.rs:1:1: 1:1, kind: Wild }, Pattern { ty: (), span: src/lib.rs:1:1: 1:1, kind: Wild }]) = Some([Pattern { ty: (), span: src/lib.rs:1:1: 1:1, kind: Wild }, Pattern { ty: (), span: src/lib.rs:1:1: 1:1, kind: Wild }])
DEBUG:rustc_const_eval::_match: patterns_for_variant([FieldPattern { field: field[0], pattern: Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } } }, FieldPattern { field: field[1], pattern: Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } } }], [Pattern { ty: (), span: src/lib.rs:1:1: 1:1, kind: Wild }, Pattern { ty: (), span: src/lib.rs:1:1: 1:1, kind: Wild }]) = [Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } }, Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } }]
DEBUG:rustc_const_eval::_match: specialize(Pattern { ty: hyper::<unnamed>::Name<'static>, span: src/lib.rs:9:6: 9:10, kind: Leaf { subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } } }, FieldPattern { field: field[1], pattern: Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } } }] } }, [Pattern { ty: (), span: src/lib.rs:1:1: 1:1, kind: Wild }, Pattern { ty: (), span: src/lib.rs:1:1: 1:1, kind: Wild }]) = Some([Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } }, Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } }])
DEBUG:rustc_const_eval::_match: is_useful(
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Pattern { ty: (), span: src/lib.rs:1:1: 1:1, kind: Wild } + Pattern { ty: (), span: src/lib.rs:1:1: 1:1, kind: Wild } + Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } } +
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
, [Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } }, Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:9:12: 9:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 0, subpatterns: [] } }])
DEBUG:rustc_const_eval::_match: is_useful_expand_first_col: pcx=PatternContext { ty: (), max_slice_length: 1 }, expanding Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } }
DEBUG:rustc_const_eval::_match: is_useful - expanding constructors: [Single]
DEBUG:rustc_const_eval::_match: is_useful_specialized([Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } }, Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:9:12: 9:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 0, subpatterns: [] } }], Single, ())
DEBUG:rustc_const_eval::_match: constructor_sub_pattern_tys(Single, ())
DEBUG:rustc_const_eval::_match: specialize(Pattern { ty: (), span: src/lib.rs:1:1: 1:1, kind: Wild }, []) = Some([])
DEBUG:rustc_const_eval::_match: specialize(Pattern { ty: &'static str, span: src/lib.rs:9:6: 9:10, kind: Deref { subpattern: Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } } } }, []) = Some([Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } }])
DEBUG:rustc_const_eval::_match: is_useful(
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Pattern { ty: (), span: src/lib.rs:1:1: 1:1, kind: Wild } + Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:8:9: 8:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 1, subpatterns: [FieldPattern { field: field[0], pattern: Pattern { ty: hyper::<unnamed>::Name<'<empty>>, span: src/lib.rs:8:14: 8:15, kind: Wild } }] } } +
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
, [Pattern { ty: str, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: &'static str, val: Str("json") } } }, Pattern { ty: bool, span: src/lib.rs:9:6: 9:10, kind: Constant { value: Const { ty: bool, val: Bool(true) } } }, Pattern { ty: std::option::Option<hyper::<unnamed>::Name<'<empty>>>, span: src/lib.rs:9:12: 9:16, kind: Variant { adt_def: std::option::Option, substs: Slice([hyper::<unnamed>::Name<'<empty>>]), variant_index: 0, subpatterns: [] } }])
error: internal compiler error: unexpected panic

note: the compiler unexpectedly panicked. this is a bug.

note: we would appreciate a bug report: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports

note: rustc 1.24.0-dev running on x86_64-apple-darwin

note: run with `RUST_BACKTRACE=1` for a backtrace

thread 'rustc' panicked at 'assertion failed: rows.iter().all(|r| r.len() == v.len())', src/librustc_const_eval/_match.rs:596:4
stack backtrace:
   0:        0x10faf150b - std::sys::unix::backtrace::tracing::imp::unwind_backtrace::h75b9c1727f1ef869
   1:        0x10fae715b - std::sys_common::backtrace::print::h6c9dc2e8a46cfcb3
   2:        0x10faf7340 - std::panicking::default_hook::{{closure}}::h62969d07dd48231f
   3:        0x10faf703b - std::panicking::default_hook::hc7bb3cdedbae3f74
   4:        0x10faf7945 - std::panicking::rust_panic_with_hook::h796eb4b897c20bd9
   5:        0x10d5513e1 - std::panicking::begin_panic::hfdc17ff79f8f7e85
   6:        0x10d55f7ea - rustc_const_eval::_match::is_useful::h31020025e7ee4e84
   7:        0x10d560f24 - rustc_const_eval::_match::is_useful_specialized::h862dbc0f1cfee8ae
   8:        0x10d550f8c - <core::iter::Map<I, F> as core::iter::iterator::Iterator>::try_fold::hf5bef1a2e44f6bea
   9:        0x10d55fb9f - rustc_const_eval::_match::is_useful::h31020025e7ee4e84
  10:        0x10d560f24 - rustc_const_eval::_match::is_useful_specialized::h862dbc0f1cfee8ae
  11:        0x10d550f8c - <core::iter::Map<I, F> as core::iter::iterator::Iterator>::try_fold::hf5bef1a2e44f6bea
  12:        0x10d55fb9f - rustc_const_eval::_match::is_useful::h31020025e7ee4e84
  13:        0x10d560f24 - rustc_const_eval::_match::is_useful_specialized::h862dbc0f1cfee8ae
  14:        0x10d550f8c - <core::iter::Map<I, F> as core::iter::iterator::Iterator>::try_fold::hf5bef1a2e44f6bea
  15:        0x10d55fb9f - rustc_const_eval::_match::is_useful::h31020025e7ee4e84
  16:        0x10d568c35 - rustc_const_eval::check_match::check_arms::h55b7d80427a0d221
  17:        0x10d55d535 - rustc_const_eval::_match::MatchCheckCtxt::create_and_enter::h0683545c00eb0be9
  18:        0x10d5686a5 - <rustc_const_eval::check_match::MatchVisitor<'a, 'tcx> as rustc::hir::intravisit::Visitor<'tcx>>::visit_expr::h18950677cdbcad93
  19:        0x10d56848e - <rustc_const_eval::check_match::MatchVisitor<'a, 'tcx> as rustc::hir::intravisit::Visitor<'tcx>>::visit_expr::h18950677cdbcad93
  20:        0x10d568820 - <rustc_const_eval::check_match::MatchVisitor<'a, 'tcx> as rustc::hir::intravisit::Visitor<'tcx>>::visit_body::h200db49919baea77
  21:        0x10d570bcd - rustc::session::Session::track_errors::ha9bcb3c6cca859aa
  22:        0x10d5682a8 - rustc_const_eval::check_match::check_match::h5cae592ad199b4a6
  23:        0x10dffed66 - rustc::dep_graph::graph::DepGraph::with_task_impl::h2bc36caea8b204ce
  24:        0x10dcccc2a - rustc_errors::Handler::track_diagnostics::h55c906c2f86ddbe7
  25:        0x10dbd7d19 - rustc::ty::maps::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx, 'tcx>>::cycle_check::h83a7504f84ac4116
  26:        0x10e0d3064 - rustc::ty::maps::<impl rustc::ty::maps::queries::check_match<'tcx>>::force::hb1a2f35449b34af0
  27:        0x10e0d3aac - rustc::ty::maps::<impl rustc::ty::maps::queries::check_match<'tcx>>::try_get::h5f69492c7f6191be
  28:        0x10dec8a10 - rustc::ty::maps::TyCtxtAt::check_match::h6e312737ad3b3f98
  29:        0x10dc2a733 - rustc::ty::maps::<impl rustc::ty::context::TyCtxt<'a, 'tcx, 'lcx>>::check_match::hf3b2ac7af11fe550
  30:        0x10d568029 - rustc::hir::intravisit::Visitor::visit_nested_body::h8f5d7c5d7808fe9e
  31:        0x10d57a016 - rustc::hir::Crate::visit_all_item_likes::hc291ce83d88cfc77
  32:        0x10d5681cf - rustc_const_eval::check_match::check_crate::hcc976b79a9699624
  33:        0x1094bc9a1 - <std::thread::local::LocalKey<T>>::with::h9ba93edf630e5ba1
  34:        0x1094bd2fc - <std::thread::local::LocalKey<T>>::with::h9ff8e241f7614255
  35:        0x10950a48d - rustc::ty::context::TyCtxt::create_and_enter::hba5cc46e91825fe5
  36:        0x1094800fb - rustc_driver::driver::compile_input::h096e96e4036103a7
  37:        0x1094e85f8 - rustc_driver::run_compiler::h410671cff69818f3
  38:        0x10943b881 - std::sys_common::backtrace::__rust_begin_short_backtrace::h715b34804abd2a85
  39:        0x10fb2c35e - __rust_maybe_catch_panic
  40:        0x1094f3497 - std::panicking::try::h72a42d0775e3129a
  41:        0x1094156ba - <F as alloc::boxed::FnBox<A>>::call_box::h748044d708036f85
  42:        0x10fae9f17 - std::sys_common::thread::start_thread::hbccb1a1515a8b445
  43:        0x10fb08338 - std::sys::unix::thread::Thread::new::thread_start::ha9d840ea903629e8
  44:     0x7fff995e293a - _pthread_body
  45:     0x7fff995e2886 - _pthread_start

@arielb1
Copy link
Contributor

arielb1 commented Dec 25, 2017

Minified:

mod my_mod {
    #[derive(Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
    pub struct Name<'a> {
        source: &'a str,
    }

    pub const JSON: Name = Name { source: "JSON" };
}

pub fn crash() -> bool {
  match (my_mod::JSON, None) {
    (_, Some(my_mod::JSON)) => true,
    (my_mod::JSON, None) => true,
    _ => false,
  }
}

fn main() {}

@arielb1 arielb1 mentioned this issue Dec 25, 2017
Merged
bors added a commit that referenced this issue Jan 21, 2018
@bors
Auto merge of #47001 - arielb1:private-match, r=nikomatsakis
3001ab1 
check_match: fix handling of privately uninhabited types

the match-checking code used to use TyErr for signaling "unknown,
inhabited" types for a long time. It had been switched to using the
exact type in #38069, to handle uninhabited types.

However, in #39980, we discovered that we still needed the "unknown
inhabited" logic, but I used `()` instead of `TyErr` to handle that.
Revert to using `TyErr` to fix that problem.

Fixes #46964.

r? @nikomatsakis
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
I-ICE Issue: The compiler panicked, giving an Internal Compilation Error (ICE) ❄️
Projects
None yet
Milestone
No milestone
Development

Successfully merging a pull request may close this issue.

check_match: fix handling of privately uninhabited types arielb1/rust
3 participants
@idubrov @sfackler @arielb1