auto merge of #17603 : jakub-/rust/ty_bot, r=nikomatsakis

We now instead use a fresh variable for expressions that diverge.

Closes #14973.
Closes #13847.

[Work in progress]

cc @nikomatsakis

src/libcore/intrinsics.rs

@@ -149,7 +149,7 @@ pub trait TyVisitor {
  fn visit_fn_input(&mut self, i: uint, mode: uint,
  inner: *const TyDesc) -> bool;
  fn visit_fn_output(&mut self, retstyle: uint, variadic: bool,
- inner: *const TyDesc) -> bool;
+ converging: bool, inner: *const TyDesc) -> bool;
  fn visit_leave_fn(&mut self, purity: uint, proto: uint,
  n_inputs: uint, retstyle: uint) -> bool;
 

src/librustc/diagnostics.rs

@@ -145,5 +145,6 @@ register_diagnostics!(
  E0162,
  E0163,
  E0164,
- E0165
+ E0165,
+ E0166
 )

src/librustc/lint/builtin.rs

@@ -683,7 +683,7 @@ impl LintPass for UnusedResults {
  let t = ty::expr_ty(cx.tcx, expr);
  let mut warned = false;
  match ty::get(t).sty {
- ty::ty_nil | ty::ty_bot | ty::ty_bool => return,
+ ty::ty_nil | ty::ty_bool => return,
  ty::ty_struct(did, _) |
  ty::ty_enum(did, _) => {
  if ast_util::is_local(did) {

src/librustc/metadata/tydecode.rs

@@ -359,7 +359,6 @@ fn parse_trait_ref(st: &mut PState, conv: conv_did) -> ty::TraitRef {
 fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
  match next(st) {
  'n' => return ty::mk_nil(),
- 'z' => return ty::mk_bot(),
  'b' => return ty::mk_bool(),
  'i' => return ty::mk_int(),
  'u' => return ty::mk_uint(),
@@ -590,10 +589,16 @@ fn parse_sig(st: &mut PState, conv: conv_did) -> ty::FnSig {
  'N' => false,
  r => fail!(format!("bad variadic: {}", r)),
  };
- let ret_ty = parse_ty(st, |x,y| conv(x,y));
+ let output = match peek(st) {
+ 'z' => {
+ st.pos += 1u;
+ ty::FnDiverging
+ }
+ _ => ty::FnConverging(parse_ty(st, |x,y| conv(x,y)))
+ };
  ty::FnSig {binder_id: id,
  inputs: inputs,
- output: ret_ty,
+ output: output,
  variadic: variadic}
 }
 

src/librustc/metadata/tyencode.rs

@@ -200,7 +200,6 @@ pub fn enc_trait_store(w: &mut SeekableMemWriter, cx: &ctxt, s: ty::TraitStore)
 fn enc_sty(w: &mut SeekableMemWriter, cx: &ctxt, st: &ty::sty) {
  match *st {
  ty::ty_nil => mywrite!(w, "n"),
- ty::ty_bot => mywrite!(w, "z"),
  ty::ty_bool => mywrite!(w, "b"),
  ty::ty_char => mywrite!(w, "c"),
  ty::ty_int(t) => {
@@ -346,7 +345,14 @@ fn enc_fn_sig(w: &mut SeekableMemWriter, cx: &ctxt, fsig: &ty::FnSig) {
  } else {
  mywrite!(w, "N");
  }
- enc_ty(w, cx, fsig.output);
+ match fsig.output {
+ ty::FnConverging(result_type) => {
+ enc_ty(w, cx, result_type);
+ }
+ ty::FnDiverging => {
+ mywrite!(w, "z");
+ }
+ }
 }
 
 pub fn enc_builtin_bounds(w: &mut SeekableMemWriter, _cx: &ctxt, bs: &ty::BuiltinBounds) {

src/librustc/middle/cfg/construct.rs

@@ -511,12 +511,15 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
  pred: CFGIndex,
  func_or_rcvr: &ast::Expr,
  args: I) -> CFGIndex {
+ let method_call = typeck::MethodCall::expr(call_expr.id);
+ let return_ty = ty::ty_fn_ret(match self.tcx.method_map.borrow().find(&method_call) {
+ Some(method) => method.ty,
+ None => ty::expr_ty(self.tcx, func_or_rcvr)
+ });
+
  let func_or_rcvr_exit = self.expr(func_or_rcvr, pred);
  let ret = self.straightline(call_expr, func_or_rcvr_exit, args);
-
- let return_ty = ty::node_id_to_type(self.tcx, call_expr.id);
- let fails = ty::type_is_bot(return_ty);
- if fails {
+ if return_ty == ty::FnDiverging {
  self.add_node(ast::DUMMY_NODE_ID, [])
  } else {
  ret

src/librustc/middle/expr_use_visitor.rs

@@ -396,13 +396,9 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,TYPER> {
  // make sure that the thing we are pointing out stays valid
  // for the lifetime `scope_r` of the resulting ptr:
  let expr_ty = ty::expr_ty(self.tcx(), expr);
- if !ty::type_is_bot(expr_ty) {
- let r = ty::ty_region(self.tcx(), expr.span, expr_ty);
- let bk = ty::BorrowKind::from_mutbl(m);
- self.borrow_expr(&**base, r, bk, AddrOf);
- } else {
- self.walk_expr(&**base);
- }
+ let r = ty::ty_region(self.tcx(), expr.span, expr_ty);
+ let bk = ty::BorrowKind::from_mutbl(m);
+ self.borrow_expr(&**base, r, bk, AddrOf);
  }
 
  ast::ExprInlineAsm(ref ia) => {

src/librustc/middle/intrinsicck.rs

@@ -126,9 +126,10 @@ impl<'a, 'tcx, 'v> Visitor<'v> for IntrinsicCheckingVisitor<'a, 'tcx> {
  match ty::get(typ).sty {
  ty_bare_fn(ref bare_fn_ty)
  if bare_fn_ty.abi == RustIntrinsic => {
- let from = bare_fn_ty.sig.inputs[0];
- let to = bare_fn_ty.sig.output;
- self.check_transmute(expr.span, from, to, expr.id);
+ if let ty::FnConverging(to) = bare_fn_ty.sig.output {
+ let from = bare_fn_ty.sig.inputs[0];
+ self.check_transmute(expr.span, from, to, expr.id);
+ }
  }
  _ => {
  self.tcx

src/librustc/middle/liveness.rs

@@ -100,11 +100,18 @@
  * - `no_ret_var`: a synthetic variable that is only 'read' from, the
  * fallthrough node. This allows us to detect functions where we fail
  * to return explicitly.
+ * - `clean_exit_var`: a synthetic variable that is only 'read' from the
+ * fallthrough node. It is only live if the function could converge
+ * via means other than an explicit `return` expression. That is, it is
+ * only dead if the end of the function's block can never be reached.
+ * It is the responsibility of typeck to ensure that there are no
+ * `return` expressions in a function declared as diverging.
  */
 
 use middle::def::*;
 use middle::mem_categorization::Typer;
 use middle::pat_util;
+use middle::typeck;
 use middle::ty;
 use lint;
 use util::nodemap::NodeMap;
@@ -250,7 +257,8 @@ struct LocalInfo {
 enum VarKind {
  Arg(NodeId, Ident),
  Local(LocalInfo),
- ImplicitRet
+ ImplicitRet,
+ CleanExit
 }
 
 struct IrMaps<'a, 'tcx: 'a> {
@@ -306,7 +314,7 @@ impl<'a, 'tcx> IrMaps<'a, 'tcx> {
  Local(LocalInfo { id: node_id, .. }) | Arg(node_id, _) => {
  self.variable_map.insert(node_id, v);
  },
- ImplicitRet => {}
+ ImplicitRet | CleanExit => {}
  }
 
  debug!("{} is {}", v.to_string(), vk);
@@ -331,7 +339,8 @@ impl<'a, 'tcx> IrMaps<'a, 'tcx> {
  Local(LocalInfo { ident: nm, .. }) | Arg(_, nm) => {
  token::get_ident(nm).get().to_string()
  },
- ImplicitRet => "<implicit-ret>".to_string()
+ ImplicitRet => "<implicit-ret>".to_string(),
+ CleanExit => "<clean-exit>".to_string()
  }
  }
 
@@ -397,7 +406,8 @@ fn visit_fn(ir: &mut IrMaps,
  let specials = Specials {
  exit_ln: fn_maps.add_live_node(ExitNode),
  fallthrough_ln: fn_maps.add_live_node(ExitNode),
- no_ret_var: fn_maps.add_variable(ImplicitRet)
+ no_ret_var: fn_maps.add_variable(ImplicitRet),
+ clean_exit_var: fn_maps.add_variable(CleanExit)
  };
 
  // compute liveness
@@ -546,7 +556,8 @@ fn invalid_users() -> Users {
 struct Specials {
  exit_ln: LiveNode,
  fallthrough_ln: LiveNode,
- no_ret_var: Variable
+ no_ret_var: Variable,
+ clean_exit_var: Variable
 }
 
 static ACC_READ: uint = 1u;
@@ -873,6 +884,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
  if blk.expr.is_none() {
  self.acc(s.fallthrough_ln, s.no_ret_var, ACC_READ)
  }
+ self.acc(s.fallthrough_ln, s.clean_exit_var, ACC_READ);
 
  self.propagate_through_block(blk, s.fallthrough_ln)
  }
@@ -943,9 +955,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
  opt_expr: Option<&Expr>,
  succ: LiveNode)
  -> LiveNode {
- opt_expr.iter().fold(succ, |succ, expr| {
- self.propagate_through_expr(&**expr, succ)
- })
+ opt_expr.map_or(succ, |expr| self.propagate_through_expr(expr, succ))
  }
 
  fn propagate_through_expr(&mut self, expr: &Expr, succ: LiveNode)
@@ -1146,13 +1156,11 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
  }
 
  ExprCall(ref f, ref args) => {
- // calling a fn with bot return type means that the fn
- // will fail, and hence the successors can be ignored
- let is_bot = !self.ir.tcx.is_method_call(expr.id) && {
+ let diverges = !self.ir.tcx.is_method_call(expr.id) && {
  let t_ret = ty::ty_fn_ret(ty::expr_ty(self.ir.tcx, &**f));
- ty::type_is_bot(t_ret)
+ t_ret == ty::FnDiverging
  };
- let succ = if is_bot {
+ let succ = if diverges {
  self.s.exit_ln
  } else {
  succ
@@ -1162,11 +1170,14 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
  }
 
  ExprMethodCall(_, _, ref args) => {
- // calling a method with bot return type means that the method
- // will fail, and hence the successors can be ignored
- let t_ret = ty::node_id_to_type(self.ir.tcx, expr.id);
- let succ = if ty::type_is_bot(t_ret) {self.s.exit_ln}
- else {succ};
+ let method_call = typeck::MethodCall::expr(expr.id);
+ let method_ty = self.ir.tcx.method_map.borrow().find(&method_call).unwrap().ty;
+ let diverges = ty::ty_fn_ret(method_ty) == ty::FnDiverging;
+ let succ = if diverges {
+ self.s.exit_ln
+ } else {
+ succ
+ };
  self.propagate_through_exprs(args.as_slice(), succ)
  }
 
@@ -1507,50 +1518,68 @@ fn check_fn(_v: &Liveness,
 }
 
 impl<'a, 'tcx> Liveness<'a, 'tcx> {
+ fn fn_ret(&self, id: NodeId) -> ty::FnOutput {
+ let fn_ty = ty::node_id_to_type(self.ir.tcx, id);
+ match ty::get(fn_ty).sty {
+ ty::ty_unboxed_closure(closure_def_id, _, _) =>
+ self.ir.tcx.unboxed_closures()
+ .borrow()
+ .find(&closure_def_id)
+ .unwrap()
+ .closure_type
+ .sig
+ .output,
+ _ => ty::ty_fn_ret(fn_ty)
+ }
+ }
+
  fn check_ret(&self,
  id: NodeId,
  sp: Span,
  _fk: FnKind,
  entry_ln: LiveNode,
  body: &Block) {
- if self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() {
- // if no_ret_var is live, then we fall off the end of the
- // function without any kind of return expression:
-
- let t_ret = ty::ty_fn_ret(ty::node_id_to_type(self.ir.tcx, id));
- if ty::type_is_nil(t_ret) {
- // for nil return types, it is ok to not return a value expl.
- } else if ty::type_is_bot(t_ret) {
- // for bot return types, not ok. Function should fail.
- self.ir.tcx.sess.span_err(
- sp, "some control paths may return");
- } else {
- let ends_with_stmt = match body.expr {
- None if body.stmts.len() > 0 =>
- match body.stmts.last().unwrap().node {
- StmtSemi(ref e, _) => {
- let t_stmt = ty::expr_ty(self.ir.tcx, &**e);
- ty::get(t_stmt).sty == ty::get(t_ret).sty
+ match self.fn_ret(id) {
+ ty::FnConverging(t_ret)
+ if self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() => {
+
+ if ty::type_is_nil(t_ret) {
+ // for nil return types, it is ok to not return a value expl.
+ } else {
+ let ends_with_stmt = match body.expr {
+ None if body.stmts.len() > 0 =>
+ match body.stmts.last().unwrap().node {
+ StmtSemi(ref e, _) => {
+ let t_stmt = ty::expr_ty(self.ir.tcx, &**e);
+ ty::get(t_stmt).sty == ty::get(t_ret).sty
+ },
+ _ => false
  },
- _ => false
- },
- _ => false
- };
- self.ir.tcx.sess.span_err(
- sp, "not all control paths return a value");
- if ends_with_stmt {
- let last_stmt = body.stmts.last().unwrap();
- let original_span = original_sp(self.ir.tcx.sess.codemap(),
- last_stmt.span, sp);
- let span_semicolon = Span {
- lo: original_span.hi - BytePos(1),
- hi: original_span.hi,
- expn_id: original_span.expn_id
+ _ => false
  };
- self.ir.tcx.sess.span_note(
- span_semicolon, "consider removing this semicolon:");
+ self.ir.tcx.sess.span_err(
+ sp, "not all control paths return a value");
+ if ends_with_stmt {
+ let last_stmt = body.stmts.last().unwrap();
+ let original_span = original_sp(self.ir.tcx.sess.codemap(),
+ last_stmt.span, sp);
+ let span_semicolon = Span {
+ lo: original_span.hi - BytePos(1),
+ hi: original_span.hi,
+ expn_id: original_span.expn_id
+ };
+ self.ir.tcx.sess.span_note(
+ span_semicolon, "consider removing this semicolon:");
+ }
  }
- }
+ }
+ ty::FnDiverging
+ if self.live_on_entry(entry_ln, self.s.clean_exit_var).is_some() => {
+ self.ir.tcx.sess.span_err(sp,
+ "computation may converge in a function marked as diverging");
+ }
+
+ _ => {}
  }
  }
 

src/librustc/middle/mem_categorization.rs

@@ -485,7 +485,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
  Some(method_ty) => {
  // If this is an index implemented by a method call, then it will
  // include an implicit deref of the result.
- let ret_ty = ty::ty_fn_ret(method_ty);
+ let ret_ty = ty::ty_fn_ret(method_ty).unwrap();
  Ok(self.cat_deref(expr,
  self.cat_rvalue_node(expr.id(),
  expr.span(),
@@ -878,7 +878,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
 
  let base_cmt = match method_ty {
  Some(method_ty) => {
- let ref_ty = ty::ty_fn_ret(method_ty);
+ let ref_ty = ty::ty_fn_ret(method_ty).unwrap();
  self.cat_rvalue_node(node.id(), node.span(), ref_ty)
  }
  None => base_cmt
@@ -957,7 +957,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
 
  let element_ty = match method_ty {
  Some(method_ty) => {
- let ref_ty = ty::ty_fn_ret(method_ty);
+ let ref_ty = ty::ty_fn_ret(method_ty).unwrap();
  base_cmt = self.cat_rvalue_node(elt.id(), elt.span(), ref_ty);
  ty::ty_fn_args(method_ty)[0]
  }

src/librustc/middle/traits/coherence.rs

@@ -80,7 +80,6 @@ pub fn ty_is_local(tcx: &ty::ctxt,
 
  match ty::get(ty).sty {
  ty::ty_nil |
- ty::ty_bot |
  ty::ty_bool |
  ty::ty_char |
  ty::ty_int(..) |