code review 13395046: cmd/cgo: record full source path to input .go files

src/cmd/cgo/ast.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.
 
 // Parse input AST and prepare Prog structure.
 
 package main
 
 import (
         "fmt"
         "go/ast"
         "go/parser"
         "go/scanner"
         "go/token"
         "os"
+        "path/filepath"
         "strings"
 )
 
 func parse(name string, flags parser.Mode) *ast.File {
         ast1, err := parser.ParseFile(fset, name, nil, flags)
         if err != nil {
                 if list, ok := err.(scanner.ErrorList); ok {
                         // If err is a scanner.ErrorList, its String will print just
                         // the first error and then (+n more errors).
                         // Instead, turn it into a new Error that will return
@@ skipping 11 matching lines @@
 func sourceLine(n ast.Node) int {
         return fset.Position(n.Pos()).Line
 }
 
 // ReadGo populates f with information learned from reading the
 // Go source file with the given file name.  It gathers the C preamble
 // attached to the import "C" comment, a list of references to C.xxx,
 // a list of exported functions, and the actual AST, to be rewritten and
 // printed.
 func (f *File) ReadGo(name string) {
+        // Create absolute path for file, so that it will be used in error
+        // messages and recorded in debug line number information.
+        // This matches the rest of the toolchain. See golang.org/issue/5122.
+        if aname, err := filepath.Abs(name); err == nil {
+                name = aname
+        }
+
         // Two different parses: once with comments, once without.
         // The printer is not good enough at printing comments in the
         // right place when we start editing the AST behind its back,
         // so we use ast1 to look for the doc comments on import "C"
         // and on exported functions, and we use ast2 for translating
         // and reprinting.
         ast1 := parse(name, parser.ParseComments)
         ast2 := parse(name, 0)
 
         f.Package = ast1.Name.Name
@@ skipping 379 matching lines @@
         case []ast.Stmt:
                 for _, s := range n {
                         f.walk(s, context, visit)
                 }
         case []ast.Spec:
                 for _, s := range n {
                         f.walk(s, context, visit)
                 }
         }
 }