Implement printer for closure signature

Author: wutchzone

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -1963,6 +1963,32 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
         })
     }
 
+    fn pretty_closure_signature(
+        &mut self,
+        closure: ty::ClosureArgs<'tcx>,
+    ) -> Result<(), PrintError> {
+        let sig = closure.sig();
+
+        self.wrap_binder(&sig, |sig, cx| {
+            define_scoped_cx!(cx);
+
+            p!(write("fn("));
+            for (i, arg) in sig.inputs()[0].tuple_fields().iter().enumerate() {
+                if i > 0 {
+                    p!(", ");
+                }
+                p!(print(arg));
+            }
+            p!(")");
+
+            if !sig.output().is_unit() {
+                p!(" -> ", print(sig.output()));
+            }
+
+            Ok(())
+        })
+    }
+
     fn pretty_print_bound_constness(
         &mut self,
         trait_ref: ty::TraitRef<'tcx>,
@@ -2973,6 +2999,11 @@ pub struct PrintClosureAsImpl<'tcx> {
     pub closure: ty::ClosureArgs<'tcx>,
 }
 
+#[derive(Debug, Copy, Clone, Lift)]
+pub struct PrintClosureSignature<'tcx> {
+    pub closure: ty::ClosureArgs<'tcx>,
+}
+
 macro_rules! forward_display_to_print {
     ($($ty:ty),+) => {
         // Some of the $ty arguments may not actually use 'tcx
@@ -3157,6 +3188,10 @@ define_print_and_forward_display! {
         p!(pretty_closure_as_impl(self.closure))
     }
 
+    PrintClosureSignature<'tcx> {
+        p!(pretty_closure_signature(self.closure))
+    }
+
     ty::ParamTy {
         p!(write("{}", self.name))
     }

compiler/rustc_middle/src/ty/sty.rs

@@ -266,6 +266,11 @@ impl<'tcx> ClosureArgs<'tcx> {
     pub fn print_as_impl_trait(self) -> ty::print::PrintClosureAsImpl<'tcx> {
         ty::print::PrintClosureAsImpl { closure: self }
     }
+
+    /// Prints closure signature in form of `fn(Args) -> Output` with stripped `extern "rust-call`.
+    pub fn print_signature(self) -> ty::print::PrintClosureSignature<'tcx> {
+        ty::print::PrintClosureSignature { closure: self }
+    }
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug, TypeFoldable, TypeVisitable, Lift)]