From f65ded56263a9dd7d125f2b0001fb996df1fb3f3 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 18 Aug 2022 09:47:53 -0700 Subject: [PATCH] go/printer: rename printPos to setPos MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Follow-up on feedback in CL 412557. Change-Id: I5a693efccade97a62ab880c6e1b9e50cb597c293 Reviewed-on: https://go-review.googlesource.com/c/go/+/424814 Reviewed-by: Daniel Martí Run-TryBot: Robert Griesemer TryBot-Result: Gopher Robot Auto-Submit: Robert Griesemer Reviewed-by: Joedian Reid Reviewed-by: Robert Griesemer --- src/go/printer/nodes.go | 112 +++++++++++++++++++------------------- src/go/printer/printer.go | 2 +- 2 files changed, 57 insertions(+), 57 deletions(-) diff --git a/src/go/printer/nodes.go b/src/go/printer/nodes.go index f16d76acc7e..e41ffc19583 100644 --- a/src/go/printer/nodes.go +++ b/src/go/printer/nodes.go @@ -152,7 +152,7 @@ func (p *printer) exprList(prev0 token.Pos, list []ast.Expr, depth int, mode exp if i > 0 { // use position of expression following the comma as // comma position for correct comment placement - p.printPos(x.Pos()) + p.setPos(x.Pos()) p.print(token.COMMA, blank) } p.expr0(x, depth) @@ -244,7 +244,7 @@ func (p *printer) exprList(prev0 token.Pos, list []ast.Expr, depth int, mode exp // comma position for correct comment placement, but // only if the expression is on the same line. if !needsLinebreak { - p.printPos(x.Pos()) + p.setPos(x.Pos()) } p.print(token.COMMA) needsBlank := true @@ -279,7 +279,7 @@ func (p *printer) exprList(prev0 token.Pos, list []ast.Expr, depth int, mode exp // can align if possible. // (needsLinebreak is set if we started a new line before) p.expr(pair.Key) - p.printPos(pair.Colon) + p.setPos(pair.Colon) p.print(token.COLON, vtab) p.expr(pair.Value) } else { @@ -333,7 +333,7 @@ func (p *printer) parameters(fields *ast.FieldList, mode paramMode) { if mode != funcParam { openTok, closeTok = token.LBRACK, token.RBRACK } - p.printPos(fields.Opening) + p.setPos(fields.Opening) p.print(openTok) if len(fields.List) > 0 { prevLine := p.lineFor(fields.Opening) @@ -351,7 +351,7 @@ func (p *printer) parameters(fields *ast.FieldList, mode paramMode) { // comma position for correct comma placement, but // only if the next parameter is on the same line if !needsLinebreak { - p.printPos(par.Pos()) + p.setPos(par.Pos()) } p.print(token.COMMA) } @@ -397,7 +397,7 @@ func (p *printer) parameters(fields *ast.FieldList, mode paramMode) { } } - p.printPos(fields.Closing) + p.setPos(fields.Closing) p.print(closeTok) } @@ -506,15 +506,15 @@ func (p *printer) fieldList(fields *ast.FieldList, isStruct, isIncomplete bool) // possibly a one-line struct/interface if len(list) == 0 { // no blank between keyword and {} in this case - p.printPos(lbrace) + p.setPos(lbrace) p.print(token.LBRACE) - p.printPos(rbrace) + p.setPos(rbrace) p.print(token.RBRACE) return } else if p.isOneLineFieldList(list) { // small enough - print on one line // (don't use identList and ignore source line breaks) - p.printPos(lbrace) + p.setPos(lbrace) p.print(token.LBRACE, blank) f := list[0] if isStruct { @@ -540,7 +540,7 @@ func (p *printer) fieldList(fields *ast.FieldList, isStruct, isIncomplete bool) } } p.print(blank) - p.printPos(rbrace) + p.setPos(rbrace) p.print(token.RBRACE) return } @@ -548,7 +548,7 @@ func (p *printer) fieldList(fields *ast.FieldList, isStruct, isIncomplete bool) // hasComments || !srcIsOneLine p.print(blank) - p.printPos(lbrace) + p.setPos(lbrace) p.print(token.LBRACE, indent) if hasComments || len(list) > 0 { p.print(formfeed) @@ -645,7 +645,7 @@ func (p *printer) fieldList(fields *ast.FieldList, isStruct, isIncomplete bool) } p.print(unindent, formfeed) - p.printPos(rbrace) + p.setPos(rbrace) p.print(token.RBRACE) } @@ -797,7 +797,7 @@ func (p *printer) binaryExpr(x *ast.BinaryExpr, prec1, cutoff, depth int) { } xline := p.pos.Line // before the operator (it may be on the next line!) yline := p.lineFor(x.Y.Pos()) - p.printPos(x.OpPos) + p.setPos(x.OpPos) p.print(x.Op) if xline != yline && xline > 0 && yline > 0 { // at least one line break, but respect an extra empty line @@ -822,7 +822,7 @@ func isBinary(expr ast.Expr) bool { } func (p *printer) expr1(expr ast.Expr, prec1, depth int) { - p.printPos(expr.Pos()) + p.setPos(expr.Pos()) switch x := expr.(type) { case *ast.BadExpr: @@ -840,7 +840,7 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) { case *ast.KeyValueExpr: p.expr(x.Key) - p.printPos(x.Colon) + p.setPos(x.Colon) p.print(token.COLON, blank) p.expr(x.Value) @@ -882,7 +882,7 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) { p.print(x) case *ast.FuncLit: - p.printPos(x.Type.Pos()) + p.setPos(x.Type.Pos()) p.print(token.FUNC) // See the comment in funcDecl about how the header size is computed. startCol := p.out.Column - len("func") @@ -897,7 +897,7 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) { } else { p.print(token.LPAREN) p.expr0(x.X, reduceDepth(depth)) // parentheses undo one level of depth - p.printPos(x.Rparen) + p.setPos(x.Rparen) p.print(token.RPAREN) } @@ -907,39 +907,39 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) { case *ast.TypeAssertExpr: p.expr1(x.X, token.HighestPrec, depth) p.print(token.PERIOD) - p.printPos(x.Lparen) + p.setPos(x.Lparen) p.print(token.LPAREN) if x.Type != nil { p.expr(x.Type) } else { p.print(token.TYPE) } - p.printPos(x.Rparen) + p.setPos(x.Rparen) p.print(token.RPAREN) case *ast.IndexExpr: // TODO(gri): should treat[] like parentheses and undo one level of depth p.expr1(x.X, token.HighestPrec, 1) - p.printPos(x.Lbrack) + p.setPos(x.Lbrack) p.print(token.LBRACK) p.expr0(x.Index, depth+1) - p.printPos(x.Rbrack) + p.setPos(x.Rbrack) p.print(token.RBRACK) case *ast.IndexListExpr: // TODO(gri): as for IndexExpr, should treat [] like parentheses and undo // one level of depth p.expr1(x.X, token.HighestPrec, 1) - p.printPos(x.Lbrack) + p.setPos(x.Lbrack) p.print(token.LBRACK) p.exprList(x.Lbrack, x.Indices, depth+1, commaTerm, x.Rbrack, false) - p.printPos(x.Rbrack) + p.setPos(x.Rbrack) p.print(token.RBRACK) case *ast.SliceExpr: // TODO(gri): should treat[] like parentheses and undo one level of depth p.expr1(x.X, token.HighestPrec, 1) - p.printPos(x.Lbrack) + p.setPos(x.Lbrack) p.print(token.LBRACK) indices := []ast.Expr{x.Low, x.High} if x.Max != nil { @@ -976,7 +976,7 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) { p.expr0(x, depth+1) } } - p.printPos(x.Rbrack) + p.setPos(x.Rbrack) p.print(token.RBRACK) case *ast.CallExpr: @@ -992,11 +992,11 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) { } else { wasIndented = p.possibleSelectorExpr(x.Fun, token.HighestPrec, depth) } - p.printPos(x.Lparen) + p.setPos(x.Lparen) p.print(token.LPAREN) if x.Ellipsis.IsValid() { p.exprList(x.Lparen, x.Args, depth, 0, x.Ellipsis, false) - p.printPos(x.Ellipsis) + p.setPos(x.Ellipsis) p.print(token.ELLIPSIS) if x.Rparen.IsValid() && p.lineFor(x.Ellipsis) < p.lineFor(x.Rparen) { p.print(token.COMMA, formfeed) @@ -1004,7 +1004,7 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) { } else { p.exprList(x.Lparen, x.Args, depth, commaTerm, x.Rparen, false) } - p.printPos(x.Rparen) + p.setPos(x.Rparen) p.print(token.RPAREN) if wasIndented { p.print(unindent) @@ -1016,7 +1016,7 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) { p.expr1(x.Type, token.HighestPrec, depth) } p.level++ - p.printPos(x.Lbrace) + p.setPos(x.Lbrace) p.print(token.LBRACE) p.exprList(x.Lbrace, x.Elts, 1, commaTerm, x.Rbrace, x.Incomplete) // do not insert extra line break following a /*-style comment @@ -1031,7 +1031,7 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) { // need the initial indent to print lone comments with // the proper level of indentation p.print(indent, unindent, mode) - p.printPos(x.Rbrace) + p.setPos(x.Rbrace) p.print(token.RBRACE, mode) p.level-- @@ -1075,7 +1075,7 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) { p.print(token.ARROW, token.CHAN) // x.Arrow and x.Pos() are the same case ast.SEND: p.print(token.CHAN) - p.printPos(x.Arrow) + p.setPos(x.Arrow) p.print(token.ARROW) } p.print(blank) @@ -1161,14 +1161,14 @@ func (p *printer) selectorExpr(x *ast.SelectorExpr, depth int, isMethod bool) bo p.print(token.PERIOD) if line := p.lineFor(x.Sel.Pos()); p.pos.IsValid() && p.pos.Line < line { p.print(indent, newline) - p.printPos(x.Sel.Pos()) + p.setPos(x.Sel.Pos()) p.print(x.Sel) if !isMethod { p.print(unindent) } return true } - p.printPos(x.Sel.Pos()) + p.setPos(x.Sel.Pos()) p.print(x.Sel) return false } @@ -1227,11 +1227,11 @@ func (p *printer) stmtList(list []ast.Stmt, nindent int, nextIsRBrace bool) { // block prints an *ast.BlockStmt; it always spans at least two lines. func (p *printer) block(b *ast.BlockStmt, nindent int) { - p.printPos(b.Lbrace) + p.setPos(b.Lbrace) p.print(token.LBRACE) p.stmtList(b.List, nindent, true) p.linebreak(p.lineFor(b.Rbrace), 1, ignore, true) - p.printPos(b.Rbrace) + p.setPos(b.Rbrace) p.print(token.RBRACE) } @@ -1347,7 +1347,7 @@ func (p *printer) indentList(list []ast.Expr) bool { } func (p *printer) stmt(stmt ast.Stmt, nextIsRBrace bool) { - p.printPos(stmt.Pos()) + p.setPos(stmt.Pos()) switch s := stmt.(type) { case *ast.BadStmt: @@ -1365,12 +1365,12 @@ func (p *printer) stmt(stmt ast.Stmt, nextIsRBrace bool) { // between (see writeWhitespace) p.print(unindent) p.expr(s.Label) - p.printPos(s.Colon) + p.setPos(s.Colon) p.print(token.COLON, indent) if e, isEmpty := s.Stmt.(*ast.EmptyStmt); isEmpty { if !nextIsRBrace { p.print(newline) - p.printPos(e.Pos()) + p.setPos(e.Pos()) p.print(token.SEMICOLON) break } @@ -1387,14 +1387,14 @@ func (p *printer) stmt(stmt ast.Stmt, nextIsRBrace bool) { const depth = 1 p.expr0(s.Chan, depth) p.print(blank) - p.printPos(s.Arrow) + p.setPos(s.Arrow) p.print(token.ARROW, blank) p.expr0(s.Value, depth) case *ast.IncDecStmt: const depth = 1 p.expr0(s.X, depth+1) - p.printPos(s.TokPos) + p.setPos(s.TokPos) p.print(s.Tok) case *ast.AssignStmt: @@ -1404,7 +1404,7 @@ func (p *printer) stmt(stmt ast.Stmt, nextIsRBrace bool) { } p.exprList(s.Pos(), s.Lhs, depth, 0, s.TokPos, false) p.print(blank) - p.printPos(s.TokPos) + p.setPos(s.TokPos) p.print(s.Tok, blank) p.exprList(s.TokPos, s.Rhs, depth, 0, token.NoPos, false) @@ -1472,7 +1472,7 @@ func (p *printer) stmt(stmt ast.Stmt, nextIsRBrace bool) { } else { p.print(token.DEFAULT) } - p.printPos(s.Colon) + p.setPos(s.Colon) p.print(token.COLON) p.stmtList(s.Body, 1, nextIsRBrace) @@ -1500,7 +1500,7 @@ func (p *printer) stmt(stmt ast.Stmt, nextIsRBrace bool) { } else { p.print(token.DEFAULT) } - p.printPos(s.Colon) + p.setPos(s.Colon) p.print(token.COLON) p.stmtList(s.Body, 1, nextIsRBrace) @@ -1509,9 +1509,9 @@ func (p *printer) stmt(stmt ast.Stmt, nextIsRBrace bool) { body := s.Body if len(body.List) == 0 && !p.commentBefore(p.posFor(body.Rbrace)) { // print empty select statement w/o comments on one line - p.printPos(body.Lbrace) + p.setPos(body.Lbrace) p.print(token.LBRACE) - p.printPos(body.Rbrace) + p.setPos(body.Rbrace) p.print(token.RBRACE) } else { p.block(body, 0) @@ -1529,12 +1529,12 @@ func (p *printer) stmt(stmt ast.Stmt, nextIsRBrace bool) { if s.Value != nil { // use position of value following the comma as // comma position for correct comment placement - p.printPos(s.Value.Pos()) + p.setPos(s.Value.Pos()) p.print(token.COMMA, blank) p.expr(s.Value) } p.print(blank) - p.printPos(s.TokPos) + p.setPos(s.TokPos) p.print(s.Tok, blank) } p.print(token.RANGE, blank) @@ -1694,7 +1694,7 @@ func (p *printer) spec(spec ast.Spec, n int, doIndent bool) { } p.expr(sanitizeImportPath(s.Path)) p.setComment(s.Comment) - p.printPos(s.EndPos) + p.setPos(s.EndPos) case *ast.ValueSpec: if n != 1 { @@ -1736,12 +1736,12 @@ func (p *printer) spec(spec ast.Spec, n int, doIndent bool) { func (p *printer) genDecl(d *ast.GenDecl) { p.setComment(d.Doc) - p.printPos(d.Pos()) + p.setPos(d.Pos()) p.print(d.Tok, blank) if d.Lparen.IsValid() || len(d.Specs) > 1 { // group of parenthesized declarations - p.printPos(d.Lparen) + p.setPos(d.Lparen) p.print(token.LPAREN) if n := len(d.Specs); n > 0 { p.print(indent, formfeed) @@ -1769,7 +1769,7 @@ func (p *printer) genDecl(d *ast.GenDecl) { } p.print(unindent, formfeed) } - p.printPos(d.Rparen) + p.setPos(d.Rparen) p.print(token.RPAREN) } else if len(d.Specs) > 0 { @@ -1885,7 +1885,7 @@ func (p *printer) funcBody(headerSize int, sep whiteSpace, b *ast.BlockStmt) { const maxSize = 100 if headerSize+p.bodySize(b, maxSize) <= maxSize { p.print(sep) - p.printPos(b.Lbrace) + p.setPos(b.Lbrace) p.print(token.LBRACE) if len(b.List) > 0 { p.print(blank) @@ -1898,7 +1898,7 @@ func (p *printer) funcBody(headerSize int, sep whiteSpace, b *ast.BlockStmt) { p.print(blank) } p.print(noExtraLinebreak) - p.printPos(b.Rbrace) + p.setPos(b.Rbrace) p.print(token.RBRACE, noExtraLinebreak) return } @@ -1921,7 +1921,7 @@ func (p *printer) distanceFrom(startPos token.Pos, startOutCol int) int { func (p *printer) funcDecl(d *ast.FuncDecl) { p.setComment(d.Doc) - p.printPos(d.Pos()) + p.setPos(d.Pos()) p.print(token.FUNC, blank) // We have to save startCol only after emitting FUNC; otherwise it can be on a // different line (all whitespace preceding the FUNC is emitted only when the @@ -1939,7 +1939,7 @@ func (p *printer) funcDecl(d *ast.FuncDecl) { func (p *printer) decl(decl ast.Decl) { switch d := decl.(type) { case *ast.BadDecl: - p.printPos(d.Pos()) + p.setPos(d.Pos()) p.print("BadDecl") case *ast.GenDecl: p.genDecl(d) @@ -1993,7 +1993,7 @@ func (p *printer) declList(list []ast.Decl) { func (p *printer) file(src *ast.File) { p.setComment(src.Doc) - p.printPos(src.Pos()) + p.setPos(src.Pos()) p.print(token.PACKAGE, blank) p.expr(src.Name) p.declList(src.Decls) diff --git a/src/go/printer/printer.go b/src/go/printer/printer.go index ec73eec34d8..2cb11939411 100644 --- a/src/go/printer/printer.go +++ b/src/go/printer/printer.go @@ -886,7 +886,7 @@ func mayCombine(prev token.Token, next byte) (b bool) { return } -func (p *printer) printPos(pos token.Pos) { +func (p *printer) setPos(pos token.Pos) { if pos.IsValid() { p.pos = p.posFor(pos) // accurate position of next item }