Source file src/pkg/cmd/go/internal/modload/import.go

     1	// Copyright 2018 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.
     4	
     5	package modload
     6	
     7	import (
     8		"bytes"
     9		"errors"
    10		"fmt"
    11		"go/build"
    12		"internal/goroot"
    13		"os"
    14		"path/filepath"
    15		"sort"
    16		"strings"
    17		"time"
    18	
    19		"cmd/go/internal/cfg"
    20		"cmd/go/internal/modfetch"
    21		"cmd/go/internal/module"
    22		"cmd/go/internal/par"
    23		"cmd/go/internal/search"
    24		"cmd/go/internal/semver"
    25		"cmd/go/internal/str"
    26	)
    27	
    28	type ImportMissingError struct {
    29		ImportPath string
    30		Module     module.Version
    31	
    32		// newMissingVersion is set to a newer version of Module if one is present
    33		// in the build list. When set, we can't automatically upgrade.
    34		newMissingVersion string
    35	}
    36	
    37	func (e *ImportMissingError) Error() string {
    38		if e.Module.Path == "" {
    39			if str.HasPathPrefix(e.ImportPath, "cmd") {
    40				return fmt.Sprintf("package %s is not in GOROOT (%s)", e.ImportPath, filepath.Join(cfg.GOROOT, "src", e.ImportPath))
    41			}
    42			return "cannot find module providing package " + e.ImportPath
    43		}
    44		return "missing module for import: " + e.Module.Path + "@" + e.Module.Version + " provides " + e.ImportPath
    45	}
    46	
    47	// Import finds the module and directory in the build list
    48	// containing the package with the given import path.
    49	// The answer must be unique: Import returns an error
    50	// if multiple modules attempt to provide the same package.
    51	// Import can return a module with an empty m.Path, for packages in the standard library.
    52	// Import can return an empty directory string, for fake packages like "C" and "unsafe".
    53	//
    54	// If the package cannot be found in the current build list,
    55	// Import returns an ImportMissingError as the error.
    56	// If Import can identify a module that could be added to supply the package,
    57	// the ImportMissingError records that module.
    58	func Import(path string) (m module.Version, dir string, err error) {
    59		if strings.Contains(path, "@") {
    60			return module.Version{}, "", fmt.Errorf("import path should not have @version")
    61		}
    62		if build.IsLocalImport(path) {
    63			return module.Version{}, "", fmt.Errorf("relative import not supported")
    64		}
    65		if path == "C" || path == "unsafe" {
    66			// There's no directory for import "C" or import "unsafe".
    67			return module.Version{}, "", nil
    68		}
    69	
    70		// Is the package in the standard library?
    71		if search.IsStandardImportPath(path) &&
    72			goroot.IsStandardPackage(cfg.GOROOT, cfg.BuildContext.Compiler, path) {
    73			if targetInGorootSrc {
    74				if dir, ok := dirInModule(path, targetPrefix, ModRoot(), true); ok {
    75					return Target, dir, nil
    76				}
    77			}
    78			dir := filepath.Join(cfg.GOROOT, "src", path)
    79			return module.Version{}, dir, nil
    80		}
    81		if str.HasPathPrefix(path, "cmd") {
    82			return module.Version{}, "", &ImportMissingError{ImportPath: path}
    83		}
    84	
    85		// -mod=vendor is special.
    86		// Everything must be in the main module or the main module's vendor directory.
    87		if cfg.BuildMod == "vendor" {
    88			mainDir, mainOK := dirInModule(path, targetPrefix, ModRoot(), true)
    89			vendorDir, vendorOK := dirInModule(path, "", filepath.Join(ModRoot(), "vendor"), false)
    90			if mainOK && vendorOK {
    91				return module.Version{}, "", fmt.Errorf("ambiguous import: found %s in multiple directories:\n\t%s\n\t%s", path, mainDir, vendorDir)
    92			}
    93			// Prefer to return main directory if there is one,
    94			// Note that we're not checking that the package exists.
    95			// We'll leave that for load.
    96			if !vendorOK && mainDir != "" {
    97				return Target, mainDir, nil
    98			}
    99			readVendorList()
   100			return vendorMap[path], vendorDir, nil
   101		}
   102	
   103		// Check each module on the build list.
   104		var dirs []string
   105		var mods []module.Version
   106		for _, m := range buildList {
   107			if !maybeInModule(path, m.Path) {
   108				// Avoid possibly downloading irrelevant modules.
   109				continue
   110			}
   111			root, isLocal, err := fetch(m)
   112			if err != nil {
   113				// Report fetch error.
   114				// Note that we don't know for sure this module is necessary,
   115				// but it certainly _could_ provide the package, and even if we
   116				// continue the loop and find the package in some other module,
   117				// we need to look at this module to make sure the import is
   118				// not ambiguous.
   119				return module.Version{}, "", err
   120			}
   121			dir, ok := dirInModule(path, m.Path, root, isLocal)
   122			if ok {
   123				mods = append(mods, m)
   124				dirs = append(dirs, dir)
   125			}
   126		}
   127		if len(mods) == 1 {
   128			return mods[0], dirs[0], nil
   129		}
   130		if len(mods) > 0 {
   131			var buf bytes.Buffer
   132			fmt.Fprintf(&buf, "ambiguous import: found %s in multiple modules:", path)
   133			for i, m := range mods {
   134				fmt.Fprintf(&buf, "\n\t%s", m.Path)
   135				if m.Version != "" {
   136					fmt.Fprintf(&buf, " %s", m.Version)
   137				}
   138				fmt.Fprintf(&buf, " (%s)", dirs[i])
   139			}
   140			return module.Version{}, "", errors.New(buf.String())
   141		}
   142	
   143		// Look up module containing the package, for addition to the build list.
   144		// Goal is to determine the module, download it to dir, and return m, dir, ErrMissing.
   145		if cfg.BuildMod == "readonly" {
   146			return module.Version{}, "", fmt.Errorf("import lookup disabled by -mod=%s", cfg.BuildMod)
   147		}
   148	
   149		// Not on build list.
   150		// To avoid spurious remote fetches, next try the latest replacement for each module.
   151		// (golang.org/issue/26241)
   152		if modFile != nil {
   153			latest := map[string]string{} // path -> version
   154			for _, r := range modFile.Replace {
   155				if maybeInModule(path, r.Old.Path) {
   156					latest[r.Old.Path] = semver.Max(r.Old.Version, latest[r.Old.Path])
   157				}
   158			}
   159	
   160			mods = make([]module.Version, 0, len(latest))
   161			for p, v := range latest {
   162				// If the replacement didn't specify a version, synthesize a
   163				// pseudo-version with an appropriate major version and a timestamp below
   164				// any real timestamp. That way, if the main module is used from within
   165				// some other module, the user will be able to upgrade the requirement to
   166				// any real version they choose.
   167				if v == "" {
   168					if _, pathMajor, ok := module.SplitPathVersion(p); ok && len(pathMajor) > 0 {
   169						v = modfetch.PseudoVersion(pathMajor[1:], "", time.Time{}, "000000000000")
   170					} else {
   171						v = modfetch.PseudoVersion("v0", "", time.Time{}, "000000000000")
   172					}
   173				}
   174				mods = append(mods, module.Version{Path: p, Version: v})
   175			}
   176	
   177			// Every module path in mods is a prefix of the import path.
   178			// As in QueryPackage, prefer the longest prefix that satisfies the import.
   179			sort.Slice(mods, func(i, j int) bool {
   180				return len(mods[i].Path) > len(mods[j].Path)
   181			})
   182			for _, m := range mods {
   183				root, isLocal, err := fetch(m)
   184				if err != nil {
   185					// Report fetch error as above.
   186					return module.Version{}, "", err
   187				}
   188				_, ok := dirInModule(path, m.Path, root, isLocal)
   189				if ok {
   190					return m, "", &ImportMissingError{ImportPath: path, Module: m}
   191				}
   192			}
   193		}
   194	
   195		candidates, err := QueryPackage(path, "latest", Allowed)
   196		if err != nil {
   197			if errors.Is(err, os.ErrNotExist) {
   198				// Return "cannot find module providing package […]" instead of whatever
   199				// low-level error QueryPackage produced.
   200				return module.Version{}, "", &ImportMissingError{ImportPath: path}
   201			} else {
   202				return module.Version{}, "", err
   203			}
   204		}
   205		m = candidates[0].Mod
   206		newMissingVersion := ""
   207		for _, c := range candidates {
   208			cm := c.Mod
   209			for _, bm := range buildList {
   210				if bm.Path == cm.Path && semver.Compare(bm.Version, cm.Version) > 0 {
   211					// QueryPackage proposed that we add module cm to provide the package,
   212					// but we already depend on a newer version of that module (and we don't
   213					// have the package).
   214					//
   215					// This typically happens when a package is present at the "@latest"
   216					// version (e.g., v1.0.0) of a module, but we have a newer version
   217					// of the same module in the build list (e.g., v1.0.1-beta), and
   218					// the package is not present there.
   219					m = cm
   220					newMissingVersion = bm.Version
   221					break
   222				}
   223			}
   224		}
   225		return m, "", &ImportMissingError{ImportPath: path, Module: m, newMissingVersion: newMissingVersion}
   226	}
   227	
   228	// maybeInModule reports whether, syntactically,
   229	// a package with the given import path could be supplied
   230	// by a module with the given module path (mpath).
   231	func maybeInModule(path, mpath string) bool {
   232		return mpath == path ||
   233			len(path) > len(mpath) && path[len(mpath)] == '/' && path[:len(mpath)] == mpath
   234	}
   235	
   236	var haveGoModCache, haveGoFilesCache par.Cache
   237	
   238	// dirInModule locates the directory that would hold the package named by the given path,
   239	// if it were in the module with module path mpath and root mdir.
   240	// If path is syntactically not within mpath,
   241	// or if mdir is a local file tree (isLocal == true) and the directory
   242	// that would hold path is in a sub-module (covered by a go.mod below mdir),
   243	// dirInModule returns "", false.
   244	//
   245	// Otherwise, dirInModule returns the name of the directory where
   246	// Go source files would be expected, along with a boolean indicating
   247	// whether there are in fact Go source files in that directory.
   248	func dirInModule(path, mpath, mdir string, isLocal bool) (dir string, haveGoFiles bool) {
   249		// Determine where to expect the package.
   250		if path == mpath {
   251			dir = mdir
   252		} else if mpath == "" { // vendor directory
   253			dir = filepath.Join(mdir, path)
   254		} else if len(path) > len(mpath) && path[len(mpath)] == '/' && path[:len(mpath)] == mpath {
   255			dir = filepath.Join(mdir, path[len(mpath)+1:])
   256		} else {
   257			return "", false
   258		}
   259	
   260		// Check that there aren't other modules in the way.
   261		// This check is unnecessary inside the module cache
   262		// and important to skip in the vendor directory,
   263		// where all the module trees have been overlaid.
   264		// So we only check local module trees
   265		// (the main module, and any directory trees pointed at by replace directives).
   266		if isLocal {
   267			for d := dir; d != mdir && len(d) > len(mdir); {
   268				haveGoMod := haveGoModCache.Do(d, func() interface{} {
   269					fi, err := os.Stat(filepath.Join(d, "go.mod"))
   270					return err == nil && !fi.IsDir()
   271				}).(bool)
   272	
   273				if haveGoMod {
   274					return "", false
   275				}
   276				parent := filepath.Dir(d)
   277				if parent == d {
   278					// Break the loop, as otherwise we'd loop
   279					// forever if d=="." and mdir=="".
   280					break
   281				}
   282				d = parent
   283			}
   284		}
   285	
   286		// Now committed to returning dir (not "").
   287	
   288		// Are there Go source files in the directory?
   289		// We don't care about build tags, not even "+build ignore".
   290		// We're just looking for a plausible directory.
   291		haveGoFiles = haveGoFilesCache.Do(dir, func() interface{} {
   292			f, err := os.Open(dir)
   293			if err != nil {
   294				return false
   295			}
   296			defer f.Close()
   297			names, _ := f.Readdirnames(-1)
   298			for _, name := range names {
   299				if strings.HasSuffix(name, ".go") {
   300					info, err := os.Stat(filepath.Join(dir, name))
   301					if err == nil && info.Mode().IsRegular() {
   302						return true
   303					}
   304				}
   305			}
   306			return false
   307		}).(bool)
   308	
   309		return dir, haveGoFiles
   310	}
   311	

View as plain text