code review 4715041: go/printer: changed max. number of newlines from 3 to 2

src/pkg/go/printer/nodes.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // This file implements printing of AST nodes; specifically
 // expressions, statements, declarations, and files. It uses
 // the print functionality implemented in printer.go.
 
 package printer
 
 import (
         "bytes"
         "go/ast"
         "go/token"
 )
 
-
 // Other formatting issues:
 // - better comment formatting for /*-style comments at the end of a line (e.g. a declaration)
 //   when the comment spans multiple lines; if such a comment is just two lines, formatting is
 //   not idempotent
 // - formatting of expression lists
 // - should use blank instead of tab to separate one-line function bodies from
 //   the function header unless there is a group of consecutive one-liners
 
-
 // ----------------------------------------------------------------------------
 // Common AST nodes.
 
 // Print as many newlines as necessary (but at least min newlines) to get to
 // the current line. ws is printed before the first line break. If newSection
 // is set, the first line break is printed as formfeed. Returns true if any
 // line break was printed; returns false otherwise.
 //
 // TODO(gri): linebreak may add too many lines if the next statement at "line"
 //            is preceded by comments because the computation of n assumes
@@ skipping 12 matching lines @@
                         n--
                 }
                 for ; n > 0; n-- {
                         p.print(newline)
                 }
                 printedBreak = true
         }
         return
 }
 
-
 // setComment sets g as the next comment if g != nil and if node comments
 // are enabled - this mode is used when printing source code fragments such
 // as exports only. It assumes that there are no other pending comments to
 // intersperse.
 func (p *printer) setComment(g *ast.CommentGroup) {
         if g == nil || !p.useNodeComments {
                 return
         }
         if p.comments == nil {
                 // initialize p.comments lazily
                 p.comments = make([]*ast.CommentGroup, 1)
         } else if p.cindex < len(p.comments) {
                 // for some reason there are pending comments; this
                 // should never happen - handle gracefully and flush
                 // all comments up to g, ignore anything after that
                 p.flush(p.fset.Position(g.List[0].Pos()), token.ILLEGAL)
         }
         p.comments[0] = g
         p.cindex = 0
 }
 
-
 type exprListMode uint
 
 const (
         blankStart exprListMode = 1 << iota // print a blank before a non-empty list
         blankEnd                            // print a blank after a non-empty list
         commaSep                            // elements are separated by commas
         commaTerm                           // list is optionally terminated by a comma
         noIndent                            // no extra indentation in multi-line lists
         periodSep                           // elements are separated by periods
 )
 
-
 // Sets multiLine to true if the identifier list spans multiple lines.
 // If indent is set, a multi-line identifier list is indented after the
 // first linebreak encountered.
 func (p *printer) identList(list []*ast.Ident, indent bool, multiLine *bool) {
         // convert into an expression list so we can re-use exprList formatting
         xlist := make([]ast.Expr, len(list))
         for i, x := range list {
                 xlist[i] = x
         }
         mode := commaSep
         if !indent {
                 mode |= noIndent
         }
         p.exprList(token.NoPos, xlist, 1, mode, multiLine, token.NoPos)
 }
 
-
 // Print a list of expressions. If the list spans multiple
 // source lines, the original line breaks are respected between
 // expressions. Sets multiLine to true if the list spans multiple
 // lines.
 //
 // TODO(gri) Consider rewriting this to be independent of []ast.Expr
 //           so that we can use the algorithm for any kind of list
 //           (e.g., pass list via a channel over which to range).
 func (p *printer) exprList(prev0 token.Pos, list []ast.Expr, depth int, mode exprListMode, multiLine *bool, next0 token.Pos) {
         if len(list) == 0 {
@@ skipping 143 matching lines @@
         if mode&blankEnd != 0 {
                 p.print(blank)
         }
 
         if ws == ignore && mode&noIndent == 0 {
                 // unindent if we indented
                 p.print(unindent)
         }
 }
 
-
 // Sets multiLine to true if the the parameter list spans multiple lines.
 func (p *printer) parameters(fields *ast.FieldList, multiLine *bool) {
         p.print(fields.Opening, token.LPAREN)
         if len(fields.List) > 0 {
                 var prevLine, line int
                 for i, par := range fields.List {
                         if i > 0 {
                                 p.print(token.COMMA)
                                 if len(par.Names) > 0 {
                                         line = p.fset.Position(par.Names[0].Pos()).Line
@@ skipping 10 matching lines @@
                                 p.identList(par.Names, false, multiLine)
                                 p.print(blank)
                         }
                         p.expr(par.Type, multiLine)
                         prevLine = p.fset.Position(par.Type.Pos()).Line
                 }
         }
         p.print(fields.Closing, token.RPAREN)
 }
 
-
 // Sets multiLine to true if the signature spans multiple lines.
 func (p *printer) signature(params, result *ast.FieldList, multiLine *bool) {
         p.parameters(params, multiLine)
         n := result.NumFields()
         if n > 0 {
                 p.print(blank)
                 if n == 1 && result.List[0].Names == nil {
                         // single anonymous result; no ()'s
                         p.expr(result.List[0].Type, multiLine)
                         return
                 }
                 p.parameters(result, multiLine)
         }
 }
 
-
 func identListSize(list []*ast.Ident, maxSize int) (size int) {
         for i, x := range list {
                 if i > 0 {
                         size += 2 // ", "
                 }
                 size += len(x.Name)
                 if size >= maxSize {
                         break
                 }
         }
         return
 }
 
-
 func (p *printer) isOneLineFieldList(list []*ast.Field) bool {
         if len(list) != 1 {
                 return false // allow only one field
         }
         f := list[0]
         if f.Tag != nil || f.Comment != nil {
                 return false // don't allow tags or comments
         }
         // only name(s) and type
         const maxSize = 30 // adjust as appropriate, this is an approximate value
         namesSize := identListSize(f.Names, maxSize)
         if namesSize > 0 {
                 namesSize = 1 // blank between names and types
         }
         typeSize := p.nodeSize(f.Type, maxSize)
         return namesSize+typeSize <= maxSize
 }
 
-
 func (p *printer) setLineComment(text string) {
         p.setComment(&ast.CommentGroup{[]*ast.Comment{&ast.Comment{token.NoPos, text}}})
 }
 
-
 func (p *printer) fieldList(fields *ast.FieldList, isStruct, isIncomplete bool) {
         p.nesting++
         defer func() {
                 p.nesting--
         }()
 
         lbrace := fields.Opening
         list := fields.List
         rbrace := fields.Closing
         srcIsOneLine := lbrace.IsValid() && rbrace.IsValid() && p.fset.Position(lbrace).Line == p.fset.Position(rbrace).Line
@@ skipping 98 matching lines @@
                                 p.print(formfeed)
                         }
                         p.flush(p.fset.Position(rbrace), token.RBRACE) // make sure we don't lose the last line comment
                         p.setLineComment("// contains filtered or unexported methods")
                 }
 
         }
         p.print(unindent, formfeed, rbrace, token.RBRACE)
 }
 
-
 // ----------------------------------------------------------------------------
 // Expressions
 
 func walkBinary(e *ast.BinaryExpr) (has4, has5 bool, maxProblem int) {
         switch e.Op.Precedence() {
         case 4:
                 has4 = true
         case 5:
                 has5 = true
         }
@@ skipping 38 matching lines @@
                         maxProblem = 5
                 case "++", "--":
                         if maxProblem < 4 {
                                 maxProblem = 4
                         }
                 }
         }
         return
 }
 
-
 func cutoff(e *ast.BinaryExpr, depth int) int {
         has4, has5, maxProblem := walkBinary(e)
         if maxProblem > 0 {
                 return maxProblem + 1
         }
         if has4 && has5 {
                 if depth == 1 {
                         return 5
                 }
                 return 4
         }
         if depth == 1 {
                 return 6
         }
         return 4
 }
 
-
 func diffPrec(expr ast.Expr, prec int) int {
         x, ok := expr.(*ast.BinaryExpr)
         if !ok || prec != x.Op.Precedence() {
                 return 1
         }
         return 0
 }
 
-
 func reduceDepth(depth int) int {
         depth--
         if depth < 1 {
                 depth = 1
         }
         return depth
 }
 
-
 // Format the binary expression: decide the cutoff and then format.
 // Let's call depth == 1 Normal mode, and depth > 1 Compact mode.
 // (Algorithm suggestion by Russ Cox.)
 //
 // The precedences are:
 //      5             *  /  %  <<  >>  &  &^
 //      4             +  -  |  ^
 //      3             ==  !=  <  <=  >  >=
 //      2             &&
 //      1             ||
@@ skipping 57 matching lines @@
         }
         if printBlank {
                 p.print(blank)
         }
         p.expr1(x.Y, prec+1, depth+1, multiLine)
         if ws == ignore {
                 p.print(unindent)
         }
 }
 
-
 func isBinary(expr ast.Expr) bool {
         _, ok := expr.(*ast.BinaryExpr)
         return ok
 }
 
-
 // If the expression contains one or more selector expressions, splits it into
 // two expressions at the rightmost period. Writes entire expr to suffix when
 // selector isn't found. Rewrites AST nodes for calls, index expressions and
 // type assertions, all of which may be found in selector chains, to make them
 // parts of the chain.
 func splitSelector(expr ast.Expr) (body, suffix ast.Expr) {
         switch x := expr.(type) {
         case *ast.SelectorExpr:
                 body, suffix = x.X, x.Sel
                 return
@@ skipping 19 matching lines @@
                 body, suffix = splitSelector(x.X)
                 if body != nil {
                         suffix = &ast.TypeAssertExpr{suffix, x.Type}
                         return
                 }
         }
         suffix = expr
         return
 }
 
-
 // Convert an expression into an expression list split at the periods of
 // selector expressions.
 func selectorExprList(expr ast.Expr) (list []ast.Expr) {
         // split expression
         for expr != nil {
                 var suffix ast.Expr
                 expr, suffix = splitSelector(expr)
                 list = append(list, suffix)
         }
 
         // reverse list
         for i, j := 0, len(list)-1; i < j; i, j = i+1, j-1 {
                 list[i], list[j] = list[j], list[i]
         }
 
         return
 }
 
-
 // Sets multiLine to true if the expression spans multiple lines.
 func (p *printer) expr1(expr ast.Expr, prec1, depth int, multiLine *bool) {
         p.print(expr.Pos())
 
         switch x := expr.(type) {
         case *ast.BadExpr:
                 p.print("BadExpr")
 
         case *ast.Ident:
                 p.print(x)
@@ skipping 166 matching lines @@
                 p.print(blank)
                 p.expr(x.Value, multiLine)
 
         default:
                 panic("unreachable")
         }
 
         return
 }
 
-
 func (p *printer) expr0(x ast.Expr, depth int, multiLine *bool) {
         p.expr1(x, token.LowestPrec, depth, multiLine)
 }
 
-
 // Sets multiLine to true if the expression spans multiple lines.
 func (p *printer) expr(x ast.Expr, multiLine *bool) {
         const depth = 1
         p.expr1(x, token.LowestPrec, depth, multiLine)
 }
 
-
 // ----------------------------------------------------------------------------
 // Statements
 
 // Print the statement list indented, but without a newline after the last statement.
 // Extra line breaks between statements in the source are respected but at most one
 // empty line is printed between statements.
 func (p *printer) stmtList(list []ast.Stmt, _indent int, nextIsRBrace bool) {
         // TODO(gri): fix _indent code
         if _indent > 0 {
                 p.print(indent)
         }
         var multiLine bool
         for i, s := range list {
                 // _indent == 0 only for lists of switch/select case clauses;
                 // in those cases each clause is a new section
                 p.linebreak(p.fset.Position(s.Pos()).Line, 1, ignore, i == 0 || _indent == 0 || multiLine)
                 multiLine = false
                 p.stmt(s, nextIsRBrace && i == len(list)-1, &multiLine)
         }
         if _indent > 0 {
                 p.print(unindent)
         }
 }
 
-
 // block prints an *ast.BlockStmt; it always spans at least two lines.
 func (p *printer) block(s *ast.BlockStmt, indent int) {
         p.print(s.Pos(), token.LBRACE)
         p.stmtList(s.List, indent, true)
         p.linebreak(p.fset.Position(s.Rbrace).Line, 1, ignore, true)
         p.print(s.Rbrace, token.RBRACE)
 }
 
-
 func isTypeName(x ast.Expr) bool {
         switch t := x.(type) {
         case *ast.Ident:
                 return true
         case *ast.SelectorExpr:
                 return isTypeName(t.X)
         }
         return false
 }
 
-
 func stripParens(x ast.Expr) ast.Expr {
         if px, strip := x.(*ast.ParenExpr); strip {
                 // parentheses must not be stripped if there are any
                 // unparenthesized composite literals starting with
                 // a type name
                 ast.Inspect(px.X, func(node ast.Node) bool {
                         switch x := node.(type) {
                         case *ast.ParenExpr:
                                 // parentheses protect enclosed composite literals
                                 return false
                         case *ast.CompositeLit:
                                 if isTypeName(x.Type) {
                                         strip = false // do not strip parentheses
                                 }
                                 return false
                         }
                         // in all other cases, keep inspecting
                         return true
                 })
                 if strip {
                         return stripParens(px.X)
                 }
         }
         return x
 }
 
-
 func (p *printer) controlClause(isForStmt bool, init ast.Stmt, expr ast.Expr, post ast.Stmt) {
         p.print(blank)
         needsBlank := false
         if init == nil && post == nil {
                 // no semicolons required
                 if expr != nil {
                         p.expr(stripParens(expr), ignoreMultiLine)
                         needsBlank = true
                 }
         } else {
@@ skipping 14 matching lines @@
                                 p.stmt(post, false, ignoreMultiLine)
                                 needsBlank = true
                         }
                 }
         }
         if needsBlank {
                 p.print(blank)
         }
 }
 
-
 // Sets multiLine to true if the statements spans multiple lines.
 func (p *printer) stmt(stmt ast.Stmt, nextIsRBrace bool, multiLine *bool) {
         p.print(stmt.Pos())
 
         switch s := stmt.(type) {
         case *ast.BadStmt:
                 p.print("BadStmt")
 
         case *ast.DeclStmt:
                 p.decl(s.Decl, multiLine)
@@ skipping 153 matching lines @@
                 p.block(s.Body, 1)
                 *multiLine = true
 
         default:
                 panic("unreachable")
         }
 
         return
 }
 
-
 // ----------------------------------------------------------------------------
 // Declarations
 
 // The keepTypeColumn function determines if the type column of a series of
 // consecutive const or var declarations must be kept, or if initialization
 // values (V) can be placed in the type column (T) instead. The i'th entry
 // in the result slice is true if the type column in spec[i] must be kept.
 //
 // For example, the declaration:
 //
@@ skipping 48 matching lines @@
                 }
         }
         if i0 >= 0 {
                 // end of a run
                 populate(i0, len(specs), keepType)
         }
 
         return m
 }
 
-
 func (p *printer) valueSpec(s *ast.ValueSpec, keepType, doIndent bool, multiLine *bool) {
         p.setComment(s.Doc)
         p.identList(s.Names, doIndent, multiLine) // always present
         extraTabs := 3
         if s.Type != nil || keepType {
                 p.print(vtab)
                 extraTabs--
         }
         if s.Type != nil {
                 p.expr(s.Type, multiLine)
         }
         if s.Values != nil {
                 p.print(vtab, token.ASSIGN)
                 p.exprList(token.NoPos, s.Values, 1, blankStart|commaSep, multiLine, token.NoPos)
                 extraTabs--
         }
         if s.Comment != nil {
                 for ; extraTabs > 0; extraTabs-- {
                         p.print(vtab)
                 }
                 p.setComment(s.Comment)
         }
 }
 
-
 // The parameter n is the number of specs in the group. If doIndent is set,
 // multi-line identifier lists in the spec are indented when the first
 // linebreak is encountered.
 // Sets multiLine to true if the spec spans multiple lines.
 //
 func (p *printer) spec(spec ast.Spec, n int, doIndent bool, multiLine *bool) {
         switch s := spec.(type) {
         case *ast.ImportSpec:
                 p.setComment(s.Doc)
                 if s.Name != nil {
@@ skipping 28 matching lines @@
                         p.print(vtab)
                 }
                 p.expr(s.Type, multiLine)
                 p.setComment(s.Comment)
 
         default:
                 panic("unreachable")
         }
 }
 
-
 // Sets multiLine to true if the declaration spans multiple lines.
 func (p *printer) genDecl(d *ast.GenDecl, multiLine *bool) {
         p.setComment(d.Doc)
         p.print(d.Pos(), d.Tok, blank)
 
         if d.Lparen.IsValid() {
                 // group of parenthesized declarations
                 p.print(d.Lparen, token.LPAREN)
                 if n := len(d.Specs); n > 0 {
                         p.print(indent, formfeed)
@@ skipping 23 matching lines @@
                         *multiLine = true
                 }
                 p.print(d.Rparen, token.RPAREN)
 
         } else {
                 // single declaration
                 p.spec(d.Specs[0], 1, true, multiLine)
         }
 }
 
-
 // nodeSize determines the size of n in chars after formatting.
 // The result is <= maxSize if the node fits on one line with at
 // most maxSize chars and the formatted output doesn't contain
 // any control chars. Otherwise, the result is > maxSize.
 //
 func (p *printer) nodeSize(n ast.Node, maxSize int) (size int) {
         // nodeSize invokes the printer, which may invoke nodeSize
         // recursively. For deep composite literal nests, this can
         // lead to an exponential algorithm. Remember previous
         // results to prune the recursion (was issue 1628).
@@ skipping 17 matching lines @@
                         if ch < ' ' {
                                 return
                         }
                 }
                 size = buf.Len() // n fits
                 p.nodeSizes[n] = size
         }
         return
 }
 
-
 func (p *printer) isOneLineFunc(b *ast.BlockStmt, headerSize int) bool {
         pos1 := b.Pos()
         pos2 := b.Rbrace
         if pos1.IsValid() && pos2.IsValid() && p.fset.Position(pos1).Line != p.fset.Position(pos2).Line {
                 // opening and closing brace are on different lines - don't make it a one-liner
                 return false
         }
         if len(b.List) > 5 || p.commentBefore(p.fset.Position(pos2)) {
                 // too many statements or there is a comment inside - don't make it a one-liner
                 return false
         }
         // otherwise, estimate body size
         const maxSize = 100
         bodySize := 0
         for i, s := range b.List {
                 if i > 0 {
                         bodySize += 2 // space for a semicolon and blank
                 }
                 bodySize += p.nodeSize(s, maxSize)
         }
         return headerSize+bodySize <= maxSize
 }
 
-
 // Sets multiLine to true if the function body spans multiple lines.
 func (p *printer) funcBody(b *ast.BlockStmt, headerSize int, isLit bool, multiLine *bool) {
         if b == nil {
                 return
         }
 
         p.nesting++
         defer func() {
                 p.nesting--
         }()
@@ skipping 16 matching lines @@
                 }
                 p.print(b.Rbrace, token.RBRACE)
                 return
         }
 
         p.print(blank)
         p.block(b, 1)
         *multiLine = true
 }
 
-
 // distance returns the column difference between from and to if both
 // are on the same line; if they are on different lines (or unknown)
 // the result is infinity.
 func (p *printer) distance(from0 token.Pos, to token.Position) int {
         from := p.fset.Position(from0)
         if from.IsValid() && to.IsValid() && from.Line == to.Line {
                 return to.Column - from.Column
         }
         return infinity
 }
 
-
 // Sets multiLine to true if the declaration spans multiple lines.
 func (p *printer) funcDecl(d *ast.FuncDecl, multiLine *bool) {
         p.setComment(d.Doc)
         p.print(d.Pos(), token.FUNC, blank)
         if d.Recv != nil {
                 p.parameters(d.Recv, multiLine) // method: print receiver
                 p.print(blank)
         }
         p.expr(d.Name, multiLine)
         p.signature(d.Type.Params, d.Type.Results, multiLine)
         p.funcBody(d.Body, p.distance(d.Pos(), p.pos), false, multiLine)
 }
 
-
 // Sets multiLine to true if the declaration spans multiple lines.
 func (p *printer) decl(decl ast.Decl, multiLine *bool) {
         switch d := decl.(type) {
         case *ast.BadDecl:
                 p.print(d.Pos(), "BadDecl")
         case *ast.GenDecl:
                 p.genDecl(d, multiLine)
         case *ast.FuncDecl:
                 p.funcDecl(d, multiLine)
         default:
                 panic("unreachable")
         }
 }
 
-
 // ----------------------------------------------------------------------------
 // Files
 
 func declToken(decl ast.Decl) (tok token.Token) {
         tok = token.ILLEGAL
         switch d := decl.(type) {
         case *ast.GenDecl:
                 tok = d.Tok
         case *ast.FuncDecl:
                 tok = token.FUNC
         }
         return
 }
 
-
 func (p *printer) file(src *ast.File) {
         p.setComment(src.Doc)
         p.print(src.Pos(), token.PACKAGE, blank)
         p.expr(src.Name, ignoreMultiLine)
 
         if len(src.Decls) > 0 {
                 tok := token.ILLEGAL
                 for _, d := range src.Decls {
                         prev := tok
                         tok = declToken(d)
                         // if the declaration token changed (e.g., from CONST to TYPE)
                         // print an empty line between top-level declarations
                         min := 1
                         if prev != tok {
                                 min = 2
                         }
                         p.linebreak(p.fset.Position(d.Pos()).Line, min, ignore, false)
                         p.decl(d, ignoreMultiLine)
                 }
         }
 
         p.print(newline)
 }