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.

// This file implements printing of AST nodes; specifically

// expressions, statements, declarations, and files. It uses

// the print functionality implemented in printer.go.

package printer

import (

        "bytes"

        "go/ast"

        "go/token"

)

// Other formatting issues:

// - better comment formatting for /*-style comments at the end of a line (e.g. a declaration)

//   when the comment spans multiple lines; if such a comment is just two lines, formatting is

//   not idempotent

// - formatting of expression lists

// - should use blank instead of tab to separate one-line function bodies from

//   the function header unless there is a group of consecutive one-liners

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

// Common AST nodes.

// Print as many newlines as necessary (but at least min newlines) to get to

// the current line. ws is printed before the first line break. If newSection

// is set, the first line break is printed as formfeed. Returns true if any

// line break was printed; returns false otherwise.

//

// TODO(gri): linebreak may add too many lines if the next statement at "line"

//            is preceded by comments because the computation of n assumes

//            the current position before the comment and the target position

//            after the comment. Thus, after interspersing such comments, the

//            space taken up by them is not considered to reduce the number of

//            linebreaks. At the moment there is no easy way to know about

//            future (not yet interspersed) comments in this function.

//

func (p *printer) linebreak(line, min int, ws whiteSpace, newSection bool) (printedBreak bool) {

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

        if n < min {

                n = min

        }

        if n > 0 {

                p.print(ws)

                if newSection {

                        p.print(formfeed)

                        n--

                }

                for ; n > 0; n-- {

                        p.print(newline)

                }

                printedBreak = true

        }

        return

}

// setComment sets g as the next comment if g != nil and if node comments

// are enabled - this mode is used when printing source code fragments such

// as exports only. It assumes that there are no other pending comments to

// intersperse.

func (p *printer) setComment(g *ast.CommentGroup) {

        if g == nil || !p.useNodeComments {

                return

        }

        if p.comments == nil {

                // initialize p.comments lazily

                p.comments = make([]*ast.CommentGroup, 1)

        } else if p.cindex < len(p.comments) {

                // for some reason there are pending comments; this

                // should never happen - handle gracefully and flush

                // all comments up to g, ignore anything after that

                p.flush(p.posFor(g.List[0].Pos()), token.ILLEGAL)

        }

        p.comments[0] = g

        p.cindex = 0

        p.nextComment() // get comment ready for use

}

type exprListMode uint

const (

        blankStart exprListMode = 1 << iota // print a blank before a non-empty list

        blankEnd                            // print a blank after a non-empty list

        commaSep                            // elements are separated by commas

        commaTerm                           // list is optionally terminated by a comma

        noIndent                            // no extra indentation in multi-line lists

        periodSep                           // elements are separated by periods

)

// Sets multiLine to true if the identifier list spans multiple lines.

// If indent is set, a multi-line identifier list is indented after the

// first linebreak encountered.

func (p *printer) identList(list []*ast.Ident, indent bool, multiLine *bool) {

        // convert into an expression list so we can re-use exprList formatting

        xlist := make([]ast.Expr, len(list))

        for i, x := range list {

                xlist[i] = x

        }

        mode := commaSep

        if !indent {

                mode |= noIndent

        }

        p.exprList(token.NoPos, xlist, 1, mode, multiLine, token.NoPos)

}

// Print a list of expressions. If the list spans multiple

// source lines, the original line breaks are respected between

// expressions. Sets multiLine to true if the list spans multiple

// lines.

//

// TODO(gri) Consider rewriting this to be independent of []ast.Expr

//           so that we can use the algorithm for any kind of list

//           (e.g., pass list via a channel over which to range).

func (p *printer) exprList(prev0 token.Pos, list []ast.Expr, depth int, mode exprListMode, multiLine *bool, next0 token.Pos) {

        if len(list) == 0 {

                return

        }

        if mode&blankStart != 0 {

                p.print(blank)

        }

        prev := p.posFor(prev0)

        next := p.posFor(next0)

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

        endLine := p.lineFor(list[len(list)-1].End())

        if prev.IsValid() && prev.Line == line && line == endLine {

                // all list entries on a single line

                for i, x := range list {

                        if i > 0 {

                                if mode&commaSep != 0 {

                                        p.print(token.COMMA)

                                }

                                p.print(blank)

                        }

                        p.expr0(x, depth, multiLine)

                }

                if mode&blankEnd != 0 {

                        p.print(blank)

                }

                return

        }

        // list entries span multiple lines;

        // use source code positions to guide line breaks

        // don't add extra indentation if noIndent is set;

        // i.e., pretend that the first line is already indented

        ws := ignore

        if mode&noIndent == 0 {

                ws = indent

        }

        // the first linebreak is always a formfeed since this section must not

        // depend on any previous formatting

        prevBreak := -1 // index of last expression that was followed by a linebreak

        if prev.IsValid() && prev.Line < line && p.linebreak(line, 0, ws, true) {

                ws = ignore

                *multiLine = true

                prevBreak = 0

        }

        // initialize expression/key size: a zero value indicates expr/key doesn't fit on a single line

        size := 0

        // print all list elements

        for i, x := range list {

                prevLine := line

                line = p.lineFor(x.Pos())

                // determine if the next linebreak, if any, needs to use formfeed:

                // in general, use the entire node size to make the decision; for

                // key:value expressions, use the key size

                // TODO(gri) for a better result, should probably incorporate both

                //           the key and the node size into the decision process

                useFF := true

                // determine element size: all bets are off if we don't have

                // position information for the previous and next token (likely

                // generated code - simply ignore the size in this case by setting

                // it to 0)

                prevSize := size

                const infinity = 1e6 // larger than any source line

                size = p.nodeSize(x, infinity)

                pair, isPair := x.(*ast.KeyValueExpr)

                if size <= infinity && prev.IsValid() && next.IsValid() {

                        // x fits on a single line

                        if isPair {

                                size = p.nodeSize(pair.Key, infinity) // size <= infinity

                        }

                } else {

                        // size too large or we don't have good layout information

                        size = 0

                }

                // if the previous line and the current line had single-

                // line-expressions and the key sizes are small or the

                // the ratio between the key sizes does not exceed a

                // threshold, align columns and do not use formfeed

                if prevSize > 0 && size > 0 {

                        const smallSize = 20

                        if prevSize <= smallSize && size <= smallSize {

                                useFF = false

                        } else {

                                const r = 4 // threshold

                                ratio := float64(size) / float64(prevSize)

                                useFF = ratio <= 1/r || r <= ratio

                        }

                }

                if i > 0 {

                        switch {

                        case mode&commaSep != 0:

                                p.print(token.COMMA)

                        case mode&periodSep != 0:

                                p.print(token.PERIOD)

                        }

                        needsBlank := mode&periodSep == 0 // period-separated list elements don't need a blank

                        if prevLine < line && prevLine > 0 && line > 0 {

                                // lines are broken using newlines so comments remain aligned

                                // unless forceFF is set or there are multiple expressions on

                                // the same line in which case formfeed is used

                                if p.linebreak(line, 0, ws, useFF || prevBreak+1 < i) {

                                        ws = ignore

                                        *multiLine = true

                                        prevBreak = i

                                        needsBlank = false // we got a line break instead

                                }

                        }

                        if needsBlank {

                                p.print(blank)

                        }

                }

                if isPair && size > 0 && len(list) > 1 {

                        // we have a key:value expression that fits onto one line and

                        // is in a list with more then one entry: use a column for the

                        // key such that consecutive entries can align if possible

                        p.expr(pair.Key, multiLine)

                        p.print(pair.Colon, token.COLON, vtab)

                        p.expr(pair.Value, multiLine)

                } else {

                        p.expr0(x, depth, multiLine)

                }

        }

        if mode&commaTerm != 0 && next.IsValid() && p.pos.Line < next.Line {

                // print a terminating comma if the next token is on a new line

                p.print(token.COMMA)

                if ws == ignore && mode&noIndent == 0 {

                        // unindent if we indented

                        p.print(unindent)

                }

                p.print(formfeed) // terminating comma needs a line break to look good

                return

        }

        if mode&blankEnd != 0 {

                p.print(blank)

        }

        if ws == ignore && mode&noIndent == 0 {

                // unindent if we indented

                p.print(unindent)

        }

}

// Sets multiLine to true if the the parameter list spans multiple lines.

func (p *printer) parameters(fields *ast.FieldList, multiLine *bool) {

        p.print(fields.Opening, token.LPAREN)

        if len(fields.List) > 0 {

                prevLine := p.lineFor(fields.Opening)

                ws := indent

                for i, par := range fields.List {

                        // determine par begin and end line (may be different

                        // if there are multiple parameter names for this par

                        // or the type is on a separate line)

                        var parLineBeg int

                        var parLineEnd = p.lineFor(par.Type.Pos())

                        if len(par.Names) > 0 {

                                parLineBeg = p.lineFor(par.Names[0].Pos())

                        } else {

                                parLineBeg = parLineEnd

                        }

                        // separating "," if needed

                        if i > 0 {

                                p.print(token.COMMA)

                        }

                        // separator if needed (linebreak or blank)

                        if 0 < prevLine && prevLine < parLineBeg && p.linebreak(parLineBeg, 0, ws, true) {

                                // break line if the opening "(" or previous parameter ended on a different line

                                ws = ignore

                                *multiLine = true

                        } else if i > 0 {

                                p.print(blank)

                        }

                        // parameter names

                        if len(par.Names) > 0 {

                                // Very subtle: If we indented before (ws == ignore), identList

                                // won't indent again. If we didn't (ws == indent), identList will

                                // indent if the identList spans multiple lines, and it will outdent

                                // again at the end (and still ws == indent). Thus, a subsequent indent

                                // by a linebreak call after a type, or in the next multi-line identList

                                // will do the right thing.

                                p.identList(par.Names, ws == indent, multiLine)

                                p.print(blank)

                        }

                        // parameter type

                        p.expr(par.Type, multiLine)

                        prevLine = parLineEnd

                }

                // if the closing ")" is on a separate line from the last parameter,

                // print an additional "," and line break

                if closing := p.lineFor(fields.Closing); 0 < prevLine && prevLine < closing {

                        p.print(",")

                        p.linebreak(closing, 0, ignore, true)

                }

                // unindent if we indented

                if ws == ignore {

                        p.print(unindent)

                }

        }

        p.print(fields.Closing, token.RPAREN)

}

// Sets multiLine to true if the signature spans multiple lines.

func (p *printer) signature(params, result *ast.FieldList, multiLine *bool) {

        p.parameters(params, multiLine)

        n := result.NumFields()

        if n > 0 {

                p.print(blank)

                if n == 1 && result.List[0].Names == nil {

                        // single anonymous result; no ()'s

                        p.expr(result.List[0].Type, multiLine)

                        return

                }

                p.parameters(result, multiLine)

        }

}

func identListSize(list []*ast.Ident, maxSize int) (size int) {

        for i, x := range list {

                if i > 0 {

                        size += 2 // ", "

                }

                size += len(x.Name)

                if size >= maxSize {

                        break

                }

        }

        return

}

func (p *printer) isOneLineFieldList(list []*ast.Field) bool {

        if len(list) != 1 {

                return false // allow only one field

        }

        f := list[0]

        if f.Tag != nil || f.Comment != nil {

                return false // don't allow tags or comments

        }

        // only name(s) and type

        const maxSize = 30 // adjust as appropriate, this is an approximate value

        namesSize := identListSize(f.Names, maxSize)

        if namesSize > 0 {

                namesSize = 1 // blank between names and types

        }

        typeSize := p.nodeSize(f.Type, maxSize)

        return namesSize+typeSize <= maxSize

}

func (p *printer) setLineComment(text string) {

        p.setComment(&ast.CommentGroup{[]*ast.Comment{{token.NoPos, text}}})

}

func (p *printer) fieldList(fields *ast.FieldList, isStruct, isIncomplete bool) {

        lbrace := fields.Opening

        list := fields.List

        rbrace := fields.Closing

        hasComments := isIncomplete || p.commentBefore(p.posFor(rbrace))

        srcIsOneLine := lbrace.IsValid() && rbrace.IsValid() && p.lineFor(lbrace) == p.lineFor(rbrace)

        if !hasComments && srcIsOneLine {

                // possibly a one-line struct/interface

                if len(list) == 0 {

                        // no blank between keyword and {} in this case

                        p.print(lbrace, token.LBRACE, rbrace, token.RBRACE)

                        return

                } else if isStruct && p.isOneLineFieldList(list) { // for now ignore interfaces

                        // small enough - print on one line

                        // (don't use identList and ignore source line breaks)

                        p.print(lbrace, token.LBRACE, blank)

                        f := list[0]

                        for i, x := range f.Names {

                                if i > 0 {

                                        p.print(token.COMMA, blank)

                                }

                                p.expr(x, ignoreMultiLine)

                        }

                        if len(f.Names) > 0 {

                                p.print(blank)

                        }

                        p.expr(f.Type, ignoreMultiLine)

                        p.print(blank, rbrace, token.RBRACE)

                        return

                }

        }

        // hasComments || !srcIsOneLine

        p.print(blank, lbrace, token.LBRACE, indent)

        if hasComments || len(list) > 0 {

                p.print(formfeed)

        }

        if isStruct {

                sep := vtab

                if len(list) == 1 {

                        sep = blank

                }

                var ml bool

                for i, f := range list {

                        if i > 0 {

                                p.linebreak(p.lineFor(f.Pos()), 1, ignore, ml)

                        }

                        ml = false

                        extraTabs := 0

                        p.setComment(f.Doc)

                        if len(f.Names) > 0 {

                                // named fields

                                p.identList(f.Names, false, &ml)

                                p.print(sep)

                                p.expr(f.Type, &ml)

                                extraTabs = 1

                        } else {

                                // anonymous field

                                p.expr(f.Type, &ml)

                                extraTabs = 2

                        }

                        if f.Tag != nil {

                                if len(f.Names) > 0 && sep == vtab {

                                        p.print(sep)

                                }

                                p.print(sep)

                                p.expr(f.Tag, &ml)

                                extraTabs = 0

                        }

                        if f.Comment != nil {

                                for ; extraTabs > 0; extraTabs-- {

                                        p.print(sep)

                                }

                                p.setComment(f.Comment)

                        }

                }

                if isIncomplete {

                        if len(list) > 0 {

                                p.print(formfeed)

                        }

                        p.flush(p.posFor(rbrace), token.RBRACE) // make sure we don't lose the last line comment

                        p.setLineComment("// contains filtered or unexported fields")

                }

        } else { // interface

                var ml bool

                for i, f := range list {

                        if i > 0 {

                                p.linebreak(p.lineFor(f.Pos()), 1, ignore, ml)

                        }

                        ml = false

                        p.setComment(f.Doc)

                        if ftyp, isFtyp := f.Type.(*ast.FuncType); isFtyp {

                                // method

                                p.expr(f.Names[0], &ml)

                                p.signature(ftyp.Params, ftyp.Results, &ml)

                        } else {

                                // embedded interface

                                p.expr(f.Type, &ml)

                        }

                        p.setComment(f.Comment)

                }

                if isIncomplete {

                        if len(list) > 0 {

                                p.print(formfeed)

                        }

                        p.flush(p.posFor(rbrace), token.RBRACE) // make sure we don't lose the last line comment

                        p.setLineComment("// contains filtered or unexported methods")

                }

        }

        p.print(unindent, formfeed, rbrace, token.RBRACE)

}

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

// Expressions

func walkBinary(e *ast.BinaryExpr) (has4, has5 bool, maxProblem int) {

        switch e.Op.Precedence() {

        case 4:

                has4 = true

        case 5:

                has5 = true

        }

        switch l := e.X.(type) {

        case *ast.BinaryExpr:

                if l.Op.Precedence() < e.Op.Precedence() {

                        // parens will be inserted.

                        // pretend this is an *ast.ParenExpr and do nothing.

                        break

                }

                h4, h5, mp := walkBinary(l)

                has4 = has4 || h4

                has5 = has5 || h5

                if maxProblem < mp {

                        maxProblem = mp

                }

        }

        switch r := e.Y.(type) {

        case *ast.BinaryExpr:

                if r.Op.Precedence() <= e.Op.Precedence() {

                        // parens will be inserted.

                        // pretend this is an *ast.ParenExpr and do nothing.

                        break

                }

                h4, h5, mp := walkBinary(r)

                has4 = has4 || h4

                has5 = has5 || h5

                if maxProblem < mp {

                        maxProblem = mp

                }

        case *ast.StarExpr:

                if e.Op == token.QUO { // `*/`

                        maxProblem = 5

                }

        case *ast.UnaryExpr:

                switch e.Op.String() + r.Op.String() {

                case "/*", "&&", "&^":

                        maxProblem = 5

                case "++", "--":

                        if maxProblem < 4 {

                                maxProblem = 4

                        }

                }

        }

        return

}

func cutoff(e *ast.BinaryExpr, depth int) int {

        has4, has5, maxProblem := walkBinary(e)

        if maxProblem > 0 {

                return maxProblem + 1

        }

        if has4 && has5 {

                if depth == 1 {

                        return 5

                }

                return 4

        }

        if depth == 1 {

                return 6

        }

        return 4

}

func diffPrec(expr ast.Expr, prec int) int {

        x, ok := expr.(*ast.BinaryExpr)

        if !ok || prec != x.Op.Precedence() {

                return 1

        }

        return 0

}

func reduceDepth(depth int) int {

        depth--

        if depth < 1 {

                depth = 1

        }

        return depth

}

// Format the binary expression: decide the cutoff and then format.

// Let's call depth == 1 Normal mode, and depth > 1 Compact mode.

// (Algorithm suggestion by Russ Cox.)

//

// The precedences are:

//      5             *  /  %  <<  >>  &  &^

//      4             +  -  |  ^

//      3             ==  !=  <  <=  >  >=

//      2             &&

//      1             ||

//

// The only decision is whether there will be spaces around levels 4 and 5.

// There are never spaces at level 6 (unary), and always spaces at levels 3 and below.

//

// To choose the cutoff, look at the whole expression but excluding primary

// expressions (function calls, parenthesized exprs), and apply these rules:

//

//      1) If there is a binary operator with a right side unary operand

//         that would clash without a space, the cutoff must be (in order):

//

//              /*      6

//              &&       6

//              &^       6

//              ++      5

//              --      5

//

//         (Comparison operators always have spaces around them.)

//

//      2) If there is a mix of level 5 and level 4 operators, then the cutoff

//         is 5 (use spaces to distinguish precedence) in Normal mode

//         and 4 (never use spaces) in Compact mode.

//

//      3) If there are no level 4 operators or no level 5 operators, then the

//         cutoff is 6 (always use spaces) in Normal mode

//         and 4 (never use spaces) in Compact mode.

//

// Sets multiLine to true if the binary expression spans multiple lines.

func (p *printer) binaryExpr(x *ast.BinaryExpr, prec1, cutoff, depth int, multiLine *bool) {

        prec := x.Op.Precedence()

        if prec < prec1 {

                // parenthesis needed

                // Note: The parser inserts an ast.ParenExpr node; thus this case

                //       can only occur if the AST is created in a different way.

                p.print(token.LPAREN)

                p.expr0(x, reduceDepth(depth), multiLine) // parentheses undo one level of depth

                p.print(token.RPAREN)

                return

        }

        printBlank := prec < cutoff

        ws := indent

        p.expr1(x.X, prec, depth+diffPrec(x.X, prec), multiLine)

        if printBlank {

                p.print(blank)

        }

        xline := p.pos.Line // before the operator (it may be on the next line!)

        yline := p.lineFor(x.Y.Pos())

        p.print(x.OpPos, x.Op)

        if xline != yline && xline > 0 && yline > 0 {

                // at least one line break, but respect an extra empty line

                // in the source

                if p.linebreak(yline, 1, ws, true) {

                        ws = ignore

                        *multiLine = true

                        printBlank = false // no blank after line break

                }

        }

        if printBlank {

                p.print(blank)

        }

        p.expr1(x.Y, prec+1, depth+1, multiLine)

        if ws == ignore {

                p.print(unindent)

        }

}

func isBinary(expr ast.Expr) bool {

        _, ok := expr.(*ast.BinaryExpr)

        return ok

}

// If the expression contains one or more selector expressions, splits it into

// two expressions at the rightmost period. Writes entire expr to suffix when

// selector isn't found. Rewrites AST nodes for calls, index expressions and

// type assertions, all of which may be found in selector chains, to make them

// parts of the chain.

func splitSelector(expr ast.Expr) (body, suffix ast.Expr) {

        switch x := expr.(type) {

        case *ast.SelectorExpr:

                body, suffix = x.X, x.Sel

                return

        case *ast.CallExpr:

                body, suffix = splitSelector(x.Fun)

                if body != nil {

                        suffix = &ast.CallExpr{suffix, x.Lparen, x.Args, x.Ellipsis, x.Rparen}

                        return

                }

        case *ast.IndexExpr:

                body, suffix = splitSelector(x.X)

                if body != nil {

                        suffix = &ast.IndexExpr{suffix, x.Lbrack, x.Index, x.Rbrack}

                        return

                }

        case *ast.SliceExpr:

                body, suffix = splitSelector(x.X)

                if body != nil {

                        suffix = &ast.SliceExpr{suffix, x.Lbrack, x.Low, x.High, x.Rbrack}

                        return

                }

        case *ast.TypeAssertExpr:

                body, suffix = splitSelector(x.X)

                if body != nil {

                        suffix = &ast.TypeAssertExpr{suffix, x.Type}

                        return

                }

        }

        suffix = expr

        return

}

// Convert an expression into an expression list split at the periods of

// selector expressions.

func selectorExprList(expr ast.Expr) (list []ast.Expr) {

        // split expression

        for expr != nil {

                var suffix ast.Expr

                expr, suffix = splitSelector(expr)

                list = append(list, suffix)

        }

        // reverse list

        for i, j := 0, len(list)-1; i < j; i, j = i+1, j-1 {

                list[i], list[j] = list[j], list[i]

        }

        return

}

// Sets multiLine to true if the expression spans multiple lines.

func (p *printer) expr1(expr ast.Expr, prec1, depth int, multiLine *bool) {

        p.print(expr.Pos())

        switch x := expr.(type) {

        case *ast.BadExpr:

                p.print("BadExpr")

        case *ast.Ident:

                p.print(x)

        case *ast.BinaryExpr:

                if depth < 1 {

                        p.internalError("depth < 1:", depth)

                        depth = 1

                }

                p.binaryExpr(x, prec1, cutoff(x, depth), depth, multiLine)

        case *ast.KeyValueExpr:

                p.expr(x.Key, multiLine)

                p.print(x.Colon, token.COLON, blank)

                p.expr(x.Value, multiLine)

        case *ast.StarExpr:

                const prec = token.UnaryPrec

                if prec < prec1 {

                        // parenthesis needed

                        p.print(token.LPAREN)

                        p.print(token.MUL)

                        p.expr(x.X, multiLine)

                        p.print(token.RPAREN)

                } else {

                        // no parenthesis needed

                        p.print(token.MUL)

                        p.expr(x.X, multiLine)

                }

        case *ast.UnaryExpr:

                const prec = token.UnaryPrec

                if prec < prec1 {

                        // parenthesis needed

                        p.print(token.LPAREN)

                        p.expr(x, multiLine)

                        p.print(token.RPAREN)

                } else {

                        // no parenthesis needed

                        p.print(x.Op)

                        if x.Op == token.RANGE {

                                // TODO(gri) Remove this code if it cannot be reached.

                                p.print(blank)

                        }

                        p.expr1(x.X, prec, depth, multiLine)

                }

        case *ast.BasicLit:

                p.print(x)

        case *ast.FuncLit:

                p.expr(x.Type, multiLine)

                p.funcBody(x.Body, p.distance(x.Type.Pos(), p.pos), true, multiLine)

        case *ast.ParenExpr:

                if _, hasParens := x.X.(*ast.ParenExpr); hasParens {

                        // don't print parentheses around an already parenthesized expression

                        // TODO(gri) consider making this more general and incorporate precedence levels

                        p.expr0(x.X, reduceDepth(depth), multiLine) // parentheses undo one level of depth

                } else {

                        p.print(token.LPAREN)

                        p.expr0(x.X, reduceDepth(depth), multiLine) // parentheses undo one level of depth

                        p.print(x.Rparen, token.RPAREN)

                }

        case *ast.SelectorExpr:

                parts := selectorExprList(expr)

                p.exprList(token.NoPos, parts, depth, periodSep, multiLine, token.NoPos)

        case *ast.TypeAssertExpr:

                p.expr1(x.X, token.HighestPrec, depth, multiLine)

                p.print(token.PERIOD, token.LPAREN)

                if x.Type != nil {

                        p.expr(x.Type, multiLine)

                } else {

                        p.print(token.TYPE)

                }

                p.print(token.RPAREN)

        case *ast.IndexExpr:

                // TODO(gri): should treat[] like parentheses and undo one level of depth

                p.expr1(x.X, token.HighestPrec, 1, multiLine)

                p.print(x.Lbrack, token.LBRACK)

                p.expr0(x.Index, depth+1, multiLine)

                p.print(x.Rbrack, token.RBRACK)

        case *ast.SliceExpr:

                // TODO(gri): should treat[] like parentheses and undo one level of depth

                p.expr1(x.X, token.HighestPrec, 1, multiLine)

                p.print(x.Lbrack, token.LBRACK)

                if x.Low != nil {

                        p.expr0(x.Low, depth+1, multiLine)

                }

                // blanks around ":" if both sides exist and either side is a binary expression

                if depth <= 1 && x.Low != nil && x.High != nil && (isBinary(x.Low) || isBinary(x.High)) {

                        p.print(blank, token.COLON, blank)

                } else {

                        p.print(token.COLON)

                }

                if x.High != nil {

                        p.expr0(x.High, depth+1, multiLine)

                }

                p.print(x.Rbrack, token.RBRACK)

        case *ast.CallExpr:

                if len(x.Args) > 1 {

                        depth++

                }

                p.expr1(x.Fun, token.HighestPrec, depth, multiLine)

                p.print(x.Lparen, token.LPAREN)

                p.exprList(x.Lparen, x.Args, depth, commaSep|commaTerm, multiLine, x.Rparen)

                if x.Ellipsis.IsValid() {

                        p.print(x.Ellipsis, token.ELLIPSIS)

                }

                p.print(x.Rparen, token.RPAREN)

        case *ast.CompositeLit:

                // composite literal elements that are composite literals themselves may have the type omitted

                if x.Type != nil {

                        p.expr1(x.Type, token.HighestPrec, depth, multiLine)

                }

                p.print(x.Lbrace, token.LBRACE)

                p.exprList(x.Lbrace, x.Elts, 1, commaSep|commaTerm, multiLine, x.Rbrace)

                // do not insert extra line breaks because of comments before

                // the closing '}' as it might break the code if there is no

                // trailing ','

                p.print(noExtraLinebreak, x.Rbrace, token.RBRACE, noExtraLinebreak)

        case *ast.Ellipsis:

                p.print(token.ELLIPSIS)

                if x.Elt != nil {

                        p.expr(x.Elt, multiLine)

                }

        case *ast.ArrayType:

                p.print(token.LBRACK)

                if x.Len != nil {

                        p.expr(x.Len, multiLine)

                }

                p.print(token.RBRACK)

                p.expr(x.Elt, multiLine)

        case *ast.StructType:

                p.print(token.STRUCT)

                p.fieldList(x.Fields, true, x.Incomplete)

        case *ast.FuncType:

                p.print(token.FUNC)

                p.signature(x.Params, x.Results, multiLine)

        case *ast.InterfaceType:

                p.print(token.INTERFACE)

                p.fieldList(x.Methods, false, x.Incomplete)

        case *ast.MapType:

                p.print(token.MAP, token.LBRACK)

                p.expr(x.Key, multiLine)

                p.print(token.RBRACK)

                p.expr(x.Value, multiLine)

        case *ast.ChanType:

                switch x.Dir {

                case ast.SEND | ast.RECV:

                        p.print(token.CHAN)

                case ast.RECV:

                        p.print(token.ARROW, token.CHAN)

                case ast.SEND:

                        p.print(token.CHAN, token.ARROW)

                }

                p.print(blank)

                p.expr(x.Value, multiLine)

        default:

                panic("unreachable")

        }

        return

}

func (p *printer) expr0(x ast.Expr, depth int, multiLine *bool) {

        p.expr1(x, token.LowestPrec, depth, multiLine)

}

// Sets multiLine to true if the expression spans multiple lines.

func (p *printer) expr(x ast.Expr, multiLine *bool) {

        const depth = 1

        p.expr1(x, token.LowestPrec, depth, multiLine)

}

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

// Statements

// Print the statement list indented, but without a newline after the last statement.

// Extra line breaks between statements in the source are respected but at most one

// empty line is printed between statements.

func (p *printer) stmtList(list []ast.Stmt, _indent int, nextIsRBrace bool) {

        // TODO(gri): fix _indent code

        if _indent > 0 {

                p.print(indent)

        }

        var multiLine bool

        for i, s := range list {

                // _indent == 0 only for lists of switch/select case clauses;