cue/load: update for OCI modules

Note: This is an experimental feature and is intended for internal-only
use for now.

Summary of changes:
- adapt cue/load/internal/registrytest to use OCI registry API;
- change cue/load to use new internal/mod/modfile package;
- change cue/load.TestLoad to use tdtest package for easier test
updating;
- change cue/load to support inferring major module version from
module.cue deps.
- remove now-unused packages inside cue/load/internal.

For #2330.

Signed-off-by: Roger Peppe <rogpeppe@gmail.com>
Change-Id: I7b6d71993c253e6525fc3a69216e87d814ba6b3e
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1168508
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: CUEcueckoo <cueckoo@cuelang.org>

cmd/cue/cmd/testdata/script/eval_loaderr.txtar

@@ -1,6 +1,6 @@
-! exec cue eval non-existing .
+! exec cue eval nonexisting .
 ! stdout .
 cmp stderr expect-stderr
 
 -- expect-stderr --
-cannot find package "non-existing"
+cannot find package "nonexisting"

cue/load/config.go

@@ -27,6 +27,7 @@ import (
 	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/cue/token"
 	"cuelang.org/go/internal"
+	"cuelang.org/go/internal/mod/modfile"
 )
 
 const (
@@ -139,7 +140,7 @@ type Config struct {
 	// if no module file was present. If non-nil, then
 	// after calling Config.complete, modFile.Module will be
 	// equal to Module.
-	modFile *modFile
+	modFile *modfile.File
 
 	// Package defines the name of the package to be loaded. If this is not set,
 	// the package must be uniquely defined from its context. Special values:
@@ -364,6 +365,7 @@ func (c Config) complete() (cfg *Config, err error) {
 	} else if !filepath.IsAbs(c.ModuleRoot) {
 		c.ModuleRoot = filepath.Join(c.Dir, c.ModuleRoot)
 	}
+	//c.Registry = "registry.cue.works"
 	if c.Registry != "" {
 		u, err := url.Parse(c.Registry)
 		if err != nil {

cue/load/import.go

@@ -15,17 +15,20 @@
 package load
 
 import (
+	"context"
 	"fmt"
 	"os"
 	pathpkg "path"
 	"path/filepath"
 	"sort"
 	"strings"
 
+	"cuelang.org/go/cue/ast"
 	"cuelang.org/go/cue/build"
 	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/cue/token"
 	"cuelang.org/go/internal/filetypes"
+	"cuelang.org/go/internal/mod/module"
 )
 
 // importPkg returns details about the CUE package named by the import path,
@@ -353,15 +356,25 @@ func (l *loader) absDirFromImportPath(pos token.Pos, p importPath) (absDir, name
 		p = p[:i]
 
 	default: // p[i] == '/'
-		name = string(p[i+1:])
+		mp, _, ok := module.SplitPathVersion(string(p))
+		if ok {
+			// import of the form: example.com/foo/bar@v1
+			if i := strings.LastIndex(mp, "/"); i >= 0 {
+				name = mp[i+1:]
+			}
+		} else {
+			name = string(p[i+1:])
+		}
 	}
-
 	// TODO: fully test that name is a valid identifier.
 	if name == "" {
 		err = errors.Newf(pos, "empty package name in import path %q", p)
 	} else if strings.IndexByte(name, '.') >= 0 {
 		err = errors.Newf(pos,
 			"cannot determine package name for %q (set explicitly with ':')", p)
+	} else if !ast.IsValidIdent(name) {
+		err = errors.Newf(pos,
+			"implied package identifier %q from import path %q is not valid", name, p)
 	}
 
 	// Determine the directory.
@@ -381,7 +394,7 @@ func (l *loader) absDirFromImportPath(pos token.Pos, p importPath) (absDir, name
 			absDir, err = l.externalPackageDir(p)
 			if err != nil {
 				// TODO why can't we use %w ?
-				return "", name, errors.Newf(token.NoPos, "cannot get directory for external module %q: %v", p, err)
+				return "", name, errors.Newf(token.NoPos, "cannot get directory for external module %q (registry %q): %v", p, l.cfg.Registry, err)
 			}
 		} else {
 			absDir = filepath.Join(GenPath(l.cfg.ModuleRoot), sub)
@@ -392,12 +405,15 @@ func (l *loader) absDirFromImportPath(pos token.Pos, p importPath) (absDir, name
 }
 
 func (l *loader) externalPackageDir(p importPath) (dir string, err error) {
-	m, subPath, ok := l.deps.lookup(p)
-	if !ok {
-		return "", fmt.Errorf("no dependency found for import path %q", p)
+	if l.deps == nil {
+		return "", fmt.Errorf("no dependency found for import path %q (no dependencies at all)", p)
+	}
+	m, subPath, err := l.deps.lookup(p)
+	if err != nil {
+		return "", err
 	}
 
-	dir, err = l.regClient.getModContents(m)
+	dir, err = l.regClient.getModContents(context.TODO(), m)
 	if err != nil {
 		return "", fmt.Errorf("cannot get contents for %v: %v", m, err)
 	}

cue/load/import_test.go

@@ -15,6 +15,7 @@
 package load
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -37,15 +38,23 @@ func getInst(pkg, cwd string) (*build.Instance, error) {
 	// all the way to the root of the git repository, causing Go's test caching
 	// to never kick in, as the .git directory almost always changes.
 	// Moreover, it's extra work that isn't useful to the tests.
-	c, _ := (&Config{ModuleRoot: cwd, Dir: cwd}).complete()
+	c, err := (&Config{ModuleRoot: cwd, Dir: cwd}).complete()
+	if err != nil {
+		return nil, fmt.Errorf("unexpected error on Config.complete: %v", err)
+	}
 	l := loader{cfg: c}
 	inst := l.newRelInstance(token.NoPos, pkg, c.Package)
 	p := l.importPkg(token.NoPos, inst)[0]
 	return p, p.Err
 }
 
 func TestEmptyImport(t *testing.T) {
-	c, _ := (&Config{}).complete()
+	c, err := (&Config{
+		ModuleRoot: ".",
+	}).complete()
+	if err != nil {
+		t.Fatal(err)
+	}
 	l := loader{cfg: c}
 	inst := l.newInstance(token.NoPos, "")
 	p := l.importPkg(token.NoPos, inst)[0]

cue/load/instances.go

@@ -20,6 +20,7 @@ package load
 //    - go/build
 
 import (
+	"fmt"
 	"os"
 
 	"cuelang.org/go/cue/ast"
@@ -56,12 +57,16 @@ func Instances(args []string, c *Config) []*build.Instance {
 		if err != nil {
 			return []*build.Instance{c.newErrInstance(err)}
 		}
-		regClient = newRegistryClient(c.Registry, tmpDir)
+		regClient, err = newRegistryClient(c.Registry, tmpDir)
+		if err != nil {
+			return []*build.Instance{c.newErrInstance(fmt.Errorf("cannot make registry client: %v", err))}
+		}
 		deps1, err := resolveDependencies(c.modFile, regClient)
 		if err != nil {
 			return []*build.Instance{c.newErrInstance(err)}
 		}
 		deps = deps1
+
 	}
 	tg := newTagger(c)
 	l := newLoader(c, tg, deps, regClient)