work on pretty printing contracts and fixing their lowering.

Author: pnkfelix

compiler/rustc_ast_lowering/src/item.rs

@@ -224,6 +224,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         coroutine_kind,
                         body.as_deref(),
                     );
+                    let last_recorded_body = this.bodies.last().unwrap();
+                    assert_eq!(last_recorded_body.0, body_id.hir_id.local_id);
+                    let contract_params: &'hir [hir::Param<'hir>] = last_recorded_body.1.params;
 
                     let itctx = ImplTraitContext::Universal;
                     let (generics, decl) =
@@ -241,7 +244,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         header: this.lower_fn_header(*header, hir::Safety::Safe),
                         span: this.lower_span(*fn_sig_span),
                     };
-                    let contract_ids = this.lower_contract(contract);
+                    let contract_ids = this.lower_contract(contract_params, contract);
                     hir::ItemKind::Fn(sig, generics, Some(contract_ids), body_id)
                 })
             }
@@ -1131,13 +1134,23 @@ impl<'hir> LoweringContext<'_, 'hir> {
         })
     }
 
-    fn lower_contract(&mut self, contract: &ast::FnContract) -> &'hir hir::FnContractIds {
-        let precond_expr = contract.requires.as_ref().map(|e| self.lower_expr(&e));
-        let postcond_expr = contract.ensures.as_ref().map(|e| self.lower_expr(&e));
-        let precond_hir_id: Option<hir::HirId> = precond_expr.map(|e| e.hir_id);
-        let postcond_hir_id: Option<hir::HirId> = postcond_expr.map(|e| e.hir_id);
+    fn lower_contract(&mut self, params: &'hir [hir::Param<'hir>], contract: &ast::FnContract) -> &'hir hir::FnContractIds {
+        let precond: Option<&P<Expr>> = contract.requires.as_ref();
+        let postcond: Option<&P<Expr>> = contract.ensures.as_ref();
+        let precond: Option<hir::BodyId> = precond.map(|e| {
+            self.lower_body(|this| {
+                (params,
+                 this.lower_expr_mut(e))
+            })
+        });
+        let postcond: Option<hir::BodyId> = postcond.map(|e| {
+            self.lower_body(|this| {
+                (params,
+                 this.lower_expr_mut(e))
+            })
+        });
 
-        self.arena.alloc(hir::FnContractIds { precond_hir_id, postcond_hir_id, })
+        self.arena.alloc(hir::FnContractIds { precond, postcond, })
     }
 
     /// Takes what may be the body of an `async fn` or a `gen fn` and wraps it in an `async {}` or

compiler/rustc_ast_lowering/src/lib.rs

@@ -598,7 +598,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let current_attrs = std::mem::take(&mut self.attrs);
         let current_bodies = std::mem::take(&mut self.bodies);
         let current_node_ids = std::mem::take(&mut self.node_id_to_local_id);
-        let current_trait_map = std::mem::take(&mut self.trait_map);
+        let current_trait_map: rustc_data_structures::unord::UnordMap<rustc_hir::ItemLocalId, Box<[TraitCandidate]>> = std::mem::take(&mut self.trait_map);
         let current_owner =
             std::mem::replace(&mut self.current_hir_id_owner, hir::OwnerId { def_id });
         let current_local_counter =

compiler/rustc_hir/src/hir.rs

@@ -1443,8 +1443,8 @@ pub struct BodyId {
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
 pub struct FnContractIds {
-    pub precond_hir_id: Option<HirId>,
-    pub postcond_hir_id: Option<HirId>,
+    pub precond: Option<BodyId>,
+    pub postcond: Option<BodyId>,
 }
 
 /// The body of a function, closure, or constant value. In the case of

compiler/rustc_hir_pretty/src/lib.rs

@@ -363,6 +363,7 @@ impl<'a> State<'a> {
                     generics,
                     arg_names,
                     None,
+                    None,
                 );
                 self.end(); // end head-ibox
                 self.word(";");
@@ -522,14 +523,15 @@ impl<'a> State<'a> {
                 self.word(";");
                 self.end(); // end the outer cbox
             }
-            hir::ItemKind::Fn(ref sig, generics, _fn_contract_ids, body) => {
+            hir::ItemKind::Fn(ref sig, generics, fn_contract_ids, body) => {
                 self.head("");
                 self.print_fn(
                     sig.decl,
                     sig.header,
                     Some(item.ident.name),
                     generics,
                     &[],
+                    fn_contract_ids,
                     Some(body),
                 );
                 self.word(" ");
@@ -792,7 +794,7 @@ impl<'a> State<'a> {
         arg_names: &[Ident],
         body_id: Option<hir::BodyId>,
     ) {
-        self.print_fn(m.decl, m.header, Some(ident.name), generics, arg_names, body_id);
+        self.print_fn(m.decl, m.header, Some(ident.name), generics, arg_names, None, body_id);
     }
 
     fn print_trait_item(&mut self, ti: &hir::TraitItem<'_>) {
@@ -1942,6 +1944,7 @@ impl<'a> State<'a> {
         name: Option<Symbol>,
         generics: &hir::Generics<'_>,
         arg_names: &[Ident],
+        fn_contract_ids: Option<&hir::FnContractIds>,
         body_id: Option<hir::BodyId>,
     ) {
         self.print_fn_header_info(header);
@@ -1982,6 +1985,7 @@ impl<'a> State<'a> {
         self.pclose();
 
         self.print_fn_output(decl);
+        if let Some(contract_ids) = fn_contract_ids { self.print_contracts(contract_ids); }
         self.print_where_clause(generics)
     }
 
@@ -2146,6 +2150,15 @@ impl<'a> State<'a> {
         self.print_ident(lifetime.ident)
     }
 
+    fn print_contracts(&mut self, fn_contract_ids: &hir::FnContractIds) {
+        if let Some(precond) = fn_contract_ids.precond {
+            self.ann.nested(self, Nested::Body(precond));
+        }
+        if let Some(postcond) = fn_contract_ids.postcond {
+            self.ann.nested(self, Nested::Body(postcond));
+        }
+    }
+
     fn print_where_clause(&mut self, generics: &hir::Generics<'_>) {
         if generics.predicates.is_empty() {
             return;
@@ -2260,6 +2273,7 @@ impl<'a> State<'a> {
             generics,
             arg_names,
             None,
+            None,
         );
         self.end();
     }