Merge pull request rust-lang#100 from oli-obk/tuple_struct_constructo…

…r_as_fn

allow the use of tuple struct constructors as functions

src/error.rs

@@ -52,6 +52,7 @@ pub enum EvalError<'tcx> {
  ReallocatedFrozenMemory,
  DeallocatedFrozenMemory,
  Layout(layout::LayoutError<'tcx>),
+ Unreachable,
 }
 
 pub type EvalResult<'tcx, T> = Result<T, EvalError<'tcx>>;
@@ -122,6 +123,8 @@ impl<'tcx> Error for EvalError<'tcx> {
  "rustc layout computation failed",
  EvalError::UnterminatedCString(_) =>
  "attempted to get length of a null terminated string, but no null found before end of allocation",
+ EvalError::Unreachable =>
+ "entered unreachable code",
  }
  }
 

src/eval_context.rs

@@ -10,6 +10,7 @@ use rustc::ty::layout::{self, Layout, Size};
 use rustc::ty::subst::{self, Subst, Substs};
 use rustc::ty::{self, Ty, TyCtxt, TypeFoldable};
 use rustc_data_structures::indexed_vec::Idx;
+use rustc_data_structures::fx::FxHashSet;
 use syntax::codemap::{self, DUMMY_SP};
 
 use error::{EvalError, EvalResult};
@@ -1468,3 +1469,7 @@ pub fn monomorphize_field_ty<'a, 'tcx:'a >(tcx: TyCtxt<'a, 'tcx, 'tcx>, f: &ty::
  let substituted = &f.ty(tcx, substs);
  tcx.normalize_associated_type(&substituted)
 }
+
+pub fn is_inhabited<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>) -> bool {
+ ty.uninhabited_from(&mut FxHashSet::default(), tcx).is_empty()
+}

src/terminator/mod.rs

@@ -9,7 +9,7 @@ use syntax::codemap::{DUMMY_SP, Span};
 use syntax::{ast, attr};
 
 use error::{EvalError, EvalResult};
-use eval_context::{EvalContext, IntegerExt, StackPopCleanup, monomorphize_field_ty};
+use eval_context::{EvalContext, IntegerExt, StackPopCleanup, monomorphize_field_ty, is_inhabited};
 use lvalue::{Lvalue, LvalueExtra};
 use memory::Pointer;
 use value::PrimVal;
@@ -155,7 +155,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
 
  DropAndReplace { .. } => unimplemented!(),
  Resume => unimplemented!(),
- Unreachable => unimplemented!(),
+ Unreachable => return Err(EvalError::Unreachable),
  }
 
  Ok(())
@@ -200,7 +200,10 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
  Abi::RustIntrinsic => {
  let ty = fn_ty.sig.0.output();
  let layout = self.type_layout(ty)?;
- let (ret, target) = destination.unwrap();
+ let (ret, target) = match destination {
+ Some(dest) if is_inhabited(self.tcx, ty) => dest,
+ _ => return Err(EvalError::Unreachable),
+ };
  self.call_intrinsic(def_id, substs, arg_operands, ret, ty, layout, target)?;
  Ok(())
  }
@@ -229,6 +232,33 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
  (def_id, substs, Vec::new())
  };
 
+ // FIXME(eddyb) Detect ADT constructors more efficiently.
+ if let Some(adt_def) = fn_ty.sig.skip_binder().output().ty_adt_def() {
+ if let Some(v) = adt_def.variants.iter().find(|v| resolved_def_id == v.did) {
+ let (lvalue, target) = destination.expect("tuple struct constructors can't diverge");
+ let dest_ty = self.tcx.item_type(adt_def.did);
+ let dest_layout = self.type_layout(dest_ty)?;
+ match *dest_layout {
+ Layout::Univariant { ref variant, .. } => {
+ assert_eq!(v.disr_val.to_u128_unchecked(), 0);
+ let offsets = variant.offsets.iter().map(|s| s.bytes());
+
+ // FIXME: don't allocate for single or dual field structs
+ let dest = self.force_allocation(lvalue)?.to_ptr();
+
+ for (offset, (value, value_ty)) in offsets.into_iter().zip(args) {
+ let field_dest = dest.offset(offset);
+ self.write_value_to_ptr(value, field_dest, value_ty)?;
+ }
+ },
+ // FIXME: enum variant constructors
+ _ => bug!("bad layout for tuple struct constructor: {:?}", dest_layout),
+ }
+ self.goto_block(target);
+ return Ok(());
+ }
+ }
+
  let mir = self.load_mir(resolved_def_id)?;
  let (return_lvalue, return_to_block) = match destination {
  Some((lvalue, block)) => (lvalue, StackPopCleanup::Goto(block)),

tests/compile-fail/never_say_never.rs

@@ -0,0 +1,12 @@
+#![feature(never_type)]
+#![allow(unreachable_code)]
+
+fn main() {
+ let y = &5;
+ let x: ! = unsafe {
+ *(y as *const _ as *const !) //~ ERROR entered unreachable code
+ };
+ f(x)
+}
+
+fn f(x: !) -> ! { x }

tests/compile-fail/never_transmute_humans.rs

@@ -0,0 +1,14 @@
+#![feature(never_type)]
+#![allow(unreachable_code)]
+#![allow(unused_variables)]
+
+struct Human;
+
+fn main() {
+ let x: ! = unsafe {
+ std::mem::transmute::<Human, !>(Human) //~ ERROR entered unreachable code
+ };
+ f(x)
+}
+
+fn f(x: !) -> ! { x }

tests/compile-fail/never_transmute_void.rs

@@ -0,0 +1,16 @@
+#![feature(never_type)]
+#![allow(unreachable_code)]
+#![allow(unused_variables)]
+
+enum Void {}
+
+fn f(v: Void) -> ! {
+ match v {}
+}
+
+fn main() {
+ let v: Void = unsafe {
+ std::mem::transmute::<(), Void>(()) //~ ERROR entered unreachable code
+ };
+ f(v);
+}

tests/run-pass/tuple_like_struct_constructor.rs

@@ -0,0 +1,5 @@
+fn main() {
+ #[derive(PartialEq, Eq, Debug)]
+ struct A(i32);
+ assert_eq!(Some(42).map(A), Some(A(42)));
+}