XXX: closures

Author: nnethercote

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1085,6 +1085,27 @@ impl<'a> State<'a> {
         State { s: pp::Printer::new(), comments: None, ann: &NoAnn }
     }
 
+    pub fn with_ibox(&mut self, indent: isize, f: impl FnOnce(&mut Self)) {
+        let ib = self.ibox(indent);
+        f(self);
+        self.end(ib);
+    }
+
+    // njn: name?
+    pub fn with_cbox_ibox_print_block_with_attrs(
+        &mut self,
+        cindent: isize, // njn: always 0?
+        iindent: isize,
+        block: &ast::Block,
+        attrs: &[ast::Attribute],
+        f: impl FnOnce(&mut Self),
+    ) {
+        let cb = self.cbox(cindent);
+        let ib = self.ibox(iindent);
+        f(self);
+        self.print_block_with_attrs(block, attrs, cb, ib);
+    }
+
     fn commasep_cmnt<T, F, G>(&mut self, b: Breaks, elts: &[T], mut op: F, mut get_span: G)
     where
         F: FnMut(&mut State<'_>, &T),

compiler/rustc_ast_pretty/src/pprust/state/expr.rs

@@ -110,39 +110,37 @@ impl<'a> State<'a> {
     }
 
     fn print_expr_vec(&mut self, exprs: &[P<ast::Expr>]) {
-        let ib = self.ibox(INDENT_UNIT);
-        self.word("[");
-        self.commasep_exprs(Inconsistent, exprs);
-        self.word("]");
-        self.end(ib);
+        self.with_ibox(INDENT_UNIT, |this: &mut Self| {
+            this.word("[");
+            this.commasep_exprs(Inconsistent, exprs);
+            this.word("]");
+        });
     }
 
     pub(super) fn print_expr_anon_const(
         &mut self,
         expr: &ast::AnonConst,
         attrs: &[ast::Attribute],
     ) {
-        let ib = self.ibox(INDENT_UNIT);
-        self.word("const");
-        self.nbsp();
-        if let ast::ExprKind::Block(block, None) = &expr.value.kind {
-            let cb = self.cbox(0);
-            let ib = self.ibox(0);
-            self.print_block_with_attrs(block, attrs, cb, ib);
-        } else {
-            self.print_expr(&expr.value, FixupContext::default());
-        }
-        self.end(ib);
+        self.with_ibox(INDENT_UNIT, |this| {
+            this.word("const");
+            this.nbsp();
+            if let ast::ExprKind::Block(block, None) = &expr.value.kind {
+                this.with_cbox_ibox_print_block_with_attrs(0, 0, block, attrs, |_| {});
+            } else {
+                this.print_expr(&expr.value, FixupContext::default());
+            }
+        });
     }
 
     fn print_expr_repeat(&mut self, element: &ast::Expr, count: &ast::AnonConst) {
-        let ib = self.ibox(INDENT_UNIT);
-        self.word("[");
-        self.print_expr(element, FixupContext::default());
-        self.word_space(";");
-        self.print_expr(&count.value, FixupContext::default());
-        self.word("]");
-        self.end(ib);
+        self.with_ibox(INDENT_UNIT, |this| {
+            this.word("[");
+            this.print_expr(element, FixupContext::default());
+            this.word_space(";");
+            this.print_expr(&count.value, FixupContext::default());
+            this.word("]");
+        });
     }
 
     fn print_expr_struct(
@@ -438,14 +436,12 @@ impl<'a> State<'a> {
             ast::ExprKind::Type(expr, ty) => {
                 self.word("builtin # type_ascribe");
                 self.popen();
-                let ib = self.ibox(0);
-                self.print_expr(expr, FixupContext::default());
-
-                self.word(",");
-                self.space_if_not_bol();
-                self.print_type(ty);
-
-                self.end(ib);
+                self.with_ibox(0, |this| {
+                    this.print_expr(expr, FixupContext::default());
+                    this.word(",");
+                    this.space_if_not_bol();
+                    this.print_type(ty);
+                });
                 self.pclose();
             }
             ast::ExprKind::Let(pat, scrutinee, _, _) => {
@@ -457,12 +453,11 @@ impl<'a> State<'a> {
                     self.print_ident(label.ident);
                     self.word_space(":");
                 }
-                let cb = self.cbox(0);
-                let ib = self.ibox(0);
-                self.word_nbsp("while");
-                self.print_expr_as_cond(test);
-                self.space();
-                self.print_block_with_attrs(blk, attrs, cb, ib);
+                self.with_cbox_ibox_print_block_with_attrs(0, 0, blk, attrs, |this| {
+                    this.word_nbsp("while");
+                    this.print_expr_as_cond(test);
+                    this.space();
+                }
             }
             ast::ExprKind::ForLoop { pat, iter, body, label, kind } => {
                 if let Some(label) = label {
@@ -833,6 +828,7 @@ impl<'a> State<'a> {
         if arm.attrs.is_empty() {
             self.space();
         }
+        // njn: hmm, tricky case for the closure approach
         let cb = self.cbox(INDENT_UNIT);
         let ib = self.ibox(0);
         self.maybe_print_comment(arm.pat.span.lo());
@@ -874,7 +870,7 @@ impl<'a> State<'a> {
             // other path :(
             self.word(",");
         }
-        self.end(cb); // Close enclosing cbox.
+        self.end(cb); // Close enclosing cbox. // njn: remove low-value comments of this sort
     }
 
     fn print_closure_binder(&mut self, binder: &ast::ClosureBinder) {