code review 3050041: go/ast: use token.Pos instead of token.Position; adjus...

src/pkg/go/printer/printer.go

 // 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.
 
 // The printer package implements printing of AST nodes.
 package printer
 
 import (
         "bytes"
         "fmt"
@@ skipping 44 matching lines @@
 
 
 // Use ignoreMultiLine if the multiLine information is not important.
 var ignoreMultiLine = new(bool)
 
 
 type printer struct {
         // Configuration (does not change after initialization)
         output io.Writer
         Config
+        fset   *token.FileSet
         errors chan os.Error
 
         // Current state
         nesting int         // nesting level (0: top-level (package scope), >0: functions/decls.)
         written int         // number of bytes written
         indent  int         // current indentation
         escape  bool        // true if in escape sequence
         lastTok token.Token // the last token printed (token.ILLEGAL if it's whitespace)
 
         // Buffered whitespace
@@ skipping 12 matching lines @@
         // HTML support
         lastTaggedLine int // last line for which a line tag was written
 
         // 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
 }
 
 
-func (p *printer) init(output io.Writer, cfg *Config) {
+func (p *printer) init(output io.Writer, cfg *Config, fset *token.FileSet) {
         p.output = output
         p.Config = *cfg
+        p.fset = fset
         p.errors = make(chan os.Error)
         p.buffer = make([]whiteSpace, 0, 16) // whitespace sequences are short
 }
 
 
 func (p *printer) internalError(msg ...interface{}) {
         if debug {
                 fmt.Print(p.pos.String() + ": ")
                 fmt.Println(msg...)
                 panic("go/printer")
@@ skipping 479 matching lines @@
                 }
         }
 }
 
 
 func (p *printer) writeComment(comment *ast.Comment) {
         text := comment.Text
 
         // shortcut common case of //-style comments
         if text[1] == '/' {
-                p.writeCommentLine(comment, comment.Pos(), text)
+                p.writeCommentLine(comment, p.fset.Position(comment.Pos()), text)
                 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
         linebreak := formfeeds[0:1]
-        pos := comment.Pos()
+        pos := p.fset.Position(comment.Pos())
         for i, line := range lines {
                 if i > 0 {
                         p.write(linebreak)
                         pos = p.pos
                 }
                 if len(line) > 0 {
                         p.writeCommentLine(comment, pos, line)
                 }
         }
 }
@@ skipping 40 matching lines @@
 // 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. intersperseComments returns true if a pending
 // formfeed was dropped from the whitespace buffer.
 //
 func (p *printer) intersperseComments(next token.Position, tok token.Token) (droppedFF bool) {
         var last *ast.Comment
         for ; p.commentBefore(next); p.cindex++ {
                 for _, c := range p.comments[p.cindex].List {
-                        p.writeCommentPrefix(c.Pos(), next, last == nil, tok.IsKeyword())
+                        p.writeCommentPrefix(p.fset.Position(c.Pos()), next, last == nil, tok.IsKeyword())
                         p.writeComment(c)
                         last = c
                 }
         }
 
         if last != nil {
-                if last.Text[1] == '*' && last.Pos().Line == next.Line {
+                if last.Text[1] == '*' && p.fset.Position(last.Pos()).Line == next.Line {
                         // the last comment is a /*-style comment and the next item
                         // follows on the same line: separate with an extra blank
                         p.write([]byte{' '})
                 }
                 // ensure that there is a newline after a //-style comment
                 // or if we are before a closing '}' or at the end of a file
                 return p.writeCommentSuffix(last.Text[1] == '/' || tok == token.RBRACE || tok == token.EOF)
         }
 
         // no comment was written - we should never reach here since
@@ skipping 145 matching lines @@
                                 }
                                 p.buffer = p.buffer[0:1]
                                 p.buffer[0] = ' '
                         }
                         if p.Styler != nil {
                                 data, tag = p.Styler.Token(x)
                         } else {
                                 data = []byte(s)
                         }
                         tok = x
-                case token.Position:
+                case token.Pos:
                         if x.IsValid() {
-                                next = x // accurate position of next item
+                                next = p.fset.Position(x) // accurate position of next item
                         }
                         tok = p.lastTok
                 default:
                         fmt.Fprintf(os.Stderr, "print: unsupported argument type %T\n", f)
                         panic("go/printer type")
                 }
                 p.lastTok = tok
                 p.pos = next
 
                 if data != nil {
                         droppedFF := p.flush(next, tok)
 
                         // intersperse extra newlines if present in the source
                         // (don't do this in flush as it will cause extra newlines
                         // at the end of a file) - use formfeeds if we dropped one
                         // before
                         p.writeNewlines(next.Line-p.pos.Line, droppedFF)
 
                         p.writeItem(next, data, tag)
                 }
         }
 }
 
 
 // commentBefore returns true iff the current comment occurs
 // before the next position in the source code.
 //
 func (p *printer) commentBefore(next token.Position) bool {
-        return p.cindex < len(p.comments) && p.comments[p.cindex].List[0].Pos().Offset < next.Offset
+        return p.cindex < len(p.comments) && p.fset.Position(p.comments[p.cindex].List[0].Pos()).Offset < next.Offset
 }
 
 
 // Flush prints any pending comments and whitespace occuring
 // textually before the position of the next token tok. Flush
 // returns true if a pending formfeed character was dropped
 // from the whitespace buffer as a result of interspersing
 // comments.
 //
 func (p *printer) flush(next token.Position, tok token.Token) (droppedFF bool) {
@@ skipping 132 matching lines @@
 // A Config node controls the output of Fprint.
 type Config struct {
         Mode     uint   // default: 0
         Tabwidth int    // default: 8
         Styler   Styler // default: nil
 }
 
 
 // Fprint "pretty-prints" an AST node to output and returns the number
 // of bytes written and an error (if any) for a given configuration cfg.
+// Position information is interpreted relative to the file set fset.
 // The node type must be *ast.File, or assignment-compatible to ast.Expr,
 // ast.Decl, ast.Spec, or ast.Stmt.
 //
-func (cfg *Config) Fprint(output io.Writer, node interface{}) (int, os.Error) {
+func (cfg *Config) Fprint(output io.Writer, fset *token.FileSet, node interface{}) (int, os.Error) {
         // redirect output through a trimmer to eliminate trailing whitespace
         // (Input to a tabwriter must be untrimmed since trailing tabs provide
         // formatting information. The tabwriter could provide trimming
         // functionality but no tabwriter is used when RawFormat is set.)
         output = &trimmer{output: output}
 
         // setup tabwriter if needed and redirect output
         var tw *tabwriter.Writer
         if cfg.Mode&RawFormat == 0 {
                 minwidth := cfg.Tabwidth
@@ skipping 11 matching lines @@
                         minwidth = 0
                         twmode |= tabwriter.TabIndent
                 }
 
                 tw = tabwriter.NewWriter(output, minwidth, cfg.Tabwidth, 1, padchar, twmode)
                 output = tw
         }
 
         // setup printer and print node
         var p printer
-        p.init(output, cfg)
+        p.init(output, cfg, fset)
         go func() {
                 switch n := node.(type) {
                 case ast.Expr:
                         p.nesting = 1
                         p.useNodeComments = true
                         p.expr(n, ignoreMultiLine)
                 case ast.Stmt:
                         p.nesting = 1
                         p.useNodeComments = true
                         // A labeled statement will un-indent to position the
@@ skipping 29 matching lines @@
                 tw.Flush() // ignore errors
         }
 
         return p.written, err
 }
 
 
 // Fprint "pretty-prints" an AST node to output.
 // It calls Config.Fprint with default settings.
 //
-func Fprint(output io.Writer, node interface{}) os.Error {
-        _, err := (&Config{Tabwidth: 8}).Fprint(output, node) // don't care about number of bytes written
+func Fprint(output io.Writer, fset *token.FileSet, node interface{}) os.Error {
+        _, err := (&Config{Tabwidth: 8}).Fprint(output, fset, node) // don't care about number of bytes written
         return err
 }