Remove needless indent arguments

Mark-Simulacrum · Mark-Simulacrum · commit 63fdf1a5274d · 2019-07-10T07:13:22.000-04:00
We're always indenting by INDENT_UNIT anyway
diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs
@@ -183,19 +183,18 @@ impl<'a> State<'a> {
 
     pub fn bclose_maybe_open(&mut self,
                              span: syntax_pos::Span,
-                             indented: usize,
                              close_box: bool)
                              {
         self.maybe_print_comment(span.hi());
-        self.break_offset_if_not_bol(1, -(indented as isize));
+        self.break_offset_if_not_bol(1, -(INDENT_UNIT as isize));
         self.s.word("}");
         if close_box {
             self.end(); // close the outer-box
         }
     }
 
     pub fn bclose(&mut self, span: syntax_pos::Span) {
-        self.bclose_maybe_open(span, INDENT_UNIT, true)
+        self.bclose_maybe_open(span, true)
     }
 
     pub fn space_if_not_bol(&mut self) {
@@ -963,26 +962,18 @@ impl<'a> State<'a> {
     }
 
     pub fn print_block_unclosed(&mut self, blk: &hir::Block) {
-        self.print_block_unclosed_indent(blk, INDENT_UNIT)
-    }
-
-    pub fn print_block_unclosed_indent(&mut self,
-                                       blk: &hir::Block,
-                                       indented: usize)
-                                       {
-        self.print_block_maybe_unclosed(blk, indented, &[], false)
+        self.print_block_maybe_unclosed(blk, &[], false)
     }
 
     pub fn print_block_with_attrs(&mut self,
                                   blk: &hir::Block,
                                   attrs: &[ast::Attribute])
                                   {
-        self.print_block_maybe_unclosed(blk, INDENT_UNIT, attrs, true)
+        self.print_block_maybe_unclosed(blk, attrs, true)
     }
 
     pub fn print_block_maybe_unclosed(&mut self,
                                       blk: &hir::Block,
-                                      indented: usize,
                                       attrs: &[ast::Attribute],
                                       close_box: bool)
                                       {
@@ -1006,7 +997,7 @@ impl<'a> State<'a> {
             self.print_expr(&expr);
             self.maybe_print_trailing_comment(expr.span, Some(blk.span.hi()));
         }
-        self.bclose_maybe_open(blk.span, indented, close_box);
+        self.bclose_maybe_open(blk.span, close_box);
         self.ann.post(self, AnnNode::Block(blk))
     }
 
@@ -1263,7 +1254,7 @@ impl<'a> State<'a> {
                 self.print_ident(temp);
 
                 // Print `}`:
-                self.bclose_maybe_open(expr.span, INDENT_UNIT, true);
+                self.bclose_maybe_open(expr.span, true);
             }
             hir::ExprKind::Loop(ref blk, opt_label, _) => {
                 if let Some(label) = opt_label {
@@ -1819,7 +1810,7 @@ impl<'a> State<'a> {
                     self.word_space(":");
                 }
                 // the block will close the pattern's ibox
-                self.print_block_unclosed_indent(&blk, INDENT_UNIT);
+                self.print_block_unclosed(&blk);
 
                 // If it is a user-provided unsafe block, print a comma after it
                 if let hir::UnsafeBlock(hir::UserProvided) = blk.rules {
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -4591,7 +4591,7 @@ impl<'a> Parser<'a> {
                         s.ibox(INDENT_UNIT);
                         s.bopen();
                         s.print_stmt(&stmt);
-                        s.bclose_maybe_open(stmt.span, INDENT_UNIT, false)
+                        s.bclose_maybe_open(stmt.span, false)
                     });
                     e.span_suggestion(
                         stmt_span,
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
@@ -743,17 +743,16 @@ impl<'a> State<'a> {
         self.end(); // close the head-box
     }
 
-    crate fn bclose_maybe_open(&mut self, span: syntax_pos::Span,
-                             indented: usize, close_box: bool) {
+    crate fn bclose_maybe_open(&mut self, span: syntax_pos::Span, close_box: bool) {
         self.maybe_print_comment(span.hi());
-        self.break_offset_if_not_bol(1, -(indented as isize));
+        self.break_offset_if_not_bol(1, -(INDENT_UNIT as isize));
         self.s.word("}");
         if close_box {
             self.end(); // close the outer-box
         }
     }
     crate fn bclose(&mut self, span: syntax_pos::Span) {
-        self.bclose_maybe_open(span, INDENT_UNIT, true)
+        self.bclose_maybe_open(span, true)
     }
 
     crate fn break_offset_if_not_bol(&mut self, n: usize,
@@ -1559,20 +1558,18 @@ impl<'a> State<'a> {
         self.print_block_with_attrs(blk, &[])
     }
 
-    crate fn print_block_unclosed_indent(&mut self, blk: &ast::Block,
-                                       indented: usize) {
-        self.print_block_maybe_unclosed(blk, indented, &[], false)
+    crate fn print_block_unclosed_indent(&mut self, blk: &ast::Block) {
+        self.print_block_maybe_unclosed(blk, &[], false)
     }
 
     crate fn print_block_with_attrs(&mut self,
                                   blk: &ast::Block,
                                   attrs: &[ast::Attribute]) {
-        self.print_block_maybe_unclosed(blk, INDENT_UNIT, attrs, true)
+        self.print_block_maybe_unclosed(blk, attrs, true)
     }
 
     crate fn print_block_maybe_unclosed(&mut self,
                                       blk: &ast::Block,
-                                      indented: usize,
                                       attrs: &[ast::Attribute],
                                       close_box: bool) {
         match blk.rules {
@@ -1597,7 +1594,7 @@ impl<'a> State<'a> {
             }
         }
 
-        self.bclose_maybe_open(blk.span, indented, close_box);
+        self.bclose_maybe_open(blk.span, close_box);
         self.ann.post(self, AnnNode::Block(blk))
     }
 
@@ -2519,7 +2516,7 @@ impl<'a> State<'a> {
                 }
 
                 // the block will close the pattern's ibox
-                self.print_block_unclosed_indent(blk, INDENT_UNIT);
+                self.print_block_unclosed_indent(blk);
 
                 // If it is a user-provided unsafe block, print a comma after it
                 if let BlockCheckMode::Unsafe(ast::UserProvided) = blk.rules {

Original file line number	Diff line number	Diff line change
`@@ -183,19 +183,18 @@ impl<'a> State<'a> {`
`183`	`183`
`184`	`184`	`pub fn bclose_maybe_open(&mut self,`
`185`	`185`	`span: syntax_pos::Span,`
`186`		`- indented: usize,`
`187`	`186`	`close_box: bool)`
`188`	`187`	`{`
`189`	`188`	`self.maybe_print_comment(span.hi());`
`190`		`- self.break_offset_if_not_bol(1, -(indented as isize));`
	`189`	`+ self.break_offset_if_not_bol(1, -(INDENT_UNIT as isize));`
`191`	`190`	`self.s.word("}");`
`192`	`191`	`if close_box {`
`193`	`192`	`self.end(); // close the outer-box`
`194`	`193`	`}`
`195`	`194`	`}`
`196`	`195`
`197`	`196`	`pub fn bclose(&mut self, span: syntax_pos::Span) {`
`198`		`- self.bclose_maybe_open(span, INDENT_UNIT, true)`
	`197`	`+ self.bclose_maybe_open(span, true)`
`199`	`198`	`}`
`200`	`199`
`201`	`200`	`pub fn space_if_not_bol(&mut self) {`
`@@ -963,26 +962,18 @@ impl<'a> State<'a> {`
`963`	`962`	`}`
`964`	`963`
`965`	`964`	`pub fn print_block_unclosed(&mut self, blk: &hir::Block) {`
`966`		`- self.print_block_unclosed_indent(blk, INDENT_UNIT)`
`967`		`- }`
`968`		`-`
`969`		`- pub fn print_block_unclosed_indent(&mut self,`
`970`		`- blk: &hir::Block,`
`971`		`- indented: usize)`
`972`		`- {`
`973`		`- self.print_block_maybe_unclosed(blk, indented, &[], false)`
	`965`	`+ self.print_block_maybe_unclosed(blk, &[], false)`
`974`	`966`	`}`
`975`	`967`
`976`	`968`	`pub fn print_block_with_attrs(&mut self,`
`977`	`969`	`blk: &hir::Block,`
`978`	`970`	`attrs: &[ast::Attribute])`
`979`	`971`	`{`
`980`		`- self.print_block_maybe_unclosed(blk, INDENT_UNIT, attrs, true)`
	`972`	`+ self.print_block_maybe_unclosed(blk, attrs, true)`
`981`	`973`	`}`
`982`	`974`
`983`	`975`	`pub fn print_block_maybe_unclosed(&mut self,`
`984`	`976`	`blk: &hir::Block,`
`985`		`- indented: usize,`
`986`	`977`	`attrs: &[ast::Attribute],`
`987`	`978`	`close_box: bool)`
`988`	`979`	`{`
`@@ -1006,7 +997,7 @@ impl<'a> State<'a> {`
`1006`	`997`	`self.print_expr(&expr);`
`1007`	`998`	`self.maybe_print_trailing_comment(expr.span, Some(blk.span.hi()));`
`1008`	`999`	`}`
`1009`		`- self.bclose_maybe_open(blk.span, indented, close_box);`
	`1000`	`+ self.bclose_maybe_open(blk.span, close_box);`
`1010`	`1001`	`self.ann.post(self, AnnNode::Block(blk))`
`1011`	`1002`	`}`
`1012`	`1003`
`@@ -1263,7 +1254,7 @@ impl<'a> State<'a> {`
`1263`	`1254`	`self.print_ident(temp);`
`1264`	`1255`
`1265`	`1256`	// Print `}`:
`1266`		`- self.bclose_maybe_open(expr.span, INDENT_UNIT, true);`
	`1257`	`+ self.bclose_maybe_open(expr.span, true);`
`1267`	`1258`	`}`
`1268`	`1259`	`hir::ExprKind::Loop(ref blk, opt_label, _) => {`
`1269`	`1260`	`if let Some(label) = opt_label {`
`@@ -1819,7 +1810,7 @@ impl<'a> State<'a> {`
`1819`	`1810`	`self.word_space(":");`
`1820`	`1811`	`}`
`1821`	`1812`	`// the block will close the pattern's ibox`
`1822`		`- self.print_block_unclosed_indent(&blk, INDENT_UNIT);`
	`1813`	`+ self.print_block_unclosed(&blk);`
`1823`	`1814`
`1824`	`1815`	`// If it is a user-provided unsafe block, print a comma after it`
`1825`	`1816`	`if let hir::UnsafeBlock(hir::UserProvided) = blk.rules {`
Original file line number	Diff line number	Diff line change
`@@ -743,17 +743,16 @@ impl<'a> State<'a> {`
`743`	`743`	`self.end(); // close the head-box`
`744`	`744`	`}`
`745`	`745`
`746`		`- crate fn bclose_maybe_open(&mut self, span: syntax_pos::Span,`
`747`		`- indented: usize, close_box: bool) {`
	`746`	`+ crate fn bclose_maybe_open(&mut self, span: syntax_pos::Span, close_box: bool) {`
`748`	`747`	`self.maybe_print_comment(span.hi());`
`749`		`- self.break_offset_if_not_bol(1, -(indented as isize));`
	`748`	`+ self.break_offset_if_not_bol(1, -(INDENT_UNIT as isize));`
`750`	`749`	`self.s.word("}");`
`751`	`750`	`if close_box {`
`752`	`751`	`self.end(); // close the outer-box`
`753`	`752`	`}`
`754`	`753`	`}`
`755`	`754`	`crate fn bclose(&mut self, span: syntax_pos::Span) {`
`756`		`- self.bclose_maybe_open(span, INDENT_UNIT, true)`
	`755`	`+ self.bclose_maybe_open(span, true)`
`757`	`756`	`}`
`758`	`757`
`759`	`758`	`crate fn break_offset_if_not_bol(&mut self, n: usize,`
`@@ -1559,20 +1558,18 @@ impl<'a> State<'a> {`
`1559`	`1558`	`self.print_block_with_attrs(blk, &[])`
`1560`	`1559`	`}`
`1561`	`1560`
`1562`		`- crate fn print_block_unclosed_indent(&mut self, blk: &ast::Block,`
`1563`		`- indented: usize) {`
`1564`		`- self.print_block_maybe_unclosed(blk, indented, &[], false)`
	`1561`	`+ crate fn print_block_unclosed_indent(&mut self, blk: &ast::Block) {`
	`1562`	`+ self.print_block_maybe_unclosed(blk, &[], false)`
`1565`	`1563`	`}`
`1566`	`1564`
`1567`	`1565`	`crate fn print_block_with_attrs(&mut self,`
`1568`	`1566`	`blk: &ast::Block,`
`1569`	`1567`	`attrs: &[ast::Attribute]) {`
`1570`		`- self.print_block_maybe_unclosed(blk, INDENT_UNIT, attrs, true)`
	`1568`	`+ self.print_block_maybe_unclosed(blk, attrs, true)`
`1571`	`1569`	`}`
`1572`	`1570`
`1573`	`1571`	`crate fn print_block_maybe_unclosed(&mut self,`
`1574`	`1572`	`blk: &ast::Block,`
`1575`		`- indented: usize,`
`1576`	`1573`	`attrs: &[ast::Attribute],`
`1577`	`1574`	`close_box: bool) {`
`1578`	`1575`	`match blk.rules {`
`@@ -1597,7 +1594,7 @@ impl<'a> State<'a> {`
`1597`	`1594`	`}`
`1598`	`1595`	`}`
`1599`	`1596`
`1600`		`- self.bclose_maybe_open(blk.span, indented, close_box);`
	`1597`	`+ self.bclose_maybe_open(blk.span, close_box);`
`1601`	`1598`	`self.ann.post(self, AnnNode::Block(blk))`
`1602`	`1599`	`}`
`1603`	`1600`
`@@ -2519,7 +2516,7 @@ impl<'a> State<'a> {`
`2519`	`2516`	`}`
`2520`	`2517`
`2521`	`2518`	`// the block will close the pattern's ibox`
`2522`		`- self.print_block_unclosed_indent(blk, INDENT_UNIT);`
	`2519`	`+ self.print_block_unclosed_indent(blk);`
`2523`	`2520`
`2524`	`2521`	`// If it is a user-provided unsafe block, print a comma after it`
`2525`	`2522`	`if let BlockCheckMode::Unsafe(ast::UserProvided) = blk.rules {`