~ubuntu-branches/ubuntu/utopic/golang/utopic

// Copyright 2009 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// Package printer implements printing of AST nodes.

package printer

import (

	"fmt"

	"go/ast"

	"go/token"

	"io"

	"os"

	"strconv"

	"strings"

	"text/tabwriter"

	"unicode"

)

const (

	maxNewlines = 2     // max. number of newlines between source text

	debug       = false // enable for debugging

	infinity    = 1 << 30

)

type whiteSpace byte

const (

	ignore   = whiteSpace(0)

	blank    = whiteSpace(' ')

	vtab     = whiteSpace('\v')

	newline  = whiteSpace('\n')

	formfeed = whiteSpace('\f')

	indent   = whiteSpace('>')

	unindent = whiteSpace('<')

)

// A pmode value represents the current printer mode.

type pmode int

const (

	noExtraLinebreak pmode = 1 << iota

)

type printer struct {

	// Configuration (does not change after initialization)

	Config

	fset *token.FileSet

	// Current state

	output      []byte       // raw printer result

	indent      int          // current indentation

	mode        pmode        // current printer mode

	impliedSemi bool         // if set, a linebreak implies a semicolon

	lastTok     token.Token  // the last token printed (token.ILLEGAL if it's whitespace)

	wsbuf       []whiteSpace // delayed white space

	// Positions

	// The out position differs from the pos position when the result

	// formatting differs from the source formatting (in the amount of

	// white space). If there's a difference and SourcePos is set in

	// ConfigMode, //line comments are used in the output to restore

	// original source positions for a reader.

	pos  token.Position // current position in AST (source) space

	out  token.Position // current position in output space

	last token.Position // value of pos after calling writeString

	// The list of all source comments, in order of appearance.

	comments        []*ast.CommentGroup // may be nil

	cindex          int                 // current comment index

	useNodeComments bool                // if not set, ignore lead and line comments of nodes

	// Information about p.comments[p.cindex]; set up by nextComment.

	comment        *ast.CommentGroup // = p.comments[p.cindex]; or nil

	commentOffset  int               // = p.posFor(p.comments[p.cindex].List[0].Pos()).Offset; or infinity

	commentNewline bool              // true if the comment group contains newlines

	// Cache of already computed node sizes.

	nodeSizes map[ast.Node]int

	// Cache of most recently computed line position.

	cachedPos  token.Pos

	cachedLine int // line corresponding to cachedPos

}

func (p *printer) init(cfg *Config, fset *token.FileSet, nodeSizes map[ast.Node]int) {

	p.Config = *cfg

	p.fset = fset

	p.pos = token.Position{Line: 1, Column: 1}

	p.out = token.Position{Line: 1, Column: 1}

	p.wsbuf = make([]whiteSpace, 0, 16) // whitespace sequences are short

	p.nodeSizes = nodeSizes

	p.cachedPos = -1

}

// commentsHaveNewline reports whether a list of comments belonging to

// an *ast.CommentGroup contains newlines. Because the position information

// may only be partially correct, we also have to read the comment text.

func (p *printer) commentsHaveNewline(list []*ast.Comment) bool {

	// len(list) > 0

	line := p.lineFor(list[0].Pos())

	for i, c := range list {

		if i > 0 && p.lineFor(list[i].Pos()) != line {

			// not all comments on the same line

			return true

		}

		if t := c.Text; len(t) >= 2 && (t[1] == '/' || strings.Contains(t, "\n")) {

			return true

		}

	}

	_ = line

	return false

}

func (p *printer) nextComment() {

	for p.cindex < len(p.comments) {

		c := p.comments[p.cindex]

		p.cindex++

		if list := c.List; len(list) > 0 {

			p.comment = c

			p.commentOffset = p.posFor(list[0].Pos()).Offset

			p.commentNewline = p.commentsHaveNewline(list)

			return

		}

		// we should not reach here (correct ASTs don't have empty

		// ast.CommentGroup nodes), but be conservative and try again

	}

	// no more comments

	p.commentOffset = infinity

}

func (p *printer) internalError(msg ...interface{}) {

	if debug {

		fmt.Print(p.pos.String() + ": ")

		fmt.Println(msg...)

		panic("go/printer")

	}

}

func (p *printer) posFor(pos token.Pos) token.Position {

	// not used frequently enough to cache entire token.Position

	return p.fset.Position(pos)

}

func (p *printer) lineFor(pos token.Pos) int {

	if pos != p.cachedPos {

		p.cachedPos = pos

		p.cachedLine = p.fset.Position(pos).Line

	}

	return p.cachedLine

}

// atLineBegin emits a //line comment if necessary and prints indentation.

func (p *printer) atLineBegin(pos token.Position) {

	// write a //line comment if necessary

	if p.Config.Mode&SourcePos != 0 && pos.IsValid() && (p.out.Line != pos.Line || p.out.Filename != pos.Filename) {

		p.output = append(p.output, tabwriter.Escape) // protect '\n' in //line from tabwriter interpretation

		p.output = append(p.output, fmt.Sprintf("//line %s:%d\n", pos.Filename, pos.Line)...)

		p.output = append(p.output, tabwriter.Escape)

		// p.out must match the //line comment

		p.out.Filename = pos.Filename

		p.out.Line = pos.Line

	}

	// write indentation

	// use "hard" htabs - indentation columns

	// must not be discarded by the tabwriter

	n := p.Config.Indent + p.indent // include base indentation

	for i := 0; i < n; i++ {

		p.output = append(p.output, '\t')

	}

	// update positions

	p.pos.Offset += n

	p.pos.Column += n

	p.out.Column += n

}

// writeByte writes ch n times to p.output and updates p.pos.

func (p *printer) writeByte(ch byte, n int) {

	if p.out.Column == 1 {

		p.atLineBegin(p.pos)

	}

	for i := 0; i < n; i++ {

		p.output = append(p.output, ch)

	}

	// update positions

	p.pos.Offset += n

	if ch == '\n' || ch == '\f' {

		p.pos.Line += n

		p.out.Line += n

		p.pos.Column = 1

		p.out.Column = 1

		return

	}

	p.pos.Column += n

	p.out.Column += n

}

// writeString writes the string s to p.output and updates p.pos, p.out,

// and p.last. If isLit is set, s is escaped w/ tabwriter.Escape characters

// to protect s from being interpreted by the tabwriter.

//

// Note: writeString is only used to write Go tokens, literals, and

// comments, all of which must be written literally. Thus, it is correct

// to always set isLit = true. However, setting it explicitly only when

// needed (i.e., when we don't know that s contains no tabs or line breaks)

// avoids processing extra escape characters and reduces run time of the

// printer benchmark by up to 10%.

//

func (p *printer) writeString(pos token.Position, s string, isLit bool) {

	if p.out.Column == 1 {

		p.atLineBegin(pos)

	}

	if pos.IsValid() {

		// update p.pos (if pos is invalid, continue with existing p.pos)

		// Note: Must do this after handling line beginnings because

		// atLineBegin updates p.pos if there's indentation, but p.pos

		// is the position of s.

		p.pos = pos

	}

	if isLit {

		// Protect s such that is passes through the tabwriter

		// unchanged. Note that valid Go programs cannot contain

		// tabwriter.Escape bytes since they do not appear in legal

		// UTF-8 sequences.

		p.output = append(p.output, tabwriter.Escape)

	}

	if debug {

		p.output = append(p.output, fmt.Sprintf("/*%s*/", pos)...) // do not update p.pos!

	}

	p.output = append(p.output, s...)

	// update positions

	nlines := 0

	var li int // index of last newline; valid if nlines > 0

	for i := 0; i < len(s); i++ {

		// Go tokens cannot contain '\f' - no need to look for it

		if s[i] == '\n' {

			nlines++

			li = i

		}

	}

	p.pos.Offset += len(s)

	if nlines > 0 {

		p.pos.Line += nlines

		p.out.Line += nlines

		c := len(s) - li

		p.pos.Column = c

		p.out.Column = c

	} else {

		p.pos.Column += len(s)

		p.out.Column += len(s)

	}

	if isLit {

		p.output = append(p.output, tabwriter.Escape)

	}

	p.last = p.pos

}

// writeCommentPrefix writes the whitespace before a comment.

// If there is any pending whitespace, it consumes as much of

// it as is likely to help position the comment nicely.

// pos is the comment position, next the position of the item

// after all pending comments, prev is the previous comment in

// a group of comments (or nil), and tok is the next token.

//

func (p *printer) writeCommentPrefix(pos, next token.Position, prev, comment *ast.Comment, tok token.Token) {

	if len(p.output) == 0 {

		// the comment is the first item to be printed - don't write any whitespace

		return

	}

	if pos.IsValid() && pos.Filename != p.last.Filename {

		// comment in a different file - separate with newlines

		p.writeByte('\f', maxNewlines)

		return

	}

	if pos.Line == p.last.Line && (prev == nil || prev.Text[1] != '/') {

		// comment on the same line as last item:

		// separate with at least one separator

		hasSep := false

		if prev == nil {

			// first comment of a comment group

			j := 0

			for i, ch := range p.wsbuf {

				switch ch {

				case blank:

					// ignore any blanks before a comment

					p.wsbuf[i] = ignore

					continue

				case vtab:

					// respect existing tabs - important

					// for proper formatting of commented structs

					hasSep = true

					continue

				case indent:

					// apply pending indentation

					continue

				}

				j = i

				break

			}

			p.writeWhitespace(j)

		}

		// make sure there is at least one separator

		if !hasSep {

			sep := byte('\t')

			if pos.Line == next.Line {

				// next item is on the same line as the comment

				// (which must be a /*-style comment): separate

				// with a blank instead of a tab

				sep = ' '

			}

			p.writeByte(sep, 1)

		}

	} else {

		// comment on a different line:

		// separate with at least one line break

		droppedLinebreak := false

		j := 0

		for i, ch := range p.wsbuf {

			switch ch {

			case blank, vtab:

				// ignore any horizontal whitespace before line breaks

				p.wsbuf[i] = ignore

				continue

			case indent:

				// apply pending indentation

				continue

			case unindent:

				// if this is not the last unindent, apply it

				// as it is (likely) belonging to the last

				// construct (e.g., a multi-line expression list)

				// and is not part of closing a block

				if i+1 < len(p.wsbuf) && p.wsbuf[i+1] == unindent {

					continue

				}

				// if the next token is not a closing }, apply the unindent

				// if it appears that the comment is aligned with the

				// token; otherwise assume the unindent is part of a

				// closing block and stop (this scenario appears with

				// comments before a case label where the comments

				// apply to the next case instead of the current one)

				if tok != token.RBRACE && pos.Column == next.Column {

					continue

				}

			case newline, formfeed:

				p.wsbuf[i] = ignore

				droppedLinebreak = prev == nil // record only if first comment of a group

			}

			j = i

			break

		}

		p.writeWhitespace(j)

		// determine number of linebreaks before the comment

		n := 0

		if pos.IsValid() && p.last.IsValid() {

			n = pos.Line - p.last.Line

			if n < 0 { // should never happen

				n = 0

			}

		}

		// at the package scope level only (p.indent == 0),

		// add an extra newline if we dropped one before:

		// this preserves a blank line before documentation

		// comments at the package scope level (issue 2570)

		if p.indent == 0 && droppedLinebreak {

			n++

		}

		// make sure there is at least one line break

		// if the previous comment was a line comment

		if n == 0 && prev != nil && prev.Text[1] == '/' {

			n = 1

		}

		if n > 0 {

			// use formfeeds to break columns before a comment;

			// this is analogous to using formfeeds to separate

			// individual lines of /*-style comments

			p.writeByte('\f', nlimit(n))

		}

	}

}

// Returns true if s contains only white space

// (only tabs and blanks can appear in the printer's context).

//

func isBlank(s string) bool {

	for i := 0; i < len(s); i++ {

		if s[i] > ' ' {

			return false

		}

	}

	return true

}

// commonPrefix returns the common prefix of a and b.

func commonPrefix(a, b string) string {

	i := 0

	for i < len(a) && i < len(b) && a[i] == b[i] && (a[i] <= ' ' || a[i] == '*') {

		i++

	}

	return a[0:i]

}

// trimRight returns s with trailing whitespace removed.

func trimRight(s string) string {

	return strings.TrimRightFunc(s, unicode.IsSpace)

}

// stripCommonPrefix removes a common prefix from /*-style comment lines (unless no

// comment line is indented, all but the first line have some form of space prefix).

// The prefix is computed using heuristics such that is likely that the comment

// contents are nicely laid out after re-printing each line using the printer's

// current indentation.

//

func stripCommonPrefix(lines []string) {

	if len(lines) <= 1 {

		return // at most one line - nothing to do

	}

	// len(lines) > 1

	// The heuristic in this function tries to handle a few

	// common patterns of /*-style comments: Comments where

	// the opening /* and closing */ are aligned and the

	// rest of the comment text is aligned and indented with

	// blanks or tabs, cases with a vertical "line of stars"

	// on the left, and cases where the closing */ is on the

	// same line as the last comment text.

	// Compute maximum common white prefix of all but the first,

	// last, and blank lines, and replace blank lines with empty

	// lines (the first line starts with /* and has no prefix).

	// In case of two-line comments, consider the last line for

	// the prefix computation since otherwise the prefix would

	// be empty.

	//

	// Note that the first and last line are never empty (they

	// contain the opening /* and closing */ respectively) and

	// thus they can be ignored by the blank line check.

	var prefix string

	if len(lines) > 2 {

		first := true

		for i, line := range lines[1 : len(lines)-1] {

			switch {

			case isBlank(line):

				lines[1+i] = "" // range starts with lines[1]

			case first:

				prefix = commonPrefix(line, line)

				first = false

			default:

				prefix = commonPrefix(prefix, line)

			}

		}

	} else { // len(lines) == 2, lines cannot be blank (contain /* and */)

		line := lines[1]

		prefix = commonPrefix(line, line)

	}

	/*

	 * Check for vertical "line of stars" and correct prefix accordingly.

	 */

	lineOfStars := false

	if i := strings.Index(prefix, "*"); i >= 0 {

		// Line of stars present.

		if i > 0 && prefix[i-1] == ' ' {

			i-- // remove trailing blank from prefix so stars remain aligned

		}

		prefix = prefix[0:i]

		lineOfStars = true

	} else {

		// No line of stars present.

		// Determine the white space on the first line after the /*

		// and before the beginning of the comment text, assume two

		// blanks instead of the /* unless the first character after

		// the /* is a tab. If the first comment line is empty but

		// for the opening /*, assume up to 3 blanks or a tab. This

		// whitespace may be found as suffix in the common prefix.

		first := lines[0]

		if isBlank(first[2:]) {

			// no comment text on the first line:

			// reduce prefix by up to 3 blanks or a tab

			// if present - this keeps comment text indented

			// relative to the /* and */'s if it was indented

			// in the first place

			i := len(prefix)

			for n := 0; n < 3 && i > 0 && prefix[i-1] == ' '; n++ {

				i--

			}

			if i == len(prefix) && i > 0 && prefix[i-1] == '\t' {

				i--

			}

			prefix = prefix[0:i]

		} else {

			// comment text on the first line

			suffix := make([]byte, len(first))

			n := 2 // start after opening /*

			for n < len(first) && first[n] <= ' ' {

				suffix[n] = first[n]

				n++

			}

			if n > 2 && suffix[2] == '\t' {

				// assume the '\t' compensates for the /*

				suffix = suffix[2:n]

			} else {

				// otherwise assume two blanks

				suffix[0], suffix[1] = ' ', ' '

				suffix = suffix[0:n]

			}

			// Shorten the computed common prefix by the length of

			// suffix, if it is found as suffix of the prefix.

			prefix = strings.TrimSuffix(prefix, string(suffix))

		}

	}

	// Handle last line: If it only contains a closing */, align it

	// with the opening /*, otherwise align the text with the other

	// lines.

	last := lines[len(lines)-1]

	closing := "*/"

	i := strings.Index(last, closing) // i >= 0 (closing is always present)

	if isBlank(last[0:i]) {

		// last line only contains closing */

		if lineOfStars {

			closing = " */" // add blank to align final star

		}

		lines[len(lines)-1] = prefix + closing

	} else {

		// last line contains more comment text - assume

		// it is aligned like the other lines and include

		// in prefix computation

		prefix = commonPrefix(prefix, last)

	}

	// Remove the common prefix from all but the first and empty lines.

	for i, line := range lines {

		if i > 0 && line != "" {

			lines[i] = line[len(prefix):]

		}

	}

}

func (p *printer) writeComment(comment *ast.Comment) {

	text := comment.Text

	pos := p.posFor(comment.Pos())

	const linePrefix = "//line "

	if strings.HasPrefix(text, linePrefix) && (!pos.IsValid() || pos.Column == 1) {

		// possibly a line directive

		ldir := strings.TrimSpace(text[len(linePrefix):])

		if i := strings.LastIndex(ldir, ":"); i >= 0 {

			if line, err := strconv.Atoi(ldir[i+1:]); err == nil && line > 0 {

				// The line directive we are about to print changed

				// the Filename and Line number used for subsequent

				// tokens. We have to update our AST-space position

				// accordingly and suspend indentation temporarily.

				indent := p.indent

				p.indent = 0

				defer func() {

					p.pos.Filename = ldir[:i]

					p.pos.Line = line

					p.pos.Column = 1

					p.indent = indent

				}()

			}

		}

	}

	// shortcut common case of //-style comments

	if text[1] == '/' {

		p.writeString(pos, trimRight(text), true)

		return

	}

	// for /*-style comments, print line by line and let the

	// write function take care of the proper indentation

	lines := strings.Split(text, "\n")

	// The comment started in the first column but is going

	// to be indented. For an idempotent result, add indentation

	// to all lines such that they look like they were indented

	// before - this will make sure the common prefix computation

	// is the same independent of how many times formatting is

	// applied (was issue 1835).

	if pos.IsValid() && pos.Column == 1 && p.indent > 0 {

		for i, line := range lines[1:] {

			lines[1+i] = "   " + line

		}

	}

	stripCommonPrefix(lines)

	// write comment lines, separated by formfeed,

	// without a line break after the last line

	for i, line := range lines {

		if i > 0 {

			p.writeByte('\f', 1)

			pos = p.pos

		}

		if len(line) > 0 {

			p.writeString(pos, trimRight(line), true)

		}

	}

}

// writeCommentSuffix writes a line break after a comment if indicated

// and processes any leftover indentation information. If a line break

// is needed, the kind of break (newline vs formfeed) depends on the

// pending whitespace. The writeCommentSuffix result indicates if a

// newline was written or if a formfeed was dropped from the whitespace

// buffer.

//

func (p *printer) writeCommentSuffix(needsLinebreak bool) (wroteNewline, droppedFF bool) {

	for i, ch := range p.wsbuf {

		switch ch {

		case blank, vtab:

			// ignore trailing whitespace

			p.wsbuf[i] = ignore

		case indent, unindent:

			// don't lose indentation information

		case newline, formfeed:

			// if we need a line break, keep exactly one

			// but remember if we dropped any formfeeds

			if needsLinebreak {

				needsLinebreak = false

				wroteNewline = true

			} else {

				if ch == formfeed {

					droppedFF = true

				}

				p.wsbuf[i] = ignore

			}

		}

	}

	p.writeWhitespace(len(p.wsbuf))

	// make sure we have a line break

	if needsLinebreak {

		p.writeByte('\n', 1)

		wroteNewline = true

	}

	return

}

// intersperseComments consumes all comments that appear before the next token

// tok and prints it together with the buffered whitespace (i.e., the whitespace

// that needs to be written before the next token). A heuristic is used to mix

// the comments and whitespace. The intersperseComments result indicates if a

// newline was written or if a formfeed was dropped from the whitespace buffer.

//

func (p *printer) intersperseComments(next token.Position, tok token.Token) (wroteNewline, droppedFF bool) {

	var last *ast.Comment

	for p.commentBefore(next) {

		for _, c := range p.comment.List {

			p.writeCommentPrefix(p.posFor(c.Pos()), next, last, c, tok)

			p.writeComment(c)

			last = c

		}

		p.nextComment()

	}

	if last != nil {

		// if the last comment is a /*-style comment and the next item

		// follows on the same line but is not a comma or a "closing"

		// token, add an extra blank for separation

		if last.Text[1] == '*' && p.lineFor(last.Pos()) == next.Line && tok != token.COMMA &&

			tok != token.RPAREN && tok != token.RBRACK && tok != token.RBRACE {

			p.writeByte(' ', 1)

		}

		// ensure that there is a line break after a //-style comment,

		// before a closing '}' unless explicitly disabled, or at eof

		needsLinebreak :=

			last.Text[1] == '/' ||

				tok == token.RBRACE && p.mode&noExtraLinebreak == 0 ||

				tok == token.EOF

		return p.writeCommentSuffix(needsLinebreak)

	}

	// no comment was written - we should never reach here since

	// intersperseComments should not be called in that case

	p.internalError("intersperseComments called without pending comments")

	return

}

// whiteWhitespace writes the first n whitespace entries.

func (p *printer) writeWhitespace(n int) {

	// write entries

	for i := 0; i < n; i++ {

		switch ch := p.wsbuf[i]; ch {

		case ignore:

			// ignore!

		case indent:

			p.indent++

		case unindent:

			p.indent--

			if p.indent < 0 {

				p.internalError("negative indentation:", p.indent)

				p.indent = 0

			}

		case newline, formfeed:

			// A line break immediately followed by a "correcting"

			// unindent is swapped with the unindent - this permits

			// proper label positioning. If a comment is between

			// the line break and the label, the unindent is not

			// part of the comment whitespace prefix and the comment

			// will be positioned correctly indented.

			if i+1 < n && p.wsbuf[i+1] == unindent {