...
Run Format

Source file src/go/printer/printer.go

Documentation: go/printer

     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.
     4  
     5  // Package printer implements printing of AST nodes.
     6  package printer
     7  
     8  import (
     9  	"fmt"
    10  	"go/ast"
    11  	"go/token"
    12  	"io"
    13  	"os"
    14  	"strings"
    15  	"text/tabwriter"
    16  	"unicode"
    17  )
    18  
    19  const (
    20  	maxNewlines = 2     // max. number of newlines between source text
    21  	debug       = false // enable for debugging
    22  	infinity    = 1 << 30
    23  )
    24  
    25  type whiteSpace byte
    26  
    27  const (
    28  	ignore   = whiteSpace(0)
    29  	blank    = whiteSpace(' ')
    30  	vtab     = whiteSpace('\v')
    31  	newline  = whiteSpace('\n')
    32  	formfeed = whiteSpace('\f')
    33  	indent   = whiteSpace('>')
    34  	unindent = whiteSpace('<')
    35  )
    36  
    37  // A pmode value represents the current printer mode.
    38  type pmode int
    39  
    40  const (
    41  	noExtraBlank     pmode = 1 << iota // disables extra blank after /*-style comment
    42  	noExtraLinebreak                   // disables extra line break after /*-style comment
    43  )
    44  
    45  type commentInfo struct {
    46  	cindex         int               // current comment index
    47  	comment        *ast.CommentGroup // = printer.comments[cindex]; or nil
    48  	commentOffset  int               // = printer.posFor(printer.comments[cindex].List[0].Pos()).Offset; or infinity
    49  	commentNewline bool              // true if the comment group contains newlines
    50  }
    51  
    52  type printer struct {
    53  	// Configuration (does not change after initialization)
    54  	Config
    55  	fset *token.FileSet
    56  
    57  	// Current state
    58  	output       []byte       // raw printer result
    59  	indent       int          // current indentation
    60  	level        int          // level == 0: outside composite literal; level > 0: inside composite literal
    61  	mode         pmode        // current printer mode
    62  	endAlignment bool         // if set, terminate alignment immediately
    63  	impliedSemi  bool         // if set, a linebreak implies a semicolon
    64  	lastTok      token.Token  // last token printed (token.ILLEGAL if it's whitespace)
    65  	prevOpen     token.Token  // previous non-brace "open" token (, [, or token.ILLEGAL
    66  	wsbuf        []whiteSpace // delayed white space
    67  
    68  	// Positions
    69  	// The out position differs from the pos position when the result
    70  	// formatting differs from the source formatting (in the amount of
    71  	// white space). If there's a difference and SourcePos is set in
    72  	// ConfigMode, //line directives are used in the output to restore
    73  	// original source positions for a reader.
    74  	pos     token.Position // current position in AST (source) space
    75  	out     token.Position // current position in output space
    76  	last    token.Position // value of pos after calling writeString
    77  	linePtr *int           // if set, record out.Line for the next token in *linePtr
    78  
    79  	// The list of all source comments, in order of appearance.
    80  	comments        []*ast.CommentGroup // may be nil
    81  	useNodeComments bool                // if not set, ignore lead and line comments of nodes
    82  
    83  	// Information about p.comments[p.cindex]; set up by nextComment.
    84  	commentInfo
    85  
    86  	// Cache of already computed node sizes.
    87  	nodeSizes map[ast.Node]int
    88  
    89  	// Cache of most recently computed line position.
    90  	cachedPos  token.Pos
    91  	cachedLine int // line corresponding to cachedPos
    92  }
    93  
    94  func (p *printer) init(cfg *Config, fset *token.FileSet, nodeSizes map[ast.Node]int) {
    95  	p.Config = *cfg
    96  	p.fset = fset
    97  	p.pos = token.Position{Line: 1, Column: 1}
    98  	p.out = token.Position{Line: 1, Column: 1}
    99  	p.wsbuf = make([]whiteSpace, 0, 16) // whitespace sequences are short
   100  	p.nodeSizes = nodeSizes
   101  	p.cachedPos = -1
   102  }
   103  
   104  func (p *printer) internalError(msg ...interface{}) {
   105  	if debug {
   106  		fmt.Print(p.pos.String() + ": ")
   107  		fmt.Println(msg...)
   108  		panic("go/printer")
   109  	}
   110  }
   111  
   112  // commentsHaveNewline reports whether a list of comments belonging to
   113  // an *ast.CommentGroup contains newlines. Because the position information
   114  // may only be partially correct, we also have to read the comment text.
   115  func (p *printer) commentsHaveNewline(list []*ast.Comment) bool {
   116  	// len(list) > 0
   117  	line := p.lineFor(list[0].Pos())
   118  	for i, c := range list {
   119  		if i > 0 && p.lineFor(list[i].Pos()) != line {
   120  			// not all comments on the same line
   121  			return true
   122  		}
   123  		if t := c.Text; len(t) >= 2 && (t[1] == '/' || strings.Contains(t, "\n")) {
   124  			return true
   125  		}
   126  	}
   127  	_ = line
   128  	return false
   129  }
   130  
   131  func (p *printer) nextComment() {
   132  	for p.cindex < len(p.comments) {
   133  		c := p.comments[p.cindex]
   134  		p.cindex++
   135  		if list := c.List; len(list) > 0 {
   136  			p.comment = c
   137  			p.commentOffset = p.posFor(list[0].Pos()).Offset
   138  			p.commentNewline = p.commentsHaveNewline(list)
   139  			return
   140  		}
   141  		// we should not reach here (correct ASTs don't have empty
   142  		// ast.CommentGroup nodes), but be conservative and try again
   143  	}
   144  	// no more comments
   145  	p.commentOffset = infinity
   146  }
   147  
   148  // commentBefore reports whether the current comment group occurs
   149  // before the next position in the source code and printing it does
   150  // not introduce implicit semicolons.
   151  //
   152  func (p *printer) commentBefore(next token.Position) bool {
   153  	return p.commentOffset < next.Offset && (!p.impliedSemi || !p.commentNewline)
   154  }
   155  
   156  // commentSizeBefore returns the estimated size of the
   157  // comments on the same line before the next position.
   158  //
   159  func (p *printer) commentSizeBefore(next token.Position) int {
   160  	// save/restore current p.commentInfo (p.nextComment() modifies it)
   161  	defer func(info commentInfo) {
   162  		p.commentInfo = info
   163  	}(p.commentInfo)
   164  
   165  	size := 0
   166  	for p.commentBefore(next) {
   167  		for _, c := range p.comment.List {
   168  			size += len(c.Text)
   169  		}
   170  		p.nextComment()
   171  	}
   172  	return size
   173  }
   174  
   175  // recordLine records the output line number for the next non-whitespace
   176  // token in *linePtr. It is used to compute an accurate line number for a
   177  // formatted construct, independent of pending (not yet emitted) whitespace
   178  // or comments.
   179  //
   180  func (p *printer) recordLine(linePtr *int) {
   181  	p.linePtr = linePtr
   182  }
   183  
   184  // linesFrom returns the number of output lines between the current
   185  // output line and the line argument, ignoring any pending (not yet
   186  // emitted) whitespace or comments. It is used to compute an accurate
   187  // size (in number of lines) for a formatted construct.
   188  //
   189  func (p *printer) linesFrom(line int) int {
   190  	return p.out.Line - line
   191  }
   192  
   193  func (p *printer) posFor(pos token.Pos) token.Position {
   194  	// not used frequently enough to cache entire token.Position
   195  	return p.fset.PositionFor(pos, false /* absolute position */)
   196  }
   197  
   198  func (p *printer) lineFor(pos token.Pos) int {
   199  	if pos != p.cachedPos {
   200  		p.cachedPos = pos
   201  		p.cachedLine = p.fset.PositionFor(pos, false /* absolute position */).Line
   202  	}
   203  	return p.cachedLine
   204  }
   205  
   206  // writeLineDirective writes a //line directive if necessary.
   207  func (p *printer) writeLineDirective(pos token.Position) {
   208  	if pos.IsValid() && (p.out.Line != pos.Line || p.out.Filename != pos.Filename) {
   209  		p.output = append(p.output, tabwriter.Escape) // protect '\n' in //line from tabwriter interpretation
   210  		p.output = append(p.output, fmt.Sprintf("//line %s:%d\n", pos.Filename, pos.Line)...)
   211  		p.output = append(p.output, tabwriter.Escape)
   212  		// p.out must match the //line directive
   213  		p.out.Filename = pos.Filename
   214  		p.out.Line = pos.Line
   215  	}
   216  }
   217  
   218  // writeIndent writes indentation.
   219  func (p *printer) writeIndent() {
   220  	// use "hard" htabs - indentation columns
   221  	// must not be discarded by the tabwriter
   222  	n := p.Config.Indent + p.indent // include base indentation
   223  	for i := 0; i < n; i++ {
   224  		p.output = append(p.output, '\t')
   225  	}
   226  
   227  	// update positions
   228  	p.pos.Offset += n
   229  	p.pos.Column += n
   230  	p.out.Column += n
   231  }
   232  
   233  // writeByte writes ch n times to p.output and updates p.pos.
   234  // Only used to write formatting (white space) characters.
   235  func (p *printer) writeByte(ch byte, n int) {
   236  	if p.endAlignment {
   237  		// Ignore any alignment control character;
   238  		// and at the end of the line, break with
   239  		// a formfeed to indicate termination of
   240  		// existing columns.
   241  		switch ch {
   242  		case '\t', '\v':
   243  			ch = ' '
   244  		case '\n', '\f':
   245  			ch = '\f'
   246  			p.endAlignment = false
   247  		}
   248  	}
   249  
   250  	if p.out.Column == 1 {
   251  		// no need to write line directives before white space
   252  		p.writeIndent()
   253  	}
   254  
   255  	for i := 0; i < n; i++ {
   256  		p.output = append(p.output, ch)
   257  	}
   258  
   259  	// update positions
   260  	p.pos.Offset += n
   261  	if ch == '\n' || ch == '\f' {
   262  		p.pos.Line += n
   263  		p.out.Line += n
   264  		p.pos.Column = 1
   265  		p.out.Column = 1
   266  		return
   267  	}
   268  	p.pos.Column += n
   269  	p.out.Column += n
   270  }
   271  
   272  // writeString writes the string s to p.output and updates p.pos, p.out,
   273  // and p.last. If isLit is set, s is escaped w/ tabwriter.Escape characters
   274  // to protect s from being interpreted by the tabwriter.
   275  //
   276  // Note: writeString is only used to write Go tokens, literals, and
   277  // comments, all of which must be written literally. Thus, it is correct
   278  // to always set isLit = true. However, setting it explicitly only when
   279  // needed (i.e., when we don't know that s contains no tabs or line breaks)
   280  // avoids processing extra escape characters and reduces run time of the
   281  // printer benchmark by up to 10%.
   282  //
   283  func (p *printer) writeString(pos token.Position, s string, isLit bool) {
   284  	if p.out.Column == 1 {
   285  		if p.Config.Mode&SourcePos != 0 {
   286  			p.writeLineDirective(pos)
   287  		}
   288  		p.writeIndent()
   289  	}
   290  
   291  	if pos.IsValid() {
   292  		// update p.pos (if pos is invalid, continue with existing p.pos)
   293  		// Note: Must do this after handling line beginnings because
   294  		// writeIndent updates p.pos if there's indentation, but p.pos
   295  		// is the position of s.
   296  		p.pos = pos
   297  	}
   298  
   299  	if isLit {
   300  		// Protect s such that is passes through the tabwriter
   301  		// unchanged. Note that valid Go programs cannot contain
   302  		// tabwriter.Escape bytes since they do not appear in legal
   303  		// UTF-8 sequences.
   304  		p.output = append(p.output, tabwriter.Escape)
   305  	}
   306  
   307  	if debug {
   308  		p.output = append(p.output, fmt.Sprintf("/*%s*/", pos)...) // do not update p.pos!
   309  	}
   310  	p.output = append(p.output, s...)
   311  
   312  	// update positions
   313  	nlines := 0
   314  	var li int // index of last newline; valid if nlines > 0
   315  	for i := 0; i < len(s); i++ {
   316  		// Raw string literals may contain any character except back quote (`).
   317  		if ch := s[i]; ch == '\n' || ch == '\f' {
   318  			// account for line break
   319  			nlines++
   320  			li = i
   321  			// A line break inside a literal will break whatever column
   322  			// formatting is in place; ignore any further alignment through
   323  			// the end of the line.
   324  			p.endAlignment = true
   325  		}
   326  	}
   327  	p.pos.Offset += len(s)
   328  	if nlines > 0 {
   329  		p.pos.Line += nlines
   330  		p.out.Line += nlines
   331  		c := len(s) - li
   332  		p.pos.Column = c
   333  		p.out.Column = c
   334  	} else {
   335  		p.pos.Column += len(s)
   336  		p.out.Column += len(s)
   337  	}
   338  
   339  	if isLit {
   340  		p.output = append(p.output, tabwriter.Escape)
   341  	}
   342  
   343  	p.last = p.pos
   344  }
   345  
   346  // writeCommentPrefix writes the whitespace before a comment.
   347  // If there is any pending whitespace, it consumes as much of
   348  // it as is likely to help position the comment nicely.
   349  // pos is the comment position, next the position of the item
   350  // after all pending comments, prev is the previous comment in
   351  // a group of comments (or nil), and tok is the next token.
   352  //
   353  func (p *printer) writeCommentPrefix(pos, next token.Position, prev *ast.Comment, tok token.Token) {
   354  	if len(p.output) == 0 {
   355  		// the comment is the first item to be printed - don't write any whitespace
   356  		return
   357  	}
   358  
   359  	if pos.IsValid() && pos.Filename != p.last.Filename {
   360  		// comment in a different file - separate with newlines
   361  		p.writeByte('\f', maxNewlines)
   362  		return
   363  	}
   364  
   365  	if pos.Line == p.last.Line && (prev == nil || prev.Text[1] != '/') {
   366  		// comment on the same line as last item:
   367  		// separate with at least one separator
   368  		hasSep := false
   369  		if prev == nil {
   370  			// first comment of a comment group
   371  			j := 0
   372  			for i, ch := range p.wsbuf {
   373  				switch ch {
   374  				case blank:
   375  					// ignore any blanks before a comment
   376  					p.wsbuf[i] = ignore
   377  					continue
   378  				case vtab:
   379  					// respect existing tabs - important
   380  					// for proper formatting of commented structs
   381  					hasSep = true
   382  					continue
   383  				case indent:
   384  					// apply pending indentation
   385  					continue
   386  				}
   387  				j = i
   388  				break
   389  			}
   390  			p.writeWhitespace(j)
   391  		}
   392  		// make sure there is at least one separator
   393  		if !hasSep {
   394  			sep := byte('\t')
   395  			if pos.Line == next.Line {
   396  				// next item is on the same line as the comment
   397  				// (which must be a /*-style comment): separate
   398  				// with a blank instead of a tab
   399  				sep = ' '
   400  			}
   401  			p.writeByte(sep, 1)
   402  		}
   403  
   404  	} else {
   405  		// comment on a different line:
   406  		// separate with at least one line break
   407  		droppedLinebreak := false
   408  		j := 0
   409  		for i, ch := range p.wsbuf {
   410  			switch ch {
   411  			case blank, vtab:
   412  				// ignore any horizontal whitespace before line breaks
   413  				p.wsbuf[i] = ignore
   414  				continue
   415  			case indent:
   416  				// apply pending indentation
   417  				continue
   418  			case unindent:
   419  				// if this is not the last unindent, apply it
   420  				// as it is (likely) belonging to the last
   421  				// construct (e.g., a multi-line expression list)
   422  				// and is not part of closing a block
   423  				if i+1 < len(p.wsbuf) && p.wsbuf[i+1] == unindent {
   424  					continue
   425  				}
   426  				// if the next token is not a closing }, apply the unindent
   427  				// if it appears that the comment is aligned with the
   428  				// token; otherwise assume the unindent is part of a
   429  				// closing block and stop (this scenario appears with
   430  				// comments before a case label where the comments
   431  				// apply to the next case instead of the current one)
   432  				if tok != token.RBRACE && pos.Column == next.Column {
   433  					continue
   434  				}
   435  			case newline, formfeed:
   436  				p.wsbuf[i] = ignore
   437  				droppedLinebreak = prev == nil // record only if first comment of a group
   438  			}
   439  			j = i
   440  			break
   441  		}
   442  		p.writeWhitespace(j)
   443  
   444  		// determine number of linebreaks before the comment
   445  		n := 0
   446  		if pos.IsValid() && p.last.IsValid() {
   447  			n = pos.Line - p.last.Line
   448  			if n < 0 { // should never happen
   449  				n = 0
   450  			}
   451  		}
   452  
   453  		// at the package scope level only (p.indent == 0),
   454  		// add an extra newline if we dropped one before:
   455  		// this preserves a blank line before documentation
   456  		// comments at the package scope level (issue 2570)
   457  		if p.indent == 0 && droppedLinebreak {
   458  			n++
   459  		}
   460  
   461  		// make sure there is at least one line break
   462  		// if the previous comment was a line comment
   463  		if n == 0 && prev != nil && prev.Text[1] == '/' {
   464  			n = 1
   465  		}
   466  
   467  		if n > 0 {
   468  			// use formfeeds to break columns before a comment;
   469  			// this is analogous to using formfeeds to separate
   470  			// individual lines of /*-style comments
   471  			p.writeByte('\f', nlimit(n))
   472  		}
   473  	}
   474  }
   475  
   476  // Returns true if s contains only white space
   477  // (only tabs and blanks can appear in the printer's context).
   478  //
   479  func isBlank(s string) bool {
   480  	for i := 0; i < len(s); i++ {
   481  		if s[i] > ' ' {
   482  			return false
   483  		}
   484  	}
   485  	return true
   486  }
   487  
   488  // commonPrefix returns the common prefix of a and b.
   489  func commonPrefix(a, b string) string {
   490  	i := 0
   491  	for i < len(a) && i < len(b) && a[i] == b[i] && (a[i] <= ' ' || a[i] == '*') {
   492  		i++
   493  	}
   494  	return a[0:i]
   495  }
   496  
   497  // trimRight returns s with trailing whitespace removed.
   498  func trimRight(s string) string {
   499  	return strings.TrimRightFunc(s, unicode.IsSpace)
   500  }
   501  
   502  // stripCommonPrefix removes a common prefix from /*-style comment lines (unless no
   503  // comment line is indented, all but the first line have some form of space prefix).
   504  // The prefix is computed using heuristics such that is likely that the comment
   505  // contents are nicely laid out after re-printing each line using the printer's
   506  // current indentation.
   507  //
   508  func stripCommonPrefix(lines []string) {
   509  	if len(lines) <= 1 {
   510  		return // at most one line - nothing to do
   511  	}
   512  	// len(lines) > 1
   513  
   514  	// The heuristic in this function tries to handle a few
   515  	// common patterns of /*-style comments: Comments where
   516  	// the opening /* and closing */ are aligned and the
   517  	// rest of the comment text is aligned and indented with
   518  	// blanks or tabs, cases with a vertical "line of stars"
   519  	// on the left, and cases where the closing */ is on the
   520  	// same line as the last comment text.
   521  
   522  	// Compute maximum common white prefix of all but the first,
   523  	// last, and blank lines, and replace blank lines with empty
   524  	// lines (the first line starts with /* and has no prefix).
   525  	// In cases where only the first and last lines are not blank,
   526  	// such as two-line comments, or comments where all inner lines
   527  	// are blank, consider the last line for the prefix computation
   528  	// since otherwise the prefix would be empty.
   529  	//
   530  	// Note that the first and last line are never empty (they
   531  	// contain the opening /* and closing */ respectively) and
   532  	// thus they can be ignored by the blank line check.
   533  	prefix := ""
   534  	prefixSet := false
   535  	if len(lines) > 2 {
   536  		for i, line := range lines[1 : len(lines)-1] {
   537  			if isBlank(line) {
   538  				lines[1+i] = "" // range starts with lines[1]
   539  			} else {
   540  				if !prefixSet {
   541  					prefix = line
   542  					prefixSet = true
   543  				}
   544  				prefix = commonPrefix(prefix, line)
   545  			}
   546  
   547  		}
   548  	}
   549  	// If we don't have a prefix yet, consider the last line.
   550  	if !prefixSet {
   551  		line := lines[len(lines)-1]
   552  		prefix = commonPrefix(line, line)
   553  	}
   554  
   555  	/*
   556  	 * Check for vertical "line of stars" and correct prefix accordingly.
   557  	 */
   558  	lineOfStars := false
   559  	if i := strings.Index(prefix, "*"); i >= 0 {
   560  		// Line of stars present.
   561  		if i > 0 && prefix[i-1] == ' ' {
   562  			i-- // remove trailing blank from prefix so stars remain aligned
   563  		}
   564  		prefix = prefix[0:i]
   565  		lineOfStars = true
   566  	} else {
   567  		// No line of stars present.
   568  		// Determine the white space on the first line after the /*
   569  		// and before the beginning of the comment text, assume two
   570  		// blanks instead of the /* unless the first character after
   571  		// the /* is a tab. If the first comment line is empty but
   572  		// for the opening /*, assume up to 3 blanks or a tab. This
   573  		// whitespace may be found as suffix in the common prefix.
   574  		first := lines[0]
   575  		if isBlank(first[2:]) {
   576  			// no comment text on the first line:
   577  			// reduce prefix by up to 3 blanks or a tab
   578  			// if present - this keeps comment text indented
   579  			// relative to the /* and */'s if it was indented
   580  			// in the first place
   581  			i := len(prefix)
   582  			for n := 0; n < 3 && i > 0 && prefix[i-1] == ' '; n++ {
   583  				i--
   584  			}
   585  			if i == len(prefix) && i > 0 && prefix[i-1] == '\t' {
   586  				i--
   587  			}
   588  			prefix = prefix[0:i]
   589  		} else {
   590  			// comment text on the first line
   591  			suffix := make([]byte, len(first))
   592  			n := 2 // start after opening /*
   593  			for n < len(first) && first[n] <= ' ' {
   594  				suffix[n] = first[n]
   595  				n++
   596  			}
   597  			if n > 2 && suffix[2] == '\t' {
   598  				// assume the '\t' compensates for the /*
   599  				suffix = suffix[2:n]
   600  			} else {
   601  				// otherwise assume two blanks
   602  				suffix[0], suffix[1] = ' ', ' '
   603  				suffix = suffix[0:n]
   604  			}
   605  			// Shorten the computed common prefix by the length of
   606  			// suffix, if it is found as suffix of the prefix.
   607  			prefix = strings.TrimSuffix(prefix, string(suffix))
   608  		}
   609  	}
   610  
   611  	// Handle last line: If it only contains a closing */, align it
   612  	// with the opening /*, otherwise align the text with the other
   613  	// lines.
   614  	last := lines[len(lines)-1]
   615  	closing := "*/"
   616  	i := strings.Index(last, closing) // i >= 0 (closing is always present)
   617  	if isBlank(last[0:i]) {
   618  		// last line only contains closing */
   619  		if lineOfStars {
   620  			closing = " */" // add blank to align final star
   621  		}
   622  		lines[len(lines)-1] = prefix + closing
   623  	} else {
   624  		// last line contains more comment text - assume
   625  		// it is aligned like the other lines and include
   626  		// in prefix computation
   627  		prefix = commonPrefix(prefix, last)
   628  	}
   629  
   630  	// Remove the common prefix from all but the first and empty lines.
   631  	for i, line := range lines {
   632  		if i > 0 && line != "" {
   633  			lines[i] = line[len(prefix):]
   634  		}
   635  	}
   636  }
   637  
   638  func (p *printer) writeComment(comment *ast.Comment) {
   639  	text := comment.Text
   640  	pos := p.posFor(comment.Pos())
   641  
   642  	const linePrefix = "//line "
   643  	if strings.HasPrefix(text, linePrefix) && (!pos.IsValid() || pos.Column == 1) {
   644  		// Possibly a //-style line directive.
   645  		// Suspend indentation temporarily to keep line directive valid.
   646  		defer func(indent int) { p.indent = indent }(p.indent)
   647  		p.indent = 0
   648  	}
   649  
   650  	// shortcut common case of //-style comments
   651  	if text[1] == '/' {
   652  		p.writeString(pos, trimRight(text), true)
   653  		return
   654  	}
   655  
   656  	// for /*-style comments, print line by line and let the
   657  	// write function take care of the proper indentation
   658  	lines := strings.Split(text, "\n")
   659  
   660  	// The comment started in the first column but is going
   661  	// to be indented. For an idempotent result, add indentation
   662  	// to all lines such that they look like they were indented
   663  	// before - this will make sure the common prefix computation
   664  	// is the same independent of how many times formatting is
   665  	// applied (was issue 1835).
   666  	if pos.IsValid() && pos.Column == 1 && p.indent > 0 {
   667  		for i, line := range lines[1:] {
   668  			lines[1+i] = "   " + line
   669  		}
   670  	}
   671  
   672  	stripCommonPrefix(lines)
   673  
   674  	// write comment lines, separated by formfeed,
   675  	// without a line break after the last line
   676  	for i, line := range lines {
   677  		if i > 0 {
   678  			p.writeByte('\f', 1)
   679  			pos = p.pos
   680  		}
   681  		if len(line) > 0 {
   682  			p.writeString(pos, trimRight(line), true)
   683  		}
   684  	}
   685  }
   686  
   687  // writeCommentSuffix writes a line break after a comment if indicated
   688  // and processes any leftover indentation information. If a line break
   689  // is needed, the kind of break (newline vs formfeed) depends on the
   690  // pending whitespace. The writeCommentSuffix result indicates if a
   691  // newline was written or if a formfeed was dropped from the whitespace
   692  // buffer.
   693  //
   694  func (p *printer) writeCommentSuffix(needsLinebreak bool) (wroteNewline, droppedFF bool) {
   695  	for i, ch := range p.wsbuf {
   696  		switch ch {
   697  		case blank, vtab:
   698  			// ignore trailing whitespace
   699  			p.wsbuf[i] = ignore
   700  		case indent, unindent:
   701  			// don't lose indentation information
   702  		case newline, formfeed:
   703  			// if we need a line break, keep exactly one
   704  			// but remember if we dropped any formfeeds
   705  			if needsLinebreak {
   706  				needsLinebreak = false
   707  				wroteNewline = true
   708  			} else {
   709  				if ch == formfeed {
   710  					droppedFF = true
   711  				}
   712  				p.wsbuf[i] = ignore
   713  			}
   714  		}
   715  	}
   716  	p.writeWhitespace(len(p.wsbuf))
   717  
   718  	// make sure we have a line break
   719  	if needsLinebreak {
   720  		p.writeByte('\n', 1)
   721  		wroteNewline = true
   722  	}
   723  
   724  	return
   725  }
   726  
   727  // containsLinebreak reports whether the whitespace buffer contains any line breaks.
   728  func (p *printer) containsLinebreak() bool {
   729  	for _, ch := range p.wsbuf {
   730  		if ch == newline || ch == formfeed {
   731  			return true
   732  		}
   733  	}
   734  	return false
   735  }
   736  
   737  // intersperseComments consumes all comments that appear before the next token
   738  // tok and prints it together with the buffered whitespace (i.e., the whitespace
   739  // that needs to be written before the next token). A heuristic is used to mix
   740  // the comments and whitespace. The intersperseComments result indicates if a
   741  // newline was written or if a formfeed was dropped from the whitespace buffer.
   742  //
   743  func (p *printer) intersperseComments(next token.Position, tok token.Token) (wroteNewline, droppedFF bool) {
   744  	var last *ast.Comment
   745  	for p.commentBefore(next) {
   746  		for _, c := range p.comment.List {
   747  			p.writeCommentPrefix(p.posFor(c.Pos()), next, last, tok)
   748  			p.writeComment(c)
   749  			last = c
   750  		}
   751  		p.nextComment()
   752  	}
   753  
   754  	if last != nil {
   755  		// If the last comment is a /*-style comment and the next item
   756  		// follows on the same line but is not a comma, and not a "closing"
   757  		// token immediately following its corresponding "opening" token,
   758  		// add an extra separator unless explicitly disabled. Use a blank
   759  		// as separator unless we have pending linebreaks, they are not
   760  		// disabled, and we are outside a composite literal, in which case
   761  		// we want a linebreak (issue 15137).
   762  		// TODO(gri) This has become overly complicated. We should be able
   763  		// to track whether we're inside an expression or statement and
   764  		// use that information to decide more directly.
   765  		needsLinebreak := false
   766  		if p.mode&noExtraBlank == 0 &&
   767  			last.Text[1] == '*' && p.lineFor(last.Pos()) == next.Line &&
   768  			tok != token.COMMA &&
   769  			(tok != token.RPAREN || p.prevOpen == token.LPAREN) &&
   770  			(tok != token.RBRACK || p.prevOpen == token.LBRACK) {
   771  			if p.containsLinebreak() && p.mode&noExtraLinebreak == 0 && p.level == 0 {
   772  				needsLinebreak = true
   773  			} else {
   774  				p.writeByte(' ', 1)
   775  			}
   776  		}
   777  		// Ensure that there is a line break after a //-style comment,
   778  		// before EOF, and before a closing '}' unless explicitly disabled.
   779  		if last.Text[1] == '/' ||
   780  			tok == token.EOF ||
   781  			tok == token.RBRACE && p.mode&noExtraLinebreak == 0 {
   782  			needsLinebreak = true
   783  		}
   784  		return p.writeCommentSuffix(needsLinebreak)
   785  	}
   786  
   787  	// no comment was written - we should never reach here since
   788  	// intersperseComments should not be called in that case
   789  	p.internalError("intersperseComments called without pending comments")
   790  	return
   791  }
   792  
   793  // whiteWhitespace writes the first n whitespace entries.
   794  func (p *printer) writeWhitespace(n int) {
   795  	// write entries
   796  	for i := 0; i < n; i++ {
   797  		switch ch := p.wsbuf[i]; ch {
   798  		case ignore:
   799  			// ignore!
   800  		case indent:
   801  			p.indent++
   802  		case unindent:
   803  			p.indent--
   804  			if p.indent < 0 {
   805  				p.internalError("negative indentation:", p.indent)
   806  				p.indent = 0
   807  			}
   808  		case newline, formfeed:
   809  			// A line break immediately followed by a "correcting"
   810  			// unindent is swapped with the unindent - this permits
   811  			// proper label positioning. If a comment is between
   812  			// the line break and the label, the unindent is not
   813  			// part of the comment whitespace prefix and the comment
   814  			// will be positioned correctly indented.
   815  			if i+1 < n && p.wsbuf[i+1] == unindent {
   816  				// Use a formfeed to terminate the current section.
   817  				// Otherwise, a long label name on the next line leading
   818  				// to a wide column may increase the indentation column
   819  				// of lines before the label; effectively leading to wrong
   820  				// indentation.
   821  				p.wsbuf[i], p.wsbuf[i+1] = unindent, formfeed
   822  				i-- // do it again
   823  				continue
   824  			}
   825  			fallthrough
   826  		default:
   827  			p.writeByte(byte(ch), 1)
   828  		}
   829  	}
   830  
   831  	// shift remaining entries down
   832  	l := copy(p.wsbuf, p.wsbuf[n:])
   833  	p.wsbuf = p.wsbuf[:l]
   834  }
   835  
   836  // ----------------------------------------------------------------------------
   837  // Printing interface
   838  
   839  // nlines limits n to maxNewlines.
   840  func nlimit(n int) int {
   841  	if n > maxNewlines {
   842  		n = maxNewlines
   843  	}
   844  	return n
   845  }
   846  
   847  func mayCombine(prev token.Token, next byte) (b bool) {
   848  	switch prev {
   849  	case token.INT:
   850  		b = next == '.' // 1.
   851  	case token.ADD:
   852  		b = next == '+' // ++
   853  	case token.SUB:
   854  		b = next == '-' // --
   855  	case token.QUO:
   856  		b = next == '*' // /*
   857  	case token.LSS:
   858  		b = next == '-' || next == '<' // <- or <<
   859  	case token.AND:
   860  		b = next == '&' || next == '^' // && or &^
   861  	}
   862  	return
   863  }
   864  
   865  // print prints a list of "items" (roughly corresponding to syntactic
   866  // tokens, but also including whitespace and formatting information).
   867  // It is the only print function that should be called directly from
   868  // any of the AST printing functions in nodes.go.
   869  //
   870  // Whitespace is accumulated until a non-whitespace token appears. Any
   871  // comments that need to appear before that token are printed first,
   872  // taking into account the amount and structure of any pending white-
   873  // space for best comment placement. Then, any leftover whitespace is
   874  // printed, followed by the actual token.
   875  //
   876  func (p *printer) print(args ...interface{}) {
   877  	for _, arg := range args {
   878  		// information about the current arg
   879  		var data string
   880  		var isLit bool
   881  		var impliedSemi bool // value for p.impliedSemi after this arg
   882  
   883  		// record previous opening token, if any
   884  		switch p.lastTok {
   885  		case token.ILLEGAL:
   886  			// ignore (white space)
   887  		case token.LPAREN, token.LBRACK:
   888  			p.prevOpen = p.lastTok
   889  		default:
   890  			// other tokens followed any opening token
   891  			p.prevOpen = token.ILLEGAL
   892  		}
   893  
   894  		switch x := arg.(type) {
   895  		case pmode:
   896  			// toggle printer mode
   897  			p.mode ^= x
   898  			continue
   899  
   900  		case whiteSpace:
   901  			if x == ignore {
   902  				// don't add ignore's to the buffer; they
   903  				// may screw up "correcting" unindents (see
   904  				// LabeledStmt)
   905  				continue
   906  			}
   907  			i := len(p.wsbuf)
   908  			if i == cap(p.wsbuf) {
   909  				// Whitespace sequences are very short so this should
   910  				// never happen. Handle gracefully (but possibly with
   911  				// bad comment placement) if it does happen.
   912  				p.writeWhitespace(i)
   913  				i = 0
   914  			}
   915  			p.wsbuf = p.wsbuf[0 : i+1]
   916  			p.wsbuf[i] = x
   917  			if x == newline || x == formfeed {
   918  				// newlines affect the current state (p.impliedSemi)
   919  				// and not the state after printing arg (impliedSemi)
   920  				// because comments can be interspersed before the arg
   921  				// in this case
   922  				p.impliedSemi = false
   923  			}
   924  			p.lastTok = token.ILLEGAL
   925  			continue
   926  
   927  		case *ast.Ident:
   928  			data = x.Name
   929  			impliedSemi = true
   930  			p.lastTok = token.IDENT
   931  
   932  		case *ast.BasicLit:
   933  			data = x.Value
   934  			isLit = true
   935  			impliedSemi = true
   936  			p.lastTok = x.Kind
   937  
   938  		case token.Token:
   939  			s := x.String()
   940  			if mayCombine(p.lastTok, s[0]) {
   941  				// the previous and the current token must be
   942  				// separated by a blank otherwise they combine
   943  				// into a different incorrect token sequence
   944  				// (except for token.INT followed by a '.' this
   945  				// should never happen because it is taken care
   946  				// of via binary expression formatting)
   947  				if len(p.wsbuf) != 0 {
   948  					p.internalError("whitespace buffer not empty")
   949  				}
   950  				p.wsbuf = p.wsbuf[0:1]
   951  				p.wsbuf[0] = ' '
   952  			}
   953  			data = s
   954  			// some keywords followed by a newline imply a semicolon
   955  			switch x {
   956  			case token.BREAK, token.CONTINUE, token.FALLTHROUGH, token.RETURN,
   957  				token.INC, token.DEC, token.RPAREN, token.RBRACK, token.RBRACE:
   958  				impliedSemi = true
   959  			}
   960  			p.lastTok = x
   961  
   962  		case token.Pos:
   963  			if x.IsValid() {
   964  				p.pos = p.posFor(x) // accurate position of next item
   965  			}
   966  			continue
   967  
   968  		case string:
   969  			// incorrect AST - print error message
   970  			data = x
   971  			isLit = true
   972  			impliedSemi = true
   973  			p.lastTok = token.STRING
   974  
   975  		default:
   976  			fmt.Fprintf(os.Stderr, "print: unsupported argument %v (%T)\n", arg, arg)
   977  			panic("go/printer type")
   978  		}
   979  		// data != ""
   980  
   981  		next := p.pos // estimated/accurate position of next item
   982  		wroteNewline, droppedFF := p.flush(next, p.lastTok)
   983  
   984  		// intersperse extra newlines if present in the source and
   985  		// if they don't cause extra semicolons (don't do this in
   986  		// flush as it will cause extra newlines at the end of a file)
   987  		if !p.impliedSemi {
   988  			n := nlimit(next.Line - p.pos.Line)
   989  			// don't exceed maxNewlines if we already wrote one
   990  			if wroteNewline && n == maxNewlines {
   991  				n = maxNewlines - 1
   992  			}
   993  			if n > 0 {
   994  				ch := byte('\n')
   995  				if droppedFF {
   996  					ch = '\f' // use formfeed since we dropped one before
   997  				}
   998  				p.writeByte(ch, n)
   999  				impliedSemi = false
  1000  			}
  1001  		}
  1002  
  1003  		// the next token starts now - record its line number if requested
  1004  		if p.linePtr != nil {
  1005  			*p.linePtr = p.out.Line
  1006  			p.linePtr = nil
  1007  		}
  1008  
  1009  		p.writeString(next, data, isLit)
  1010  		p.impliedSemi = impliedSemi
  1011  	}
  1012  }
  1013  
  1014  // flush prints any pending comments and whitespace occurring textually
  1015  // before the position of the next token tok. The flush result indicates
  1016  // if a newline was written or if a formfeed was dropped from the whitespace
  1017  // buffer.
  1018  //
  1019  func (p *printer) flush(next token.Position, tok token.Token) (wroteNewline, droppedFF bool) {
  1020  	if p.commentBefore(next) {
  1021  		// if there are comments before the next item, intersperse them
  1022  		wroteNewline, droppedFF = p.intersperseComments(next, tok)
  1023  	} else {
  1024  		// otherwise, write any leftover whitespace
  1025  		p.writeWhitespace(len(p.wsbuf))
  1026  	}
  1027  	return
  1028  }
  1029  
  1030  // getNode returns the ast.CommentGroup associated with n, if any.
  1031  func getDoc(n ast.Node) *ast.CommentGroup {
  1032  	switch n := n.(type) {
  1033  	case *ast.Field:
  1034  		return n.Doc
  1035  	case *ast.ImportSpec:
  1036  		return n.Doc
  1037  	case *ast.ValueSpec:
  1038  		return n.Doc
  1039  	case *ast.TypeSpec:
  1040  		return n.Doc
  1041  	case *ast.GenDecl:
  1042  		return n.Doc
  1043  	case *ast.FuncDecl:
  1044  		return n.Doc
  1045  	case *ast.File:
  1046  		return n.Doc
  1047  	}
  1048  	return nil
  1049  }
  1050  
  1051  func getLastComment(n ast.Node) *ast.CommentGroup {
  1052  	switch n := n.(type) {
  1053  	case *ast.Field:
  1054  		return n.Comment
  1055  	case *ast.ImportSpec:
  1056  		return n.Comment
  1057  	case *ast.ValueSpec:
  1058  		return n.Comment
  1059  	case *ast.TypeSpec:
  1060  		return n.Comment
  1061  	case *ast.GenDecl:
  1062  		if len(n.Specs) > 0 {
  1063  			return getLastComment(n.Specs[len(n.Specs)-1])
  1064  		}
  1065  	case *ast.File:
  1066  		if len(n.Comments) > 0 {
  1067  			return n.Comments[len(n.Comments)-1]
  1068  		}
  1069  	}
  1070  	return nil
  1071  }
  1072  
  1073  func (p *printer) printNode(node interface{}) error {
  1074  	// unpack *CommentedNode, if any
  1075  	var comments []*ast.CommentGroup
  1076  	if cnode, ok := node.(*CommentedNode); ok {
  1077  		node = cnode.Node
  1078  		comments = cnode.Comments
  1079  	}
  1080  
  1081  	if comments != nil {
  1082  		// commented node - restrict comment list to relevant range
  1083  		n, ok := node.(ast.Node)
  1084  		if !ok {
  1085  			goto unsupported
  1086  		}
  1087  		beg := n.Pos()
  1088  		end := n.End()
  1089  		// if the node has associated documentation,
  1090  		// include that commentgroup in the range
  1091  		// (the comment list is sorted in the order
  1092  		// of the comment appearance in the source code)
  1093  		if doc := getDoc(n); doc != nil {
  1094  			beg = doc.Pos()
  1095  		}
  1096  		if com := getLastComment(n); com != nil {
  1097  			if e := com.End(); e > end {
  1098  				end = e
  1099  			}
  1100  		}
  1101  		// token.Pos values are global offsets, we can
  1102  		// compare them directly
  1103  		i := 0
  1104  		for i < len(comments) && comments[i].End() < beg {
  1105  			i++
  1106  		}
  1107  		j := i
  1108  		for j < len(comments) && comments[j].Pos() < end {
  1109  			j++
  1110  		}
  1111  		if i < j {
  1112  			p.comments = comments[i:j]
  1113  		}
  1114  	} else if n, ok := node.(*ast.File); ok {
  1115  		// use ast.File comments, if any
  1116  		p.comments = n.Comments
  1117  	}
  1118  
  1119  	// if there are no comments, use node comments
  1120  	p.useNodeComments = p.comments == nil
  1121  
  1122  	// get comments ready for use
  1123  	p.nextComment()
  1124  
  1125  	// format node
  1126  	switch n := node.(type) {
  1127  	case ast.Expr:
  1128  		p.expr(n)
  1129  	case ast.Stmt:
  1130  		// A labeled statement will un-indent to position the label.
  1131  		// Set p.indent to 1 so we don't get indent "underflow".
  1132  		if _, ok := n.(*ast.LabeledStmt); ok {
  1133  			p.indent = 1
  1134  		}
  1135  		p.stmt(n, false)
  1136  	case ast.Decl:
  1137  		p.decl(n)
  1138  	case ast.Spec:
  1139  		p.spec(n, 1, false)
  1140  	case []ast.Stmt:
  1141  		// A labeled statement will un-indent to position the label.
  1142  		// Set p.indent to 1 so we don't get indent "underflow".
  1143  		for _, s := range n {
  1144  			if _, ok := s.(*ast.LabeledStmt); ok {
  1145  				p.indent = 1
  1146  			}
  1147  		}
  1148  		p.stmtList(n, 0, false)
  1149  	case []ast.Decl:
  1150  		p.declList(n)
  1151  	case *ast.File:
  1152  		p.file(n)
  1153  	default:
  1154  		goto unsupported
  1155  	}
  1156  
  1157  	return nil
  1158  
  1159  unsupported:
  1160  	return fmt.Errorf("go/printer: unsupported node type %T", node)
  1161  }
  1162  
  1163  // ----------------------------------------------------------------------------
  1164  // Trimmer
  1165  
  1166  // A trimmer is an io.Writer filter for stripping tabwriter.Escape
  1167  // characters, trailing blanks and tabs, and for converting formfeed
  1168  // and vtab characters into newlines and htabs (in case no tabwriter
  1169  // is used). Text bracketed by tabwriter.Escape characters is passed
  1170  // through unchanged.
  1171  //
  1172  type trimmer struct {
  1173  	output io.Writer
  1174  	state  int
  1175  	space  []byte
  1176  }
  1177  
  1178  // trimmer is implemented as a state machine.
  1179  // It can be in one of the following states:
  1180  const (
  1181  	inSpace  = iota // inside space
  1182  	inEscape        // inside text bracketed by tabwriter.Escapes
  1183  	inText          // inside text
  1184  )
  1185  
  1186  func (p *trimmer) resetSpace() {
  1187  	p.state = inSpace
  1188  	p.space = p.space[0:0]
  1189  }
  1190  
  1191  // Design note: It is tempting to eliminate extra blanks occurring in
  1192  //              whitespace in this function as it could simplify some
  1193  //              of the blanks logic in the node printing functions.
  1194  //              However, this would mess up any formatting done by
  1195  //              the tabwriter.
  1196  
  1197  var aNewline = []byte("\n")
  1198  
  1199  func (p *trimmer) Write(data []byte) (n int, err error) {
  1200  	// invariants:
  1201  	// p.state == inSpace:
  1202  	//	p.space is unwritten
  1203  	// p.state == inEscape, inText:
  1204  	//	data[m:n] is unwritten
  1205  	m := 0
  1206  	var b byte
  1207  	for n, b = range data {
  1208  		if b == '\v' {
  1209  			b = '\t' // convert to htab
  1210  		}
  1211  		switch p.state {
  1212  		case inSpace:
  1213  			switch b {
  1214  			case '\t', ' ':
  1215  				p.space = append(p.space, b)
  1216  			case '\n', '\f':
  1217  				p.resetSpace() // discard trailing space
  1218  				_, err = p.output.Write(aNewline)
  1219  			case tabwriter.Escape:
  1220  				_, err = p.output.Write(p.space)
  1221  				p.state = inEscape
  1222  				m = n + 1 // +1: skip tabwriter.Escape
  1223  			default:
  1224  				_, err = p.output.Write(p.space)
  1225  				p.state = inText
  1226  				m = n
  1227  			}
  1228  		case inEscape:
  1229  			if b == tabwriter.Escape {
  1230  				_, err = p.output.Write(data[m:n])
  1231  				p.resetSpace()
  1232  			}
  1233  		case inText:
  1234  			switch b {
  1235  			case '\t', ' ':
  1236  				_, err = p.output.Write(data[m:n])
  1237  				p.resetSpace()
  1238  				p.space = append(p.space, b)
  1239  			case '\n', '\f':
  1240  				_, err = p.output.Write(data[m:n])
  1241  				p.resetSpace()
  1242  				if err == nil {
  1243  					_, err = p.output.Write(aNewline)
  1244  				}
  1245  			case tabwriter.Escape:
  1246  				_, err = p.output.Write(data[m:n])
  1247  				p.state = inEscape
  1248  				m = n + 1 // +1: skip tabwriter.Escape
  1249  			}
  1250  		default:
  1251  			panic("unreachable")
  1252  		}
  1253  		if err != nil {
  1254  			return
  1255  		}
  1256  	}
  1257  	n = len(data)
  1258  
  1259  	switch p.state {
  1260  	case inEscape, inText:
  1261  		_, err = p.output.Write(data[m:n])
  1262  		p.resetSpace()
  1263  	}
  1264  
  1265  	return
  1266  }
  1267  
  1268  // ----------------------------------------------------------------------------
  1269  // Public interface
  1270  
  1271  // A Mode value is a set of flags (or 0). They control printing.
  1272  type Mode uint
  1273  
  1274  const (
  1275  	RawFormat Mode = 1 << iota // do not use a tabwriter; if set, UseSpaces is ignored
  1276  	TabIndent                  // use tabs for indentation independent of UseSpaces
  1277  	UseSpaces                  // use spaces instead of tabs for alignment
  1278  	SourcePos                  // emit //line directives to preserve original source positions
  1279  )
  1280  
  1281  // A Config node controls the output of Fprint.
  1282  type Config struct {
  1283  	Mode     Mode // default: 0
  1284  	Tabwidth int  // default: 8
  1285  	Indent   int  // default: 0 (all code is indented at least by this much)
  1286  }
  1287  
  1288  // fprint implements Fprint and takes a nodesSizes map for setting up the printer state.
  1289  func (cfg *Config) fprint(output io.Writer, fset *token.FileSet, node interface{}, nodeSizes map[ast.Node]int) (err error) {
  1290  	// print node
  1291  	var p printer
  1292  	p.init(cfg, fset, nodeSizes)
  1293  	if err = p.printNode(node); err != nil {
  1294  		return
  1295  	}
  1296  	// print outstanding comments
  1297  	p.impliedSemi = false // EOF acts like a newline
  1298  	p.flush(token.Position{Offset: infinity, Line: infinity}, token.EOF)
  1299  
  1300  	// redirect output through a trimmer to eliminate trailing whitespace
  1301  	// (Input to a tabwriter must be untrimmed since trailing tabs provide
  1302  	// formatting information. The tabwriter could provide trimming
  1303  	// functionality but no tabwriter is used when RawFormat is set.)
  1304  	output = &trimmer{output: output}
  1305  
  1306  	// redirect output through a tabwriter if necessary
  1307  	if cfg.Mode&RawFormat == 0 {
  1308  		minwidth := cfg.Tabwidth
  1309  
  1310  		padchar := byte('\t')
  1311  		if cfg.Mode&UseSpaces != 0 {
  1312  			padchar = ' '
  1313  		}
  1314  
  1315  		twmode := tabwriter.DiscardEmptyColumns
  1316  		if cfg.Mode&TabIndent != 0 {
  1317  			minwidth = 0
  1318  			twmode |= tabwriter.TabIndent
  1319  		}
  1320  
  1321  		output = tabwriter.NewWriter(output, minwidth, cfg.Tabwidth, 1, padchar, twmode)
  1322  	}
  1323  
  1324  	// write printer result via tabwriter/trimmer to output
  1325  	if _, err = output.Write(p.output); err != nil {
  1326  		return
  1327  	}
  1328  
  1329  	// flush tabwriter, if any
  1330  	if tw, _ := output.(*tabwriter.Writer); tw != nil {
  1331  		err = tw.Flush()
  1332  	}
  1333  
  1334  	return
  1335  }
  1336  
  1337  // A CommentedNode bundles an AST node and corresponding comments.
  1338  // It may be provided as argument to any of the Fprint functions.
  1339  //
  1340  type CommentedNode struct {
  1341  	Node     interface{} // *ast.File, or ast.Expr, ast.Decl, ast.Spec, or ast.Stmt
  1342  	Comments []*ast.CommentGroup
  1343  }
  1344  
  1345  // Fprint "pretty-prints" an AST node to output for a given configuration cfg.
  1346  // Position information is interpreted relative to the file set fset.
  1347  // The node type must be *ast.File, *CommentedNode, []ast.Decl, []ast.Stmt,
  1348  // or assignment-compatible to ast.Expr, ast.Decl, ast.Spec, or ast.Stmt.
  1349  //
  1350  func (cfg *Config) Fprint(output io.Writer, fset *token.FileSet, node interface{}) error {
  1351  	return cfg.fprint(output, fset, node, make(map[ast.Node]int))
  1352  }
  1353  
  1354  // Fprint "pretty-prints" an AST node to output.
  1355  // It calls Config.Fprint with default settings.
  1356  // Note that gofmt uses tabs for indentation but spaces for alignment;
  1357  // use format.Node (package go/format) for output that matches gofmt.
  1358  //
  1359  func Fprint(output io.Writer, fset *token.FileSet, node interface{}) error {
  1360  	return (&Config{Tabwidth: 8}).Fprint(output, fset, node)
  1361  }
  1362  

View as plain text