Subversion Repositories openrisc

// 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 (

        "bytes"

        "fmt"

        "go/ast"

        "go/token"

        "io"

        "os"

        "strconv"

        "strings"

        "text/tabwriter"

)

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('<')

)

// Use ignoreMultiLine if the multiLine information is not important.

var ignoreMultiLine = new(bool)

// 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      bytes.Buffer // 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

        // The (possibly estimated) position in the generated output;

        // in AST space (i.e., pos is set whenever a token position is

        // known accurately, and updated dependending on what has been

        // written).

        pos token.Position

        // The value of pos immediately after the last item has been

        // written using writeItem.

        last token.Position

        // 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.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

}

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

func (p *printer) writeByte(ch byte) {

        p.output.WriteByte(ch)

        p.pos.Offset++

        p.pos.Column++

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

                // write indentation

                // use "hard" htabs - indentation columns

                // must not be discarded by the tabwriter

                const htabs = "\t\t\t\t\t\t\t\t"

                j := p.indent

                for j > len(htabs) {

                        p.output.WriteString(htabs)

                        j -= len(htabs)

                }

                p.output.WriteString(htabs[0:j])

                // update p.pos

                p.pos.Line++

                p.pos.Offset += p.indent

                p.pos.Column = 1 + p.indent

        }

}

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

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

        for n > 0 {

                p.writeByte(ch)

                n--

        }

}

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

// 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(s string, isLit bool) {

        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.WriteByte(tabwriter.Escape)

        }

        p.output.WriteString(s)

        // update p.pos

        nlines := 0

        column := p.pos.Column + len(s)

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

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

                        nlines++

                        column = len(s) - i

                }

        }

        p.pos.Offset += len(s)

        p.pos.Line += nlines

        p.pos.Column = column

        if isLit {

                p.output.WriteByte(tabwriter.Escape)

        }

}

// writeItem writes data at position pos. data is the text corresponding to

// a single lexical token, but may also be comment text. pos is the actual

// (or at least very accurately estimated) position of the data in the original

// source text. writeItem updates p.last to the position immediately following

// the data.

//

func (p *printer) writeItem(pos token.Position, data string, isLit bool) {

        if pos.IsValid() {

                // continue with previous position if we don't have a valid pos

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

                        // the file has changed - reset state

                        // (used when printing merged ASTs of different files

                        // e.g., the result of ast.MergePackageFiles)

                        p.indent = 0

                        p.mode = 0

                        p.wsbuf = p.wsbuf[0:0]

                }

                p.pos = pos

        }

        if debug {

                // do not update p.pos - use write0

                fmt.Fprintf(&p.output, "/*%s*/", pos)

        }

        p.writeString(data, isLit)

        p.last = p.pos

}

const linePrefix = "//line "

// 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 isKeyword indicates if the

// next item is a keyword.

//

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

        if p.output.Len() == 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.writeByteN('\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)

                }

        } else {

                // comment on a different line:

                // separate with at least one line break

                droppedLinebreak := false

                if prev == nil {

                        // first comment of a comment group

                        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 the next token is a keyword, apply the outdent

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

                                        // keyword; otherwise assume the outdent 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 isKeyword && pos.Column == next.Column {

                                                continue

                                        }

                                case newline, formfeed:

                                        // TODO(gri): may want to keep formfeed info in some cases

                                        p.wsbuf[i] = ignore

                                        droppedLinebreak = true

                                }

                                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 {

                        // turn off indent if we're about to print a line directive

                        indent := p.indent

                        if strings.HasPrefix(comment.Text, linePrefix) {

                                p.indent = 0

                        }

                        // use formfeeds to break columns before a comment;

                        // this is analogous to using formfeeds to separate

                        // individual lines of /*-style comments

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

                        p.indent = indent // restore indent

                }

        }

}

// Split comment text into lines

// (using strings.Split(text, "\n") is significantly slower for

// this specific purpose, as measured with: gotest -bench=Print)

func split(text string) []string {

        // count lines (comment text never ends in a newline)

        n := 1

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

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

                        n++

                }

        }

        // split

        lines := make([]string, n)

        n = 0

        i := 0

        for j := 0; j < len(text); j++ {

                if text[j] == '\n' {

                        lines[n] = text[i:j] // exclude newline

                        i = j + 1            // discard newline

                        n++

                }

        }

        lines[n] = text[i:]

        return lines

}

// 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

}

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]

}

func stripCommonPrefix(lines []string) {

        if len(lines) < 2 {

                return // at most one line - nothing to do

        }

        // len(lines) >= 2

        // 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 at line 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.

                        if strings.HasSuffix(prefix, string(suffix)) {

                                prefix = prefix[0 : len(prefix)-len(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[1:] {

                if len(line) != 0 {

                        lines[1+i] = line[len(prefix):] // range starts at line 1

                }

        }

}

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

        text := comment.Text

        if strings.HasPrefix(text, linePrefix) {

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

                i := strings.LastIndex(pos, ":")

                if i >= 0 {

                        // The line directive we are about to print changed

                        // the Filename and Line number used by go/token

                        // as it was reading the input originally.

                        // In order to match the original input, we have to

                        // update our own idea of the file and line number

                        // accordingly, after printing the directive.

                        file := pos[:i]

                        line, _ := strconv.Atoi(pos[i+1:])

                        defer func() {

                                p.pos.Filename = file

                                p.pos.Line = line

                                p.pos.Column = 1

                        }()

                }

        }

        // shortcut common case of //-style comments

        if text[1] == '/' {

                p.writeItem(p.posFor(comment.Pos()), text, true)

                return

        }

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

        // write function take care of the proper indentation

        lines := split(text)

        stripCommonPrefix(lines)

        // write comment lines, separated by formfeed,

        // without a line break after the last line

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

        for i, line := range lines {

                if i > 0 {

                        p.writeByte('\f')

                        pos = p.pos

                }

                if len(line) > 0 {

                        p.writeItem(pos, 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')

                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.IsKeyword())

                        p.writeComment(c)

                        last = c

                }

                p.nextComment()

        }

        if last != nil {

                if last.Text[1] == '*' && p.lineFor(last.Pos()) == next.Line {

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

                        // follows on the same line: separate with an extra blank

                        p.writeByte(' ')

                }

                // 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 {

                                // Use a formfeed to terminate the current section.

                                // Otherwise, a long label name on the next line leading

                                // to a wide column may increase the indentation column

                                // of lines before the label; effectively leading to wrong

                                // indentation.

                                p.wsbuf[i], p.wsbuf[i+1] = unindent, formfeed

                                i-- // do it again

                                continue

                        }

                        fallthrough

                default:

                        p.writeByte(byte(ch))

                }

        }

        // shift remaining entries down

        i := 0

        for ; n < len(p.wsbuf); n++ {

                p.wsbuf[i] = p.wsbuf[n]

                i++

        }

        p.wsbuf = p.wsbuf[0:i]

}

// ----------------------------------------------------------------------------

// Printing interface

// nlines limits n to maxNewlines.

func nlimit(n int) int {

        if n > maxNewlines {

                n = maxNewlines

        }

        return n

}

func mayCombine(prev token.Token, next byte) (b bool) {

        switch prev {

        case token.INT:

                b = next == '.' // 1.

        case token.ADD:

                b = next == '+' // ++

        case token.SUB:

                b = next == '-' // --

        case token.QUO:

                b = next == '*' // /*

        case token.LSS:

                b = next == '-' || next == '<' // <- or <<

        case token.AND:

                b = next == '&' || next == '^' // && or &^

        }

        return

}

// print prints a list of "items" (roughly corresponding to syntactic

// tokens, but also including whitespace and formatting information).

// It is the only print function that should be called directly from

// any of the AST printing functions in nodes.go.

//

// Whitespace is accumulated until a non-whitespace token appears. Any

// comments that need to appear before that token are printed first,

// taking into account the amount and structure of any pending white-

// space for best comment placement. Then, any leftover whitespace is

// printed, followed by the actual token.

//

func (p *printer) print(args ...interface{}) {

        for _, arg := range args {

                // information about the current arg

                var data string

                var isLit bool

                var impliedSemi bool // value for p.impliedSemi after this arg

                switch x := arg.(type) {

                case pmode:

                        // toggle printer mode

                        p.mode ^= x

                        continue

                case whiteSpace:

                        if x == ignore {

                                // don't add ignore's to the buffer; they

                                // may screw up "correcting" unindents (see

                                // LabeledStmt)

                                continue

                        }

                        i := len(p.wsbuf)

                        if i == cap(p.wsbuf) {

                                // Whitespace sequences are very short so this should

                                // never happen. Handle gracefully (but possibly with

                                // bad comment placement) if it does happen.

                                p.writeWhitespace(i)

                                i = 0

                        }

                        p.wsbuf = p.wsbuf[0 : i+1]

                        p.wsbuf[i] = x

                        if x == newline || x == formfeed {

                                // newlines affect the current state (p.impliedSemi)

                                // and not the state after printing arg (impliedSemi)

                                // because comments can be interspersed before the arg

                                // in this case

                                p.impliedSemi = false

                        }

                        p.lastTok = token.ILLEGAL

                        continue

                case *ast.Ident:

                        data = x.Name

                        impliedSemi = true

                        p.lastTok = token.IDENT

                case *ast.BasicLit:

                        data = x.Value

                        isLit = true

                        impliedSemi = true

                        p.lastTok = x.Kind

                case token.Token:

                        s := x.String()

                        if mayCombine(p.lastTok, s[0]) {

                                // the previous and the current token must be

                                // separated by a blank otherwise they combine

                                // into a different incorrect token sequence

                                // (except for token.INT followed by a '.' this

                                // should never happen because it is taken care

                                // of via binary expression formatting)

                                if len(p.wsbuf) != 0 {

                                        p.internalError("whitespace buffer not empty")

                                }

                                p.wsbuf = p.wsbuf[0:1]

                                p.wsbuf[0] = ' '

                        }

                        data = s

                        // some keywords followed by a newline imply a semicolon

                        switch x {

                        case token.BREAK, token.CONTINUE, token.FALLTHROUGH, token.RETURN,

                                token.INC, token.DEC, token.RPAREN, token.RBRACK, token.RBRACE:

                                impliedSemi = true

                        }

                        p.lastTok = x

                case token.Pos:

                        if x.IsValid() {

                                p.pos = p.posFor(x) // accurate position of next item

                        }

                        continue

                case string:

                        // incorrect AST - print error message

                        data = x

                        isLit = true

                        impliedSemi = true

                        p.lastTok = token.STRING

                default:

                        fmt.Fprintf(os.Stderr, "print: unsupported argument %v (%T)\n", arg, arg)

                        panic("go/printer type")

                }

                // data != ""

                next := p.pos // estimated/accurate position of next item

                wroteNewline, droppedFF := p.flush(next, p.lastTok)

                // intersperse extra newlines if present in the source and

                // if they don't cause extra semicolons (don't do this in

                // flush as it will cause extra newlines at the end of a file)

                if !p.impliedSemi {

                        n := nlimit(next.Line - p.pos.Line)

                        // don't exceed maxNewlines if we already wrote one

                        if wroteNewline && n == maxNewlines {

                                n = maxNewlines - 1

                        }

                        if n > 0 {

                                ch := byte('\n')

                                if droppedFF {

                                        ch = '\f' // use formfeed since we dropped one before

                                }

                                p.writeByteN(ch, n)

                                impliedSemi = false

                        }

                }

                p.writeItem(next, data, isLit)

                p.impliedSemi = impliedSemi

        }

}

// commentBefore returns true iff the current comment group occurs

// before the next position in the source code and printing it does

// not introduce implicit semicolons.

//

func (p *printer) commentBefore(next token.Position) (result bool) {

        return p.commentOffset < next.Offset && (!p.impliedSemi || !p.commentNewline)

}

// flush prints any pending comments and whitespace occurring textually

// before the position of the next token tok. The flush result indicates

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

// buffer.

//

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

        if p.commentBefore(next) {

                // if there are comments before the next item, intersperse them

                wroteNewline, droppedFF = p.intersperseComments(next, tok)

        } else {

                // otherwise, write any leftover whitespace

                p.writeWhitespace(len(p.wsbuf))

        }

        return

}

// getNode returns the ast.CommentGroup associated with n, if any.

func getDoc(n ast.Node) *ast.CommentGroup {

        switch n := n.(type) {

        case *ast.Field:

                return n.Doc

        case *ast.ImportSpec:

                return n.Doc

        case *ast.ValueSpec:

                return n.Doc

        case *ast.TypeSpec:

                return n.Doc

        case *ast.GenDecl:

                return n.Doc

        case *ast.FuncDecl:

                return n.Doc