1 // Copyright 2009 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
5 // This file implements printing of AST nodes; specifically
6 // expressions, statements, declarations, and files. It uses
7 // the print functionality implemented in printer.go.
22 // - better comment formatting for /*-style comments at the end of a line (e.g. a declaration)
23 // when the comment spans multiple lines; if such a comment is just two lines, formatting is
25 // - formatting of expression lists
26 // - should use blank instead of tab to separate one-line function bodies from
27 // the function header unless there is a group of consecutive one-liners
29 // ----------------------------------------------------------------------------
32 // Print as many newlines as necessary (but at least min newlines) to get to
33 // the current line. ws is printed before the first line break. If newSection
34 // is set, the first line break is printed as formfeed. Returns true if any
35 // line break was printed; returns false otherwise.
37 // TODO(gri): linebreak may add too many lines if the next statement at "line"
38 // is preceded by comments because the computation of n assumes
39 // the current position before the comment and the target position
40 // after the comment. Thus, after interspersing such comments, the
41 // space taken up by them is not considered to reduce the number of
42 // linebreaks. At the moment there is no easy way to know about
43 // future (not yet interspersed) comments in this function.
45 func (p
*printer
) linebreak(line
, min
int, ws whiteSpace
, newSection
bool) (printedBreak
bool) {
46 n
:= nlimit(line
- p
.pos
.Line
)
64 // setComment sets g as the next comment if g != nil and if node comments
65 // are enabled - this mode is used when printing source code fragments such
66 // as exports only. It assumes that there is no pending comment in p.comments
67 // and at most one pending comment in the p.comment cache.
68 func (p
*printer
) setComment(g
*ast
.CommentGroup
) {
69 if g
== nil ||
!p
.useNodeComments
{
72 if p
.comments
== nil {
73 // initialize p.comments lazily
74 p
.comments
= make([]*ast
.CommentGroup
, 1)
75 } else if p
.cindex
< len(p
.comments
) {
76 // for some reason there are pending comments; this
77 // should never happen - handle gracefully and flush
78 // all comments up to g, ignore anything after that
79 p
.flush(p
.posFor(g
.List
[0].Pos()), token
.ILLEGAL
)
80 p
.comments
= p
.comments
[0:1]
81 // in debug mode, report error
82 p
.internalError("setComment found pending comments")
86 // don't overwrite any pending comment in the p.comment cache
87 // (there may be a pending comment when a line comment is
88 // immediately followed by a lead comment with no other
90 if p
.commentOffset
== infinity
{
91 p
.nextComment() // get comment ready for use
95 type exprListMode
uint
98 commaTerm exprListMode
= 1 << iota // list is optionally terminated by a comma
99 noIndent
// no extra indentation in multi-line lists
102 // If indent is set, a multi-line identifier list is indented after the
103 // first linebreak encountered.
104 func (p
*printer
) identList(list
[]*ast
.Ident
, indent
bool) {
105 // convert into an expression list so we can re-use exprList formatting
106 xlist
:= make([]ast
.Expr
, len(list
))
107 for i
, x
:= range list
{
110 var mode exprListMode
114 p
.exprList(token
.NoPos
, xlist
, 1, mode
, token
.NoPos
)
117 // Print a list of expressions. If the list spans multiple
118 // source lines, the original line breaks are respected between
121 // TODO(gri) Consider rewriting this to be independent of []ast.Expr
122 // so that we can use the algorithm for any kind of list
123 // (e.g., pass list via a channel over which to range).
124 func (p
*printer
) exprList(prev0 token
.Pos
, list
[]ast
.Expr
, depth
int, mode exprListMode
, next0 token
.Pos
) {
129 prev
:= p
.posFor(prev0
)
130 next
:= p
.posFor(next0
)
131 line
:= p
.lineFor(list
[0].Pos())
132 endLine
:= p
.lineFor(list
[len(list
)-1].End())
134 if prev
.IsValid() && prev
.Line
== line
&& line
== endLine
{
135 // all list entries on a single line
136 for i
, x
:= range list
{
138 // use position of expression following the comma as
139 // comma position for correct comment placement
140 p
.print(x
.Pos(), token
.COMMA
, blank
)
147 // list entries span multiple lines;
148 // use source code positions to guide line breaks
150 // don't add extra indentation if noIndent is set;
151 // i.e., pretend that the first line is already indented
153 if mode
&noIndent
== 0 {
157 // the first linebreak is always a formfeed since this section must not
158 // depend on any previous formatting
159 prevBreak
:= -1 // index of last expression that was followed by a linebreak
160 if prev
.IsValid() && prev
.Line
< line
&& p
.linebreak(line
, 0, ws
, true) {
165 // initialize expression/key size: a zero value indicates expr/key doesn't fit on a single line
168 // print all list elements
169 prevLine
:= prev
.Line
170 for i
, x
:= range list
{
171 line
= p
.lineFor(x
.Pos())
173 // determine if the next linebreak, if any, needs to use formfeed:
174 // in general, use the entire node size to make the decision; for
175 // key:value expressions, use the key size
176 // TODO(gri) for a better result, should probably incorporate both
177 // the key and the node size into the decision process
180 // determine element size: all bets are off if we don't have
181 // position information for the previous and next token (likely
182 // generated code - simply ignore the size in this case by setting
185 const infinity
= 1e6
// larger than any source line
186 size
= p
.nodeSize(x
, infinity
)
187 pair
, isPair
:= x
.(*ast
.KeyValueExpr
)
188 if size
<= infinity
&& prev
.IsValid() && next
.IsValid() {
189 // x fits on a single line
191 size
= p
.nodeSize(pair
.Key
, infinity
) // size <= infinity
194 // size too large or we don't have good layout information
198 // if the previous line and the current line had single-
199 // line-expressions and the key sizes are small or the
200 // the ratio between the key sizes does not exceed a
201 // threshold, align columns and do not use formfeed
202 if prevSize
> 0 && size
> 0 {
204 if prevSize
<= smallSize
&& size
<= smallSize
{
207 const r
= 4 // threshold
208 ratio
:= float64(size
) / float64(prevSize
)
209 useFF
= ratio
<= 1.0/r || r
<= ratio
213 needsLinebreak
:= 0 < prevLine
&& prevLine
< line
215 // use position of expression following the comma as
216 // comma position for correct comment placement, but
217 // only if the expression is on the same line
224 // lines are broken using newlines so comments remain aligned
225 // unless forceFF is set or there are multiple expressions on
226 // the same line in which case formfeed is used
227 if p
.linebreak(line
, 0, ws
, useFF || prevBreak
+1 < i
) {
230 needsBlank
= false // we got a line break instead
238 if len(list
) > 1 && isPair
&& size
> 0 && needsLinebreak
{
239 // we have a key:value expression that fits onto one line
240 // and it's not on the same line as the prior expression:
241 // use a column for the key such that consecutive entries
242 // can align if possible
243 // (needsLinebreak is set if we started a new line before)
245 p
.print(pair
.Colon
, token
.COLON
, vtab
)
254 if mode
&commaTerm
!= 0 && next
.IsValid() && p
.pos
.Line
< next
.Line
{
255 // print a terminating comma if the next token is on a new line
257 if ws
== ignore
&& mode
&noIndent
== 0 {
258 // unindent if we indented
261 p
.print(formfeed
) // terminating comma needs a line break to look good
265 if ws
== ignore
&& mode
&noIndent
== 0 {
266 // unindent if we indented
271 func (p
*printer
) parameters(fields
*ast
.FieldList
) {
272 p
.print(fields
.Opening
, token
.LPAREN
)
273 if len(fields
.List
) > 0 {
274 prevLine
:= p
.lineFor(fields
.Opening
)
276 for i
, par
:= range fields
.List
{
277 // determine par begin and end line (may be different
278 // if there are multiple parameter names for this par
279 // or the type is on a separate line)
281 if len(par
.Names
) > 0 {
282 parLineBeg
= p
.lineFor(par
.Names
[0].Pos())
284 parLineBeg
= p
.lineFor(par
.Type
.Pos())
286 var parLineEnd
= p
.lineFor(par
.Type
.End())
287 // separating "," if needed
288 needsLinebreak
:= 0 < prevLine
&& prevLine
< parLineBeg
290 // use position of parameter following the comma as
291 // comma position for correct comma placement, but
292 // only if the next parameter is on the same line
298 // separator if needed (linebreak or blank)
299 if needsLinebreak
&& p
.linebreak(parLineBeg
, 0, ws
, true) {
300 // break line if the opening "(" or previous parameter ended on a different line
306 if len(par
.Names
) > 0 {
307 // Very subtle: If we indented before (ws == ignore), identList
308 // won't indent again. If we didn't (ws == indent), identList will
309 // indent if the identList spans multiple lines, and it will outdent
310 // again at the end (and still ws == indent). Thus, a subsequent indent
311 // by a linebreak call after a type, or in the next multi-line identList
312 // will do the right thing.
313 p
.identList(par
.Names
, ws
== indent
)
317 p
.expr(stripParensAlways(par
.Type
))
318 prevLine
= parLineEnd
320 // if the closing ")" is on a separate line from the last parameter,
321 // print an additional "," and line break
322 if closing
:= p
.lineFor(fields
.Closing
); 0 < prevLine
&& prevLine
< closing
{
324 p
.linebreak(closing
, 0, ignore
, true)
326 // unindent if we indented
331 p
.print(fields
.Closing
, token
.RPAREN
)
334 func (p
*printer
) signature(params
, result
*ast
.FieldList
) {
338 p
.print(token
.LPAREN
, token
.RPAREN
)
340 n
:= result
.NumFields()
344 if n
== 1 && result
.List
[0].Names
== nil {
345 // single anonymous result; no ()'s
346 p
.expr(stripParensAlways(result
.List
[0].Type
))
353 func identListSize(list
[]*ast
.Ident
, maxSize
int) (size
int) {
354 for i
, x
:= range list
{
358 size
+= utf8
.RuneCountInString(x
.Name
)
366 func (p
*printer
) isOneLineFieldList(list
[]*ast
.Field
) bool {
368 return false // allow only one field
371 if f
.Tag
!= nil || f
.Comment
!= nil {
372 return false // don't allow tags or comments
374 // only name(s) and type
375 const maxSize
= 30 // adjust as appropriate, this is an approximate value
376 namesSize
:= identListSize(f
.Names
, maxSize
)
378 namesSize
= 1 // blank between names and types
380 typeSize
:= p
.nodeSize(f
.Type
, maxSize
)
381 return namesSize
+typeSize
<= maxSize
384 func (p
*printer
) setLineComment(text
string) {
385 p
.setComment(&ast
.CommentGroup
{List
: []*ast
.Comment
{{Slash
: token
.NoPos
, Text
: text
}}})
388 func (p
*printer
) fieldList(fields
*ast
.FieldList
, isStruct
, isIncomplete
bool) {
389 lbrace
:= fields
.Opening
391 rbrace
:= fields
.Closing
392 hasComments
:= isIncomplete || p
.commentBefore(p
.posFor(rbrace
))
393 srcIsOneLine
:= lbrace
.IsValid() && rbrace
.IsValid() && p
.lineFor(lbrace
) == p
.lineFor(rbrace
)
395 if !hasComments
&& srcIsOneLine
{
396 // possibly a one-line struct/interface
398 // no blank between keyword and {} in this case
399 p
.print(lbrace
, token
.LBRACE
, rbrace
, token
.RBRACE
)
401 } else if isStruct
&& p
.isOneLineFieldList(list
) { // for now ignore interfaces
402 // small enough - print on one line
403 // (don't use identList and ignore source line breaks)
404 p
.print(lbrace
, token
.LBRACE
, blank
)
406 for i
, x
:= range f
.Names
{
408 // no comments so no need for comma position
409 p
.print(token
.COMMA
, blank
)
413 if len(f
.Names
) > 0 {
417 p
.print(blank
, rbrace
, token
.RBRACE
)
421 // hasComments || !srcIsOneLine
423 p
.print(blank
, lbrace
, token
.LBRACE
, indent
)
424 if hasComments ||
len(list
) > 0 {
435 for i
, f
:= range list
{
437 p
.linebreak(p
.lineFor(f
.Pos()), 1, ignore
, p
.linesFrom(line
) > 0)
442 if len(f
.Names
) > 0 {
444 p
.identList(f
.Names
, false)
454 if len(f
.Names
) > 0 && sep
== vtab
{
461 if f
.Comment
!= nil {
462 for ; extraTabs
> 0; extraTabs
-- {
465 p
.setComment(f
.Comment
)
472 p
.flush(p
.posFor(rbrace
), token
.RBRACE
) // make sure we don't lose the last line comment
473 p
.setLineComment("// contains filtered or unexported fields")
476 } else { // interface
479 for i
, f
:= range list
{
481 p
.linebreak(p
.lineFor(f
.Pos()), 1, ignore
, p
.linesFrom(line
) > 0)
485 if ftyp
, isFtyp
:= f
.Type
.(*ast
.FuncType
); isFtyp
{
488 p
.signature(ftyp
.Params
, ftyp
.Results
)
490 // embedded interface
493 p
.setComment(f
.Comment
)
499 p
.flush(p
.posFor(rbrace
), token
.RBRACE
) // make sure we don't lose the last line comment
500 p
.setLineComment("// contains filtered or unexported methods")
504 p
.print(unindent
, formfeed
, rbrace
, token
.RBRACE
)
507 // ----------------------------------------------------------------------------
510 func walkBinary(e
*ast
.BinaryExpr
) (has4
, has5
bool, maxProblem
int) {
511 switch e
.Op
.Precedence() {
518 switch l
:= e
.X
.(type) {
519 case *ast
.BinaryExpr
:
520 if l
.Op
.Precedence() < e
.Op
.Precedence() {
521 // parens will be inserted.
522 // pretend this is an *ast.ParenExpr and do nothing.
525 h4
, h5
, mp
:= walkBinary(l
)
533 switch r
:= e
.Y
.(type) {
534 case *ast
.BinaryExpr
:
535 if r
.Op
.Precedence() <= e
.Op
.Precedence() {
536 // parens will be inserted.
537 // pretend this is an *ast.ParenExpr and do nothing.
540 h4
, h5
, mp
:= walkBinary(r
)
548 if e
.Op
== token
.QUO
{ // `*/`
553 switch e
.Op
.String() + r
.Op
.String() {
554 case "/*", "&&", "&^":
565 func cutoff(e
*ast
.BinaryExpr
, depth
int) int {
566 has4
, has5
, maxProblem
:= walkBinary(e
)
568 return maxProblem
+ 1
582 func diffPrec(expr ast
.Expr
, prec
int) int {
583 x
, ok
:= expr
.(*ast
.BinaryExpr
)
584 if !ok || prec
!= x
.Op
.Precedence() {
590 func reduceDepth(depth
int) int {
598 // Format the binary expression: decide the cutoff and then format.
599 // Let's call depth == 1 Normal mode, and depth > 1 Compact mode.
600 // (Algorithm suggestion by Russ Cox.)
602 // The precedences are:
603 // 5 * / % << >> & &^
609 // The only decision is whether there will be spaces around levels 4 and 5.
610 // There are never spaces at level 6 (unary), and always spaces at levels 3 and below.
612 // To choose the cutoff, look at the whole expression but excluding primary
613 // expressions (function calls, parenthesized exprs), and apply these rules:
615 // 1) If there is a binary operator with a right side unary operand
616 // that would clash without a space, the cutoff must be (in order):
624 // (Comparison operators always have spaces around them.)
626 // 2) If there is a mix of level 5 and level 4 operators, then the cutoff
627 // is 5 (use spaces to distinguish precedence) in Normal mode
628 // and 4 (never use spaces) in Compact mode.
630 // 3) If there are no level 4 operators or no level 5 operators, then the
631 // cutoff is 6 (always use spaces) in Normal mode
632 // and 4 (never use spaces) in Compact mode.
634 func (p
*printer
) binaryExpr(x
*ast
.BinaryExpr
, prec1
, cutoff
, depth
int) {
635 prec
:= x
.Op
.Precedence()
637 // parenthesis needed
638 // Note: The parser inserts an ast.ParenExpr node; thus this case
639 // can only occur if the AST is created in a different way.
640 p
.print(token
.LPAREN
)
641 p
.expr0(x
, reduceDepth(depth
)) // parentheses undo one level of depth
642 p
.print(token
.RPAREN
)
646 printBlank
:= prec
< cutoff
649 p
.expr1(x
.X
, prec
, depth
+diffPrec(x
.X
, prec
))
653 xline
:= p
.pos
.Line
// before the operator (it may be on the next line!)
654 yline
:= p
.lineFor(x
.Y
.Pos())
655 p
.print(x
.OpPos
, x
.Op
)
656 if xline
!= yline
&& xline
> 0 && yline
> 0 {
657 // at least one line break, but respect an extra empty line
659 if p
.linebreak(yline
, 1, ws
, true) {
661 printBlank
= false // no blank after line break
667 p
.expr1(x
.Y
, prec
+1, depth
+1)
673 func isBinary(expr ast
.Expr
) bool {
674 _
, ok
:= expr
.(*ast
.BinaryExpr
)
678 func (p
*printer
) expr1(expr ast
.Expr
, prec1
, depth
int) {
681 switch x
:= expr
.(type) {
688 case *ast
.BinaryExpr
:
690 p
.internalError("depth < 1:", depth
)
693 p
.binaryExpr(x
, prec1
, cutoff(x
, depth
), depth
)
695 case *ast
.KeyValueExpr
:
697 p
.print(x
.Colon
, token
.COLON
, blank
)
701 const prec
= token
.UnaryPrec
703 // parenthesis needed
704 p
.print(token
.LPAREN
)
707 p
.print(token
.RPAREN
)
709 // no parenthesis needed
715 const prec
= token
.UnaryPrec
717 // parenthesis needed
718 p
.print(token
.LPAREN
)
720 p
.print(token
.RPAREN
)
722 // no parenthesis needed
724 if x
.Op
== token
.RANGE
{
725 // TODO(gri) Remove this code if it cannot be reached.
728 p
.expr1(x
.X
, prec
, depth
)
736 p
.funcBody(p
.distanceFrom(x
.Type
.Pos()), blank
, x
.Body
)
739 if _
, hasParens
:= x
.X
.(*ast
.ParenExpr
); hasParens
{
740 // don't print parentheses around an already parenthesized expression
741 // TODO(gri) consider making this more general and incorporate precedence levels
744 p
.print(token
.LPAREN
)
745 p
.expr0(x
.X
, reduceDepth(depth
)) // parentheses undo one level of depth
746 p
.print(x
.Rparen
, token
.RPAREN
)
749 case *ast
.SelectorExpr
:
750 p
.selectorExpr(x
, depth
, false)
752 case *ast
.TypeAssertExpr
:
753 p
.expr1(x
.X
, token
.HighestPrec
, depth
)
754 p
.print(token
.PERIOD
, x
.Lparen
, token
.LPAREN
)
760 p
.print(x
.Rparen
, token
.RPAREN
)
763 // TODO(gri): should treat[] like parentheses and undo one level of depth
764 p
.expr1(x
.X
, token
.HighestPrec
, 1)
765 p
.print(x
.Lbrack
, token
.LBRACK
)
766 p
.expr0(x
.Index
, depth
+1)
767 p
.print(x
.Rbrack
, token
.RBRACK
)
770 // TODO(gri): should treat[] like parentheses and undo one level of depth
771 p
.expr1(x
.X
, token
.HighestPrec
, 1)
772 p
.print(x
.Lbrack
, token
.LBRACK
)
773 indices
:= []ast
.Expr
{x
.Low
, x
.High
}
775 indices
= append(indices
, x
.Max
)
777 for i
, y
:= range indices
{
779 // blanks around ":" if both sides exist and either side is a binary expression
780 // TODO(gri) once we have committed a variant of a[i:j:k] we may want to fine-
781 // tune the formatting here
783 if depth
<= 1 && x
!= nil && y
!= nil && (isBinary(x
) ||
isBinary(y
)) {
784 p
.print(blank
, token
.COLON
, blank
)
793 p
.print(x
.Rbrack
, token
.RBRACK
)
800 if _
, ok
:= x
.Fun
.(*ast
.FuncType
); ok
{
801 // conversions to literal function types require parentheses around the type
802 p
.print(token
.LPAREN
)
803 wasIndented
= p
.possibleSelectorExpr(x
.Fun
, token
.HighestPrec
, depth
)
804 p
.print(token
.RPAREN
)
806 wasIndented
= p
.possibleSelectorExpr(x
.Fun
, token
.HighestPrec
, depth
)
808 p
.print(x
.Lparen
, token
.LPAREN
)
809 if x
.Ellipsis
.IsValid() {
810 p
.exprList(x
.Lparen
, x
.Args
, depth
, 0, x
.Ellipsis
)
811 p
.print(x
.Ellipsis
, token
.ELLIPSIS
)
812 if x
.Rparen
.IsValid() && p
.lineFor(x
.Ellipsis
) < p
.lineFor(x
.Rparen
) {
813 p
.print(token
.COMMA
, formfeed
)
816 p
.exprList(x
.Lparen
, x
.Args
, depth
, commaTerm
, x
.Rparen
)
818 p
.print(x
.Rparen
, token
.RPAREN
)
823 case *ast
.CompositeLit
:
824 // composite literal elements that are composite literals themselves may have the type omitted
826 p
.expr1(x
.Type
, token
.HighestPrec
, depth
)
829 p
.print(x
.Lbrace
, token
.LBRACE
)
830 p
.exprList(x
.Lbrace
, x
.Elts
, 1, commaTerm
, x
.Rbrace
)
831 // do not insert extra line break following a /*-style comment
832 // before the closing '}' as it might break the code if there
833 // is no trailing ','
834 mode
:= noExtraLinebreak
835 // do not insert extra blank following a /*-style comment
836 // before the closing '}' unless the literal is empty
840 p
.print(mode
, x
.Rbrace
, token
.RBRACE
, mode
)
844 p
.print(token
.ELLIPSIS
)
850 p
.print(token
.LBRACK
)
854 p
.print(token
.RBRACK
)
857 case *ast
.StructType
:
858 p
.print(token
.STRUCT
)
859 p
.fieldList(x
.Fields
, true, x
.Incomplete
)
863 p
.signature(x
.Params
, x
.Results
)
865 case *ast
.InterfaceType
:
866 p
.print(token
.INTERFACE
)
867 p
.fieldList(x
.Methods
, false, x
.Incomplete
)
870 p
.print(token
.MAP
, token
.LBRACK
)
872 p
.print(token
.RBRACK
)
877 case ast
.SEND | ast
.RECV
:
880 p
.print(token
.ARROW
, token
.CHAN
) // x.Arrow and x.Pos() are the same
882 p
.print(token
.CHAN
, x
.Arrow
, token
.ARROW
)
892 func (p
*printer
) possibleSelectorExpr(expr ast
.Expr
, prec1
, depth
int) bool {
893 if x
, ok
:= expr
.(*ast
.SelectorExpr
); ok
{
894 return p
.selectorExpr(x
, depth
, true)
896 p
.expr1(expr
, prec1
, depth
)
900 // selectorExpr handles an *ast.SelectorExpr node and returns whether x spans
902 func (p
*printer
) selectorExpr(x
*ast
.SelectorExpr
, depth
int, isMethod
bool) bool {
903 p
.expr1(x
.X
, token
.HighestPrec
, depth
)
904 p
.print(token
.PERIOD
)
905 if line
:= p
.lineFor(x
.Sel
.Pos()); p
.pos
.IsValid() && p
.pos
.Line
< line
{
906 p
.print(indent
, newline
, x
.Sel
.Pos(), x
.Sel
)
912 p
.print(x
.Sel
.Pos(), x
.Sel
)
916 func (p
*printer
) expr0(x ast
.Expr
, depth
int) {
917 p
.expr1(x
, token
.LowestPrec
, depth
)
920 func (p
*printer
) expr(x ast
.Expr
) {
922 p
.expr1(x
, token
.LowestPrec
, depth
)
925 // ----------------------------------------------------------------------------
928 // Print the statement list indented, but without a newline after the last statement.
929 // Extra line breaks between statements in the source are respected but at most one
930 // empty line is printed between statements.
931 func (p
*printer
) stmtList(list
[]ast
.Stmt
, nindent
int, nextIsRBrace
bool) {
937 for _
, s
:= range list
{
938 // ignore empty statements (was issue 3466)
939 if _
, isEmpty
:= s
.(*ast
.EmptyStmt
); !isEmpty
{
940 // nindent == 0 only for lists of switch/select case clauses;
941 // in those cases each clause is a new section
942 if len(p
.output
) > 0 {
943 // only print line break if we are not at the beginning of the output
944 // (i.e., we are not printing only a partial program)
945 p
.linebreak(p
.lineFor(s
.Pos()), 1, ignore
, i
== 0 || nindent
== 0 || p
.linesFrom(line
) > 0)
948 p
.stmt(s
, nextIsRBrace
&& i
== len(list
)-1)
949 // labeled statements put labels on a separate line, but here
950 // we only care about the start line of the actual statement
951 // without label - correct line for each label
953 lt
, _
:= t
.(*ast
.LabeledStmt
)
968 // block prints an *ast.BlockStmt; it always spans at least two lines.
969 func (p
*printer
) block(b
*ast
.BlockStmt
, nindent
int) {
970 p
.print(b
.Lbrace
, token
.LBRACE
)
971 p
.stmtList(b
.List
, nindent
, true)
972 p
.linebreak(p
.lineFor(b
.Rbrace
), 1, ignore
, true)
973 p
.print(b
.Rbrace
, token
.RBRACE
)
976 func isTypeName(x ast
.Expr
) bool {
977 switch t
:= x
.(type) {
980 case *ast
.SelectorExpr
:
981 return isTypeName(t
.X
)
986 func stripParens(x ast
.Expr
) ast
.Expr
{
987 if px
, strip
:= x
.(*ast
.ParenExpr
); strip
{
988 // parentheses must not be stripped if there are any
989 // unparenthesized composite literals starting with
991 ast
.Inspect(px
.X
, func(node ast
.Node
) bool {
992 switch x
:= node
.(type) {
994 // parentheses protect enclosed composite literals
996 case *ast
.CompositeLit
:
997 if isTypeName(x
.Type
) {
998 strip
= false // do not strip parentheses
1002 // in all other cases, keep inspecting
1006 return stripParens(px
.X
)
1012 func stripParensAlways(x ast
.Expr
) ast
.Expr
{
1013 if x
, ok
:= x
.(*ast
.ParenExpr
); ok
{
1014 return stripParensAlways(x
.X
)
1019 func (p
*printer
) controlClause(isForStmt
bool, init ast
.Stmt
, expr ast
.Expr
, post ast
.Stmt
) {
1022 if init
== nil && post
== nil {
1023 // no semicolons required
1025 p
.expr(stripParens(expr
))
1029 // all semicolons required
1030 // (they are not separators, print them explicitly)
1034 p
.print(token
.SEMICOLON
, blank
)
1036 p
.expr(stripParens(expr
))
1040 p
.print(token
.SEMICOLON
, blank
)
1053 // indentList reports whether an expression list would look better if it
1054 // were indented wholesale (starting with the very first element, rather
1055 // than starting at the first line break).
1057 func (p
*printer
) indentList(list
[]ast
.Expr
) bool {
1058 // Heuristic: indentList returns true if there are more than one multi-
1059 // line element in the list, or if there is any element that is not
1060 // starting on the same line as the previous one ends.
1062 var b
= p
.lineFor(list
[0].Pos())
1063 var e
= p
.lineFor(list
[len(list
)-1].End())
1065 // list spans multiple lines
1066 n
:= 0 // multi-line element count
1068 for _
, x
:= range list
{
1069 xb
:= p
.lineFor(x
.Pos())
1070 xe
:= p
.lineFor(x
.End())
1072 // x is not starting on the same
1073 // line as the previous one ended
1077 // x is a multi-line element
1088 func (p
*printer
) stmt(stmt ast
.Stmt
, nextIsRBrace
bool) {
1091 switch s
:= stmt
.(type) {
1098 case *ast
.EmptyStmt
:
1101 case *ast
.LabeledStmt
:
1102 // a "correcting" unindent immediately following a line break
1103 // is applied before the line break if there is no comment
1104 // between (see writeWhitespace)
1107 p
.print(s
.Colon
, token
.COLON
, indent
)
1108 if e
, isEmpty
:= s
.Stmt
.(*ast
.EmptyStmt
); isEmpty
{
1110 p
.print(newline
, e
.Pos(), token
.SEMICOLON
)
1114 p
.linebreak(p
.lineFor(s
.Stmt
.Pos()), 1, ignore
, true)
1116 p
.stmt(s
.Stmt
, nextIsRBrace
)
1124 p
.expr0(s
.Chan
, depth
)
1125 p
.print(blank
, s
.Arrow
, token
.ARROW
, blank
)
1126 p
.expr0(s
.Value
, depth
)
1128 case *ast
.IncDecStmt
:
1130 p
.expr0(s
.X
, depth
+1)
1131 p
.print(s
.TokPos
, s
.Tok
)
1133 case *ast
.AssignStmt
:
1135 if len(s
.Lhs
) > 1 && len(s
.Rhs
) > 1 {
1138 p
.exprList(s
.Pos(), s
.Lhs
, depth
, 0, s
.TokPos
)
1139 p
.print(blank
, s
.TokPos
, s
.Tok
, blank
)
1140 p
.exprList(s
.TokPos
, s
.Rhs
, depth
, 0, token
.NoPos
)
1143 p
.print(token
.GO
, blank
)
1146 case *ast
.DeferStmt
:
1147 p
.print(token
.DEFER
, blank
)
1150 case *ast
.ReturnStmt
:
1151 p
.print(token
.RETURN
)
1152 if s
.Results
!= nil {
1154 // Use indentList heuristic to make corner cases look
1155 // better (issue 1207). A more systematic approach would
1156 // always indent, but this would cause significant
1157 // reformatting of the code base and not necessarily
1158 // lead to more nicely formatted code in general.
1159 if p
.indentList(s
.Results
) {
1161 p
.exprList(s
.Pos(), s
.Results
, 1, noIndent
, token
.NoPos
)
1164 p
.exprList(s
.Pos(), s
.Results
, 1, 0, token
.NoPos
)
1168 case *ast
.BranchStmt
:
1175 case *ast
.BlockStmt
:
1180 p
.controlClause(false, s
.Init
, s
.Cond
, nil)
1183 p
.print(blank
, token
.ELSE
, blank
)
1184 switch s
.Else
.(type) {
1185 case *ast
.BlockStmt
, *ast
.IfStmt
:
1186 p
.stmt(s
.Else
, nextIsRBrace
)
1188 // This can only happen with an incorrectly
1189 // constructed AST. Permit it but print so
1190 // that it can be parsed without errors.
1191 p
.print(token
.LBRACE
, indent
, formfeed
)
1192 p
.stmt(s
.Else
, true)
1193 p
.print(unindent
, formfeed
, token
.RBRACE
)
1197 case *ast
.CaseClause
:
1199 p
.print(token
.CASE
, blank
)
1200 p
.exprList(s
.Pos(), s
.List
, 1, 0, s
.Colon
)
1202 p
.print(token
.DEFAULT
)
1204 p
.print(s
.Colon
, token
.COLON
)
1205 p
.stmtList(s
.Body
, 1, nextIsRBrace
)
1207 case *ast
.SwitchStmt
:
1208 p
.print(token
.SWITCH
)
1209 p
.controlClause(false, s
.Init
, s
.Tag
, nil)
1212 case *ast
.TypeSwitchStmt
:
1213 p
.print(token
.SWITCH
)
1216 p
.stmt(s
.Init
, false)
1217 p
.print(token
.SEMICOLON
)
1220 p
.stmt(s
.Assign
, false)
1224 case *ast
.CommClause
:
1226 p
.print(token
.CASE
, blank
)
1227 p
.stmt(s
.Comm
, false)
1229 p
.print(token
.DEFAULT
)
1231 p
.print(s
.Colon
, token
.COLON
)
1232 p
.stmtList(s
.Body
, 1, nextIsRBrace
)
1234 case *ast
.SelectStmt
:
1235 p
.print(token
.SELECT
, blank
)
1237 if len(body
.List
) == 0 && !p
.commentBefore(p
.posFor(body
.Rbrace
)) {
1238 // print empty select statement w/o comments on one line
1239 p
.print(body
.Lbrace
, token
.LBRACE
, body
.Rbrace
, token
.RBRACE
)
1246 p
.controlClause(true, s
.Init
, s
.Cond
, s
.Post
)
1249 case *ast
.RangeStmt
:
1250 p
.print(token
.FOR
, blank
)
1254 // use position of value following the comma as
1255 // comma position for correct comment placement
1256 p
.print(s
.Value
.Pos(), token
.COMMA
, blank
)
1259 p
.print(blank
, s
.TokPos
, s
.Tok
, blank
)
1261 p
.print(token
.RANGE
, blank
)
1262 p
.expr(stripParens(s
.X
))
1267 panic("unreachable")
1271 // ----------------------------------------------------------------------------
1274 // The keepTypeColumn function determines if the type column of a series of
1275 // consecutive const or var declarations must be kept, or if initialization
1276 // values (V) can be placed in the type column (T) instead. The i'th entry
1277 // in the result slice is true if the type column in spec[i] must be kept.
1279 // For example, the declaration:
1282 // foobar int = 42 // comment
1288 // leads to the type/values matrix below. A run of value columns (V) can
1289 // be moved into the type column if there is no type for any of the values
1290 // in that column (we only move entire columns so that they align properly).
1292 // matrix formatted result
1294 // T V -> T V -> true there is a T and so the type
1295 // - V - V true column must be kept
1297 // - V V - false V is moved into T column
1299 func keepTypeColumn(specs
[]ast
.Spec
) []bool {
1300 m
:= make([]bool, len(specs
))
1302 populate
:= func(i
, j
int, keepType
bool) {
1310 i0
:= -1 // if i0 >= 0 we are in a run and i0 is the start of the run
1312 for i
, s
:= range specs
{
1313 t
:= s
.(*ast
.ValueSpec
)
1314 if t
.Values
!= nil {
1316 // start of a run of ValueSpecs with non-nil Values
1323 populate(i0
, i
, keepType
)
1333 populate(i0
, len(specs
), keepType
)
1339 func (p
*printer
) valueSpec(s
*ast
.ValueSpec
, keepType
bool) {
1341 p
.identList(s
.Names
, false) // always present
1343 if s
.Type
!= nil || keepType
{
1350 if s
.Values
!= nil {
1351 p
.print(vtab
, token
.ASSIGN
, blank
)
1352 p
.exprList(token
.NoPos
, s
.Values
, 1, 0, token
.NoPos
)
1355 if s
.Comment
!= nil {
1356 for ; extraTabs
> 0; extraTabs
-- {
1359 p
.setComment(s
.Comment
)
1363 func sanitizeImportPath(lit
*ast
.BasicLit
) *ast
.BasicLit
{
1364 // Note: An unmodified AST generated by go/parser will already
1365 // contain a backward- or double-quoted path string that does
1366 // not contain any invalid characters, and most of the work
1367 // here is not needed. However, a modified or generated AST
1368 // may possibly contain non-canonical paths. Do the work in
1369 // all cases since it's not too hard and not speed-critical.
1371 // if we don't have a proper string, be conservative and return whatever we have
1372 if lit
.Kind
!= token
.STRING
{
1375 s
, err
:= strconv
.Unquote(lit
.Value
)
1380 // if the string is an invalid path, return whatever we have
1382 // spec: "Implementation restriction: A compiler may restrict
1383 // ImportPaths to non-empty strings using only characters belonging
1384 // to Unicode's L, M, N, P, and S general categories (the Graphic
1385 // characters without spaces) and may also exclude the characters
1386 // !"#$%&'()*,:;<=>?[\]^`{|} and the Unicode replacement character
1391 const illegalChars
= `!"#$%&'()*,:;<=>?[\]^{|}` + "`\uFFFD"
1392 for _
, r
:= range s
{
1393 if !unicode
.IsGraphic(r
) || unicode
.IsSpace(r
) || strings
.ContainsRune(illegalChars
, r
) {
1398 // otherwise, return the double-quoted path
1399 s
= strconv
.Quote(s
)
1401 return lit
// nothing wrong with lit
1403 return &ast
.BasicLit
{ValuePos
: lit
.ValuePos
, Kind
: token
.STRING
, Value
: s
}
1406 // The parameter n is the number of specs in the group. If doIndent is set,
1407 // multi-line identifier lists in the spec are indented when the first
1408 // linebreak is encountered.
1410 func (p
*printer
) spec(spec ast
.Spec
, n
int, doIndent
bool) {
1411 switch s
:= spec
.(type) {
1412 case *ast
.ImportSpec
:
1418 p
.expr(sanitizeImportPath(s
.Path
))
1419 p
.setComment(s
.Comment
)
1422 case *ast
.ValueSpec
:
1424 p
.internalError("expected n = 1; got", n
)
1427 p
.identList(s
.Names
, doIndent
) // always present
1432 if s
.Values
!= nil {
1433 p
.print(blank
, token
.ASSIGN
, blank
)
1434 p
.exprList(token
.NoPos
, s
.Values
, 1, 0, token
.NoPos
)
1436 p
.setComment(s
.Comment
)
1446 if s
.Assign
.IsValid() {
1447 p
.print(token
.ASSIGN
, blank
)
1450 p
.setComment(s
.Comment
)
1453 panic("unreachable")
1457 func (p
*printer
) genDecl(d
*ast
.GenDecl
) {
1459 p
.print(d
.Pos(), d
.Tok
, blank
)
1461 if d
.Lparen
.IsValid() {
1462 // group of parenthesized declarations
1463 p
.print(d
.Lparen
, token
.LPAREN
)
1464 if n
:= len(d
.Specs
); n
> 0 {
1465 p
.print(indent
, formfeed
)
1466 if n
> 1 && (d
.Tok
== token
.CONST || d
.Tok
== token
.VAR
) {
1467 // two or more grouped const/var declarations:
1468 // determine if the type column must be kept
1469 keepType
:= keepTypeColumn(d
.Specs
)
1471 for i
, s
:= range d
.Specs
{
1473 p
.linebreak(p
.lineFor(s
.Pos()), 1, ignore
, p
.linesFrom(line
) > 0)
1476 p
.valueSpec(s
.(*ast
.ValueSpec
), keepType
[i
])
1480 for i
, s
:= range d
.Specs
{
1482 p
.linebreak(p
.lineFor(s
.Pos()), 1, ignore
, p
.linesFrom(line
) > 0)
1488 p
.print(unindent
, formfeed
)
1490 p
.print(d
.Rparen
, token
.RPAREN
)
1493 // single declaration
1494 p
.spec(d
.Specs
[0], 1, true)
1498 // nodeSize determines the size of n in chars after formatting.
1499 // The result is <= maxSize if the node fits on one line with at
1500 // most maxSize chars and the formatted output doesn't contain
1501 // any control chars. Otherwise, the result is > maxSize.
1503 func (p
*printer
) nodeSize(n ast
.Node
, maxSize
int) (size
int) {
1504 // nodeSize invokes the printer, which may invoke nodeSize
1505 // recursively. For deep composite literal nests, this can
1506 // lead to an exponential algorithm. Remember previous
1507 // results to prune the recursion (was issue 1628).
1508 if size
, found
:= p
.nodeSizes
[n
]; found
{
1512 size
= maxSize
+ 1 // assume n doesn't fit
1513 p
.nodeSizes
[n
] = size
1515 // nodeSize computation must be independent of particular
1516 // style so that we always get the same decision; print
1518 cfg
:= Config
{Mode
: RawFormat
}
1519 var buf bytes
.Buffer
1520 if err
:= cfg
.fprint(&buf
, p
.fset
, n
, p
.nodeSizes
); err
!= nil {
1523 if buf
.Len() <= maxSize
{
1524 for _
, ch
:= range buf
.Bytes() {
1529 size
= buf
.Len() // n fits
1530 p
.nodeSizes
[n
] = size
1535 // numLines returns the number of lines spanned by node n in the original source.
1536 func (p
*printer
) numLines(n ast
.Node
) int {
1537 if from
:= n
.Pos(); from
.IsValid() {
1538 if to
:= n
.End(); to
.IsValid() {
1539 return p
.lineFor(to
) - p
.lineFor(from
) + 1
1545 // bodySize is like nodeSize but it is specialized for *ast.BlockStmt's.
1546 func (p
*printer
) bodySize(b
*ast
.BlockStmt
, maxSize
int) int {
1549 if pos1
.IsValid() && pos2
.IsValid() && p
.lineFor(pos1
) != p
.lineFor(pos2
) {
1550 // opening and closing brace are on different lines - don't make it a one-liner
1553 if len(b
.List
) > 5 {
1554 // too many statements - don't make it a one-liner
1557 // otherwise, estimate body size
1558 bodySize
:= p
.commentSizeBefore(p
.posFor(pos2
))
1559 for i
, s
:= range b
.List
{
1560 if bodySize
> maxSize
{
1561 break // no need to continue
1564 bodySize
+= 2 // space for a semicolon and blank
1566 bodySize
+= p
.nodeSize(s
, maxSize
)
1571 // funcBody prints a function body following a function header of given headerSize.
1572 // If the header's and block's size are "small enough" and the block is "simple enough",
1573 // the block is printed on the current line, without line breaks, spaced from the header
1574 // by sep. Otherwise the block's opening "{" is printed on the current line, followed by
1575 // lines for the block's statements and its closing "}".
1577 func (p
*printer
) funcBody(headerSize
int, sep whiteSpace
, b
*ast
.BlockStmt
) {
1582 // save/restore composite literal nesting level
1583 defer func(level
int) {
1589 if headerSize
+p
.bodySize(b
, maxSize
) <= maxSize
{
1590 p
.print(sep
, b
.Lbrace
, token
.LBRACE
)
1591 if len(b
.List
) > 0 {
1593 for i
, s
:= range b
.List
{
1595 p
.print(token
.SEMICOLON
, blank
)
1597 p
.stmt(s
, i
== len(b
.List
)-1)
1601 p
.print(noExtraLinebreak
, b
.Rbrace
, token
.RBRACE
, noExtraLinebreak
)
1606 p
.print(blank
) // always use blank
1611 // distanceFrom returns the column difference between from and p.pos (the current
1612 // estimated position) if both are on the same line; if they are on different lines
1613 // (or unknown) the result is infinity.
1614 func (p
*printer
) distanceFrom(from token
.Pos
) int {
1615 if from
.IsValid() && p
.pos
.IsValid() {
1616 if f
:= p
.posFor(from
); f
.Line
== p
.pos
.Line
{
1617 return p
.pos
.Column
- f
.Column
1623 func (p
*printer
) funcDecl(d
*ast
.FuncDecl
) {
1625 p
.print(d
.Pos(), token
.FUNC
, blank
)
1627 p
.parameters(d
.Recv
) // method: print receiver
1631 p
.signature(d
.Type
.Params
, d
.Type
.Results
)
1632 p
.funcBody(p
.distanceFrom(d
.Pos()), vtab
, d
.Body
)
1635 func (p
*printer
) decl(decl ast
.Decl
) {
1636 switch d
:= decl
.(type) {
1638 p
.print(d
.Pos(), "BadDecl")
1644 panic("unreachable")
1648 // ----------------------------------------------------------------------------
1651 func declToken(decl ast
.Decl
) (tok token
.Token
) {
1653 switch d
:= decl
.(type) {
1662 func (p
*printer
) declList(list
[]ast
.Decl
) {
1663 tok
:= token
.ILLEGAL
1664 for _
, d
:= range list
{
1667 // If the declaration token changed (e.g., from CONST to TYPE)
1668 // or the next declaration has documentation associated with it,
1669 // print an empty line between top-level declarations.
1670 // (because p.linebreak is called with the position of d, which
1671 // is past any documentation, the minimum requirement is satisfied
1672 // even w/o the extra getDoc(d) nil-check - leave it in case the
1673 // linebreak logic improves - there's already a TODO).
1674 if len(p
.output
) > 0 {
1675 // only print line break if we are not at the beginning of the output
1676 // (i.e., we are not printing only a partial program)
1678 if prev
!= tok ||
getDoc(d
) != nil {
1681 // start a new section if the next declaration is a function
1682 // that spans multiple lines (see also issue #19544)
1683 p
.linebreak(p
.lineFor(d
.Pos()), min
, ignore
, tok
== token
.FUNC
&& p
.numLines(d
) > 1)
1689 func (p
*printer
) file(src
*ast
.File
) {
1690 p
.setComment(src
.Doc
)
1691 p
.print(src
.Pos(), token
.PACKAGE
, blank
)
1693 p
.declList(src
.Decls
)