[dev.power64] code review 160200044: build: merge default into dev.power64

src/pkg/go/build/build.go

 // Copyright 2011 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 build
 
 import (
         "bytes"
         "errors"
         "fmt"
         "go/ast"
         "go/doc"
         "go/parser"
         "go/token"
         "io"
         "io/ioutil"
         "log"
         "os"
         pathpkg "path"
         "path/filepath"
         "runtime"
         "sort"
         "strconv"
         "strings"
         "unicode"
+        "unicode/utf8"
 )
 
 // A Context specifies the supporting context for a build.
 type Context struct {
         GOARCH      string // target architecture
         GOOS        string // target operating system
         GOROOT      string // Go root
         GOPATH      string // Go path
         CgoEnabled  bool   // whether cgo can be used
         UseAllFiles bool   // use files regardless of +build lines, file names
@@ skipping 294 matching lines @@
 
 const (
         // If FindOnly is set, Import stops after locating the directory
         // that should contain the sources for a package.  It does not
         // read any files in the directory.
         FindOnly ImportMode = 1 << iota
 
         // If AllowBinary is set, Import can be satisfied by a compiled
         // package object without corresponding sources.
         AllowBinary
+
+        // If ImportComment is set, parse import comments on package statements.
+        // Import returns an error if it finds a comment it cannot understand
+        // or finds conflicting comments in multiple source files.
+        // See golang.org/s/go14customimport for more information.
+        ImportComment
 )
 
 // A Package describes the Go package found in a directory.
 type Package struct {
-        Dir         string   // directory containing package sources
-        Name        string   // package name
-        Doc         string   // documentation synopsis
-        ImportPath  string   // import path of package ("" if unknown)
-        Root        string   // root of Go tree where this package lives
-        SrcRoot     string   // package source root directory ("" if unknown)
-        PkgRoot     string   // package install root directory ("" if unknown)
-        BinDir      string   // command install directory ("" if unknown)
-        Goroot      bool     // package found in Go root
-        PkgObj      string   // installed .a file
-        AllTags     []string // tags that can influence file selection in this directory
-        ConflictDir string   // this directory shadows Dir in $GOPATH
+        Dir           string   // directory containing package sources
+        Name          string   // package name
+        ImportComment string   // path in import comment on package statement
+        Doc           string   // documentation synopsis
+        ImportPath    string   // import path of package ("" if unknown)
+        Root          string   // root of Go tree where this package lives
+        SrcRoot       string   // package source root directory ("" if unknown)
+        PkgRoot       string   // package install root directory ("" if unknown)
+        BinDir        string   // command install directory ("" if unknown)
+        Goroot        bool     // package found in Go root
+        PkgObj        string   // installed .a file
+        AllTags       []string // tags that can influence file selection in this directory
+        ConflictDir   string   // this directory shadows Dir in $GOPATH
 
         // Source files
         GoFiles        []string // .go source files (excluding CgoFiles, TestGoFiles, XTestGoFiles)
         CgoFiles       []string // .go source files that import "C"
         IgnoredGoFiles []string // .go source files ignored for this build
         CFiles         []string // .c source files
         CXXFiles       []string // .cc, .cpp and .cxx source files
         MFiles         []string // .m (Objective-C) source files
         HFiles         []string // .h, .hh, .hpp and .hxx source files
         SFiles         []string // .s source files
@@ skipping 148 matching lines @@
                 }
 
                 // tried records the location of unsuccessful package lookups
                 var tried struct {
                         goroot string
                         gopath []string
                 }
 
                 // Determine directory from import path.
                 if ctxt.GOROOT != "" {
-                        dir := ctxt.joinPath(ctxt.GOROOT, "src", "pkg", path)
+                        var dir string
+                        if strings.HasPrefix(path, "cmd/") {
+                                dir = ctxt.joinPath(ctxt.GOROOT, "src", path)
+                        } else {
+                                dir = ctxt.joinPath(ctxt.GOROOT, "src", "pkg", path)
+                        }
                         isDir := ctxt.isDir(dir)
                         binaryOnly = !isDir && mode&AllowBinary != 0 && pkga != "" && ctxt.isFile(ctxt.joinPath(ctxt.GOROOT, pkga))
                         if isDir || binaryOnly {
                                 p.Dir = dir
                                 p.Goroot = true
                                 p.Root = ctxt.GOROOT
                                 goto Found
                         }
                         tried.goroot = dir
                 }
@@ skipping 50 matching lines @@
         if binaryOnly && (mode&AllowBinary) != 0 {
                 return p, pkgerr
         }
 
         dirs, err := ctxt.readDir(p.Dir)
         if err != nil {
                 return p, err
         }
 
         var Sfiles []string // files with ".S" (capital S)
-        var firstFile string
+        var firstFile, firstCommentFile string
         imported := make(map[string][]token.Position)
         testImported := make(map[string][]token.Position)
         xTestImported := make(map[string][]token.Position)
         allTags := make(map[string]bool)
         fset := token.NewFileSet()
         for _, d := range dirs {
                 if d.IsDir() {
                         continue
                 }
 
@@ skipping 66 matching lines @@
                 if p.Name == "" {
                         p.Name = pkg
                         firstFile = name
                 } else if pkg != p.Name {
                         return p, fmt.Errorf("found packages %s (%s) and %s (%s) in %s", p.Name, firstFile, pkg, name, p.Dir)
                 }
                 if pf.Doc != nil && p.Doc == "" {
                         p.Doc = doc.Synopsis(pf.Doc.Text())
                 }
 
+                if mode&ImportComment != 0 {
+                        qcom, line := findImportComment(data)
+                        if line != 0 {
+                                com, err := strconv.Unquote(qcom)
+                                if err != nil {
+                                        return p, fmt.Errorf("%s:%d: cannot parse import comment", filename, line)
+                                }
+                                if p.ImportComment == "" {
+                                        p.ImportComment = com
+                                        firstCommentFile = name
+                                } else if p.ImportComment != com {
+                                        return p, fmt.Errorf("found import comments %q (%s) and %q (%s) in %s", p.ImportComment, firstCommentFile, com, name, p.Dir)
+                                }
+                        }
+                }
+
                 // Record imports and information about cgo.
                 isCgo := false
                 for _, decl := range pf.Decls {
                         d, ok := decl.(*ast.GenDecl)
                         if !ok {
                                 continue
                         }
                         for _, dspec := range d.Specs {
                                 spec, ok := dspec.(*ast.ImportSpec)
                                 if !ok {
@@ skipping 60 matching lines @@
         // (which means gcc will compile them).
         // The standard assemblers expect .s files.
         if len(p.CgoFiles) > 0 {
                 p.SFiles = append(p.SFiles, Sfiles...)
                 sort.Strings(p.SFiles)
         }
 
         return p, pkgerr
 }
 
+func findImportComment(data []byte) (s string, line int) {
+        // expect keyword package
+        word, data := parseWord(data)
+        if string(word) != "package" {
+                return "", 0
+        }
+
+        // expect package name
+        _, data = parseWord(data)
+
+        // now ready for import comment, a // or /* */ comment
+        // beginning and ending on the current line.
+        for len(data) > 0 && (data[0] == ' ' || data[0] == '\t' || data[0] == '\r') {
+                data = data[1:]
+        }
+
+        var comment []byte
+        switch {
+        case bytes.HasPrefix(data, slashSlash):
+                i := bytes.Index(data, newline)
+                if i < 0 {
+                        i = len(data)
+                }
+                comment = data[2:i]
+        case bytes.HasPrefix(data, slashStar):
+                data = data[2:]
+                i := bytes.Index(data, starSlash)
+                if i < 0 {
+                        // malformed comment
+                        return "", 0
+                }
+                comment = data[:i]
+                if bytes.Contains(comment, newline) {
+                        return "", 0
+                }
+        }
+        comment = bytes.TrimSpace(comment)
+
+        // split comment into `import`, `"pkg"`
+        word, arg := parseWord(comment)
+        if string(word) != "import" {
+                return "", 0
+        }
+
+        line = 1 + bytes.Count(data[:cap(data)-cap(arg)], newline)
+        return strings.TrimSpace(string(arg)), line
+}
+
+var (
+        slashSlash = []byte("//")
+        slashStar  = []byte("/*")
+        starSlash  = []byte("*/")
+        newline    = []byte("\n")
+)
+
+// skipSpaceOrComment returns data with any leading spaces or comments removed.
+func skipSpaceOrComment(data []byte) []byte {
+        for len(data) > 0 {
+                switch data[0] {
+                case ' ', '\t', '\r', '\n':
+                        data = data[1:]
+                        continue
+                case '/':
+                        if bytes.HasPrefix(data, slashSlash) {
+                                i := bytes.Index(data, newline)
+                                if i < 0 {
+                                        return nil
+                                }
+                                data = data[i+1:]
+                                continue
+                        }
+                        if bytes.HasPrefix(data, slashStar) {
+                                data = data[2:]
+                                i := bytes.Index(data, starSlash)
+                                if i < 0 {
+                                        return nil
+                                }
+                                data = data[i+2:]
+                                continue
+                        }
+                }
+                break
+        }
+        return data
+}
+
+// parseWord skips any leading spaces or comments in data
+// and then parses the beginning of data as an identifier or keyword,
+// returning that word and what remains after the word.
+func parseWord(data []byte) (word, rest []byte) {
+        data = skipSpaceOrComment(data)
+
+        // Parse past leading word characters.
+        rest = data
+        for {
+                r, size := utf8.DecodeRune(rest)
+                if unicode.IsLetter(r) || '0' <= r && r <= '9' || r == '_' {
+                        rest = rest[size:]
+                        continue
+                }
+                break
+        }
+
+        word = data[:len(data)-len(rest)]
+        if len(word) == 0 {
+                return nil, nil
+        }
+
+        return word, rest
+}
+
 // MatchFile reports whether the file with the given name in the given directory
 // matches the context and would be included in a Package created by ImportDir
 // of that directory.
 //
 // MatchFile considers the name of the file and may use ctxt.OpenFile to
 // read some or all of the file's content.
 func (ctxt *Context) MatchFile(dir, name string) (match bool, err error) {
         match, _, _, err = ctxt.matchFile(dir, name, false, nil)
         return
 }
@@ skipping 456 matching lines @@
                 return "8", nil
         case "amd64", "amd64p32":
                 return "6", nil
         case "arm":
                 return "5", nil
         case "power64", "power64le":
                 return "9", nil
         }
         return "", errors.New("unsupported GOARCH " + goarch)
 }