Auto merge of #42417 - eddyb:separate-fn-sig, r=<try>

Don't drag function signatures along function item types. **TODO**: write description (made PR for crater/cargobomb shenanigans) r? @nikomatsakis

Author: bors

src/librustc/ich/impls_ty.rs

@@ -514,10 +514,9 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::TypeVariants<'
  region.hash_stable(hcx, hasher);
  pointee_ty.hash_stable(hcx, hasher);
  }
- TyFnDef(def_id, substs, ref sig) => {
+ TyFnDef(def_id, substs) => {
  def_id.hash_stable(hcx, hasher);
  substs.hash_stable(hcx, hasher);
- sig.hash_stable(hcx, hasher);
  }
  TyFnPtr(ref sig) => {
  sig.hash_stable(hcx, hasher);

src/librustc/infer/mod.rs

@@ -1546,7 +1546,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
  Some(self.tcx.closure_kind(def_id))
  }
 
- pub fn closure_type(&self, def_id: DefId) -> ty::PolyFnSig<'tcx> {
+ pub fn fn_sig(&self, def_id: DefId) -> ty::PolyFnSig<'tcx> {
  if let InferTables::InProgress(tables) = self.tables {
  if let Some(id) = self.tcx.hir.as_local_node_id(def_id) {
  if let Some(&ty) = tables.borrow().closure_tys.get(&id) {
@@ -1555,7 +1555,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
  }
  }
 
- self.tcx.closure_type(def_id)
+ self.tcx.fn_sig(def_id)
  }
 }
 

src/librustc/middle/effect.rs

@@ -12,7 +12,7 @@
 //! `unsafe`.
 use self::RootUnsafeContext::*;
 
-use ty::{self, Ty, TyCtxt};
+use ty::{self, TyCtxt};
 use lint;
 
 use syntax::ast;
@@ -40,14 +40,6 @@ enum RootUnsafeContext {
  UnsafeBlock(ast::NodeId),
 }
 
-fn type_is_unsafe_function(ty: Ty) -> bool {
- match ty.sty {
- ty::TyFnDef(.., f) |
- ty::TyFnPtr(f) => f.unsafety() == hir::Unsafety::Unsafe,
- _ => false,
- }
-}
-
 struct EffectCheckVisitor<'a, 'tcx: 'a> {
  tcx: TyCtxt<'a, 'tcx, 'tcx>,
  tables: &'a ty::TypeckTables<'tcx>,
@@ -174,10 +166,11 @@ impl<'a, 'tcx> Visitor<'tcx> for EffectCheckVisitor<'a, 'tcx> {
  match expr.node {
  hir::ExprMethodCall(..) => {
  let def_id = self.tables.type_dependent_defs[&expr.id].def_id();
- let base_type = self.tcx.type_of(def_id);
- debug!("effect: method call case, base type is {:?}",
- base_type);
- if type_is_unsafe_function(base_type) {
+ let sig = self.tcx.fn_sig(def_id);
+ debug!("effect: method call case, signature is {:?}",
+ sig);
+
+ if sig.0.unsafety == hir::Unsafety::Unsafe {
  self.require_unsafe(expr.span,
  "invocation of unsafe method")
  }
@@ -186,8 +179,13 @@ impl<'a, 'tcx> Visitor<'tcx> for EffectCheckVisitor<'a, 'tcx> {
  let base_type = self.tables.expr_ty_adjusted(base);
  debug!("effect: call case, base type is {:?}",
  base_type);
- if type_is_unsafe_function(base_type) {
- self.require_unsafe(expr.span, "call to unsafe function")
+ match base_type.sty {
+ ty::TyFnDef(..) | ty::TyFnPtr(_) => {
+ if base_type.fn_sig(self.tcx).unsafety() == hir::Unsafety::Unsafe {
+ self.require_unsafe(expr.span, "call to unsafe function")
+ }
+ }
+ _ => {}
  }
  }
  hir::ExprUnary(hir::UnDeref, ref base) => {

src/librustc/middle/intrinsicck.rs

@@ -66,11 +66,8 @@ fn unpack_option_like<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
 impl<'a, 'tcx> ExprVisitor<'a, 'tcx> {
  fn def_id_is_transmute(&self, def_id: DefId) -> bool {
- let intrinsic = match self.tcx.type_of(def_id).sty {
- ty::TyFnDef(.., bfty) => bfty.abi() == RustIntrinsic,
- _ => return false
- };
- intrinsic && self.tcx.item_name(def_id) == "transmute"
+ self.tcx.fn_sig(def_id).abi() == RustIntrinsic &&
+ self.tcx.item_name(def_id) == "transmute"
  }
 
  fn check_transmute(&self, span: Span, from: Ty<'tcx>, to: Ty<'tcx>) {
@@ -159,22 +156,14 @@ impl<'a, 'tcx> Visitor<'tcx> for ExprVisitor<'a, 'tcx> {
  } else {
  Def::Err
  };
- match def {
- Def::Fn(did) if self.def_id_is_transmute(did) => {
+ if let Def::Fn(did) = def {
+ if self.def_id_is_transmute(did) {
  let typ = self.tables.node_id_to_type(expr.id);
- let typ = self.tcx.lift_to_global(&typ).unwrap();
- match typ.sty {
- ty::TyFnDef(.., sig) if sig.abi() == RustIntrinsic => {
- let from = sig.inputs().skip_binder()[0];
- let to = *sig.output().skip_binder();
- self.check_transmute(expr.span, from, to);
- }
- _ => {
- span_bug!(expr.span, "transmute wasn't a bare fn?!");
- }
- }
+ let sig = typ.fn_sig(self.tcx);
+ let from = sig.inputs().skip_binder()[0];
+ let to = *sig.output().skip_binder();
+ self.check_transmute(expr.span, from, to);
  }
- _ => {}
  }
 
  intravisit::walk_expr(self, expr);

src/librustc/traits/object_safety.rs

@@ -260,7 +260,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
 
  // The `Self` type is erased, so it should not appear in list of
  // arguments or return type apart from the receiver.
- let ref sig = self.type_of(method.def_id).fn_sig();
+ let ref sig = self.fn_sig(method.def_id);
  for input_ty in &sig.skip_binder().inputs()[1..] {
  if self.contains_illegal_self_type_reference(trait_def_id, input_ty) {
  return Some(MethodViolationCode::ReferencesSelf);

src/librustc/traits/project.rs

@@ -1137,9 +1137,19 @@ fn confirm_fn_pointer_candidate<'cx, 'gcx, 'tcx>(
  -> Progress<'tcx>
 {
  let fn_type = selcx.infcx().shallow_resolve(fn_pointer_vtable.fn_ty);
- let sig = fn_type.fn_sig();
+ let sig = fn_type.fn_sig(selcx.tcx());
+ let Normalized {
+ value: sig,
+ obligations
+ } = normalize_with_depth(selcx,
+ obligation.param_env,
+ obligation.cause.clone(),
+ obligation.recursion_depth+1,
+ &sig);
+
  confirm_callable_candidate(selcx, obligation, sig, util::TupleArgumentsFlag::Yes)
  .with_addl_obligations(fn_pointer_vtable.nested)
+ .with_addl_obligations(obligations)
 }
 
 fn confirm_closure_candidate<'cx, 'gcx, 'tcx>(
@@ -1149,7 +1159,7 @@ fn confirm_closure_candidate<'cx, 'gcx, 'tcx>(
  -> Progress<'tcx>
 {
  let closure_typer = selcx.closure_typer();
- let closure_type = closure_typer.closure_type(vtable.closure_def_id)
+ let closure_type = closure_typer.fn_sig(vtable.closure_def_id)
  .subst(selcx.tcx(), vtable.substs.substs);
  let Normalized {
  value: closure_type,

src/librustc/traits/select.rs

@@ -1402,19 +1402,15 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
  }
 
  // provide an impl, but only for suitable `fn` pointers
- ty::TyFnDef(.., ty::Binder(ty::FnSig {
- unsafety: hir::Unsafety::Normal,
- abi: Abi::Rust,
- variadic: false,
- ..
- })) |
- ty::TyFnPtr(ty::Binder(ty::FnSig {
- unsafety: hir::Unsafety::Normal,
- abi: Abi::Rust,
- variadic: false,
- ..
- })) => {
- candidates.vec.push(FnPointerCandidate);
+ ty::TyFnDef(..) | ty::TyFnPtr(_) => {
+ if let ty::Binder(ty::FnSig {
+ unsafety: hir::Unsafety::Normal,
+ abi: Abi::Rust,
+ variadic: false,
+ ..
+ }) = self_ty.fn_sig(self.tcx()) {
+ candidates.vec.push(FnPointerCandidate);
+ }
  }
 
  _ => { }
@@ -2346,19 +2342,26 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
 
  // ok to skip binder; it is reintroduced below
  let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
- let sig = self_ty.fn_sig();
+ let sig = self_ty.fn_sig(self.tcx());
  let trait_ref =
  self.tcx().closure_trait_ref_and_return_type(obligation.predicate.def_id(),
  self_ty,
  sig,
  util::TupleArgumentsFlag::Yes)
  .map_bound(|(trait_ref, _)| trait_ref);
 
+ let Normalized { value: trait_ref, obligations } =
+ project::normalize_with_depth(self,
+ obligation.param_env,
+ obligation.cause.clone(),
+ obligation.recursion_depth + 1,
+ &trait_ref);
+
  self.confirm_poly_trait_refs(obligation.cause.clone(),
  obligation.param_env,
  obligation.predicate.to_poly_trait_ref(),
  trait_ref)?;
- Ok(VtableFnPointerData { fn_ty: self_ty, nested: vec![] })
+ Ok(VtableFnPointerData { fn_ty: self_ty, nested: obligations })
  }
 
  fn confirm_closure_candidate(&mut self,
@@ -2797,7 +2800,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
  substs: ty::ClosureSubsts<'tcx>)
  -> ty::PolyTraitRef<'tcx>
  {
- let closure_type = self.infcx.closure_type(closure_def_id)
+ let closure_type = self.infcx.fn_sig(closure_def_id)
  .subst(self.tcx(), substs.substs);
  let ty::Binder((trait_ref, _)) =
  self.tcx().closure_trait_ref_and_return_type(obligation.predicate.def_id(),

src/librustc/ty/context.rs

@@ -1378,9 +1378,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
  }
 
  pub fn mk_fn_def(self, def_id: DefId,
- substs: &'tcx Substs<'tcx>,
- fty: PolyFnSig<'tcx>) -> Ty<'tcx> {
- self.mk_ty(TyFnDef(def_id, substs, fty))
+ substs: &'tcx Substs<'tcx>) -> Ty<'tcx> {
+ self.mk_ty(TyFnDef(def_id, substs))
  }
 
  pub fn mk_fn_ptr(self, fty: PolyFnSig<'tcx>) -> Ty<'tcx> {

src/librustc/ty/fast_reject.rs

@@ -68,14 +68,15 @@ pub fn simplify_type<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
  // view of possibly unifying
  simplify_type(tcx, mt.ty, can_simplify_params)
  }
+ ty::TyFnDef(def_id, _) |
  ty::TyClosure(def_id, _) => {
  Some(ClosureSimplifiedType(def_id))
  }
  ty::TyNever => Some(NeverSimplifiedType),
  ty::TyTuple(ref tys, _) => {
  Some(TupleSimplifiedType(tys.len()))
  }
- ty::TyFnDef(.., ref f) | ty::TyFnPtr(ref f) => {
+ ty::TyFnPtr(ref f) => {
  Some(FunctionSimplifiedType(f.skip_binder().inputs().len()))
  }
  ty::TyProjection(_) | ty::TyParam(_) => {

src/librustc/ty/flags.rs

@@ -155,9 +155,8 @@ impl FlagComputation {
  self.add_tys(&ts[..]);
  }
 
- &ty::TyFnDef(_, substs, f) => {
+ &ty::TyFnDef(_, substs) => {
  self.add_substs(substs);
- self.add_fn_sig(f);
  }
 
  &ty::TyFnPtr(f) => {