Merge branch 'golang:master' into master

Author: kumarlokesh

api/go1.25.txt

@@ -101,6 +101,7 @@ pkg testing, method (*F) Output() io.Writer #59928
 pkg testing, method (*T) Attr(string, string) #43936
 pkg testing, method (*T) Output() io.Writer #59928
 pkg testing, type TB interface, Attr(string, string) #43936
+pkg testing, type TB interface, Output() io.Writer #59928
 pkg testing/fstest, method (MapFS) Lstat(string) (fs.FileInfo, error) #49580
 pkg testing/fstest, method (MapFS) ReadLink(string) (string, error) #49580
 pkg testing/synctest, func Test(*testing.T, func(*testing.T)) #67434

src/cmd/compile/internal/inline/inl.go

@@ -785,7 +785,7 @@ func inlineCallCheck(callerfn *ir.Func, call *ir.CallExpr) (bool, bool) {
 	if call.Op() != ir.OCALLFUNC {
 		return false, false
 	}
-	if call.GoDefer {
+	if call.GoDefer || call.NoInline {
 		return false, false
 	}
 

src/cmd/compile/internal/inline/interleaved/interleaved.go

@@ -279,7 +279,12 @@ func (s *inlClosureState) mark(n ir.Node) ir.Node {
 
 	ok := match(n)
 
-	ir.EditChildren(n, s.mark)
+	// can't wrap TailCall's child into ParenExpr
+	if t, ok := n.(*ir.TailCallStmt); ok {
+		ir.EditChildren(t.Call, s.mark)
+	} else {
+		ir.EditChildren(n, s.mark)
+	}
 
 	if ok {
 		if p == nil {
@@ -317,23 +322,6 @@ func (s *inlClosureState) unparenthesize() {
 			n = paren.X
 		}
 		ir.EditChildren(n, unparen)
-		// special case for tail calls: if the tail call was inlined, transform
-		// the tail call to a return stmt if the inlined function was not void,
-		// otherwise replace it with the inlined expression followed by a return.
-		if tail, ok := n.(*ir.TailCallStmt); ok {
-			if inl, done := tail.Call.(*ir.InlinedCallExpr); done {
-				if len(inl.ReturnVars) != 0 {
-					ret := ir.NewReturnStmt(tail.Pos(), []ir.Node{inl})
-					if len(inl.ReturnVars) > 1 {
-						typecheck.RewriteMultiValueCall(ret, inl)
-					}
-					n = ret
-				} else {
-					ret := ir.NewReturnStmt(tail.Pos(), nil)
-					n = ir.NewBlockStmt(tail.Pos(), []ir.Node{inl, ret})
-				}
-			}
-		}
 		return n
 	}
 	ir.EditChildren(s.fn, unparen)
@@ -370,9 +358,11 @@ func (s *inlClosureState) fixpoint() bool {
 }
 
 func match(n ir.Node) bool {
-	switch n.(type) {
+	switch n := n.(type) {
 	case *ir.CallExpr:
 		return true
+	case *ir.TailCallStmt:
+		n.Call.NoInline = true // can't inline yet
 	}
 	return false
 }

src/cmd/compile/internal/ir/expr.go

@@ -191,6 +191,7 @@ type CallExpr struct {
 	KeepAlive []*Name // vars to be kept alive until call returns
 	IsDDD     bool
 	GoDefer   bool // whether this call is part of a go or defer statement
+	NoInline  bool // whether this call must not be inlined
 }
 
 func NewCallExpr(pos src.XPos, op Op, fun Node, args []Node) *CallExpr {

src/cmd/compile/internal/ir/node_gen.go

@@ -479,7 +479,7 @@ func NewSwitchStmt(pos src.XPos, tag Node, cases []*CaseClause) *SwitchStmt {
 // code generation to jump directly to another function entirely.
 type TailCallStmt struct {
 	miniStmt
-	Call Node // the underlying call
+	Call *CallExpr // the underlying call
 }
 
 func NewTailCallStmt(pos src.XPos, call *CallExpr) *TailCallStmt {

src/cmd/compile/internal/ir/stmt.go

@@ -25,19 +25,21 @@ determines its index in the series.
                   SectionMeta
                   SectionPosBase
                   SectionPkg
-                  SectionName    // TODO(markfreeman) Define.
-                  SectionType    // TODO(markfreeman) Define.
-                  SectionObj     // TODO(markfreeman) Define.
+                  SectionName
+                  SectionType
+                  SectionObj
                   SectionObjExt  // TODO(markfreeman) Define.
                   SectionObjDict // TODO(markfreeman) Define.
                   SectionBody    // TODO(markfreeman) Define.
                   .
 
 # Sections
 A section is a series of elements of a type determined by the section's
-kind. Go constructs are mapped onto (potentially multiple) elements.
-Elements are accessed using an index relative to the start of the
-section.
+kind. Go constructs are mapped onto one or more elements with possibly
+different types; in that case, the elements are in different sections.
+
+Elements are accessed using an element index relative to the start of
+the section.
 
     RelElemIdx = Uint64 .
 
@@ -47,6 +49,9 @@ outside the string section access string values by reference.
 
     SectionString = { String } .
 
+Note that despite being an element, a string does not begin with a
+reference table.
+
 ## Meta Section
 The meta section provides fundamental information for a package. It
 contains exactly two elements — a public root and a private root.
@@ -135,6 +140,97 @@ Note, a PkgRef is *not* equivalent to Ref[Pkg] due to an extra marker.
                  Ref[Pkg]
                  .
 
+## Type Section
+The type section is a series of type definition elements.
+
+    SectionType = { TypeDef } .
+
+A type definition can be in one of several formats, which are identified
+by their TypeSpec code.
+
+    TypeDef     = RefTable
+                  [ Sync ]
+                  [ Sync ]
+                  Uint64            // denotes which TypeSpec to use
+                  TypeSpec
+                  .
+
+    TypeSpec    = TypeSpecBasic     // TODO(markfreeman): Define.
+                | TypeSpecNamed     // TODO(markfreeman): Define.
+                | TypeSpecPointer   // TODO(markfreeman): Define.
+                | TypeSpecSlice     // TODO(markfreeman): Define.
+                | TypeSpecArray     // TODO(markfreeman): Define.
+                | TypeSpecChan      // TODO(markfreeman): Define.
+                | TypeSpecMap       // TODO(markfreeman): Define.
+                | TypeSpecSignature // TODO(markfreeman): Define.
+                | TypeSpecStruct    // TODO(markfreeman): Define.
+                | TypeSpecInterface // TODO(markfreeman): Define.
+                | TypeSpecUnion     // TODO(markfreeman): Define.
+                | TypeSpecTypeParam // TODO(markfreeman): Define.
+                  .
+
+// TODO(markfreeman): Document the reader dictionary once we understand it more.
+To use a type elsewhere, a TypeUse is encoded.
+
+    TypeUse     = [ Sync ]
+                  Bool              // whether it is a derived type
+                  [ Uint64 ]        // if derived, an index into the reader dictionary
+                  [ Ref[TypeDef] ]  // else, a reference to the type
+                  .
+
+## Object Sections
+Information about an object (e.g. variable, function, type name, etc.)
+is split into multiple elements in different sections. Those elements
+have the same section-relative element index.
+
+### Name Section
+The name section holds a series of names.
+
+    SectionName = { Name } .
+
+Names are elements holding qualified identifiers and type information
+for objects.
+
+    Name        = RefTable
+                  [ Sync ]
+                  [ Sync ]
+                  PkgRef    // the object's package
+                  StringRef // the object's package-local name
+                  [ Sync ]
+                  Uint64    // the object's type (e.g. Var, Func, etc.)
+                  .
+
+### Definition Section
+The definition section holds definitions for objects defined by the target
+package; it does not contain definitions for imported objects.
+
+    SectionObj = { ObjectDef } .
+
+Object definitions can be in one of several formats. To determine the correct
+format, the name section must be referenced; it contains a code indicating
+the object's type.
+
+    ObjectDef = RefTable
+                [ Sync ]
+                ObjectSpec
+                .
+
+    ObjectSpec = ObjectSpecConst     // TODO(markfreeman) Define.
+               | ObjectSpecFunc      // TODO(markfreeman) Define.
+               | ObjectSpecAlias     // TODO(markfreeman) Define.
+               | ObjectSpecNamedType // TODO(markfreeman) Define.
+               | ObjectSpecVar       // TODO(markfreeman) Define.
+                 .
+
+To use an object definition elsewhere, an ObjectUse is encoded.
+
+    ObjectUse  = [ Sync ]
+                 [ Bool ]
+                 Ref[ObjectDef]
+                 Uint64              // the number of type arguments
+                 { TypeUse }         // references to the type arguments
+                 .
+
 # References
 A reference table precedes every element. Each entry in the table
 contains a (section, index) pair denoting the location of the
@@ -152,10 +248,15 @@ referenced element.
 Elements encode references to other elements as an index in the
 reference table — not the location of the referenced element directly.
 
-    // TODO(markfreeman): Rename to RefUse.
-    UseReloc = [ Sync ]
-               RelElemIdx
-               .
+    RefTableIdx   = Uint64 .
+
+To do this, the Ref[T] primitive is used as below; note that this is
+the same shape as provided by package pkgbits, just with new
+interpretation applied.
+
+    Ref[T]        = [ Sync ]
+                    RefTableIdx       // the Uint64
+                    .
 
 # Primitives
 Primitive encoding is handled separately by the pkgbits package. Check

src/cmd/compile/internal/noder/doc.go

@@ -458,7 +458,7 @@ func Renameinit() *types.Sym {
 func checkEmbed(decl *syntax.VarDecl, haveEmbed, withinFunc bool) error {
 	switch {
 	case !haveEmbed:
-		return errors.New("go:embed only allowed in Go files that import \"embed\"")
+		return errors.New("go:embed requires import \"embed\" (or import _ \"embed\", if package is not used)")
 	case len(decl.NameList) > 1:
 		return errors.New("go:embed cannot apply to multiple vars")
 	case decl.Values != nil:

src/cmd/compile/internal/noder/noder.go

@@ -3996,11 +3996,12 @@ func addTailCall(pos src.XPos, fn *ir.Func, recv ir.Node, method *types.Field) {
 
 	if recv.Type() != nil && recv.Type().IsPtr() && method.Type.Recv().Type.IsPtr() &&
 		method.Embedded != 0 && !types.IsInterfaceMethod(method.Type) &&
+		!unifiedHaveInlineBody(ir.MethodExprName(dot).Func) &&
 		!(base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
 		if base.Debug.TailCall != 0 {
 			base.WarnfAt(fn.Nname.Type().Recv().Type.Elem().Pos(), "tail call emitted for the method %v wrapper", method.Nname)
 		}
-		// Prefer OTAILCALL to reduce code size (the called method can be inlined).
+		// Prefer OTAILCALL to reduce code size (except the case when the called method can be inlined).
 		fn.Body.Append(ir.NewTailCallStmt(pos, call))
 		return
 	}

src/cmd/compile/internal/noder/reader.go

@@ -1921,7 +1921,7 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.OTAILCALL:
 		n := n.(*ir.TailCallStmt)
-		s.callResult(n.Call.(*ir.CallExpr), callTail)
+		s.callResult(n.Call, callTail)
 		call := s.mem()
 		b := s.endBlock()
 		b.Kind = ssa.BlockRetJmp // could use BlockExit. BlockRetJmp is mostly for clarity.

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

@@ -137,7 +137,7 @@ assignOK:
 	if cr > len(rhs) {
 		stmt := stmt.(*ir.AssignListStmt)
 		stmt.SetOp(ir.OAS2FUNC)
-		r := rhs[0]
+		r := rhs[0].(*ir.CallExpr)
 		rtyp := r.Type()
 
 		mismatched := false

src/cmd/compile/internal/typecheck/stmt.go

@@ -333,6 +333,7 @@ func TestStdFixed(t *testing.T) {
 		"issue56103.go",  // anonymous interface cycles; will be a type checker error in 1.22
 		"issue52697.go",  // types2 does not have constraints on stack size
 		"issue73309.go",  // this test requires GODEBUG=gotypesalias=1
+		"issue73309b.go", // this test requires GODEBUG=gotypesalias=1
 
 		// These tests requires runtime/cgo.Incomplete, which is only available on some platforms.
 		// However, types2 does not know about build constraints.

src/cmd/compile/internal/types2/stdlib_test.go

@@ -139,8 +139,7 @@ func walkStmt(n ir.Node) ir.Node {
 		n := n.(*ir.TailCallStmt)
 
 		var init ir.Nodes
-		call := n.Call.(*ir.CallExpr)
-		call.Fun = walkExpr(call.Fun, &init)
+		n.Call.Fun = walkExpr(n.Call.Fun, &init)
 
 		if len(init) > 0 {
 			init.Append(n)

src/cmd/compile/internal/walk/stmt.go

@@ -1516,7 +1516,7 @@ func cmdbootstrap() {
 	}
 
 	// To recap, so far we have built the new toolchain
-	// (cmd/asm, cmd/cgo, cmd/compile, cmd/link)
+	// (cmd/asm, cmd/cgo, cmd/compile, cmd/link, cmd/preprofile)
 	// using the Go bootstrap toolchain and go command.
 	// Then we built the new go command (as go_bootstrap)
 	// using the new toolchain and our own build logic (above).
@@ -1589,6 +1589,18 @@ func cmdbootstrap() {
 		os.Setenv("GOCACHE", oldgocache)
 	}
 
+	// Keep in sync with binExes in cmd/distpack/pack.go.
+	binExesIncludedInDistpack := []string{"cmd/go", "cmd/gofmt"}
+
+	// Keep in sync with the filter in cmd/distpack/pack.go.
+	toolsIncludedInDistpack := []string{"cmd/asm", "cmd/cgo", "cmd/compile", "cmd/cover", "cmd/link", "cmd/preprofile", "cmd/vet"}
+
+	// We could install all tools in "cmd", but is unnecessary because we will
+	// remove them in distpack, so instead install the tools that will actually
+	// be included in distpack, which is a superset of toolchain. Not installing
+	// the tools will help us test what happens when the tools aren't present.
+	toolsToInstall := slices.Concat(binExesIncludedInDistpack, toolsIncludedInDistpack)
+
 	if goos == oldgoos && goarch == oldgoarch {
 		// Common case - not setting up for cross-compilation.
 		timelog("build", "toolchain")
@@ -1605,9 +1617,9 @@ func cmdbootstrap() {
 			xprintf("\n")
 		}
 		xprintf("Building commands for host, %s/%s.\n", goos, goarch)
-		goInstall(toolenv(), goBootstrap, "cmd")
-		checkNotStale(toolenv(), goBootstrap, "cmd")
-		checkNotStale(toolenv(), gorootBinGo, "cmd")
+		goInstall(toolenv(), goBootstrap, toolsToInstall...)
+		checkNotStale(toolenv(), goBootstrap, toolsToInstall...)
+		checkNotStale(toolenv(), gorootBinGo, toolsToInstall...)
 
 		timelog("build", "target toolchain")
 		if vflag > 0 {
@@ -1621,12 +1633,12 @@ func cmdbootstrap() {
 		xprintf("Building packages and commands for target, %s/%s.\n", goos, goarch)
 	}
 	goInstall(nil, goBootstrap, "std")
-	goInstall(toolenv(), goBootstrap, "cmd")
+	goInstall(toolenv(), goBootstrap, toolsToInstall...)
 	checkNotStale(toolenv(), goBootstrap, toolchain...)
 	checkNotStale(nil, goBootstrap, "std")
-	checkNotStale(toolenv(), goBootstrap, "cmd")
+	checkNotStale(toolenv(), goBootstrap, toolsToInstall...)
 	checkNotStale(nil, gorootBinGo, "std")
-	checkNotStale(toolenv(), gorootBinGo, "cmd")
+	checkNotStale(toolenv(), gorootBinGo, toolsToInstall...)
 	if debug {
 		run("", ShowOutput|CheckExit, pathf("%s/compile", tooldir), "-V=full")
 		checkNotStale(toolenv(), goBootstrap, toolchain...)
@@ -1677,7 +1689,7 @@ func cmdbootstrap() {
 
 	if distpack {
 		xprintf("Packaging archives for %s/%s.\n", goos, goarch)
-		run("", ShowOutput|CheckExit, pathf("%s/distpack", tooldir))
+		run("", ShowOutput|CheckExit, gorootBinGo, "tool", "distpack")
 	}
 
 	// Print trailing banner unless instructed otherwise.

src/cmd/dist/build.go

@@ -171,6 +171,7 @@ func main() {
 			switch strings.TrimSuffix(path.Base(name), ".exe") {
 			default:
 				return false
+			// Keep in sync with toolsIncludedInDistpack in cmd/dist/build.go.
 			case "asm", "cgo", "compile", "cover", "link", "preprofile", "vet":
 			}
 		}
@@ -179,6 +180,7 @@ func main() {
 
 	// Add go and gofmt to bin, using cross-compiled binaries
 	// if this is a cross-compiled distribution.
+	// Keep in sync with binExesIncludedInDistpack in cmd/dist/build.go.
 	binExes := []string{
 		"go",
 		"gofmt",