Go 1.26.3

VERSION

@@ -1,2 +1,2 @@
-go1.26.2
-time 2026-03-27T21:58:29Z
+go1.26.3
+time 2026-05-04T20:36:18Z

lib/fips140/certified.txt

@@ -0,0 +1 @@
+v1.0.0-c2097c7c

lib/fips140/inprocess.txt

@@ -1 +1 @@
-v1.0.0-c2097c7c
+v1.26.0

src/cmd/compile/internal/bloop/bloop.go

@@ -139,6 +139,16 @@ func preserveStmt(curFn *ir.Func, stmt ir.Node) (ret ir.Node) {
 	ret = stmt
 	switch n := stmt.(type) {
 	case *ir.AssignStmt:
+		// If the left hand side is blank, we need to assign it to a temp
+		// so that it can be kept alive.
+		if ir.IsBlank(n.X) {
+			tmp := typecheck.TempAt(n.Pos(), curFn, n.Y.Type())
+			n.X = tmp
+			n.Def = true
+			n.PtrInit().Append(typecheck.Stmt(ir.NewDecl(n.Pos(), ir.ODCL, tmp)))
+			stmt = typecheck.AssignExpr(n)
+			n = stmt.(*ir.AssignStmt)
+		}
 		// Peel down struct and slice indexing to get the names
 		name := getAddressableNameFromNode(n.X)
 		if name != nil {
@@ -154,7 +164,30 @@ func preserveStmt(curFn *ir.Func, stmt ir.Node) (ret ir.Node) {
 		}
 	case *ir.AssignListStmt:
 		ns := []ir.Node{}
-		for _, lhs := range n.Lhs {
+		hasBlank := false
+		for i, lhs := range n.Lhs {
+			if ir.IsBlank(lhs) {
+				// If the left hand side has blanks, we need to assign them to temps
+				// so that they can be kept alive.
+				var typ *types.Type
+				// AssignListStmt can have tuple or a list of expressions on the right hand side.
+				if len(n.Rhs) == 1 && n.Rhs[0].Type() != nil &&
+					n.Rhs[0].Type().IsTuple() &&
+					len(n.Lhs) == n.Rhs[0].Type().NumFields() {
+					typ = n.Rhs[0].Type().Field(i).Type
+				} else if len(n.Rhs) == len(n.Lhs) {
+					typ = n.Rhs[i].Type()
+				} else {
+					// Unrecognized shapes, skip?
+					base.WarnfAt(n.Pos(), "unrecognized shape for assign list stmt for blank assignment")
+					continue
+				}
+				tmp := typecheck.TempAt(n.Pos(), curFn, typ)
+				n.Lhs[i] = tmp
+				n.PtrInit().Append(typecheck.Stmt(ir.NewDecl(n.Pos(), ir.ODCL, tmp)))
+				hasBlank = true
+				lhs = tmp
+			}
 			name := getAddressableNameFromNode(lhs)
 			if name != nil {
 				debugName(name, n.Pos())
@@ -168,6 +201,12 @@ func preserveStmt(curFn *ir.Func, stmt ir.Node) (ret ir.Node) {
 				base.WarnfAt(n.Pos(), "expr is unknown to bloop pass")
 			}
 		}
+		if hasBlank {
+			// blank nodes are rewritten to temps, we need to typecheck the node again.
+			n.Def = true
+			stmt = typecheck.AssignExpr(n)
+			n = stmt.(*ir.AssignListStmt)
+		}
 		ret = keepAliveAt(ns, n)
 	case *ir.AssignOpStmt:
 		name := getAddressableNameFromNode(n.X)

src/cmd/compile/internal/devirtualize/devirtualize.go

@@ -293,9 +293,22 @@ func concreteType1(s *State, n ir.Node, seen map[*ir.Name]struct{}) (outT *types
 				continue
 			}
 		}
-		if t == nil || (typ != nil && !types.Identical(typ, t)) {
-			return nil
+		if t == nil {
+			return nil // unknown concrete type
 		}
+
+		// Methods are only declared on named types, and each named type
+		// is represented by a unique [*types.Type], thus pointer comparison
+		// is fine here.
+		//
+		// The only scenario where [types.IdenticalStrict] could help here is with
+		// unnamed struct types that embed another type (e.g. foo = struct { Impl }{}).
+		// However, such patterns are uncommon and not worth the additional complexity
+		// in the devirtualizer.
+		if typ != nil && typ != t {
+			return nil // assigned with a different type
+		}
+
 		typ = t
 	}
 

src/cmd/compile/internal/loopvar/loopvar_test.go

@@ -6,6 +6,7 @@ package loopvar_test
 
 import (
 	"internal/testenv"
+	"os"
 	"os/exec"
 	"path/filepath"
 	"regexp"
@@ -381,3 +382,62 @@ func TestLoopVarVersionDisableGoBuild(t *testing.T) {
 		t.Errorf("err=%v == nil", err)
 	}
 }
+
+// TestLoopVarLineDirective tests that loopvar version detection works correctly
+// with line directives. This is a regression test for a bug where FileBase() was
+// used instead of Base(), causing incorrect version lookup when line directives
+// were present.
+func TestLoopVarLineDirective(t *testing.T) {
+	switch runtime.GOOS {
+	case "linux", "darwin":
+	default:
+		t.Skipf("Slow test, usually avoid it, os=%s not linux or darwin", runtime.GOOS)
+	}
+	switch runtime.GOARCH {
+	case "amd64", "arm64":
+	default:
+		t.Skipf("Slow test, usually avoid it, arch=%s not amd64 or arm64", runtime.GOARCH)
+	}
+
+	testenv.MustHaveGoBuild(t)
+	gocmd := testenv.GoToolPath(t)
+	tmpdir := t.TempDir()
+	output := filepath.Join(tmpdir, "foo.exe")
+
+	// Create a go.mod file with Go 1.21 to test compatibility behavior.
+	// When building with a higher Go compiler, the loopvar should be created per-loop.
+	gomodPath := filepath.Join(tmpdir, "go.mod")
+	if err := os.WriteFile(gomodPath, []byte("module test\n\ngo 1.21\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	// Copy the test file (with line directive) to the temporary module
+	testFile := "range_esc_closure_linedir.go"
+	srcPath := filepath.Join("testdata", testFile)
+	dstPath := filepath.Join(tmpdir, testFile)
+	src, err := os.ReadFile(srcPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(dstPath, src, 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	// Build the module (not as a single file, so go.mod is respected)
+	cmd := testenv.Command(t, gocmd, "build", "-o", output, ".")
+	cmd.Dir = tmpdir
+	b, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Logf("build output: %s", b)
+		t.Fatal(err)
+	}
+	t.Logf("build output: %s", b)
+
+	cmd = testenv.Command(t, output)
+	b, err = cmd.CombinedOutput()
+	t.Logf("run output: %s", b)
+
+	if err != nil {
+		t.Errorf("expected success (exit code 0), got: %v", err)
+	}
+}

src/cmd/compile/internal/loopvar/testdata/range_esc_closure_linedir.go

@@ -0,0 +1,24 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//line range_esc_closure_linedir.go:5
+package main
+
+import "fmt"
+
+var is []func() int
+
+func main() {
+	var ints = []int{0, 0, 0}
+	for i := range ints {
+		is = append(is, func() int { return i })
+	}
+
+	for _, f := range is {
+		fmt.Println(f())
+		if f() != 2 {
+			panic("loop variable i: expected shared per-loop, but got distinct per-iteration")
+		}
+	}
+}

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

@@ -1557,7 +1557,7 @@ func (w *writer) forStmt(stmt *syntax.ForStmt) {
 
 func (w *writer) distinctVars(stmt *syntax.ForStmt) bool {
 	lv := base.Debug.LoopVar
-	fileVersion := w.p.info.FileVersions[stmt.Pos().Base()]
+	fileVersion := w.p.info.FileVersions[stmt.Pos().FileBase()]
 	is122 := fileVersion == "" || version.Compare(fileVersion, "go1.22") >= 0
 
 	// Turning off loopvar for 1.22 is only possible with loopvarhash=qn

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

@@ -145,6 +145,12 @@ func findIndVar(f *Func) []indVar {
 		if step == 0 {
 			continue
 		}
+		// step == minInt64 cannot be safely negated below, because -step
+		// overflows back to minInt64. The later underflow checks need a
+		// positive magnitude, so reject this case here.
+		if step == minSignedValue(ind.Type) {
+			continue
+		}
 
 		// startBody is the edge that eventually returns to the loop header.
 		var startBody Edge

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

@@ -1517,124 +1517,6 @@ func prove(f *Func) {
 			// Since this induction variable is not used for anything but counting the iterations,
 			// no point in putting it into the facts table.
 		}
-
-		// try to rewrite to a downward counting loop checking against start if the
-		// loop body does not depend on ind or nxt and end is known before the loop.
-		// This reduces pressure on the register allocator because this does not need
-		// to use end on each iteration anymore. We compare against the start constant instead.
-		// That means this code:
-		//
-		//	loop:
-		//		ind = (Phi (Const [x]) nxt),
-		//		if ind < end
-		//		then goto enter_loop
-		//		else goto exit_loop
-		//
-		//	enter_loop:
-		//		do something without using ind nor nxt
-		//		nxt = inc + ind
-		//		goto loop
-		//
-		//	exit_loop:
-		//
-		// is rewritten to:
-		//
-		//	loop:
-		//		ind = (Phi end nxt)
-		//		if (Const [x]) < ind
-		//		then goto enter_loop
-		//		else goto exit_loop
-		//
-		//	enter_loop:
-		//		do something without using ind nor nxt
-		//		nxt = ind - inc
-		//		goto loop
-		//
-		//	exit_loop:
-		//
-		// this is better because it only requires to keep ind then nxt alive while looping,
-		// while the original form keeps ind then nxt and end alive
-		start, end := v.min, v.max
-		if v.flags&indVarCountDown != 0 {
-			start, end = end, start
-		}
-
-		if !start.isGenericIntConst() {
-			// if start is not a constant we would be winning nothing from inverting the loop
-			continue
-		}
-		if end.isGenericIntConst() {
-			// TODO: if both start and end are constants we should rewrite such that the comparison
-			// is against zero and nxt is ++ or -- operation
-			// That means:
-			//	for i := 2; i < 11; i += 2 {
-			// should be rewritten to:
-			//	for i := 5; 0 < i; i-- {
-			continue
-		}
-
-		if end.Block == ind.Block {
-			// we can't rewrite loops where the condition depends on the loop body
-			// this simple check is forced to work because if this is true a Phi in ind.Block must exist
-			continue
-		}
-
-		check := ind.Block.Controls[0]
-		// invert the check
-		check.Args[0], check.Args[1] = check.Args[1], check.Args[0]
-
-		// swap start and end in the loop
-		for i, v := range check.Args {
-			if v != end {
-				continue
-			}
-
-			check.SetArg(i, start)
-			goto replacedEnd
-		}
-		panic(fmt.Sprintf("unreachable, ind: %v, start: %v, end: %v", ind, start, end))
-	replacedEnd:
-
-		for i, v := range ind.Args {
-			if v != start {
-				continue
-			}
-
-			ind.SetArg(i, end)
-			goto replacedStart
-		}
-		panic(fmt.Sprintf("unreachable, ind: %v, start: %v, end: %v", ind, start, end))
-	replacedStart:
-
-		if nxt.Args[0] != ind {
-			// unlike additions subtractions are not commutative so be sure we get it right
-			nxt.Args[0], nxt.Args[1] = nxt.Args[1], nxt.Args[0]
-		}
-
-		switch nxt.Op {
-		case OpAdd8:
-			nxt.Op = OpSub8
-		case OpAdd16:
-			nxt.Op = OpSub16
-		case OpAdd32:
-			nxt.Op = OpSub32
-		case OpAdd64:
-			nxt.Op = OpSub64
-		case OpSub8:
-			nxt.Op = OpAdd8
-		case OpSub16:
-			nxt.Op = OpAdd16
-		case OpSub32:
-			nxt.Op = OpAdd32
-		case OpSub64:
-			nxt.Op = OpAdd64
-		default:
-			panic("unreachable")
-		}
-
-		if f.pass.debug > 0 {
-			f.Warnl(ind.Pos, "Inverted loop iteration")
-		}
 	}
 
 	ft := newFactsTable(f)

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

@@ -112,7 +112,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 				for _, u := range typeset(y.typ) {
 					if s, _ := u.(*Slice); s != nil && Identical(s.elem, universeByte) {
 						// typeset ⊇ {[]byte}
-					} else if isString(u) {
+					} else if u != nil && isString(u) {
 						// typeset ⊇ {string}
 						hasString = true
 					} else {
@@ -375,7 +375,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 			for _, u := range typeset(y.typ) {
 				if s, _ := u.(*Slice); s != nil && Identical(s.elem, universeByte) {
 					// typeset ⊇ {[]byte}
-				} else if isString(u) {
+				} else if u != nil && isString(u) {
 					// typeset ⊇ {string}
 				} else {
 					special = false

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

@@ -631,9 +631,13 @@ func TestIssue55030(t *testing.T) {
 	makeSig := func(typ Type, valid bool) {
 		if !valid {
 			defer func() {
-				if recover() == nil {
+				r := recover()
+				if r == nil {
 					panic("NewSignatureType panic expected")
 				}
+				if _, ok := r.(string); !ok {
+					panic("NewSignatureType string panic expected")
+				}
 			}()
 		}
 		par := NewParam(nopos, nil, "", typ)

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

@@ -61,6 +61,9 @@ func NewSignatureType(recv *Var, recvTypeParams, typeParams []*TypeParam, params
 		last := params.At(n - 1).typ
 		var S *Slice
 		for t := range typeset(last) {
+			if t == nil {
+				break
+			}
 			var s *Slice
 			if isString(t) {
 				s = NewSlice(universeByte)

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

@@ -26,12 +26,12 @@ func all(t Type, f func(t, u Type) bool) bool {
 // typeset is an iterator over the (type/underlying type) pairs of the
 // specific type terms of the type set implied by t.
 // If t is a type parameter, the implied type set is the type set of t's constraint.
-// In that case, if there are no specific terms, typeset calls yield with (nil, nil).
+// In this case, if there are no specific terms, the iterator produces (nil, nil).
 // If t is not a type parameter, the implied type set consists of just t.
-// In any case, typeset is guaranteed to call yield at least once.
+// In any case, typeset is guaranteed to produce at least one set of results.
 func typeset(t Type) iter.Seq2[Type, Type] {
 	return func(yield func(t, u Type) bool) {
-		_ = all(t, yield)
+		all(t, yield)
 	}
 }