1 // Copyright 2011 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
5 // Package load loads packages.
23 "cmd/go/internal/base"
28 var IgnoreImports
bool // control whether we ignore imports in packages
30 // A Package describes a single package found in a directory.
32 PackagePublic
// visible in 'go list'
33 Internal PackageInternal
// for use inside go command only
36 type PackagePublic
struct {
37 // Note: These fields are part of the go command's public API.
38 // See list.go. It is okay to add fields, but not to change or
39 // remove existing ones. Keep in sync with list.go
40 Dir
string `json:",omitempty"` // directory containing package sources
41 ImportPath
string `json:",omitempty"` // import path of package in dir
42 ImportComment
string `json:",omitempty"` // path in import comment on package statement
43 Name
string `json:",omitempty"` // package name
44 Doc
string `json:",omitempty"` // package documentation string
45 Target
string `json:",omitempty"` // installed target for this package (may be executable)
46 Shlib
string `json:",omitempty"` // the shared library that contains this package (only set when -linkshared)
47 Goroot
bool `json:",omitempty"` // is this package found in the Go root?
48 Standard
bool `json:",omitempty"` // is this package part of the standard Go library?
49 Root
string `json:",omitempty"` // Go root or Go path dir containing this package
50 ConflictDir
string `json:",omitempty"` // Dir is hidden by this other directory
51 BinaryOnly
bool `json:",omitempty"` // package cannot be recompiled
53 // Stale and StaleReason remain here *only* for the list command.
54 // They are only initialized in preparation for list execution.
55 // The regular build determines staleness on the fly during action execution.
56 Stale
bool `json:",omitempty"` // would 'go install' do anything for this package?
57 StaleReason
string `json:",omitempty"` // why is Stale true?
60 // If you add to this list you MUST add to p.AllFiles (below) too.
61 // Otherwise file name security lists will not apply to any new additions.
62 GoFiles
[]string `json:",omitempty"` // .go source files (excluding CgoFiles, TestGoFiles, XTestGoFiles)
63 CgoFiles
[]string `json:",omitempty"` // .go sources files that import "C"
64 IgnoredGoFiles
[]string `json:",omitempty"` // .go sources ignored due to build constraints
65 CFiles
[]string `json:",omitempty"` // .c source files
66 CXXFiles
[]string `json:",omitempty"` // .cc, .cpp and .cxx source files
67 MFiles
[]string `json:",omitempty"` // .m source files
68 HFiles
[]string `json:",omitempty"` // .h, .hh, .hpp and .hxx source files
69 FFiles
[]string `json:",omitempty"` // .f, .F, .for and .f90 Fortran source files
70 SFiles
[]string `json:",omitempty"` // .s source files
71 SwigFiles
[]string `json:",omitempty"` // .swig files
72 SwigCXXFiles
[]string `json:",omitempty"` // .swigcxx files
73 SysoFiles
[]string `json:",omitempty"` // .syso system object files added to package
76 CgoCFLAGS
[]string `json:",omitempty"` // cgo: flags for C compiler
77 CgoCPPFLAGS
[]string `json:",omitempty"` // cgo: flags for C preprocessor
78 CgoCXXFLAGS
[]string `json:",omitempty"` // cgo: flags for C++ compiler
79 CgoFFLAGS
[]string `json:",omitempty"` // cgo: flags for Fortran compiler
80 CgoLDFLAGS
[]string `json:",omitempty"` // cgo: flags for linker
81 CgoPkgConfig
[]string `json:",omitempty"` // cgo: pkg-config names
83 // Dependency information
84 Imports
[]string `json:",omitempty"` // import paths used by this package
85 Deps
[]string `json:",omitempty"` // all (recursively) imported dependencies
88 Incomplete
bool `json:",omitempty"` // was there an error loading this package or dependencies?
89 Error
*PackageError
`json:",omitempty"` // error loading this package (not dependencies)
90 DepsErrors
[]*PackageError
`json:",omitempty"` // errors loading dependencies
93 // If you add to this list you MUST add to p.AllFiles (below) too.
94 // Otherwise file name security lists will not apply to any new additions.
95 TestGoFiles
[]string `json:",omitempty"` // _test.go files in package
96 TestImports
[]string `json:",omitempty"` // imports from TestGoFiles
97 XTestGoFiles
[]string `json:",omitempty"` // _test.go files outside package
98 XTestImports
[]string `json:",omitempty"` // imports from XTestGoFiles
101 // AllFiles returns the names of all the files considered for the package.
102 // This is used for sanity and security checks, so we include all files,
103 // even IgnoredGoFiles, because some subcommands consider them.
104 // The go/build package filtered others out (like foo_wrongGOARCH.s)
106 func (p
*Package
) AllFiles() []string {
107 return str
.StringList(
125 type PackageInternal
struct {
126 // Unexported fields are not part of the public API.
128 Imports
[]*Package
// this package's direct imports
129 RawImports
[]string // this package's original imports as they appear in the text of the program
130 ForceLibrary
bool // this package is a library (even if named "main")
131 CmdlineFiles
bool // package built from files listed on command line
132 CmdlinePkg
bool // package listed on command line
133 Local
bool // imported via local path (./ or ../)
134 LocalPrefix
string // interpret ./ and ../ imports relative to this prefix
135 ExeName
string // desired name for temporary executable
136 CoverMode
string // preprocess Go source files with the coverage tool in this mode
137 CoverVars
map[string]*CoverVar
// variables created by coverage analysis
138 OmitDebug
bool // tell linker not to write debug information
139 GobinSubdir
bool // install target would be subdir of GOBIN
141 Asmflags
[]string // -asmflags for this package
142 Gcflags
[]string // -gcflags for this package
143 Ldflags
[]string // -ldflags for this package
144 Gccgoflags
[]string // -gccgoflags for this package
147 type NoGoError
struct {
151 func (e
*NoGoError
) Error() string {
152 // Count files beginning with _ and ., which we will pretend don't exist at all.
154 for _
, name
:= range e
.Package
.IgnoredGoFiles
{
155 if strings
.HasPrefix(name
, "_") || strings
.HasPrefix(name
, ".") {
160 if len(e
.Package
.IgnoredGoFiles
) > dummy
{
161 // Go files exist, but they were ignored due to build constraints.
162 return "build constraints exclude all Go files in " + e
.Package
.Dir
164 if len(e
.Package
.TestGoFiles
)+len(e
.Package
.XTestGoFiles
) > 0 {
165 // Test Go files exist, but we're not interested in them.
166 // The double-negative is unfortunate but we want e.Package.Dir
167 // to appear at the end of error message.
168 return "no non-test Go files in " + e
.Package
.Dir
170 return "no Go files in " + e
.Package
.Dir
173 // Resolve returns the resolved version of imports,
174 // which should be p.TestImports or p.XTestImports, NOT p.Imports.
175 // The imports in p.TestImports and p.XTestImports are not recursively
176 // loaded during the initial load of p, so they list the imports found in
177 // the source file, but most processing should be over the vendor-resolved
178 // import paths. We do this resolution lazily both to avoid file system work
179 // and because the eventual real load of the test imports (during 'go test')
180 // can produce better error messages if it starts with the original paths.
181 // The initial load of p loads all the non-test imports and rewrites
182 // the vendored paths, so nothing should ever call p.vendored(p.Imports).
183 func (p
*Package
) Resolve(imports
[]string) []string {
184 if len(imports
) > 0 && len(p
.Imports
) > 0 && &imports
[0] == &p
.Imports
[0] {
185 panic("internal error: p.Resolve(p.Imports) called")
187 seen
:= make(map[string]bool)
189 for _
, path
:= range imports
{
190 path
= ResolveImportPath(p
, path
)
193 all
= append(all
, path
)
200 // CoverVar holds the name of the generated coverage variables targeting the named file.
201 type CoverVar
struct {
202 File
string // local file name
203 Var
string // name of count struct
206 func (p
*Package
) copyBuild(pp
*build
.Package
) {
207 p
.Internal
.Build
= pp
209 if pp
.PkgTargetRoot
!= "" && cfg
.BuildPkgdir
!= "" {
210 old
:= pp
.PkgTargetRoot
211 pp
.PkgRoot
= cfg
.BuildPkgdir
212 pp
.PkgTargetRoot
= cfg
.BuildPkgdir
213 pp
.PkgObj
= filepath
.Join(cfg
.BuildPkgdir
, strings
.TrimPrefix(pp
.PkgObj
, old
))
217 p
.ImportPath
= pp
.ImportPath
218 p
.ImportComment
= pp
.ImportComment
222 p
.ConflictDir
= pp
.ConflictDir
223 p
.BinaryOnly
= pp
.BinaryOnly
227 p
.Standard
= p
.Goroot
&& p
.ImportPath
!= "" && isStandardImportPath(p
.ImportPath
)
228 p
.GoFiles
= pp
.GoFiles
229 p
.CgoFiles
= pp
.CgoFiles
230 p
.IgnoredGoFiles
= pp
.IgnoredGoFiles
232 p
.CXXFiles
= pp
.CXXFiles
237 p
.SwigFiles
= pp
.SwigFiles
238 p
.SwigCXXFiles
= pp
.SwigCXXFiles
239 p
.SysoFiles
= pp
.SysoFiles
240 p
.CgoCFLAGS
= pp
.CgoCFLAGS
241 p
.CgoCPPFLAGS
= pp
.CgoCPPFLAGS
242 p
.CgoCXXFLAGS
= pp
.CgoCXXFLAGS
243 p
.CgoFFLAGS
= pp
.CgoFFLAGS
244 p
.CgoLDFLAGS
= pp
.CgoLDFLAGS
245 p
.CgoPkgConfig
= pp
.CgoPkgConfig
246 // We modify p.Imports in place, so make copy now.
247 p
.Imports
= make([]string, len(pp
.Imports
))
248 copy(p
.Imports
, pp
.Imports
)
249 p
.Internal
.RawImports
= pp
.Imports
250 p
.TestGoFiles
= pp
.TestGoFiles
251 p
.TestImports
= pp
.TestImports
252 p
.XTestGoFiles
= pp
.XTestGoFiles
253 p
.XTestImports
= pp
.XTestImports
261 // isStandardImportPath reports whether $GOROOT/src/path should be considered
262 // part of the standard distribution. For historical reasons we allow people to add
263 // their own code to $GOROOT instead of using $GOPATH, but we assume that
264 // code will start with a domain name (dot in the first element).
265 func isStandardImportPath(path
string) bool {
266 i
:= strings
.Index(path
, "/")
271 return !strings
.Contains(elem
, ".")
274 // A PackageError describes an error loading information about a package.
275 type PackageError
struct {
276 ImportStack
[]string // shortest path from package named on command line to this one
277 Pos
string // position of error
278 Err
string // the error itself
279 IsImportCycle
bool `json:"-"` // the error is an import cycle
280 Hard
bool `json:"-"` // whether the error is soft or hard; soft errors are ignored in some places
283 func (p
*PackageError
) Error() string {
284 // Import cycles deserve special treatment.
286 return fmt
.Sprintf("%s\npackage %s\n", p
.Err
, strings
.Join(p
.ImportStack
, "\n\timports "))
289 // Omit import stack. The full path to the file where the error
290 // is the most important thing.
291 return p
.Pos
+ ": " + p
.Err
293 if len(p
.ImportStack
) == 0 {
296 return "package " + strings
.Join(p
.ImportStack
, "\n\timports ") + ": " + p
.Err
299 // An ImportStack is a stack of import paths.
300 type ImportStack
[]string
302 func (s
*ImportStack
) Push(p
string) {
306 func (s
*ImportStack
) Pop() {
307 *s
= (*s
)[0 : len(*s
)-1]
310 func (s
*ImportStack
) Copy() []string {
311 return append([]string{}, *s
...)
314 // shorterThan reports whether sp is shorter than t.
315 // We use this to record the shortest import sequence
316 // that leads to a particular package.
317 func (sp
*ImportStack
) shorterThan(t
[]string) bool {
319 if len(s
) != len(t
) {
320 return len(s
) < len(t
)
322 // If they are the same length, settle ties using string ordering.
328 return false // they are equal
331 // packageCache is a lookup cache for loadPackage,
332 // so that if we look up a package multiple times
333 // we return the same pointer each time.
334 var packageCache
= map[string]*Package
{}
336 func ClearPackageCache() {
337 for name
:= range packageCache
{
338 delete(packageCache
, name
)
342 func ClearPackageCachePartial(args
[]string) {
343 for _
, arg
:= range args
{
344 p
:= packageCache
[arg
]
346 delete(packageCache
, p
.Dir
)
347 delete(packageCache
, p
.ImportPath
)
352 // reloadPackage is like loadPackage but makes sure
353 // not to use the package cache.
354 func ReloadPackage(arg
string, stk
*ImportStack
) *Package
{
355 p
:= packageCache
[arg
]
357 delete(packageCache
, p
.Dir
)
358 delete(packageCache
, p
.ImportPath
)
360 return LoadPackage(arg
, stk
)
363 // dirToImportPath returns the pseudo-import path we use for a package
364 // outside the Go path. It begins with _/ and then contains the full path
365 // to the directory. If the package lives in c:\home\gopher\my\pkg then
366 // the pseudo-import path is _/c_/home/gopher/my/pkg.
367 // Using a pseudo-import path like this makes the ./ imports no longer
368 // a special case, so that all the code to deal with ordinary imports works
370 func dirToImportPath(dir
string) string {
371 return pathpkg
.Join("_", strings
.Map(makeImportValid
, filepath
.ToSlash(dir
)))
374 func makeImportValid(r rune
) rune
{
375 // Should match Go spec, compilers, and ../../go/parser/parser.go:/isValidImport.
376 const illegalChars
= `!"#$%&'()*,:;<=>?[\]^{|}` + "`\uFFFD"
377 if !unicode
.IsGraphic(r
) || unicode
.IsSpace(r
) || strings
.ContainsRune(illegalChars
, r
) {
383 // Mode flags for loadImport and download (in get.go).
385 // ResolveImport means that loadImport should do import path expansion.
386 // That is, ResolveImport means that the import path came from
387 // a source file and has not been expanded yet to account for
388 // vendoring or possible module adjustment.
389 // Every import path should be loaded initially with ResolveImport,
390 // and then the expanded version (for example with the /vendor/ in it)
391 // gets recorded as the canonical import path. At that point, future loads
392 // of that package must not pass ResolveImport, because
393 // disallowVendor will reject direct use of paths containing /vendor/.
394 ResolveImport
= 1 << iota
396 // ResolveModule is for download (part of "go get") and indicates
397 // that the module adjustment should be done, but not vendor adjustment.
400 // GetTestDeps is for download (part of "go get") and indicates
401 // that test dependencies should be fetched too.
405 // LoadImport scans the directory named by path, which must be an import path,
406 // but possibly a local import path (an absolute file system path or one beginning
407 // with ./ or ../). A local relative path is interpreted relative to srcDir.
408 // It returns a *Package describing the package found in that directory.
409 func LoadImport(path
, srcDir
string, parent
*Package
, stk
*ImportStack
, importPos
[]token
.Position
, mode
int) *Package
{
413 // Determine canonical identifier for this package.
414 // For a local import the identifier is the pseudo-import path
415 // we create from the full directory to the package.
416 // Otherwise it is the usual import path.
417 // For vendored imports, it is the expanded form.
420 isLocal
:= build
.IsLocalImport(path
)
422 importPath
= dirToImportPath(filepath
.Join(srcDir
, path
))
423 } else if mode
&ResolveImport
!= 0 {
424 // We do our own path resolution, because we want to
425 // find out the key to use in packageCache without the
426 // overhead of repeated calls to buildContext.Import.
427 // The code is also needed in a few other places anyway.
428 path
= ResolveImportPath(parent
, path
)
430 } else if mode
&ResolveModule
!= 0 {
431 path
= ModuleImportPath(parent
, path
)
435 p
:= packageCache
[importPath
]
437 p
= reusePackage(p
, stk
)
440 p
.Internal
.Local
= isLocal
441 p
.ImportPath
= importPath
442 packageCache
[importPath
] = p
445 // Import always returns bp != nil, even if an error occurs,
446 // in order to return partial information.
447 buildMode
:= build
.ImportComment
448 if mode
&ResolveImport
== 0 || path
!= origPath
{
449 // Not vendoring, or we already found the vendored path.
450 buildMode |
= build
.IgnoreVendor
452 bp
, err
:= cfg
.BuildContext
.Import(path
, srcDir
, buildMode
)
453 bp
.ImportPath
= importPath
455 bp
.BinDir
= cfg
.GOBIN
457 if err
== nil && !isLocal
&& bp
.ImportComment
!= "" && bp
.ImportComment
!= path
&&
458 !strings
.Contains(path
, "/vendor/") && !strings
.HasPrefix(path
, "vendor/") {
459 err
= fmt
.Errorf("code in directory %s expects import %q", bp
.Dir
, bp
.ImportComment
)
462 if p
.Error
!= nil && p
.Error
.Pos
== "" {
463 p
= setErrorPos(p
, importPos
)
466 if origPath
!= cleanImport(origPath
) {
467 p
.Error
= &PackageError
{
468 ImportStack
: stk
.Copy(),
469 Err
: fmt
.Sprintf("non-canonical import path: %q should be %q", origPath
, pathpkg
.Clean(origPath
)),
475 // Checked on every import because the rules depend on the code doing the importing.
476 if perr
:= disallowInternal(srcDir
, p
, stk
); perr
!= p
{
477 return setErrorPos(perr
, importPos
)
479 if mode
&ResolveImport
!= 0 {
480 if perr
:= disallowVendor(srcDir
, origPath
, p
, stk
); perr
!= p
{
481 return setErrorPos(perr
, importPos
)
485 if p
.Name
== "main" && parent
!= nil && parent
.Dir
!= p
.Dir
{
487 perr
.Error
= &PackageError
{
488 ImportStack
: stk
.Copy(),
489 Err
: fmt
.Sprintf("import %q is a program, not an importable package", path
),
491 return setErrorPos(&perr
, importPos
)
494 if p
.Internal
.Local
&& parent
!= nil && !parent
.Internal
.Local
{
496 perr
.Error
= &PackageError
{
497 ImportStack
: stk
.Copy(),
498 Err
: fmt
.Sprintf("local import %q in non-local package", path
),
500 return setErrorPos(&perr
, importPos
)
506 func setErrorPos(p
*Package
, importPos
[]token
.Position
) *Package
{
507 if len(importPos
) > 0 {
509 pos
.Filename
= base
.ShortPath(pos
.Filename
)
510 p
.Error
.Pos
= pos
.String()
515 func cleanImport(path
string) string {
517 path
= pathpkg
.Clean(path
)
518 if strings
.HasPrefix(orig
, "./") && path
!= ".." && !strings
.HasPrefix(path
, "../") {
524 var isDirCache
= map[string]bool{}
526 func isDir(path
string) bool {
527 result
, ok
:= isDirCache
[path
]
532 fi
, err
:= os
.Stat(path
)
533 result
= err
== nil && fi
.IsDir()
534 isDirCache
[path
] = result
538 // ResolveImportPath returns the true meaning of path when it appears in parent.
539 // There are two different resolutions applied.
540 // First, there is Go 1.5 vendoring (golang.org/s/go15vendor).
541 // If vendor expansion doesn't trigger, then the path is also subject to
542 // Go 1.11 vgo legacy conversion (golang.org/issue/25069).
543 func ResolveImportPath(parent
*Package
, path
string) (found
string) {
544 found
= VendoredImportPath(parent
, path
)
548 return ModuleImportPath(parent
, path
)
551 // dirAndRoot returns the source directory and workspace root
552 // for the package p, guaranteeing that root is a path prefix of dir.
553 func dirAndRoot(p
*Package
) (dir
, root
string) {
554 dir
= filepath
.Clean(p
.Dir
)
555 root
= filepath
.Join(p
.Root
, "src")
556 if !str
.HasFilePathPrefix(dir
, root
) || p
.ImportPath
!= "command-line-arguments" && filepath
.Join(root
, p
.ImportPath
) != dir
{
557 // Look for symlinks before reporting error.
558 dir
= expandPath(dir
)
559 root
= expandPath(root
)
562 if !str
.HasFilePathPrefix(dir
, root
) ||
len(dir
) <= len(root
) || dir
[len(root
)] != filepath
.Separator || p
.ImportPath
!= "command-line-arguments" && !p
.Internal
.Local
&& filepath
.Join(root
, p
.ImportPath
) != dir
{
563 base
.Fatalf("unexpected directory layout:\n"+
564 " import path: %s\n"+
567 " expand root: %s\n"+
571 filepath
.Join(p
.Root
, "src"),
572 filepath
.Clean(p
.Dir
),
575 string(filepath
.Separator
))
581 // VendoredImportPath returns the vendor-expansion of path when it appears in parent.
582 // If parent is x/y/z, then path might expand to x/y/z/vendor/path, x/y/vendor/path,
583 // x/vendor/path, vendor/path, or else stay path if none of those exist.
584 // VendoredImportPath returns the expanded path or, if no expansion is found, the original.
585 func VendoredImportPath(parent
*Package
, path
string) (found
string) {
586 if parent
== nil || parent
.Root
== "" {
590 dir
, root
:= dirAndRoot(parent
)
592 vpath
:= "vendor/" + path
593 for i
:= len(dir
); i
>= len(root
); i
-- {
594 if i
< len(dir
) && dir
[i
] != filepath
.Separator
{
597 // Note: checking for the vendor directory before checking
598 // for the vendor/path directory helps us hit the
599 // isDir cache more often. It also helps us prepare a more useful
600 // list of places we looked, to report when an import is not found.
601 if !isDir(filepath
.Join(dir
[:i
], "vendor")) {
604 targ
:= filepath
.Join(dir
[:i
], vpath
)
605 if isDir(targ
) && hasGoFiles(targ
) {
606 importPath
:= parent
.ImportPath
607 if importPath
== "command-line-arguments" {
608 // If parent.ImportPath is 'command-line-arguments'.
609 // set to relative directory to root (also chopped root directory)
610 importPath
= dir
[len(root
)+1:]
612 // We started with parent's dir c:\gopath\src\foo\bar\baz\quux\xyzzy.
613 // We know the import path for parent's dir.
614 // We chopped off some number of path elements and
615 // added vendor\path to produce c:\gopath\src\foo\bar\baz\vendor\path.
616 // Now we want to know the import path for that directory.
617 // Construct it by chopping the same number of path elements
618 // (actually the same number of bytes) from parent's import path
619 // and then append /vendor/path.
620 chopped
:= len(dir
) - i
621 if chopped
== len(importPath
)+1 {
622 // We walked up from c:\gopath\src\foo\bar
623 // and found c:\gopath\src\vendor\path.
624 // We chopped \foo\bar (length 8) but the import path is "foo/bar" (length 7).
625 // Use "vendor/path" without any prefix.
628 return importPath
[:len(importPath
)-chopped
] + "/" + vpath
635 modulePrefix
= []byte("\nmodule ")
636 goModPathCache
= make(map[string]string)
639 // goModPath returns the module path in the go.mod in dir, if any.
640 func goModPath(dir
string) (path
string) {
641 path
, ok
:= goModPathCache
[dir
]
646 goModPathCache
[dir
] = path
649 data
, err
:= ioutil
.ReadFile(filepath
.Join(dir
, "go.mod"))
654 if bytes
.HasPrefix(data
, modulePrefix
[1:]) {
657 i
= bytes
.Index(data
, modulePrefix
)
665 // Cut line at \n, drop trailing \r if present.
666 if j
:= bytes
.IndexByte(line
, '\n'); j
>= 0 {
669 if line
[len(line
)-1] == '\r' {
670 line
= line
[:len(line
)-1]
672 line
= line
[len("module "):]
674 // If quoted, unquote.
675 path
= strings
.TrimSpace(string(line
))
676 if path
!= "" && path
[0] == '"' {
677 s
, err
:= strconv
.Unquote(path
)
686 // findVersionElement returns the slice indices of the final version element /vN in path.
687 // If there is no such element, it returns -1, -1.
688 func findVersionElement(path
string) (i
, j
int) {
690 for i
= len(path
) - 1; i
>= 0; i
-- {
692 if isVersionElement(path
[i
:j
]) {
701 // isVersionElement reports whether s is a well-formed path version element:
702 // v2, v3, v10, etc, but not v0, v05, v1.
703 func isVersionElement(s
string) bool {
704 if len(s
) < 3 || s
[0] != '/' || s
[1] != 'v' || s
[2] == '0' || s
[2] == '1' && len(s
) == 3 {
707 for i
:= 2; i
< len(s
); i
++ {
708 if s
[i
] < '0' ||
'9' < s
[i
] {
715 // ModuleImportPath translates import paths found in go modules
716 // back down to paths that can be resolved in ordinary builds.
718 // Define “new” code as code with a go.mod file in the same directory
719 // or a parent directory. If an import in new code says x/y/v2/z but
720 // x/y/v2/z does not exist and x/y/go.mod says “module x/y/v2”,
721 // then go build will read the import as x/y/z instead.
722 // See golang.org/issue/25069.
723 func ModuleImportPath(parent
*Package
, path
string) (found
string) {
724 if parent
== nil || parent
.Root
== "" {
728 // If there are no vN elements in path, leave it alone.
729 // (The code below would do the same, but only after
730 // some other file system accesses that we can avoid
731 // here by returning early.)
732 if i
, _
:= findVersionElement(path
); i
< 0 {
736 dir
, root
:= dirAndRoot(parent
)
738 // Consider dir and parents, up to and including root.
739 for i
:= len(dir
); i
>= len(root
); i
-- {
740 if i
< len(dir
) && dir
[i
] != filepath
.Separator
{
743 if goModPath(dir
[:i
]) != "" {
747 // This code is not in a tree with a go.mod,
748 // so apply no changes to the path.
752 // This import is in a tree with a go.mod.
753 // Allow it to refer to code in GOPATH/src/x/y/z as x/y/v2/z
754 // if GOPATH/src/x/y/go.mod says module "x/y/v2",
756 // If x/y/v2/z exists, use it unmodified.
757 if bp
, _
:= cfg
.BuildContext
.Import(path
, "", build
.IgnoreVendor
); bp
.Dir
!= "" {
761 // Otherwise look for a go.mod supplying a version element.
762 // Some version-like elements may appear in paths but not
763 // be module versions; we skip over those to look for module
764 // versions. For example the module m/v2 might have a
765 // package m/v2/api/v1/foo.
768 i
, j
:= findVersionElement(path
[:limit
])
772 if bp
, _
:= cfg
.BuildContext
.Import(path
[:i
], "", build
.IgnoreVendor
); bp
.Dir
!= "" {
773 if mpath
:= goModPath(bp
.Dir
); mpath
!= "" {
774 // Found a valid go.mod file, so we're stopping the search.
775 // If the path is m/v2/p and we found m/go.mod that says
776 // "module m/v2", then we return "m/p".
777 if mpath
== path
[:j
] {
778 return path
[:i
] + path
[j
:]
780 // Otherwise just return the original path.
781 // We didn't find anything worth rewriting,
782 // and the go.mod indicates that we should
783 // not consider parent directories.
792 // hasGoFiles reports whether dir contains any files with names ending in .go.
793 // For a vendor check we must exclude directories that contain no .go files.
794 // Otherwise it is not possible to vendor just a/b/c and still import the
795 // non-vendored a/b. See golang.org/issue/13832.
796 func hasGoFiles(dir
string) bool {
797 fis
, _
:= ioutil
.ReadDir(dir
)
798 for _
, fi
:= range fis
{
799 if !fi
.IsDir() && strings
.HasSuffix(fi
.Name(), ".go") {
806 // reusePackage reuses package p to satisfy the import at the top
807 // of the import stack stk. If this use causes an import loop,
808 // reusePackage updates p's error information to record the loop.
809 func reusePackage(p
*Package
, stk
*ImportStack
) *Package
{
810 // We use p.Internal.Imports==nil to detect a package that
811 // is in the midst of its own loadPackage call
812 // (all the recursion below happens before p.Internal.Imports gets set).
813 if p
.Internal
.Imports
== nil {
815 p
.Error
= &PackageError
{
816 ImportStack
: stk
.Copy(),
817 Err
: "import cycle not allowed",
823 // Don't rewrite the import stack in the error if we have an import cycle.
824 // If we do, we'll lose the path that describes the cycle.
825 if p
.Error
!= nil && !p
.Error
.IsImportCycle
&& stk
.shorterThan(p
.Error
.ImportStack
) {
826 p
.Error
.ImportStack
= stk
.Copy()
831 // disallowInternal checks that srcDir is allowed to import p.
832 // If the import is allowed, disallowInternal returns the original package p.
833 // If not, it returns a new package containing just an appropriate error.
834 func disallowInternal(srcDir
string, p
*Package
, stk
*ImportStack
) *Package
{
835 // golang.org/s/go14internal:
836 // An import of a path containing the element “internal”
837 // is disallowed if the importing code is outside the tree
838 // rooted at the parent of the “internal” directory.
840 // There was an error loading the package; stop here.
845 // The generated 'testmain' package is allowed to access testing/internal/...,
846 // as if it were generated into the testing directory tree
847 // (it's actually in a temporary directory outside any Go tree).
848 // This cleans up a former kludge in passing functionality to the testing package.
849 if strings
.HasPrefix(p
.ImportPath
, "testing/internal") && len(*stk
) >= 2 && (*stk
)[len(*stk
)-2] == "testmain" {
853 // We can't check standard packages with gccgo.
854 if cfg
.BuildContext
.Compiler
== "gccgo" && p
.Standard
{
858 // The stack includes p.ImportPath.
859 // If that's the only thing on the stack, we started
860 // with a name given on the command line, not an
861 // import. Anything listed on the command line is fine.
866 // Check for "internal" element: three cases depending on begin of string and/or end of string.
867 i
, ok
:= findInternal(p
.ImportPath
)
872 // Internal is present.
873 // Map import path back to directory corresponding to parent of internal.
875 i
-- // rewind over slash in ".../internal"
877 parent
:= p
.Dir
[:i
+len(p
.Dir
)-len(p
.ImportPath
)]
878 if str
.HasFilePathPrefix(filepath
.Clean(srcDir
), filepath
.Clean(parent
)) {
882 // Look for symlinks before reporting error.
883 srcDir
= expandPath(srcDir
)
884 parent
= expandPath(parent
)
885 if str
.HasFilePathPrefix(filepath
.Clean(srcDir
), filepath
.Clean(parent
)) {
889 // Internal is present, and srcDir is outside parent's tree. Not allowed.
891 perr
.Error
= &PackageError
{
892 ImportStack
: stk
.Copy(),
893 Err
: "use of internal package not allowed",
895 perr
.Incomplete
= true
899 // findInternal looks for the final "internal" path element in the given import path.
900 // If there isn't one, findInternal returns ok=false.
901 // Otherwise, findInternal returns ok=true and the index of the "internal".
902 func findInternal(path
string) (index
int, ok
bool) {
903 // Three cases, depending on internal at start/end of string or not.
904 // The order matters: we must return the index of the final element,
905 // because the final one produces the most restrictive requirement
908 case strings
.HasSuffix(path
, "/internal"):
909 return len(path
) - len("internal"), true
910 case strings
.Contains(path
, "/internal/"):
911 return strings
.LastIndex(path
, "/internal/") + 1, true
912 case path
== "internal", strings
.HasPrefix(path
, "internal/"):
918 // disallowVendor checks that srcDir is allowed to import p as path.
919 // If the import is allowed, disallowVendor returns the original package p.
920 // If not, it returns a new package containing just an appropriate error.
921 func disallowVendor(srcDir
, path
string, p
*Package
, stk
*ImportStack
) *Package
{
922 // The stack includes p.ImportPath.
923 // If that's the only thing on the stack, we started
924 // with a name given on the command line, not an
925 // import. Anything listed on the command line is fine.
930 if perr
:= disallowVendorVisibility(srcDir
, p
, stk
); perr
!= p
{
934 // Paths like x/vendor/y must be imported as y, never as x/vendor/y.
935 if i
, ok
:= FindVendor(path
); ok
{
937 perr
.Error
= &PackageError
{
938 ImportStack
: stk
.Copy(),
939 Err
: "must be imported as " + path
[i
+len("vendor/"):],
941 perr
.Incomplete
= true
948 // disallowVendorVisibility checks that srcDir is allowed to import p.
949 // The rules are the same as for /internal/ except that a path ending in /vendor
950 // is not subject to the rules, only subdirectories of vendor.
951 // This allows people to have packages and commands named vendor,
952 // for maximal compatibility with existing source trees.
953 func disallowVendorVisibility(srcDir
string, p
*Package
, stk
*ImportStack
) *Package
{
954 // The stack includes p.ImportPath.
955 // If that's the only thing on the stack, we started
956 // with a name given on the command line, not an
957 // import. Anything listed on the command line is fine.
962 // Check for "vendor" element.
963 i
, ok
:= FindVendor(p
.ImportPath
)
968 // Vendor is present.
969 // Map import path back to directory corresponding to parent of vendor.
971 i
-- // rewind over slash in ".../vendor"
973 truncateTo
:= i
+ len(p
.Dir
) - len(p
.ImportPath
)
974 if truncateTo
< 0 ||
len(p
.Dir
) < truncateTo
{
977 parent
:= p
.Dir
[:truncateTo
]
978 if str
.HasFilePathPrefix(filepath
.Clean(srcDir
), filepath
.Clean(parent
)) {
982 // Look for symlinks before reporting error.
983 srcDir
= expandPath(srcDir
)
984 parent
= expandPath(parent
)
985 if str
.HasFilePathPrefix(filepath
.Clean(srcDir
), filepath
.Clean(parent
)) {
989 // Vendor is present, and srcDir is outside parent's tree. Not allowed.
991 perr
.Error
= &PackageError
{
992 ImportStack
: stk
.Copy(),
993 Err
: "use of vendored package not allowed",
995 perr
.Incomplete
= true
999 // FindVendor looks for the last non-terminating "vendor" path element in the given import path.
1000 // If there isn't one, FindVendor returns ok=false.
1001 // Otherwise, FindVendor returns ok=true and the index of the "vendor".
1003 // Note that terminating "vendor" elements don't count: "x/vendor" is its own package,
1004 // not the vendored copy of an import "" (the empty import path).
1005 // This will allow people to have packages or commands named vendor.
1006 // This may help reduce breakage, or it may just be confusing. We'll see.
1007 func FindVendor(path
string) (index
int, ok
bool) {
1008 // Two cases, depending on internal at start of string or not.
1009 // The order matters: we must return the index of the final element,
1010 // because the final one is where the effective import path starts.
1012 case strings
.Contains(path
, "/vendor/"):
1013 return strings
.LastIndex(path
, "/vendor/") + 1, true
1014 case strings
.HasPrefix(path
, "vendor/"):
1023 ToTool TargetDir
= iota // to GOROOT/pkg/tool (default for cmd/*)
1024 ToBin
// to bin dir inside package root (default for non-cmd/*)
1025 StalePath
// an old import path; fail to build
1028 // InstallTargetDir reports the target directory for installing the command p.
1029 func InstallTargetDir(p
*Package
) TargetDir
{
1030 if strings
.HasPrefix(p
.ImportPath
, "code.google.com/p/go.tools/cmd/") {
1033 if p
.Goroot
&& strings
.HasPrefix(p
.ImportPath
, "cmd/") && p
.Name
== "main" {
1034 switch p
.ImportPath
{
1035 case "cmd/go", "cmd/gofmt":
1043 var cgoExclude
= map[string]bool{
1044 "runtime/cgo": true,
1047 var cgoSyscallExclude
= map[string]bool{
1048 "runtime/cgo": true,
1049 "runtime/race": true,
1050 "runtime/msan": true,
1053 var foldPath
= make(map[string]string)
1055 // load populates p using information from bp, err, which should
1056 // be the result of calling build.Context.Import.
1057 func (p
*Package
) load(stk
*ImportStack
, bp
*build
.Package
, err error
) {
1060 // Decide whether p was listed on the command line.
1061 // Given that load is called while processing the command line,
1062 // you might think we could simply pass a flag down into load
1063 // saying whether we are loading something named on the command
1064 // line or something to satisfy an import. But the first load of a
1065 // package named on the command line may be as a dependency
1066 // of an earlier package named on the command line, not when we
1067 // get to that package during command line processing.
1068 // For example "go test fmt reflect" will load reflect as a dependency
1069 // of fmt before it attempts to load as a command-line argument.
1070 // Because loads are cached, the later load will be a no-op,
1071 // so it is important that the first load can fill in CmdlinePkg correctly.
1072 // Hence the call to an explicit matching check here.
1073 p
.Internal
.CmdlinePkg
= isCmdlinePkg(p
)
1075 p
.Internal
.Asmflags
= BuildAsmflags
.For(p
)
1076 p
.Internal
.Gcflags
= BuildGcflags
.For(p
)
1077 p
.Internal
.Ldflags
= BuildLdflags
.For(p
)
1078 p
.Internal
.Gccgoflags
= BuildGccgoflags
.For(p
)
1080 // The localPrefix is the path we interpret ./ imports relative to.
1081 // Synthesized main packages sometimes override this.
1082 if p
.Internal
.Local
{
1083 p
.Internal
.LocalPrefix
= dirToImportPath(p
.Dir
)
1087 if _
, ok
:= err
.(*build
.NoGoError
); ok
{
1088 err
= &NoGoError
{Package
: p
}
1091 err
= base
.ExpandScanner(err
)
1092 p
.Error
= &PackageError
{
1093 ImportStack
: stk
.Copy(),
1099 useBindir
:= p
.Name
== "main"
1101 switch cfg
.BuildBuildmode
{
1102 case "c-archive", "c-shared", "plugin":
1108 // Report an error when the old code.google.com/p/go.tools paths are used.
1109 if InstallTargetDir(p
) == StalePath
{
1110 newPath
:= strings
.Replace(p
.ImportPath
, "code.google.com/p/go.", "golang.org/x/", 1)
1111 e
:= fmt
.Sprintf("the %v command has moved; use %v instead.", p
.ImportPath
, newPath
)
1112 p
.Error
= &PackageError
{Err
: e
}
1115 _
, elem
:= filepath
.Split(p
.Dir
)
1116 full
:= cfg
.BuildContext
.GOOS
+ "_" + cfg
.BuildContext
.GOARCH
+ "/" + elem
1117 if cfg
.BuildContext
.GOOS
!= base
.ToolGOOS || cfg
.BuildContext
.GOARCH
!= base
.ToolGOARCH
{
1118 // Install cross-compiled binaries to subdirectories of bin.
1121 if p
.Internal
.Build
.BinDir
!= "" {
1122 // Install to GOBIN or bin of GOPATH entry.
1123 p
.Target
= filepath
.Join(p
.Internal
.Build
.BinDir
, elem
)
1124 if !p
.Goroot
&& strings
.Contains(elem
, "/") && cfg
.GOBIN
!= "" {
1125 // Do not create $GOBIN/goos_goarch/elem.
1127 p
.Internal
.GobinSubdir
= true
1130 if InstallTargetDir(p
) == ToTool
{
1131 // This is for 'go tool'.
1132 // Override all the usual logic and force it into the tool directory.
1133 if cfg
.BuildToolchainName
== "gccgo" {
1134 p
.Target
= filepath
.Join(base
.ToolDir
, elem
)
1136 p
.Target
= filepath
.Join(cfg
.GOROOTpkg
, "tool", full
)
1139 if p
.Target
!= "" && cfg
.BuildContext
.GOOS
== "windows" {
1142 } else if p
.Internal
.Local
{
1143 // Local import turned into absolute path.
1144 // No permanent install target.
1147 p
.Target
= p
.Internal
.Build
.PkgObj
1148 if cfg
.BuildLinkshared
{
1149 shlibnamefile
:= p
.Target
[:len(p
.Target
)-2] + ".shlibname"
1150 shlib
, err
:= ioutil
.ReadFile(shlibnamefile
)
1151 if err
!= nil && !os
.IsNotExist(err
) {
1152 base
.Fatalf("reading shlibname: %v", err
)
1155 libname
:= strings
.TrimSpace(string(shlib
))
1156 if cfg
.BuildContext
.Compiler
== "gccgo" {
1157 p
.Shlib
= filepath
.Join(p
.Internal
.Build
.PkgTargetRoot
, "shlibs", libname
)
1159 p
.Shlib
= filepath
.Join(p
.Internal
.Build
.PkgTargetRoot
, libname
)
1165 // Build augmented import list to add implicit dependencies.
1166 // Be careful not to add imports twice, just to avoid confusion.
1167 importPaths
:= p
.Imports
1168 addImport
:= func(path
string) {
1169 for _
, p
:= range importPaths
{
1174 importPaths
= append(importPaths
, path
)
1177 // Cgo translation adds imports of "runtime/cgo" and "syscall",
1178 // except for certain packages, to avoid circular dependencies.
1179 if p
.UsesCgo() && (!p
.Standard ||
!cgoExclude
[p
.ImportPath
]) && cfg
.BuildContext
.Compiler
!= "gccgo" {
1180 addImport("runtime/cgo")
1182 if p
.UsesCgo() && (!p
.Standard ||
!cgoSyscallExclude
[p
.ImportPath
]) {
1183 addImport("syscall")
1186 // SWIG adds imports of some standard packages.
1188 if cfg
.BuildContext
.Compiler
!= "gccgo" {
1189 addImport("runtime/cgo")
1191 addImport("syscall")
1194 // TODO: The .swig and .swigcxx files can use
1195 // %go_import directives to import other packages.
1198 // The linker loads implicit dependencies.
1199 if p
.Name
== "main" && !p
.Internal
.ForceLibrary
{
1200 for _
, dep
:= range LinkerDeps(p
) {
1205 // Check for case-insensitive collision of input files.
1206 // To avoid problems on case-insensitive files, we reject any package
1207 // where two different input files have equal names under a case-insensitive
1209 inputs
:= p
.AllFiles()
1210 f1
, f2
:= str
.FoldDup(inputs
)
1212 p
.Error
= &PackageError
{
1213 ImportStack
: stk
.Copy(),
1214 Err
: fmt
.Sprintf("case-insensitive file name collision: %q and %q", f1
, f2
),
1219 // If first letter of input file is ASCII, it must be alphanumeric.
1220 // This avoids files turning into flags when invoking commands,
1221 // and other problems we haven't thought of yet.
1222 // Also, _cgo_ files must be generated by us, not supplied.
1223 // They are allowed to have //go:cgo_ldflag directives.
1224 // The directory scan ignores files beginning with _,
1225 // so we shouldn't see any _cgo_ files anyway, but just be safe.
1226 for _
, file
:= range inputs
{
1227 if !SafeArg(file
) || strings
.HasPrefix(file
, "_cgo_") {
1228 p
.Error
= &PackageError
{
1229 ImportStack
: stk
.Copy(),
1230 Err
: fmt
.Sprintf("invalid input file name %q", file
),
1235 if name
:= pathpkg
.Base(p
.ImportPath
); !SafeArg(name
) {
1236 p
.Error
= &PackageError
{
1237 ImportStack
: stk
.Copy(),
1238 Err
: fmt
.Sprintf("invalid input directory name %q", name
),
1242 if !SafeArg(p
.ImportPath
) {
1243 p
.Error
= &PackageError
{
1244 ImportStack
: stk
.Copy(),
1245 Err
: fmt
.Sprintf("invalid import path %q", p
.ImportPath
),
1250 // Build list of imported packages and full dependency list.
1251 imports
:= make([]*Package
, 0, len(p
.Imports
))
1252 for i
, path
:= range importPaths
{
1256 p1
:= LoadImport(path
, p
.Dir
, p
, stk
, p
.Internal
.Build
.ImportPos
[path
], ResolveImport
)
1257 if p
.Standard
&& p
.Error
== nil && !p1
.Standard
&& p1
.Error
== nil {
1258 p
.Error
= &PackageError
{
1259 ImportStack
: stk
.Copy(),
1260 Err
: fmt
.Sprintf("non-standard import %q in standard package %q", path
, p
.ImportPath
),
1262 pos
:= p
.Internal
.Build
.ImportPos
[path
]
1264 p
.Error
.Pos
= pos
[0].String()
1268 path
= p1
.ImportPath
1269 importPaths
[i
] = path
1270 if i
< len(p
.Imports
) {
1274 imports
= append(imports
, p1
)
1279 p
.Internal
.Imports
= imports
1281 deps
:= make(map[string]*Package
)
1283 q
= append(q
, imports
...)
1284 for i
:= 0; i
< len(q
); i
++ {
1286 path
:= p1
.ImportPath
1287 // The same import path could produce an error or not,
1288 // depending on what tries to import it.
1289 // Prefer to record entries with errors, so we can report them.
1291 if p0
== nil || p1
.Error
!= nil && (p0
.Error
== nil ||
len(p0
.Error
.ImportStack
) > len(p1
.Error
.ImportStack
)) {
1293 for _
, p2
:= range p1
.Internal
.Imports
{
1294 if deps
[p2
.ImportPath
] != p2
{
1301 p
.Deps
= make([]string, 0, len(deps
))
1302 for dep
:= range deps
{
1303 p
.Deps
= append(p
.Deps
, dep
)
1305 sort
.Strings(p
.Deps
)
1306 for _
, dep
:= range p
.Deps
{
1309 panic("impossible: missing entry in package cache for " + dep
+ " imported by " + p
.ImportPath
)
1311 if p1
.Error
!= nil {
1312 p
.DepsErrors
= append(p
.DepsErrors
, p1
.Error
)
1316 // unsafe is a fake package.
1317 if p
.Standard
&& (p
.ImportPath
== "unsafe" || cfg
.BuildContext
.Compiler
== "gccgo") {
1321 // If cgo is not enabled, ignore cgo supporting sources
1322 // just as we ignore go files containing import "C".
1323 if !cfg
.BuildContext
.CgoEnabled
{
1328 p
.SwigCXXFiles
= nil
1329 // Note that SFiles are okay (they go to the Go assembler)
1330 // and HFiles are okay (they might be used by the SFiles).
1331 // Also Sysofiles are okay (they might not contain object
1332 // code; see issue #16050).
1335 setError
:= func(msg
string) {
1336 p
.Error
= &PackageError
{
1337 ImportStack
: stk
.Copy(),
1342 // The gc toolchain only permits C source files with cgo or SWIG.
1343 if len(p
.CFiles
) > 0 && !p
.UsesCgo() && !p
.UsesSwig() && cfg
.BuildContext
.Compiler
== "gc" {
1344 setError(fmt
.Sprintf("C source files not allowed when not using cgo or SWIG: %s", strings
.Join(p
.CFiles
, " ")))
1348 // C++, Objective-C, and Fortran source files are permitted only with cgo or SWIG,
1349 // regardless of toolchain.
1350 if len(p
.CXXFiles
) > 0 && !p
.UsesCgo() && !p
.UsesSwig() {
1351 setError(fmt
.Sprintf("C++ source files not allowed when not using cgo or SWIG: %s", strings
.Join(p
.CXXFiles
, " ")))
1354 if len(p
.MFiles
) > 0 && !p
.UsesCgo() && !p
.UsesSwig() {
1355 setError(fmt
.Sprintf("Objective-C source files not allowed when not using cgo or SWIG: %s", strings
.Join(p
.MFiles
, " ")))
1358 if len(p
.FFiles
) > 0 && !p
.UsesCgo() && !p
.UsesSwig() {
1359 setError(fmt
.Sprintf("Fortran source files not allowed when not using cgo or SWIG: %s", strings
.Join(p
.FFiles
, " ")))
1363 // Check for case-insensitive collisions of import paths.
1364 fold
:= str
.ToFold(p
.ImportPath
)
1365 if other
:= foldPath
[fold
]; other
== "" {
1366 foldPath
[fold
] = p
.ImportPath
1367 } else if other
!= p
.ImportPath
{
1368 setError(fmt
.Sprintf("case-insensitive import collision: %q and %q", p
.ImportPath
, other
))
1373 // SafeArg reports whether arg is a "safe" command-line argument,
1374 // meaning that when it appears in a command-line, it probably
1375 // doesn't have some special meaning other than its own name.
1376 // Obviously args beginning with - are not safe (they look like flags).
1377 // Less obviously, args beginning with @ are not safe (they look like
1378 // GNU binutils flagfile specifiers, sometimes called "response files").
1379 // To be conservative, we reject almost any arg beginning with non-alphanumeric ASCII.
1380 // We accept leading . _ and / as likely in file system paths.
1381 // There is a copy of this function in cmd/compile/internal/gc/noder.go.
1382 func SafeArg(name
string) bool {
1387 return '0' <= c
&& c
<= '9' ||
'A' <= c
&& c
<= 'Z' ||
'a' <= c
&& c
<= 'z' || c
== '.' || c
== '_' || c
== '/' || c
>= utf8
.RuneSelf
1390 // LinkerDeps returns the list of linker-induced dependencies for main package p.
1391 func LinkerDeps(p
*Package
) []string {
1392 // Everything links runtime.
1393 deps
:= []string{"runtime"}
1395 // External linking mode forces an import of runtime/cgo.
1396 if externalLinkingForced(p
) && cfg
.BuildContext
.Compiler
!= "gccgo" {
1397 deps
= append(deps
, "runtime/cgo")
1399 // On ARM with GOARM=5, it forces an import of math, for soft floating point.
1400 if cfg
.Goarch
== "arm" {
1401 deps
= append(deps
, "math")
1403 // Using the race detector forces an import of runtime/race.
1405 deps
= append(deps
, "runtime/race")
1407 // Using memory sanitizer forces an import of runtime/msan.
1409 deps
= append(deps
, "runtime/msan")
1415 // externalLinkingForced reports whether external linking is being
1416 // forced even for programs that do not use cgo.
1417 func externalLinkingForced(p
*Package
) bool {
1418 // Some targets must use external linking even inside GOROOT.
1419 switch cfg
.BuildContext
.GOOS
{
1423 switch cfg
.BuildContext
.GOARCH
{
1424 case "arm", "arm64":
1429 if !cfg
.BuildContext
.CgoEnabled
{
1432 // Currently build modes c-shared, pie (on systems that do not
1433 // support PIE with internal linking mode (currently all
1434 // systems: issue #18968)), plugin, and -linkshared force
1435 // external linking mode, as of course does
1436 // -ldflags=-linkmode=external. External linking mode forces
1437 // an import of runtime/cgo.
1438 pieCgo
:= cfg
.BuildBuildmode
== "pie"
1439 linkmodeExternal
:= false
1441 ldflags
:= BuildLdflags
.For(p
)
1442 for i
, a
:= range ldflags
{
1443 if a
== "-linkmode=external" {
1444 linkmodeExternal
= true
1446 if a
== "-linkmode" && i
+1 < len(ldflags
) && ldflags
[i
+1] == "external" {
1447 linkmodeExternal
= true
1452 return cfg
.BuildBuildmode
== "c-shared" || cfg
.BuildBuildmode
== "plugin" || pieCgo || cfg
.BuildLinkshared || linkmodeExternal
1455 // mkAbs rewrites list, which must be paths relative to p.Dir,
1456 // into a sorted list of absolute paths. It edits list in place but for
1457 // convenience also returns list back to its caller.
1458 func (p
*Package
) mkAbs(list
[]string) []string {
1459 for i
, f
:= range list
{
1460 list
[i
] = filepath
.Join(p
.Dir
, f
)
1466 // InternalGoFiles returns the list of Go files being built for the package,
1467 // using absolute paths.
1468 func (p
*Package
) InternalGoFiles() []string {
1469 return p
.mkAbs(str
.StringList(p
.GoFiles
, p
.CgoFiles
, p
.TestGoFiles
, p
.XTestGoFiles
))
1472 // InternalGoFiles returns the list of all Go files possibly relevant for the package,
1473 // using absolute paths. "Possibly relevant" means that files are not excluded
1474 // due to build tags, but files with names beginning with . or _ are still excluded.
1475 func (p
*Package
) InternalAllGoFiles() []string {
1477 for _
, f
:= range p
.IgnoredGoFiles
{
1478 if f
!= "" && f
[0] != '.' || f
[0] != '_' {
1479 extra
= append(extra
, f
)
1482 return p
.mkAbs(str
.StringList(extra
, p
.GoFiles
, p
.CgoFiles
, p
.TestGoFiles
, p
.XTestGoFiles
))
1485 // usesSwig reports whether the package needs to run SWIG.
1486 func (p
*Package
) UsesSwig() bool {
1487 return len(p
.SwigFiles
) > 0 ||
len(p
.SwigCXXFiles
) > 0
1490 // usesCgo reports whether the package needs to run cgo
1491 func (p
*Package
) UsesCgo() bool {
1492 return len(p
.CgoFiles
) > 0
1495 // packageList returns the list of packages in the dag rooted at roots
1496 // as visited in a depth-first post-order traversal.
1497 func PackageList(roots
[]*Package
) []*Package
{
1498 seen
:= map[*Package
]bool{}
1500 var walk
func(*Package
)
1501 walk
= func(p
*Package
) {
1506 for _
, p1
:= range p
.Internal
.Imports
{
1509 all
= append(all
, p
)
1511 for _
, root
:= range roots
{
1517 var cmdCache
= map[string]*Package
{}
1519 func ClearCmdCache() {
1520 for name
:= range cmdCache
{
1521 delete(cmdCache
, name
)
1525 // loadPackage is like loadImport but is used for command-line arguments,
1526 // not for paths found in import statements. In addition to ordinary import paths,
1527 // loadPackage accepts pseudo-paths beginning with cmd/ to denote commands
1528 // in the Go command directory, as well as paths to those directories.
1529 func LoadPackage(arg
string, stk
*ImportStack
) *Package
{
1530 if build
.IsLocalImport(arg
) {
1532 if !filepath
.IsAbs(dir
) {
1533 if abs
, err
:= filepath
.Abs(dir
); err
== nil {
1534 // interpret relative to current directory
1538 if sub
, ok
:= hasSubdir(cfg
.GOROOTsrc
, dir
); ok
&& strings
.HasPrefix(sub
, "cmd/") && !strings
.Contains(sub
[4:], "/") {
1542 if strings
.HasPrefix(arg
, "cmd/") && !strings
.Contains(arg
[4:], "/") {
1543 if p
:= cmdCache
[arg
]; p
!= nil {
1549 bp
, err
:= cfg
.BuildContext
.ImportDir(filepath
.Join(cfg
.GOROOTsrc
, arg
), 0)
1552 bp
.BinDir
= cfg
.GOROOTbin
1553 if cfg
.GOROOTbin
!= "" {
1554 bp
.BinDir
= cfg
.GOROOTbin
1556 bp
.Root
= cfg
.GOROOT
1557 bp
.SrcRoot
= cfg
.GOROOTsrc
1560 p
.load(stk
, bp
, err
)
1561 if p
.Error
== nil && p
.Name
!= "main" {
1562 p
.Error
= &PackageError
{
1563 ImportStack
: stk
.Copy(),
1564 Err
: fmt
.Sprintf("expected package main but found package %s in %s", p
.Name
, p
.Dir
),
1570 // Wasn't a command; must be a package.
1571 // If it is a local import path but names a standard package,
1572 // we treat it as if the user specified the standard package.
1573 // This lets you run go test ./ioutil in package io and be
1574 // referring to io/ioutil rather than a hypothetical import of
1576 if build
.IsLocalImport(arg
) {
1577 bp
, _
:= cfg
.BuildContext
.ImportDir(filepath
.Join(base
.Cwd
, arg
), build
.FindOnly
)
1578 if bp
.ImportPath
!= "" && bp
.ImportPath
!= "." {
1583 return LoadImport(arg
, base
.Cwd
, nil, stk
, nil, 0)
1586 // packages returns the packages named by the
1587 // command line arguments 'args'. If a named package
1588 // cannot be loaded at all (for example, if the directory does not exist),
1589 // then packages prints an error and does not include that
1590 // package in the results. However, if errors occur trying
1591 // to load dependencies of a named package, the named
1592 // package is still returned, with p.Incomplete = true
1593 // and details in p.DepsErrors.
1594 func Packages(args
[]string) []*Package
{
1596 for _
, pkg
:= range PackagesAndErrors(args
) {
1597 if pkg
.Error
!= nil {
1598 base
.Errorf("can't load package: %s", pkg
.Error
)
1601 pkgs
= append(pkgs
, pkg
)
1606 // packagesAndErrors is like 'packages' but returns a
1607 // *Package for every argument, even the ones that
1608 // cannot be loaded at all.
1609 // The packages that fail to load will have p.Error != nil.
1610 func PackagesAndErrors(args
[]string) []*Package
{
1611 if len(args
) > 0 && strings
.HasSuffix(args
[0], ".go") {
1612 return []*Package
{GoFilesPackage(args
)}
1615 args
= ImportPaths(args
)
1619 seenArg
= make(map[string]bool)
1620 seenPkg
= make(map[*Package
]bool)
1623 for _
, arg
:= range args
{
1628 pkg
:= LoadPackage(arg
, &stk
)
1633 pkgs
= append(pkgs
, pkg
)
1639 // packagesForBuild is like 'packages' but fails if any of
1640 // the packages or their dependencies have errors
1641 // (cannot be built).
1642 func PackagesForBuild(args
[]string) []*Package
{
1643 pkgs
:= PackagesAndErrors(args
)
1644 printed
:= map[*PackageError
]bool{}
1645 for _
, pkg
:= range pkgs
{
1646 if pkg
.Error
!= nil {
1647 base
.Errorf("can't load package: %s", pkg
.Error
)
1649 for _
, err
:= range pkg
.DepsErrors
{
1650 // Since these are errors in dependencies,
1651 // the same error might show up multiple times,
1652 // once in each package that depends on it.
1653 // Only print each once.
1656 base
.Errorf("%s", err
)
1662 // Check for duplicate loads of the same package.
1663 // That should be impossible, but if it does happen then
1664 // we end up trying to build the same package twice,
1665 // usually in parallel overwriting the same files,
1666 // which doesn't work very well.
1667 seen
:= map[string]bool{}
1668 reported
:= map[string]bool{}
1669 for _
, pkg
:= range PackageList(pkgs
) {
1670 if seen
[pkg
.ImportPath
] && !reported
[pkg
.ImportPath
] {
1671 reported
[pkg
.ImportPath
] = true
1672 base
.Errorf("internal error: duplicate loads of %s", pkg
.ImportPath
)
1674 seen
[pkg
.ImportPath
] = true
1681 // GoFilesPackage creates a package for building a collection of Go files
1682 // (typically named on the command line). The target is named p.a for
1683 // package p or named after the first Go file for package main.
1684 func GoFilesPackage(gofiles
[]string) *Package
{
1685 // TODO: Remove this restriction.
1686 for _
, f
:= range gofiles
{
1687 if !strings
.HasSuffix(f
, ".go") {
1688 base
.Fatalf("named files must be .go files")
1693 ctxt
:= cfg
.BuildContext
1694 ctxt
.UseAllFiles
= true
1696 // Synthesize fake "directory" that only shows the named files,
1697 // to make it look like this is a standard package or
1698 // command directory. So that local imports resolve
1699 // consistently, the files must all be in the same directory.
1700 var dirent
[]os
.FileInfo
1702 for _
, file
:= range gofiles
{
1703 fi
, err
:= os
.Stat(file
)
1705 base
.Fatalf("%s", err
)
1708 base
.Fatalf("%s is a directory, should be a Go file", file
)
1710 dir1
, _
:= filepath
.Split(file
)
1716 } else if dir
!= dir1
{
1717 base
.Fatalf("named files must all be in one directory; have %s and %s", dir
, dir1
)
1719 dirent
= append(dirent
, fi
)
1721 ctxt
.ReadDir
= func(string) ([]os
.FileInfo
, error
) { return dirent
, nil }
1727 dir
, err
= filepath
.Abs(dir
)
1729 base
.Fatalf("%s", err
)
1732 bp
, err
:= ctxt
.ImportDir(dir
, 0)
1734 pkg
.Internal
.Local
= true
1735 pkg
.Internal
.CmdlineFiles
= true
1737 pkg
.load(&stk
, bp
, err
)
1739 pkg
.Internal
.LocalPrefix
= dirToImportPath(dir
)
1740 pkg
.ImportPath
= "command-line-arguments"
1743 if pkg
.Name
== "main" {
1744 _
, elem
:= filepath
.Split(gofiles
[0])
1745 exe
:= elem
[:len(elem
)-len(".go")] + cfg
.ExeSuffix
1746 if cfg
.BuildO
== "" {
1749 if cfg
.GOBIN
!= "" {
1750 pkg
.Target
= filepath
.Join(cfg
.GOBIN
, exe
)
1757 // GetTestPackagesFor returns package structs ptest, the package p plus
1758 // its test files, and pxtest, the external tests of package p.
1759 // pxtest may be nil. If there are no test files, forceTest decides
1760 // whether this returns a new package struct or just returns p.
1761 func GetTestPackagesFor(p
*Package
, forceTest
bool) (ptest
, pxtest
*Package
, err error
) {
1762 var imports
, ximports
[]*Package
1764 stk
.Push(p
.ImportPath
+ " (test)")
1765 rawTestImports
:= str
.StringList(p
.TestImports
)
1766 for i
, path
:= range p
.TestImports
{
1767 p1
:= LoadImport(path
, p
.Dir
, p
, &stk
, p
.Internal
.Build
.TestImportPos
[path
], ResolveImport
)
1768 if p1
.Error
!= nil {
1769 return nil, nil, p1
.Error
1771 if len(p1
.DepsErrors
) > 0 {
1772 err
:= p1
.DepsErrors
[0]
1773 err
.Pos
= "" // show full import stack
1774 return nil, nil, err
1776 if str
.Contains(p1
.Deps
, p
.ImportPath
) || p1
.ImportPath
== p
.ImportPath
{
1777 // Same error that loadPackage returns (via reusePackage) in pkg.go.
1778 // Can't change that code, because that code is only for loading the
1779 // non-test copy of a package.
1780 err
:= &PackageError
{
1781 ImportStack
: testImportStack(stk
[0], p1
, p
.ImportPath
),
1782 Err
: "import cycle not allowed in test",
1783 IsImportCycle
: true,
1785 return nil, nil, err
1787 p
.TestImports
[i
] = p1
.ImportPath
1788 imports
= append(imports
, p1
)
1791 stk
.Push(p
.ImportPath
+ "_test")
1792 pxtestNeedsPtest
:= false
1793 rawXTestImports
:= str
.StringList(p
.XTestImports
)
1794 for i
, path
:= range p
.XTestImports
{
1795 p1
:= LoadImport(path
, p
.Dir
, p
, &stk
, p
.Internal
.Build
.XTestImportPos
[path
], ResolveImport
)
1796 if p1
.Error
!= nil {
1797 return nil, nil, p1
.Error
1799 if len(p1
.DepsErrors
) > 0 {
1800 err
:= p1
.DepsErrors
[0]
1801 err
.Pos
= "" // show full import stack
1802 return nil, nil, err
1804 if p1
.ImportPath
== p
.ImportPath
{
1805 pxtestNeedsPtest
= true
1807 ximports
= append(ximports
, p1
)
1809 p
.XTestImports
[i
] = p1
.ImportPath
1814 if len(p
.TestGoFiles
) > 0 || forceTest
{
1815 ptest
= new(Package
)
1818 ptest
.GoFiles
= append(ptest
.GoFiles
, p
.GoFiles
...)
1819 ptest
.GoFiles
= append(ptest
.GoFiles
, p
.TestGoFiles
...)
1821 // Note: The preparation of the vet config requires that common
1822 // indexes in ptest.Imports, ptest.Internal.Imports, and ptest.Internal.RawImports
1823 // all line up (but RawImports can be shorter than the others).
1824 // That is, for 0 ≤ i < len(RawImports),
1825 // RawImports[i] is the import string in the program text,
1826 // Imports[i] is the expanded import string (vendoring applied or relative path expanded away),
1827 // and Internal.Imports[i] is the corresponding *Package.
1828 // Any implicitly added imports appear in Imports and Internal.Imports
1829 // but not RawImports (because they were not in the source code).
1830 // We insert TestImports, imports, and rawTestImports at the start of
1831 // these lists to preserve the alignment.
1832 ptest
.Imports
= str
.StringList(p
.TestImports
, p
.Imports
)
1833 ptest
.Internal
.Imports
= append(imports
, p
.Internal
.Imports
...)
1834 ptest
.Internal
.RawImports
= str
.StringList(rawTestImports
, p
.Internal
.RawImports
)
1835 ptest
.Internal
.ForceLibrary
= true
1836 ptest
.Internal
.Build
= new(build
.Package
)
1837 *ptest
.Internal
.Build
= *p
.Internal
.Build
1838 m
:= map[string][]token
.Position
{}
1839 for k
, v
:= range p
.Internal
.Build
.ImportPos
{
1840 m
[k
] = append(m
[k
], v
...)
1842 for k
, v
:= range p
.Internal
.Build
.TestImportPos
{
1843 m
[k
] = append(m
[k
], v
...)
1845 ptest
.Internal
.Build
.ImportPos
= m
1850 // External test package.
1851 if len(p
.XTestGoFiles
) > 0 {
1853 PackagePublic
: PackagePublic
{
1854 Name
: p
.Name
+ "_test",
1855 ImportPath
: p
.ImportPath
+ "_test",
1858 GoFiles
: p
.XTestGoFiles
,
1859 Imports
: p
.XTestImports
,
1861 Internal
: PackageInternal
{
1862 LocalPrefix
: p
.Internal
.LocalPrefix
,
1863 Build
: &build
.Package
{
1864 ImportPos
: p
.Internal
.Build
.XTestImportPos
,
1867 RawImports
: rawXTestImports
,
1869 Asmflags
: p
.Internal
.Asmflags
,
1870 Gcflags
: p
.Internal
.Gcflags
,
1871 Ldflags
: p
.Internal
.Ldflags
,
1872 Gccgoflags
: p
.Internal
.Gccgoflags
,
1875 if pxtestNeedsPtest
{
1876 pxtest
.Internal
.Imports
= append(pxtest
.Internal
.Imports
, ptest
)
1880 return ptest
, pxtest
, nil
1883 func testImportStack(top
string, p
*Package
, target
string) []string {
1884 stk
:= []string{top
, p
.ImportPath
}
1886 for p
.ImportPath
!= target
{
1887 for _
, p1
:= range p
.Internal
.Imports
{
1888 if p1
.ImportPath
== target || str
.Contains(p1
.Deps
, target
) {
1889 stk
= append(stk
, p1
.ImportPath
)
1894 // Can't happen, but in case it does...
1895 stk
= append(stk
, "<lost path to cycle>")