Merge remote-tracking branch 'upstream/master'

Author: actions-user

src/cmd/compile/internal/ssa/writebarrier.go

@@ -593,10 +593,7 @@ func (f *Func) computeZeroMap(select1 []*Value) map[ID]ZeroRegion {
 					continue
 				}
 
-				nptr := v.Type.Elem().Size() / ptrSize
-				if nptr > 64 {
-					nptr = 64
-				}
+				nptr := min(64, v.Type.Elem().Size()/ptrSize)
 				zeroes[mem.ID] = ZeroRegion{base: v, mask: 1<<uint(nptr) - 1}
 			}
 		}
@@ -711,11 +708,6 @@ func wbcall(pos src.XPos, b *Block, fn *obj.LSym, sp, mem *Value, args ...*Value
 	return b.NewValue1I(pos, OpSelectN, types.TypeMem, 0, call)
 }
 
-// round to a multiple of r, r is a power of 2.
-func round(o int64, r int64) int64 {
-	return (o + r - 1) &^ (r - 1)
-}
-
 // IsStackAddr reports whether v is known to be an address of a stack slot.
 func IsStackAddr(v *Value) bool {
 	for v.Op == OpOffPtr || v.Op == OpAddPtr || v.Op == OpPtrIndex || v.Op == OpCopy {

src/cmd/go/alldocs.go

@@ -241,6 +241,11 @@ The meta tag has the form:
 
 	<meta name="go-import" content="import-prefix vcs repo-root">
 
+Starting in Go 1.25, an optional subdirectory will be recognized by the
+go command:
+
+	<meta name="go-import" content="import-prefix vcs repo-root subdir">
+
 The import-prefix is the import path corresponding to the repository
 root. It must be a prefix or an exact match of the package being
 fetched with "go get". If it's not an exact match, another http
@@ -255,6 +260,12 @@ The vcs is one of "bzr", "fossil", "git", "hg", "svn".
 The repo-root is the root of the version control system
 containing a scheme and not containing a .vcs qualifier.
 
+The subdir specifies the directory within the repo-root where the
+Go module's root (including its go.mod file) is located. It allows
+you to organize your repository with the Go module code in a subdirectory
+rather than directly at the repository's root.
+If set, all vcs tags must be prefixed with "subdir". i.e. "subdir/v1.2.3"
+
 For example,
 
 	import "example.org/pkg/foo"
@@ -269,8 +280,15 @@ If that page contains the meta tag
 	<meta name="go-import" content="example.org git https://code.org/r/p/exproj">
 
 the go tool will verify that https://example.org/?go-get=1 contains the
-same meta tag and then git clone https://code.org/r/p/exproj into
-GOPATH/src/example.org.
+same meta tag and then download the code from the Git repository at https://code.org/r/p/exproj
+
+If that page contains the meta tag
+
+	<meta name="go-import" content="example.org git https://code.org/r/p/exproj foo/subdir">
+
+the go tool will verify that https://example.org/?go-get=1 contains the same meta
+tag and then download the code from the "foo/subdir" subdirectory within the Git repository
+at https://code.org/r/p/exproj
 
 Downloaded packages are stored in the module cache.
 See https://golang.org/ref/mod#module-cache.

src/cmd/go/internal/help/helpdoc.go

@@ -59,9 +59,11 @@ type codeRepo struct {
 }
 
 // newCodeRepo returns a Repo that reads the source code for the module with the
-// given path, from the repo stored in code, with the root of the repo
-// containing the path given by codeRoot.
-func newCodeRepo(code codehost.Repo, codeRoot, path string) (Repo, error) {
+// given path, from the repo stored in code.
+// codeRoot gives the import path corresponding to the root of the repository,
+// and subdir gives the subdirectory within the repo containing the module.
+// If subdir is empty, the module is at the root of the repo.
+func newCodeRepo(code codehost.Repo, codeRoot, subdir, path string) (Repo, error) {
 	if !hasPathPrefix(path, codeRoot) {
 		return nil, fmt.Errorf("mismatched repo: found %s for %s", codeRoot, path)
 	}
@@ -108,13 +110,26 @@ func newCodeRepo(code codehost.Repo, codeRoot, path string) (Repo, error) {
 	//	pathMajor = .v2
 	//	pseudoMajor = v2
 	//
+	// Starting in 1.25, subdir may be passed in by the go-import meta tag.
+	// So it may be the case that:
+	//	path = github.com/rsc/foo/v2
+	//	codeRoot = github.com/rsc/foo
+	//	subdir = bar/subdir
+	//	pathPrefix = github.com/rsc/foo
+	//	pathMajor = /v2
+	//	pseudoMajor = v2
+	// which means that codeDir = bar/subdir
+
 	codeDir := ""
 	if codeRoot != path {
 		if !hasPathPrefix(pathPrefix, codeRoot) {
 			return nil, fmt.Errorf("repository rooted at %s cannot contain module %s", codeRoot, path)
 		}
 		codeDir = strings.Trim(pathPrefix[len(codeRoot):], "/")
 	}
+	if subdir != "" {
+		codeDir = filepath.ToSlash(filepath.Join(codeDir, subdir))
+	}
 
 	r := &codeRepo{
 		modPath:     path,

src/cmd/go/internal/modfetch/coderepo.go

@@ -884,6 +884,16 @@ var latestTests = []struct {
 		path:    "swtch.com/testmod",
 		version: "v1.1.1",
 	},
+	{
+		vcs:     "git",
+		path:    "vcs-test.golang.org/go/gitreposubdir",
+		version: "v1.2.3",
+	},
+	{
+		vcs:     "git",
+		path:    "vcs-test.golang.org/go/gitreposubdirv2/v2",
+		version: "v2.0.0",
+	},
 }
 
 func TestLatest(t *testing.T) {
@@ -950,7 +960,7 @@ func TestNonCanonicalSemver(t *testing.T) {
 		},
 	}
 
-	cr, err := newCodeRepo(ch, root, root)
+	cr, err := newCodeRepo(ch, root, "", root)
 	if err != nil {
 		t.Fatal(err)
 	}

src/cmd/go/internal/modfetch/coderepo_test.go

@@ -240,7 +240,7 @@ func LookupLocal(ctx context.Context, codeRoot string, path string, dir string)
 			if err != nil {
 				return nil, err
 			}
-			r, err := newCodeRepo(code, codeRoot, path)
+			r, err := newCodeRepo(code, codeRoot, "", path)
 			if err == nil && traceRepo {
 				r = newLoggingRepo(r)
 			}
@@ -319,7 +319,7 @@ func lookupDirect(ctx context.Context, path string) (Repo, error) {
 	if err != nil {
 		return nil, err
 	}
-	return newCodeRepo(code, rr.Root, path)
+	return newCodeRepo(code, rr.Root, rr.SubDir, path)
 }
 
 func lookupCodeRepo(ctx context.Context, rr *vcs.RepoRoot, local bool) (codehost.Repo, error) {

src/cmd/go/internal/modfetch/repo.go

@@ -54,12 +54,17 @@ func parseMetaGoImports(r io.Reader, mod ModuleMode) ([]metaImport, error) {
 		if attrValue(e.Attr, "name") != "go-import" {
 			continue
 		}
-		if f := strings.Fields(attrValue(e.Attr, "content")); len(f) == 3 {
-			imports = append(imports, metaImport{
+		if f := strings.Fields(attrValue(e.Attr, "content")); len(f) == 3 || len(f) == 4 {
+			mi := metaImport{
 				Prefix:   f[0],
 				VCS:      f[1],
 				RepoRoot: f[2],
-			})
+			}
+			// An optional subdirectory may be provided.
+			if len(f) == 4 {
+				mi.SubDir = f[3]
+			}
+			imports = append(imports, mi)
 		}
 	}
 

src/cmd/go/internal/vcs/discovery.go

@@ -18,82 +18,92 @@ var parseMetaGoImportsTests = []struct {
 	{
 		`<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">`,
 		IgnoreMod,
-		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar"}},
+		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar", ""}},
 	},
 	{
 		`<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">
 		<meta name="go-import" content="baz/quux git http://github.com/rsc/baz/quux">`,
 		IgnoreMod,
 		[]metaImport{
-			{"foo/bar", "git", "https://github.com/rsc/foo/bar"},
-			{"baz/quux", "git", "http://github.com/rsc/baz/quux"},
+			{"foo/bar", "git", "https://github.com/rsc/foo/bar", ""},
+			{"baz/quux", "git", "http://github.com/rsc/baz/quux", ""},
 		},
 	},
 	{
 		`<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">
 		<meta name="go-import" content="foo/bar mod http://github.com/rsc/baz/quux">`,
 		IgnoreMod,
 		[]metaImport{
-			{"foo/bar", "git", "https://github.com/rsc/foo/bar"},
+			{"foo/bar", "git", "https://github.com/rsc/foo/bar", ""},
 		},
 	},
 	{
 		`<meta name="go-import" content="foo/bar mod http://github.com/rsc/baz/quux">
 		<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">`,
 		IgnoreMod,
 		[]metaImport{
-			{"foo/bar", "git", "https://github.com/rsc/foo/bar"},
+			{"foo/bar", "git", "https://github.com/rsc/foo/bar", ""},
 		},
 	},
 	{
 		`<meta name="go-import" content="foo/bar mod http://github.com/rsc/baz/quux">
 		<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">`,
 		PreferMod,
 		[]metaImport{
-			{"foo/bar", "mod", "http://github.com/rsc/baz/quux"},
+			{"foo/bar", "mod", "http://github.com/rsc/baz/quux", ""},
 		},
 	},
 	{
 		`<head>
 		<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">
 		</head>`,
 		IgnoreMod,
-		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar"}},
+		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar", ""}},
 	},
 	{
 		`<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">
 		<body>`,
 		IgnoreMod,
-		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar"}},
+		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar", ""}},
 	},
 	{
 		`<!doctype html><meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">`,
 		IgnoreMod,
-		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar"}},
+		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar", ""}},
 	},
 	{
 		// XML doesn't like <div style=position:relative>.
 		`<!doctype html><title>Page Not Found</title><meta name=go-import content="chitin.io/chitin git https://github.com/chitin-io/chitin"><div style=position:relative>DRAFT</div>`,
 		IgnoreMod,
-		[]metaImport{{"chitin.io/chitin", "git", "https://github.com/chitin-io/chitin"}},
+		[]metaImport{{"chitin.io/chitin", "git", "https://github.com/chitin-io/chitin", ""}},
 	},
 	{
 		`<meta name="go-import" content="myitcv.io git https://github.com/myitcv/x">
 	        <meta name="go-import" content="myitcv.io/blah2 mod https://raw.githubusercontent.com/myitcv/pubx/master">
 	        `,
 		IgnoreMod,
-		[]metaImport{{"myitcv.io", "git", "https://github.com/myitcv/x"}},
+		[]metaImport{{"myitcv.io", "git", "https://github.com/myitcv/x", ""}},
 	},
 	{
 		`<meta name="go-import" content="myitcv.io git https://github.com/myitcv/x">
 	        <meta name="go-import" content="myitcv.io/blah2 mod https://raw.githubusercontent.com/myitcv/pubx/master">
 	        `,
 		PreferMod,
 		[]metaImport{
-			{"myitcv.io/blah2", "mod", "https://raw.githubusercontent.com/myitcv/pubx/master"},
-			{"myitcv.io", "git", "https://github.com/myitcv/x"},
+			{"myitcv.io/blah2", "mod", "https://raw.githubusercontent.com/myitcv/pubx/master", ""},
+			{"myitcv.io", "git", "https://github.com/myitcv/x", ""},
 		},
 	},
+	{
+		`<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar subdir">`,
+		IgnoreMod,
+		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar", "subdir"}},
+	},
+	{
+		`<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar subdir/path">`,
+		IgnoreMod,
+		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar", "subdir/path"}},
+	},
 }
 
 func TestParseMetaGoImports(t *testing.T) {

src/cmd/go/internal/vcs/discovery_test.go

@@ -1056,7 +1056,8 @@ func checkGOVCS(vcs *Cmd, root string) error {
 // RepoRoot describes the repository root for a tree of source code.
 type RepoRoot struct {
 	Repo     string // repository URL, including scheme
-	Root     string // import path corresponding to root of repo
+	Root     string // import path corresponding to the SubDir
+	SubDir   string // subdirectory within the repo (empty for root)
 	IsCustom bool   // defined by served <meta> tags (as opposed to hard-coded pattern)
 	VCS      *Cmd
 }
@@ -1368,6 +1369,7 @@ func repoRootForImportDynamic(importPath string, mod ModuleMode, security web.Se
 	rr := &RepoRoot{
 		Repo:     repoURL,
 		Root:     mmi.Prefix,
+		SubDir:   mmi.SubDir,
 		IsCustom: true,
 		VCS:      vcs,
 	}
@@ -1457,9 +1459,9 @@ type fetchResult struct {
 }
 
 // metaImport represents the parsed <meta name="go-import"
-// content="prefix vcs reporoot" /> tags from HTML files.
+// content="prefix vcs reporoot subdir" /> tags from HTML files.
 type metaImport struct {
-	Prefix, VCS, RepoRoot string
+	Prefix, VCS, RepoRoot, SubDir string
 }
 
 // An ImportMismatchError is returned where metaImport/s are present

src/cmd/go/internal/vcs/vcs.go

@@ -425,6 +425,28 @@ func TestMatchGoImport(t *testing.T) {
 			path: "myitcv.io/other",
 			mi:   metaImport{Prefix: "myitcv.io", VCS: "git", RepoRoot: "https://github.com/myitcv/x"},
 		},
+		{
+			imports: []metaImport{
+				{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target", SubDir: "subdir"},
+			},
+			path: "example.com/user/foo",
+			mi:   metaImport{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target", SubDir: "subdir"},
+		},
+		{
+			imports: []metaImport{
+				{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target", SubDir: "foo/subdir"},
+			},
+			path: "example.com/user/foo",
+			mi:   metaImport{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target", SubDir: "foo/subdir"},
+		},
+		{
+			imports: []metaImport{
+				{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target", SubDir: "subdir"},
+				{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target", SubDir: ""},
+			},
+			path: "example.com/user/foo",
+			err:  errors.New("multiple meta tags match import path"),
+		},
 	}
 
 	for _, test := range tests {