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.
19 // - better comment formatting for /*-style comments at the end of a line (e.g. a declaration)
20 // when the comment spans multiple lines; if such a comment is just two lines, formatting is
22 // - formatting of expression lists
23 // - should use blank instead of tab to separate one-line function bodies from
24 // the function header unless there is a group of consecutive one-liners
26 // ----------------------------------------------------------------------------
29 // Print as many newlines as necessary (but at least min newlines) to get to
30 // the current line. ws is printed before the first line break. If newSection
31 // is set, the first line break is printed as formfeed. Returns true if any
32 // line break was printed; returns false otherwise.
34 // TODO(gri): linebreak may add too many lines if the next statement at "line"
35 // is preceded by comments because the computation of n assumes
36 // the current position before the comment and the target position
37 // after the comment. Thus, after interspersing such comments, the
38 // space taken up by them is not considered to reduce the number of
39 // linebreaks. At the moment there is no easy way to know about
40 // future (not yet interspersed) comments in this function.
42 func (p
*printer
) linebreak(line
, min
int, ws whiteSpace
, newSection
bool) (printedBreak
bool) {
43 n
:= nlimit(line
- p
.pos
.Line
)
61 // setComment sets g as the next comment if g != nil and if node comments
62 // are enabled - this mode is used when printing source code fragments such
63 // as exports only. It assumes that there is no pending comment in p.comments
64 // and at most one pending comment in the p.comment cache.
65 func (p
*printer
) setComment(g
*ast
.CommentGroup
) {
66 if g
== nil ||
!p
.useNodeComments
{
69 if p
.comments
== nil {
70 // initialize p.comments lazily
71 p
.comments
= make([]*ast
.CommentGroup
, 1)
72 } else if p
.cindex
< len(p
.comments
) {
73 // for some reason there are pending comments; this
74 // should never happen - handle gracefully and flush
75 // all comments up to g, ignore anything after that
76 p
.flush(p
.posFor(g
.List
[0].Pos()), token
.ILLEGAL
)
77 p
.comments
= p
.comments
[0:1]
78 // in debug mode, report error
79 p
.internalError("setComment found pending comments")
83 // don't overwrite any pending comment in the p.comment cache
84 // (there may be a pending comment when a line comment is
85 // immediately followed by a lead comment with no other
87 if p
.commentOffset
== infinity
{
88 p
.nextComment() // get comment ready for use
92 type exprListMode
uint
95 commaTerm exprListMode
= 1 << iota // list is optionally terminated by a comma
96 noIndent
// no extra indentation in multi-line lists
99 // If indent is set, a multi-line identifier list is indented after the
100 // first linebreak encountered.
101 func (p
*printer
) identList(list
[]*ast
.Ident
, indent
bool) {
102 // convert into an expression list so we can re-use exprList formatting
103 xlist
:= make([]ast
.Expr
, len(list
))
104 for i
, x
:= range list
{
107 var mode exprListMode
111 p
.exprList(token
.NoPos
, xlist
, 1, mode
, token
.NoPos
)
114 // Print a list of expressions. If the list spans multiple
115 // source lines, the original line breaks are respected between
118 // TODO(gri) Consider rewriting this to be independent of []ast.Expr
119 // so that we can use the algorithm for any kind of list
120 // (e.g., pass list via a channel over which to range).
121 func (p
*printer
) exprList(prev0 token
.Pos
, list
[]ast
.Expr
, depth
int, mode exprListMode
, next0 token
.Pos
) {
126 prev
:= p
.posFor(prev0
)
127 next
:= p
.posFor(next0
)
128 line
:= p
.lineFor(list
[0].Pos())
129 endLine
:= p
.lineFor(list
[len(list
)-1].End())
131 if prev
.IsValid() && prev
.Line
== line
&& line
== endLine
{
132 // all list entries on a single line
133 for i
, x
:= range list
{
135 // use position of expression following the comma as
136 // comma position for correct comment placement
137 p
.print(x
.Pos(), token
.COMMA
, blank
)
144 // list entries span multiple lines;
145 // use source code positions to guide line breaks
147 // don't add extra indentation if noIndent is set;
148 // i.e., pretend that the first line is already indented
150 if mode
&noIndent
== 0 {
154 // the first linebreak is always a formfeed since this section must not
155 // depend on any previous formatting
156 prevBreak
:= -1 // index of last expression that was followed by a linebreak
157 if prev
.IsValid() && prev
.Line
< line
&& p
.linebreak(line
, 0, ws
, true) {
162 // initialize expression/key size: a zero value indicates expr/key doesn't fit on a single line
165 // print all list elements
166 for i
, x
:= range list
{
168 line
= p
.lineFor(x
.Pos())
170 // determine if the next linebreak, if any, needs to use formfeed:
171 // in general, use the entire node size to make the decision; for
172 // key:value expressions, use the key size
173 // TODO(gri) for a better result, should probably incorporate both
174 // the key and the node size into the decision process
177 // determine element size: all bets are off if we don't have
178 // position information for the previous and next token (likely
179 // generated code - simply ignore the size in this case by setting
182 const infinity
= 1e6
// larger than any source line
183 size
= p
.nodeSize(x
, infinity
)
184 pair
, isPair
:= x
.(*ast
.KeyValueExpr
)
185 if size
<= infinity
&& prev
.IsValid() && next
.IsValid() {
186 // x fits on a single line
188 size
= p
.nodeSize(pair
.Key
, infinity
) // size <= infinity
191 // size too large or we don't have good layout information
195 // if the previous line and the current line had single-
196 // line-expressions and the key sizes are small or the
197 // the ratio between the key sizes does not exceed a
198 // threshold, align columns and do not use formfeed
199 if prevSize
> 0 && size
> 0 {
201 if prevSize
<= smallSize
&& size
<= smallSize
{
204 const r
= 4 // threshold
205 ratio
:= float64(size
) / float64(prevSize
)
206 useFF
= ratio
<= 1.0/r || r
<= ratio
211 needsLinebreak
:= prevLine
< line
&& prevLine
> 0 && line
> 0
212 // use position of expression following the comma as
213 // comma position for correct comment placement, but
214 // only if the expression is on the same line
221 // lines are broken using newlines so comments remain aligned
222 // unless forceFF is set or there are multiple expressions on
223 // the same line in which case formfeed is used
224 if p
.linebreak(line
, 0, ws
, useFF || prevBreak
+1 < i
) {
227 needsBlank
= false // we got a line break instead
235 if isPair
&& size
> 0 && len(list
) > 1 {
236 // we have a key:value expression that fits onto one line and
237 // is in a list with more then one entry: use a column for the
238 // key such that consecutive entries can align if possible
240 p
.print(pair
.Colon
, token
.COLON
, vtab
)
247 if mode
&commaTerm
!= 0 && next
.IsValid() && p
.pos
.Line
< next
.Line
{
248 // print a terminating comma if the next token is on a new line
250 if ws
== ignore
&& mode
&noIndent
== 0 {
251 // unindent if we indented
254 p
.print(formfeed
) // terminating comma needs a line break to look good
258 if ws
== ignore
&& mode
&noIndent
== 0 {
259 // unindent if we indented
264 func (p
*printer
) parameters(fields
*ast
.FieldList
) {
265 p
.print(fields
.Opening
, token
.LPAREN
)
266 if len(fields
.List
) > 0 {
267 prevLine
:= p
.lineFor(fields
.Opening
)
269 for i
, par
:= range fields
.List
{
270 // determine par begin and end line (may be different
271 // if there are multiple parameter names for this par
272 // or the type is on a separate line)
274 if len(par
.Names
) > 0 {
275 parLineBeg
= p
.lineFor(par
.Names
[0].Pos())
277 parLineBeg
= p
.lineFor(par
.Type
.Pos())
279 var parLineEnd
= p
.lineFor(par
.Type
.End())
280 // separating "," if needed
281 needsLinebreak
:= 0 < prevLine
&& prevLine
< parLineBeg
283 // use position of parameter following the comma as
284 // comma position for correct comma placement, but
285 // only if the next parameter is on the same line
291 // separator if needed (linebreak or blank)
292 if needsLinebreak
&& p
.linebreak(parLineBeg
, 0, ws
, true) {
293 // break line if the opening "(" or previous parameter ended on a different line
299 if len(par
.Names
) > 0 {
300 // Very subtle: If we indented before (ws == ignore), identList
301 // won't indent again. If we didn't (ws == indent), identList will
302 // indent if the identList spans multiple lines, and it will outdent
303 // again at the end (and still ws == indent). Thus, a subsequent indent
304 // by a linebreak call after a type, or in the next multi-line identList
305 // will do the right thing.
306 p
.identList(par
.Names
, ws
== indent
)
310 p
.expr(stripParensAlways(par
.Type
))
311 prevLine
= parLineEnd
313 // if the closing ")" is on a separate line from the last parameter,
314 // print an additional "," and line break
315 if closing
:= p
.lineFor(fields
.Closing
); 0 < prevLine
&& prevLine
< closing
{
317 p
.linebreak(closing
, 0, ignore
, true)
319 // unindent if we indented
324 p
.print(fields
.Closing
, token
.RPAREN
)
327 func (p
*printer
) signature(params
, result
*ast
.FieldList
) {
331 p
.print(token
.LPAREN
, token
.RPAREN
)
333 n
:= result
.NumFields()
337 if n
== 1 && result
.List
[0].Names
== nil {
338 // single anonymous result; no ()'s
339 p
.expr(stripParensAlways(result
.List
[0].Type
))
346 func identListSize(list
[]*ast
.Ident
, maxSize
int) (size
int) {
347 for i
, x
:= range list
{
351 size
+= utf8
.RuneCountInString(x
.Name
)
359 func (p
*printer
) isOneLineFieldList(list
[]*ast
.Field
) bool {
361 return false // allow only one field
364 if f
.Tag
!= nil || f
.Comment
!= nil {
365 return false // don't allow tags or comments
367 // only name(s) and type
368 const maxSize
= 30 // adjust as appropriate, this is an approximate value
369 namesSize
:= identListSize(f
.Names
, maxSize
)
371 namesSize
= 1 // blank between names and types
373 typeSize
:= p
.nodeSize(f
.Type
, maxSize
)
374 return namesSize
+typeSize
<= maxSize
377 func (p
*printer
) setLineComment(text
string) {
378 p
.setComment(&ast
.CommentGroup
{List
: []*ast
.Comment
{{Slash
: token
.NoPos
, Text
: text
}}})
381 func (p
*printer
) fieldList(fields
*ast
.FieldList
, isStruct
, isIncomplete
bool) {
382 lbrace
:= fields
.Opening
384 rbrace
:= fields
.Closing
385 hasComments
:= isIncomplete || p
.commentBefore(p
.posFor(rbrace
))
386 srcIsOneLine
:= lbrace
.IsValid() && rbrace
.IsValid() && p
.lineFor(lbrace
) == p
.lineFor(rbrace
)
388 if !hasComments
&& srcIsOneLine
{
389 // possibly a one-line struct/interface
391 // no blank between keyword and {} in this case
392 p
.print(lbrace
, token
.LBRACE
, rbrace
, token
.RBRACE
)
394 } else if isStruct
&& p
.isOneLineFieldList(list
) { // for now ignore interfaces
395 // small enough - print on one line
396 // (don't use identList and ignore source line breaks)
397 p
.print(lbrace
, token
.LBRACE
, blank
)
399 for i
, x
:= range f
.Names
{
401 // no comments so no need for comma position
402 p
.print(token
.COMMA
, blank
)
406 if len(f
.Names
) > 0 {
410 p
.print(blank
, rbrace
, token
.RBRACE
)
414 // hasComments || !srcIsOneLine
416 p
.print(blank
, lbrace
, token
.LBRACE
, indent
)
417 if hasComments ||
len(list
) > 0 {
428 for i
, f
:= range list
{
430 p
.linebreak(p
.lineFor(f
.Pos()), 1, ignore
, p
.linesFrom(line
) > 0)
435 if len(f
.Names
) > 0 {
437 p
.identList(f
.Names
, false)
447 if len(f
.Names
) > 0 && sep
== vtab
{
454 if f
.Comment
!= nil {
455 for ; extraTabs
> 0; extraTabs
-- {
458 p
.setComment(f
.Comment
)
465 p
.flush(p
.posFor(rbrace
), token
.RBRACE
) // make sure we don't lose the last line comment
466 p
.setLineComment("// contains filtered or unexported fields")
469 } else { // interface
472 for i
, f
:= range list
{
474 p
.linebreak(p
.lineFor(f
.Pos()), 1, ignore
, p
.linesFrom(line
) > 0)
478 if ftyp
, isFtyp
:= f
.Type
.(*ast
.FuncType
); isFtyp
{
481 p
.signature(ftyp
.Params
, ftyp
.Results
)
483 // embedded interface
486 p
.setComment(f
.Comment
)
492 p
.flush(p
.posFor(rbrace
), token
.RBRACE
) // make sure we don't lose the last line comment
493 p
.setLineComment("// contains filtered or unexported methods")
497 p
.print(unindent
, formfeed
, rbrace
, token
.RBRACE
)
500 // ----------------------------------------------------------------------------
503 func walkBinary(e
*ast
.BinaryExpr
) (has4
, has5
bool, maxProblem
int) {
504 switch e
.Op
.Precedence() {
511 switch l
:= e
.X
.(type) {
512 case *ast
.BinaryExpr
:
513 if l
.Op
.Precedence() < e
.Op
.Precedence() {
514 // parens will be inserted.
515 // pretend this is an *ast.ParenExpr and do nothing.
518 h4
, h5
, mp
:= walkBinary(l
)
526 switch r
:= e
.Y
.(type) {
527 case *ast
.BinaryExpr
:
528 if r
.Op
.Precedence() <= e
.Op
.Precedence() {
529 // parens will be inserted.
530 // pretend this is an *ast.ParenExpr and do nothing.
533 h4
, h5
, mp
:= walkBinary(r
)
541 if e
.Op
== token
.QUO
{ // `*/`
546 switch e
.Op
.String() + r
.Op
.String() {
547 case "/*", "&&", "&^":
558 func cutoff(e
*ast
.BinaryExpr
, depth
int) int {
559 has4
, has5
, maxProblem
:= walkBinary(e
)
561 return maxProblem
+ 1
575 func diffPrec(expr ast
.Expr
, prec
int) int {
576 x
, ok
:= expr
.(*ast
.BinaryExpr
)
577 if !ok || prec
!= x
.Op
.Precedence() {
583 func reduceDepth(depth
int) int {
591 // Format the binary expression: decide the cutoff and then format.
592 // Let's call depth == 1 Normal mode, and depth > 1 Compact mode.
593 // (Algorithm suggestion by Russ Cox.)
595 // The precedences are:
596 // 5 * / % << >> & &^
602 // The only decision is whether there will be spaces around levels 4 and 5.
603 // There are never spaces at level 6 (unary), and always spaces at levels 3 and below.
605 // To choose the cutoff, look at the whole expression but excluding primary
606 // expressions (function calls, parenthesized exprs), and apply these rules:
608 // 1) If there is a binary operator with a right side unary operand
609 // that would clash without a space, the cutoff must be (in order):
617 // (Comparison operators always have spaces around them.)
619 // 2) If there is a mix of level 5 and level 4 operators, then the cutoff
620 // is 5 (use spaces to distinguish precedence) in Normal mode
621 // and 4 (never use spaces) in Compact mode.
623 // 3) If there are no level 4 operators or no level 5 operators, then the
624 // cutoff is 6 (always use spaces) in Normal mode
625 // and 4 (never use spaces) in Compact mode.
627 func (p
*printer
) binaryExpr(x
*ast
.BinaryExpr
, prec1
, cutoff
, depth
int) {
628 prec
:= x
.Op
.Precedence()
630 // parenthesis needed
631 // Note: The parser inserts an ast.ParenExpr node; thus this case
632 // can only occur if the AST is created in a different way.
633 p
.print(token
.LPAREN
)
634 p
.expr0(x
, reduceDepth(depth
)) // parentheses undo one level of depth
635 p
.print(token
.RPAREN
)
639 printBlank
:= prec
< cutoff
642 p
.expr1(x
.X
, prec
, depth
+diffPrec(x
.X
, prec
))
646 xline
:= p
.pos
.Line
// before the operator (it may be on the next line!)
647 yline
:= p
.lineFor(x
.Y
.Pos())
648 p
.print(x
.OpPos
, x
.Op
)
649 if xline
!= yline
&& xline
> 0 && yline
> 0 {
650 // at least one line break, but respect an extra empty line
652 if p
.linebreak(yline
, 1, ws
, true) {
654 printBlank
= false // no blank after line break
660 p
.expr1(x
.Y
, prec
+1, depth
+1)
666 func isBinary(expr ast
.Expr
) bool {
667 _
, ok
:= expr
.(*ast
.BinaryExpr
)
671 func (p
*printer
) expr1(expr ast
.Expr
, prec1
, depth
int) {
674 switch x
:= expr
.(type) {
681 case *ast
.BinaryExpr
:
683 p
.internalError("depth < 1:", depth
)
686 p
.binaryExpr(x
, prec1
, cutoff(x
, depth
), depth
)
688 case *ast
.KeyValueExpr
:
690 p
.print(x
.Colon
, token
.COLON
, blank
)
694 const prec
= token
.UnaryPrec
696 // parenthesis needed
697 p
.print(token
.LPAREN
)
700 p
.print(token
.RPAREN
)
702 // no parenthesis needed
708 const prec
= token
.UnaryPrec
710 // parenthesis needed
711 p
.print(token
.LPAREN
)
713 p
.print(token
.RPAREN
)
715 // no parenthesis needed
717 if x
.Op
== token
.RANGE
{
718 // TODO(gri) Remove this code if it cannot be reached.
721 p
.expr1(x
.X
, prec
, depth
)
729 p
.adjBlock(p
.distanceFrom(x
.Type
.Pos()), blank
, x
.Body
)
732 if _
, hasParens
:= x
.X
.(*ast
.ParenExpr
); hasParens
{
733 // don't print parentheses around an already parenthesized expression
734 // TODO(gri) consider making this more general and incorporate precedence levels
735 p
.expr0(x
.X
, reduceDepth(depth
)) // parentheses undo one level of depth
737 p
.print(token
.LPAREN
)
738 p
.expr0(x
.X
, reduceDepth(depth
)) // parentheses undo one level of depth
739 p
.print(x
.Rparen
, token
.RPAREN
)
742 case *ast
.SelectorExpr
:
743 p
.expr1(x
.X
, token
.HighestPrec
, depth
)
744 p
.print(token
.PERIOD
)
745 if line
:= p
.lineFor(x
.Sel
.Pos()); p
.pos
.IsValid() && p
.pos
.Line
< line
{
746 p
.print(indent
, newline
, x
.Sel
.Pos(), x
.Sel
, unindent
)
748 p
.print(x
.Sel
.Pos(), x
.Sel
)
751 case *ast
.TypeAssertExpr
:
752 p
.expr1(x
.X
, token
.HighestPrec
, depth
)
753 p
.print(token
.PERIOD
, x
.Lparen
, token
.LPAREN
)
759 p
.print(x
.Rparen
, token
.RPAREN
)
762 // TODO(gri): should treat[] like parentheses and undo one level of depth
763 p
.expr1(x
.X
, token
.HighestPrec
, 1)
764 p
.print(x
.Lbrack
, token
.LBRACK
)
765 p
.expr0(x
.Index
, depth
+1)
766 p
.print(x
.Rbrack
, token
.RBRACK
)
769 // TODO(gri): should treat[] like parentheses and undo one level of depth
770 p
.expr1(x
.X
, token
.HighestPrec
, 1)
771 p
.print(x
.Lbrack
, token
.LBRACK
)
772 indices
:= []ast
.Expr
{x
.Low
, x
.High
}
774 indices
= append(indices
, x
.Max
)
776 for i
, y
:= range indices
{
778 // blanks around ":" if both sides exist and either side is a binary expression
779 // TODO(gri) once we have committed a variant of a[i:j:k] we may want to fine-
780 // tune the formatting here
782 if depth
<= 1 && x
!= nil && y
!= nil && (isBinary(x
) ||
isBinary(y
)) {
783 p
.print(blank
, token
.COLON
, blank
)
792 p
.print(x
.Rbrack
, token
.RBRACK
)
798 if _
, ok
:= x
.Fun
.(*ast
.FuncType
); ok
{
799 // conversions to literal function types require parentheses around the type
800 p
.print(token
.LPAREN
)
801 p
.expr1(x
.Fun
, token
.HighestPrec
, depth
)
802 p
.print(token
.RPAREN
)
804 p
.expr1(x
.Fun
, token
.HighestPrec
, depth
)
806 p
.print(x
.Lparen
, token
.LPAREN
)
807 if x
.Ellipsis
.IsValid() {
808 p
.exprList(x
.Lparen
, x
.Args
, depth
, 0, x
.Ellipsis
)
809 p
.print(x
.Ellipsis
, token
.ELLIPSIS
)
810 if x
.Rparen
.IsValid() && p
.lineFor(x
.Ellipsis
) < p
.lineFor(x
.Rparen
) {
811 p
.print(token
.COMMA
, formfeed
)
814 p
.exprList(x
.Lparen
, x
.Args
, depth
, commaTerm
, x
.Rparen
)
816 p
.print(x
.Rparen
, token
.RPAREN
)
818 case *ast
.CompositeLit
:
819 // composite literal elements that are composite literals themselves may have the type omitted
821 p
.expr1(x
.Type
, token
.HighestPrec
, depth
)
823 p
.print(x
.Lbrace
, token
.LBRACE
)
824 p
.exprList(x
.Lbrace
, x
.Elts
, 1, commaTerm
, x
.Rbrace
)
825 // do not insert extra line break following a /*-style comment
826 // before the closing '}' as it might break the code if there
827 // is no trailing ','
828 mode
:= noExtraLinebreak
829 // do not insert extra blank following a /*-style comment
830 // before the closing '}' unless the literal is empty
834 p
.print(mode
, x
.Rbrace
, token
.RBRACE
, mode
)
837 p
.print(token
.ELLIPSIS
)
843 p
.print(token
.LBRACK
)
847 p
.print(token
.RBRACK
)
850 case *ast
.StructType
:
851 p
.print(token
.STRUCT
)
852 p
.fieldList(x
.Fields
, true, x
.Incomplete
)
856 p
.signature(x
.Params
, x
.Results
)
858 case *ast
.InterfaceType
:
859 p
.print(token
.INTERFACE
)
860 p
.fieldList(x
.Methods
, false, x
.Incomplete
)
863 p
.print(token
.MAP
, token
.LBRACK
)
865 p
.print(token
.RBRACK
)
870 case ast
.SEND | ast
.RECV
:
873 p
.print(token
.ARROW
, token
.CHAN
) // x.Arrow and x.Pos() are the same
875 p
.print(token
.CHAN
, x
.Arrow
, token
.ARROW
)
887 func (p
*printer
) expr0(x ast
.Expr
, depth
int) {
888 p
.expr1(x
, token
.LowestPrec
, depth
)
891 func (p
*printer
) expr(x ast
.Expr
) {
893 p
.expr1(x
, token
.LowestPrec
, depth
)
896 // ----------------------------------------------------------------------------
899 // Print the statement list indented, but without a newline after the last statement.
900 // Extra line breaks between statements in the source are respected but at most one
901 // empty line is printed between statements.
902 func (p
*printer
) stmtList(list
[]ast
.Stmt
, nindent
int, nextIsRBrace
bool) {
908 for _
, s
:= range list
{
909 // ignore empty statements (was issue 3466)
910 if _
, isEmpty
:= s
.(*ast
.EmptyStmt
); !isEmpty
{
911 // nindent == 0 only for lists of switch/select case clauses;
912 // in those cases each clause is a new section
913 if len(p
.output
) > 0 {
914 // only print line break if we are not at the beginning of the output
915 // (i.e., we are not printing only a partial program)
916 p
.linebreak(p
.lineFor(s
.Pos()), 1, ignore
, i
== 0 || nindent
== 0 || p
.linesFrom(line
) > 0)
919 p
.stmt(s
, nextIsRBrace
&& i
== len(list
)-1)
920 // labeled statements put labels on a separate line, but here
921 // we only care about the start line of the actual statement
922 // without label - correct line for each label
924 lt
, _
:= t
.(*ast
.LabeledStmt
)
939 // block prints an *ast.BlockStmt; it always spans at least two lines.
940 func (p
*printer
) block(b
*ast
.BlockStmt
, nindent
int) {
941 p
.print(b
.Lbrace
, token
.LBRACE
)
942 p
.stmtList(b
.List
, nindent
, true)
943 p
.linebreak(p
.lineFor(b
.Rbrace
), 1, ignore
, true)
944 p
.print(b
.Rbrace
, token
.RBRACE
)
947 func isTypeName(x ast
.Expr
) bool {
948 switch t
:= x
.(type) {
951 case *ast
.SelectorExpr
:
952 return isTypeName(t
.X
)
957 func stripParens(x ast
.Expr
) ast
.Expr
{
958 if px
, strip
:= x
.(*ast
.ParenExpr
); strip
{
959 // parentheses must not be stripped if there are any
960 // unparenthesized composite literals starting with
962 ast
.Inspect(px
.X
, func(node ast
.Node
) bool {
963 switch x
:= node
.(type) {
965 // parentheses protect enclosed composite literals
967 case *ast
.CompositeLit
:
968 if isTypeName(x
.Type
) {
969 strip
= false // do not strip parentheses
973 // in all other cases, keep inspecting
977 return stripParens(px
.X
)
983 func stripParensAlways(x ast
.Expr
) ast
.Expr
{
984 if x
, ok
:= x
.(*ast
.ParenExpr
); ok
{
985 return stripParensAlways(x
.X
)
990 func (p
*printer
) controlClause(isForStmt
bool, init ast
.Stmt
, expr ast
.Expr
, post ast
.Stmt
) {
993 if init
== nil && post
== nil {
994 // no semicolons required
996 p
.expr(stripParens(expr
))
1000 // all semicolons required
1001 // (they are not separators, print them explicitly)
1005 p
.print(token
.SEMICOLON
, blank
)
1007 p
.expr(stripParens(expr
))
1011 p
.print(token
.SEMICOLON
, blank
)
1024 // indentList reports whether an expression list would look better if it
1025 // were indented wholesale (starting with the very first element, rather
1026 // than starting at the first line break).
1028 func (p
*printer
) indentList(list
[]ast
.Expr
) bool {
1029 // Heuristic: indentList returns true if there are more than one multi-
1030 // line element in the list, or if there is any element that is not
1031 // starting on the same line as the previous one ends.
1033 var b
= p
.lineFor(list
[0].Pos())
1034 var e
= p
.lineFor(list
[len(list
)-1].End())
1036 // list spans multiple lines
1037 n
:= 0 // multi-line element count
1039 for _
, x
:= range list
{
1040 xb
:= p
.lineFor(x
.Pos())
1041 xe
:= p
.lineFor(x
.End())
1043 // x is not starting on the same
1044 // line as the previous one ended
1048 // x is a multi-line element
1059 func (p
*printer
) stmt(stmt ast
.Stmt
, nextIsRBrace
bool) {
1062 switch s
:= stmt
.(type) {
1069 case *ast
.EmptyStmt
:
1072 case *ast
.LabeledStmt
:
1073 // a "correcting" unindent immediately following a line break
1074 // is applied before the line break if there is no comment
1075 // between (see writeWhitespace)
1078 p
.print(s
.Colon
, token
.COLON
, indent
)
1079 if e
, isEmpty
:= s
.Stmt
.(*ast
.EmptyStmt
); isEmpty
{
1081 p
.print(newline
, e
.Pos(), token
.SEMICOLON
)
1085 p
.linebreak(p
.lineFor(s
.Stmt
.Pos()), 1, ignore
, true)
1087 p
.stmt(s
.Stmt
, nextIsRBrace
)
1095 p
.expr0(s
.Chan
, depth
)
1096 p
.print(blank
, s
.Arrow
, token
.ARROW
, blank
)
1097 p
.expr0(s
.Value
, depth
)
1099 case *ast
.IncDecStmt
:
1101 p
.expr0(s
.X
, depth
+1)
1102 p
.print(s
.TokPos
, s
.Tok
)
1104 case *ast
.AssignStmt
:
1106 if len(s
.Lhs
) > 1 && len(s
.Rhs
) > 1 {
1109 p
.exprList(s
.Pos(), s
.Lhs
, depth
, 0, s
.TokPos
)
1110 p
.print(blank
, s
.TokPos
, s
.Tok
, blank
)
1111 p
.exprList(s
.TokPos
, s
.Rhs
, depth
, 0, token
.NoPos
)
1114 p
.print(token
.GO
, blank
)
1117 case *ast
.DeferStmt
:
1118 p
.print(token
.DEFER
, blank
)
1121 case *ast
.ReturnStmt
:
1122 p
.print(token
.RETURN
)
1123 if s
.Results
!= nil {
1125 // Use indentList heuristic to make corner cases look
1126 // better (issue 1207). A more systematic approach would
1127 // always indent, but this would cause significant
1128 // reformatting of the code base and not necessarily
1129 // lead to more nicely formatted code in general.
1130 if p
.indentList(s
.Results
) {
1132 p
.exprList(s
.Pos(), s
.Results
, 1, noIndent
, token
.NoPos
)
1135 p
.exprList(s
.Pos(), s
.Results
, 1, 0, token
.NoPos
)
1139 case *ast
.BranchStmt
:
1146 case *ast
.BlockStmt
:
1151 p
.controlClause(false, s
.Init
, s
.Cond
, nil)
1154 p
.print(blank
, token
.ELSE
, blank
)
1155 switch s
.Else
.(type) {
1156 case *ast
.BlockStmt
, *ast
.IfStmt
:
1157 p
.stmt(s
.Else
, nextIsRBrace
)
1159 p
.print(token
.LBRACE
, indent
, formfeed
)
1160 p
.stmt(s
.Else
, true)
1161 p
.print(unindent
, formfeed
, token
.RBRACE
)
1165 case *ast
.CaseClause
:
1167 p
.print(token
.CASE
, blank
)
1168 p
.exprList(s
.Pos(), s
.List
, 1, 0, s
.Colon
)
1170 p
.print(token
.DEFAULT
)
1172 p
.print(s
.Colon
, token
.COLON
)
1173 p
.stmtList(s
.Body
, 1, nextIsRBrace
)
1175 case *ast
.SwitchStmt
:
1176 p
.print(token
.SWITCH
)
1177 p
.controlClause(false, s
.Init
, s
.Tag
, nil)
1180 case *ast
.TypeSwitchStmt
:
1181 p
.print(token
.SWITCH
)
1184 p
.stmt(s
.Init
, false)
1185 p
.print(token
.SEMICOLON
)
1188 p
.stmt(s
.Assign
, false)
1192 case *ast
.CommClause
:
1194 p
.print(token
.CASE
, blank
)
1195 p
.stmt(s
.Comm
, false)
1197 p
.print(token
.DEFAULT
)
1199 p
.print(s
.Colon
, token
.COLON
)
1200 p
.stmtList(s
.Body
, 1, nextIsRBrace
)
1202 case *ast
.SelectStmt
:
1203 p
.print(token
.SELECT
, blank
)
1205 if len(body
.List
) == 0 && !p
.commentBefore(p
.posFor(body
.Rbrace
)) {
1206 // print empty select statement w/o comments on one line
1207 p
.print(body
.Lbrace
, token
.LBRACE
, body
.Rbrace
, token
.RBRACE
)
1214 p
.controlClause(true, s
.Init
, s
.Cond
, s
.Post
)
1217 case *ast
.RangeStmt
:
1218 p
.print(token
.FOR
, blank
)
1221 // use position of value following the comma as
1222 // comma position for correct comment placement
1223 p
.print(s
.Value
.Pos(), token
.COMMA
, blank
)
1226 p
.print(blank
, s
.TokPos
, s
.Tok
, blank
, token
.RANGE
, blank
)
1227 p
.expr(stripParens(s
.X
))
1232 panic("unreachable")
1238 // ----------------------------------------------------------------------------
1241 // The keepTypeColumn function determines if the type column of a series of
1242 // consecutive const or var declarations must be kept, or if initialization
1243 // values (V) can be placed in the type column (T) instead. The i'th entry
1244 // in the result slice is true if the type column in spec[i] must be kept.
1246 // For example, the declaration:
1249 // foobar int = 42 // comment
1255 // leads to the type/values matrix below. A run of value columns (V) can
1256 // be moved into the type column if there is no type for any of the values
1257 // in that column (we only move entire columns so that they align properly).
1259 // matrix formatted result
1261 // T V -> T V -> true there is a T and so the type
1262 // - V - V true column must be kept
1264 // - V V - false V is moved into T column
1266 func keepTypeColumn(specs
[]ast
.Spec
) []bool {
1267 m
:= make([]bool, len(specs
))
1269 populate
:= func(i
, j
int, keepType
bool) {
1277 i0
:= -1 // if i0 >= 0 we are in a run and i0 is the start of the run
1279 for i
, s
:= range specs
{
1280 t
:= s
.(*ast
.ValueSpec
)
1281 if t
.Values
!= nil {
1283 // start of a run of ValueSpecs with non-nil Values
1290 populate(i0
, i
, keepType
)
1300 populate(i0
, len(specs
), keepType
)
1306 func (p
*printer
) valueSpec(s
*ast
.ValueSpec
, keepType
bool) {
1308 p
.identList(s
.Names
, false) // always present
1310 if s
.Type
!= nil || keepType
{
1317 if s
.Values
!= nil {
1318 p
.print(vtab
, token
.ASSIGN
, blank
)
1319 p
.exprList(token
.NoPos
, s
.Values
, 1, 0, token
.NoPos
)
1322 if s
.Comment
!= nil {
1323 for ; extraTabs
> 0; extraTabs
-- {
1326 p
.setComment(s
.Comment
)
1330 // The parameter n is the number of specs in the group. If doIndent is set,
1331 // multi-line identifier lists in the spec are indented when the first
1332 // linebreak is encountered.
1334 func (p
*printer
) spec(spec ast
.Spec
, n
int, doIndent
bool) {
1335 switch s
:= spec
.(type) {
1336 case *ast
.ImportSpec
:
1343 p
.setComment(s
.Comment
)
1346 case *ast
.ValueSpec
:
1348 p
.internalError("expected n = 1; got", n
)
1351 p
.identList(s
.Names
, doIndent
) // always present
1356 if s
.Values
!= nil {
1357 p
.print(blank
, token
.ASSIGN
, blank
)
1358 p
.exprList(token
.NoPos
, s
.Values
, 1, 0, token
.NoPos
)
1360 p
.setComment(s
.Comment
)
1371 p
.setComment(s
.Comment
)
1374 panic("unreachable")
1378 func (p
*printer
) genDecl(d
*ast
.GenDecl
) {
1380 p
.print(d
.Pos(), d
.Tok
, blank
)
1382 if d
.Lparen
.IsValid() {
1383 // group of parenthesized declarations
1384 p
.print(d
.Lparen
, token
.LPAREN
)
1385 if n
:= len(d
.Specs
); n
> 0 {
1386 p
.print(indent
, formfeed
)
1387 if n
> 1 && (d
.Tok
== token
.CONST || d
.Tok
== token
.VAR
) {
1388 // two or more grouped const/var declarations:
1389 // determine if the type column must be kept
1390 keepType
:= keepTypeColumn(d
.Specs
)
1392 for i
, s
:= range d
.Specs
{
1394 p
.linebreak(p
.lineFor(s
.Pos()), 1, ignore
, p
.linesFrom(line
) > 0)
1397 p
.valueSpec(s
.(*ast
.ValueSpec
), keepType
[i
])
1401 for i
, s
:= range d
.Specs
{
1403 p
.linebreak(p
.lineFor(s
.Pos()), 1, ignore
, p
.linesFrom(line
) > 0)
1409 p
.print(unindent
, formfeed
)
1411 p
.print(d
.Rparen
, token
.RPAREN
)
1414 // single declaration
1415 p
.spec(d
.Specs
[0], 1, true)
1419 // nodeSize determines the size of n in chars after formatting.
1420 // The result is <= maxSize if the node fits on one line with at
1421 // most maxSize chars and the formatted output doesn't contain
1422 // any control chars. Otherwise, the result is > maxSize.
1424 func (p
*printer
) nodeSize(n ast
.Node
, maxSize
int) (size
int) {
1425 // nodeSize invokes the printer, which may invoke nodeSize
1426 // recursively. For deep composite literal nests, this can
1427 // lead to an exponential algorithm. Remember previous
1428 // results to prune the recursion (was issue 1628).
1429 if size
, found
:= p
.nodeSizes
[n
]; found
{
1433 size
= maxSize
+ 1 // assume n doesn't fit
1434 p
.nodeSizes
[n
] = size
1436 // nodeSize computation must be independent of particular
1437 // style so that we always get the same decision; print
1439 cfg
:= Config
{Mode
: RawFormat
}
1440 var buf bytes
.Buffer
1441 if err
:= cfg
.fprint(&buf
, p
.fset
, n
, p
.nodeSizes
); err
!= nil {
1444 if buf
.Len() <= maxSize
{
1445 for _
, ch
:= range buf
.Bytes() {
1450 size
= buf
.Len() // n fits
1451 p
.nodeSizes
[n
] = size
1456 // bodySize is like nodeSize but it is specialized for *ast.BlockStmt's.
1457 func (p
*printer
) bodySize(b
*ast
.BlockStmt
, maxSize
int) int {
1460 if pos1
.IsValid() && pos2
.IsValid() && p
.lineFor(pos1
) != p
.lineFor(pos2
) {
1461 // opening and closing brace are on different lines - don't make it a one-liner
1464 if len(b
.List
) > 5 {
1465 // too many statements - don't make it a one-liner
1468 // otherwise, estimate body size
1469 bodySize
:= p
.commentSizeBefore(p
.posFor(pos2
))
1470 for i
, s
:= range b
.List
{
1471 if bodySize
> maxSize
{
1472 break // no need to continue
1475 bodySize
+= 2 // space for a semicolon and blank
1477 bodySize
+= p
.nodeSize(s
, maxSize
)
1482 // adjBlock prints an "adjacent" block (e.g., a for-loop or function body) following
1483 // a header (e.g., a for-loop control clause or function signature) of given headerSize.
1484 // If the header's and block's size are "small enough" and the block is "simple enough",
1485 // the block is printed on the current line, without line breaks, spaced from the header
1486 // by sep. Otherwise the block's opening "{" is printed on the current line, followed by
1487 // lines for the block's statements and its closing "}".
1489 func (p
*printer
) adjBlock(headerSize
int, sep whiteSpace
, b
*ast
.BlockStmt
) {
1495 if headerSize
+p
.bodySize(b
, maxSize
) <= maxSize
{
1496 p
.print(sep
, b
.Lbrace
, token
.LBRACE
)
1497 if len(b
.List
) > 0 {
1499 for i
, s
:= range b
.List
{
1501 p
.print(token
.SEMICOLON
, blank
)
1503 p
.stmt(s
, i
== len(b
.List
)-1)
1507 p
.print(noExtraLinebreak
, b
.Rbrace
, token
.RBRACE
, noExtraLinebreak
)
1512 p
.print(blank
) // always use blank
1517 // distanceFrom returns the column difference between from and p.pos (the current
1518 // estimated position) if both are on the same line; if they are on different lines
1519 // (or unknown) the result is infinity.
1520 func (p
*printer
) distanceFrom(from token
.Pos
) int {
1521 if from
.IsValid() && p
.pos
.IsValid() {
1522 if f
:= p
.posFor(from
); f
.Line
== p
.pos
.Line
{
1523 return p
.pos
.Column
- f
.Column
1529 func (p
*printer
) funcDecl(d
*ast
.FuncDecl
) {
1531 p
.print(d
.Pos(), token
.FUNC
, blank
)
1533 p
.parameters(d
.Recv
) // method: print receiver
1537 p
.signature(d
.Type
.Params
, d
.Type
.Results
)
1538 p
.adjBlock(p
.distanceFrom(d
.Pos()), vtab
, d
.Body
)
1541 func (p
*printer
) decl(decl ast
.Decl
) {
1542 switch d
:= decl
.(type) {
1544 p
.print(d
.Pos(), "BadDecl")
1550 panic("unreachable")
1554 // ----------------------------------------------------------------------------
1557 func declToken(decl ast
.Decl
) (tok token
.Token
) {
1559 switch d
:= decl
.(type) {
1568 func (p
*printer
) declList(list
[]ast
.Decl
) {
1569 tok
:= token
.ILLEGAL
1570 for _
, d
:= range list
{
1573 // If the declaration token changed (e.g., from CONST to TYPE)
1574 // or the next declaration has documentation associated with it,
1575 // print an empty line between top-level declarations.
1576 // (because p.linebreak is called with the position of d, which
1577 // is past any documentation, the minimum requirement is satisfied
1578 // even w/o the extra getDoc(d) nil-check - leave it in case the
1579 // linebreak logic improves - there's already a TODO).
1580 if len(p
.output
) > 0 {
1581 // only print line break if we are not at the beginning of the output
1582 // (i.e., we are not printing only a partial program)
1584 if prev
!= tok ||
getDoc(d
) != nil {
1587 p
.linebreak(p
.lineFor(d
.Pos()), min
, ignore
, false)
1593 func (p
*printer
) file(src
*ast
.File
) {
1594 p
.setComment(src
.Doc
)
1595 p
.print(src
.Pos(), token
.PACKAGE
, blank
)
1597 p
.declList(src
.Decls
)