diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 3b20a77ad0372..b801513528f7e 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -51,6 +51,7 @@ use util::nodemap::{NodeMap, FxHashMap}; use std::collections::BTreeMap; use std::iter; +use syntax::attr; use syntax::ast::*; use syntax::errors; use syntax::ptr::P; @@ -1834,8 +1835,9 @@ impl<'a> LoweringContext<'a> { // to: // // match Carrier::translate() { - // Ok(val) => val, - // Err(err) => return Carrier::from_error(From::from(err)) + // Ok(val) => #[allow(unreachable_code)] val, + // Err(err) => #[allow(unreachable_code)] + // return Carrier::from_error(From::from(err)), // } let unstable_span = self.allow_internal_unstable("?", e.span); @@ -1849,17 +1851,36 @@ impl<'a> LoweringContext<'a> { P(self.expr_call(e.span, path, hir_vec![sub_expr])) }; - // Ok(val) => val + // #[allow(unreachable_code)] + let attr = { + // allow(unreachable_code) + let allow = { + let allow_ident = self.str_to_ident("allow"); + let uc_ident = self.str_to_ident("unreachable_code"); + let uc_meta_item = attr::mk_spanned_word_item(e.span, uc_ident); + let uc_nested = NestedMetaItemKind::MetaItem(uc_meta_item); + let uc_spanned = respan(e.span, uc_nested); + attr::mk_spanned_list_item(e.span, allow_ident, vec![uc_spanned]) + }; + attr::mk_spanned_attr_outer(e.span, attr::mk_attr_id(), allow) + }; + let attrs = vec![attr]; + + // Ok(val) => #[allow(unreachable_code)] val, let ok_arm = { let val_ident = self.str_to_ident("val"); let val_pat = self.pat_ident(e.span, val_ident); - let val_expr = P(self.expr_ident(e.span, val_ident, val_pat.id)); + let val_expr = P(self.expr_ident_with_attrs(e.span, + val_ident, + val_pat.id, + ThinVec::from(attrs.clone()))); let ok_pat = self.pat_ok(e.span, val_pat); self.arm(hir_vec![ok_pat], val_expr) }; - // Err(err) => return Carrier::from_error(From::from(err)) + // Err(err) => #[allow(unreachable_code)] + // return Carrier::from_error(From::from(err)), let err_arm = { let err_ident = self.str_to_ident("err"); let err_local = self.pat_ident(e.span, err_ident); @@ -1879,7 +1900,7 @@ impl<'a> LoweringContext<'a> { let ret_expr = P(self.expr(e.span, hir::Expr_::ExprRet(Some(from_err_expr)), - ThinVec::new())); + ThinVec::from(attrs))); let err_pat = self.pat_err(e.span, err_local); self.arm(hir_vec![err_pat], ret_expr) @@ -2031,6 +2052,13 @@ impl<'a> LoweringContext<'a> { } fn expr_ident(&mut self, span: Span, id: Name, binding: NodeId) -> hir::Expr { + self.expr_ident_with_attrs(span, id, binding, ThinVec::new()) + } + + fn expr_ident_with_attrs(&mut self, span: Span, + id: Name, + binding: NodeId, + attrs: ThinVec) -> hir::Expr { let def = { let defs = self.resolver.definitions(); Def::Local(defs.local_def_id(binding)) @@ -2042,7 +2070,7 @@ impl<'a> LoweringContext<'a> { segments: hir_vec![hir::PathSegment::from_name(id)], }))); - self.expr(span, expr_path, ThinVec::new()) + self.expr(span, expr_path, attrs) } fn expr_mut_addr_of(&mut self, span: Span, e: P) -> hir::Expr { diff --git a/src/librustc_const_eval/check_match.rs b/src/librustc_const_eval/check_match.rs index 400af3c702346..52f332a30c03b 100644 --- a/src/librustc_const_eval/check_match.rs +++ b/src/librustc_const_eval/check_match.rs @@ -308,14 +308,7 @@ fn check_arms<'a, 'tcx>(cx: &mut MatchCheckCtxt<'a, 'tcx>, .emit(); }, - hir::MatchSource::ForLoopDesugar => { - // this is a bug, because on `match iter.next()` we cover - // `Some()` and `None`. It's impossible to have an unreachable - // pattern - // (see libsyntax/ext/expand.rs for the full expansion of a for loop) - span_bug!(pat.span, "unreachable for-loop pattern") - }, - + hir::MatchSource::ForLoopDesugar | hir::MatchSource::Normal => { let mut diagnostic = Diagnostic::new(Level::Warning, "unreachable pattern"); @@ -329,9 +322,9 @@ fn check_arms<'a, 'tcx>(cx: &mut MatchCheckCtxt<'a, 'tcx>, hir_pat.id, diagnostic); }, - hir::MatchSource::TryDesugar => { - span_bug!(pat.span, "unreachable try pattern") - }, + // Unreachable patterns in try expressions occur when one of the arms + // are an uninhabited type. Which is OK. + hir::MatchSource::TryDesugar => {} } } Useful => (), diff --git a/src/test/compile-fail/recursive-types-are-not-uninhabited.rs b/src/test/compile-fail/recursive-types-are-not-uninhabited.rs new file mode 100644 index 0000000000000..f8d6c3de2ab03 --- /dev/null +++ b/src/test/compile-fail/recursive-types-are-not-uninhabited.rs @@ -0,0 +1,26 @@ +// Copyright 2014 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//#![feature(never_type)] + +struct R<'a> { + r: &'a R<'a>, +} + +fn foo(res: Result) -> u32 { + let Ok(x) = res; + //~^ ERROR refutable pattern + x +} + +fn main() { + foo(Ok(23)); +} + diff --git a/src/test/compile-fail/unreachable-loop-patterns.rs b/src/test/compile-fail/unreachable-loop-patterns.rs new file mode 100644 index 0000000000000..6147692658f94 --- /dev/null +++ b/src/test/compile-fail/unreachable-loop-patterns.rs @@ -0,0 +1,20 @@ +// Copyright 2013 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(never_type)] +#![deny(unreachable_patterns)] + +fn main() { + let x: &[!] = &[]; + + for _ in x {} + //~^ ERROR unreachable pattern +} + diff --git a/src/test/compile-fail/unreachable-try-pattern.rs b/src/test/compile-fail/unreachable-try-pattern.rs new file mode 100644 index 0000000000000..f4817ba33b518 --- /dev/null +++ b/src/test/compile-fail/unreachable-try-pattern.rs @@ -0,0 +1,50 @@ +// Copyright 2013 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(never_type)] +#![deny(unreachable_code)] +#![deny(unreachable_patterns)] + +enum Void {} + +impl From for i32 { + fn from(v: Void) -> i32 { + match v {} + } +} + +fn bar(x: Result) -> Result { + x? +} + +fn foo(x: Result) -> Result { + let y = (match x { Ok(n) => Ok(n as u32), Err(e) => Err(e) })?; + //~^ ERROR unreachable pattern + //~| ERROR unreachable expression + Ok(y) +} + +fn qux(x: Result) -> Result { + Ok(x?) +} + +fn vom(x: Result) -> Result { + let y = (match x { Ok(n) => Ok(n), Err(e) => Err(e) })?; + //~^ ERROR unreachable pattern + Ok(y) +} + +fn main() { + let _ = bar(Err(123)); + let _ = foo(Err(123)); + let _ = qux(Ok(123)); + let _ = vom(Ok(123)); +} +