rustc_infer: remove InferCtxt::closure_sig as the FnSig is always shallowly known.

Author: eddyb

src/librustc/ty/print/pretty.rs

@@ -681,9 +681,9 @@ pub trait PrettyPrinter<'tcx>:
 
                 if self.tcx().sess.verbose() {
                     p!(write(
-                        " closure_kind_ty={:?} closure_sig_ty={:?}",
+                        " closure_kind_ty={:?} closure_sig_as_fn_ptr_ty={:?}",
                         substs.as_closure().kind_ty(did, self.tcx()),
-                        substs.as_closure().sig_ty(did, self.tcx())
+                        substs.as_closure().sig_as_fn_ptr_ty(did, self.tcx())
                     ));
                 }
 

src/librustc/ty/sty.rs

@@ -371,7 +371,7 @@ pub struct ClosureSubsts<'tcx> {
 /// parent slice and not canonical substs themselves.
 struct SplitClosureSubsts<'tcx> {
     closure_kind_ty: Ty<'tcx>,
-    closure_sig_ty: Ty<'tcx>,
+    closure_sig_as_fn_ptr_ty: Ty<'tcx>,
     upvar_kinds: &'tcx [GenericArg<'tcx>],
 }
 
@@ -384,7 +384,7 @@ impl<'tcx> ClosureSubsts<'tcx> {
         let parent_len = generics.parent_count;
         SplitClosureSubsts {
             closure_kind_ty: self.substs.type_at(parent_len),
-            closure_sig_ty: self.substs.type_at(parent_len + 1),
+            closure_sig_as_fn_ptr_ty: self.substs.type_at(parent_len + 1),
             upvar_kinds: &self.substs[parent_len + 2..],
         }
     }
@@ -412,12 +412,10 @@ impl<'tcx> ClosureSubsts<'tcx> {
         self.split(def_id, tcx).closure_kind_ty
     }
 
-    /// Returns the type representing the closure signature for this
-    /// closure; may contain type variables during inference. To get
-    /// the closure signature during inference, use
-    /// `infcx.fn_sig(def_id)`.
-    pub fn sig_ty(self, def_id: DefId, tcx: TyCtxt<'_>) -> Ty<'tcx> {
-        self.split(def_id, tcx).closure_sig_ty
+    /// Returns the `fn` pointer type representing the closure signature for this
+    /// closure.
+    pub fn sig_as_fn_ptr_ty(self, def_id: DefId, tcx: TyCtxt<'_>) -> Ty<'tcx> {
+        self.split(def_id, tcx).closure_sig_as_fn_ptr_ty
     }
 
     /// Returns the closure kind for this closure; only usable outside
@@ -429,16 +427,12 @@ impl<'tcx> ClosureSubsts<'tcx> {
         self.split(def_id, tcx).closure_kind_ty.to_opt_closure_kind().unwrap()
     }
 
-    /// Extracts the signature from the closure; only usable outside
-    /// of an inference context, because in that context we know that
-    /// there are no type variables.
-    ///
-    /// If you have an inference context, use `infcx.closure_sig()`.
+    /// Extracts the signature from the closure.
     pub fn sig(&self, def_id: DefId, tcx: TyCtxt<'tcx>) -> ty::PolyFnSig<'tcx> {
-        let ty = self.sig_ty(def_id, tcx);
+        let ty = self.sig_as_fn_ptr_ty(def_id, tcx);
         match ty.kind {
             ty::FnPtr(sig) => sig,
-            _ => bug!("closure_sig_ty is not a fn-ptr: {:?}", ty.kind),
+            _ => bug!("closure_sig_as_fn_ptr_ty is not a fn-ptr: {:?}", ty.kind),
         }
     }
 }
@@ -2200,9 +2194,9 @@ impl<'tcx> TyS<'tcx> {
                 // ignore errors (#54954)
                 ty::Binder::dummy(FnSig::fake())
             }
-            Closure(..) => {
-                bug!("to get the signature of a closure, use `closure_sig()` not `fn_sig()`",)
-            }
+            Closure(..) => bug!(
+                "to get the signature of a closure, use `substs.as_closure().sig()` not `fn_sig()`",
+            ),
             _ => bug!("Ty::fn_sig() called on non-fn type: {:?}", self),
         }
     }

src/librustc_infer/infer/mod.rs

@@ -1486,16 +1486,6 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         closure_kind_ty.to_opt_closure_kind()
     }
 
-    /// Obtains the signature of a closure. For closures, unlike
-    /// `tcx.fn_sig(def_id)`, this method will work during the
-    /// type-checking of the enclosing function and return the closure
-    /// signature in its partially inferred state.
-    pub fn closure_sig(&self, def_id: DefId, substs: SubstsRef<'tcx>) -> ty::PolyFnSig<'tcx> {
-        let closure_sig_ty = substs.as_closure().sig_ty(def_id, self.tcx);
-        let closure_sig_ty = self.shallow_resolve(closure_sig_ty);
-        closure_sig_ty.fn_sig(self.tcx)
-    }
-
     /// Clears the selection, evaluation, and projection caches. This is useful when
     /// repeatedly attempting to select an `Obligation` while changing only
     /// its `ParamEnv`, since `FulfillmentContext` doesn't use probing.

src/librustc_mir/borrow_check/diagnostics/conflict_errors.rs

@@ -1684,7 +1684,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                                 // case it ends up being assigned into the return place.
                                 annotated_closure = self.annotate_fn_sig(
                                     *def_id,
-                                    self.infcx.closure_sig(*def_id, *substs),
+                                    substs.as_closure().sig(*def_id, self.infcx.tcx),
                                 );
                                 debug!(
                                     "annotate_argument_and_return_for_borrow: \

src/librustc_mir/borrow_check/type_check/mod.rs

@@ -2083,9 +2083,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
                     CastKind::Pointer(PointerCast::ClosureFnPointer(unsafety)) => {
                         let sig = match op.ty(*body, tcx).kind {
-                            ty::Closure(def_id, substs) => {
-                                substs.as_closure().sig_ty(def_id, tcx).fn_sig(tcx)
-                            }
+                            ty::Closure(def_id, substs) => substs.as_closure().sig(def_id, tcx),
                             _ => bug!(),
                         };
                         let ty_fn_ptr_from = tcx.coerce_closure_fn_ty(sig, *unsafety);

src/librustc_mir/borrow_check/universal_regions.rs

@@ -580,7 +580,7 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
         match defining_ty {
             DefiningTy::Closure(def_id, substs) => {
                 assert_eq!(self.mir_def_id, def_id);
-                let closure_sig = substs.as_closure().sig_ty(def_id, tcx).fn_sig(tcx);
+                let closure_sig = substs.as_closure().sig(def_id, tcx);
                 let inputs_and_output = closure_sig.inputs_and_output();
                 let closure_ty = tcx.closure_env_ty(def_id, substs).unwrap();
                 ty::Binder::fuse(closure_ty, inputs_and_output, |closure_ty, inputs_and_output| {

src/librustc_trait_selection/opaque_types.rs

@@ -724,7 +724,7 @@ where
                     upvar_ty.visit_with(self);
                 }
 
-                substs.as_closure().sig_ty(def_id, self.tcx).visit_with(self);
+                substs.as_closure().sig_as_fn_ptr_ty(def_id, self.tcx).visit_with(self);
             }
 
             ty::Generator(def_id, ref substs, _) => {

src/librustc_trait_selection/traits/error_reporting/suggestions.rs

@@ -368,7 +368,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
         let self_ty = trait_ref.self_ty();
         let (def_id, output_ty, callable) = match self_ty.kind {
             ty::Closure(def_id, substs) => {
-                (def_id, self.closure_sig(def_id, substs).output(), "closure")
+                (def_id, substs.as_closure().sig(def_id, self.tcx).output(), "closure")
             }
             ty::FnDef(def_id, _) => (def_id, self_ty.fn_sig(self.tcx).output(), "function"),
             _ => return,

src/librustc_trait_selection/traits/project.rs

@@ -1311,9 +1311,7 @@ fn confirm_closure_candidate<'cx, 'tcx>(
     vtable: VtableClosureData<'tcx, PredicateObligation<'tcx>>,
 ) -> Progress<'tcx> {
     let tcx = selcx.tcx();
-    let infcx = selcx.infcx();
-    let closure_sig_ty = vtable.substs.as_closure().sig_ty(vtable.closure_def_id, tcx);
-    let closure_sig = infcx.shallow_resolve(closure_sig_ty).fn_sig(tcx);
+    let closure_sig = vtable.substs.as_closure().sig(vtable.closure_def_id, tcx);
     let Normalized { value: closure_sig, obligations } = normalize_with_depth(
         selcx,
         obligation.param_env,

src/librustc_trait_selection/traits/select.rs

@@ -3349,9 +3349,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             "closure_trait_ref_unnormalized(obligation={:?}, closure_def_id={:?}, substs={:?})",
             obligation, closure_def_id, substs,
         );
-        let closure_type = self.infcx.closure_sig(closure_def_id, substs);
+        let closure_sig = substs.as_closure().sig(closure_def_id, self.tcx());
 
-        debug!("closure_trait_ref_unnormalized: closure_type = {:?}", closure_type);
+        debug!("closure_trait_ref_unnormalized: closure_sig = {:?}", closure_sig);
 
         // (1) Feels icky to skip the binder here, but OTOH we know
         // that the self-type is an unboxed closure type and hence is
@@ -3362,7 +3362,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             self.tcx(),
             obligation.predicate.def_id(),
             obligation.predicate.skip_binder().self_ty(), // (1)
-            closure_type,
+            closure_sig,
             util::TupleArgumentsFlag::No,
         )
         .map_bound(|(trait_ref, _)| trait_ref)