errors: add Match and IsAny

api/next/51945.txt

@@ -0,0 +1 @@
+pkg errors, func AsType[$0 error](error) ($0, bool) #51945

api/next/73161.txt

@@ -0,0 +1 @@
+pkg net/http/httputil, type ReverseProxy struct, Director //deprecated #73161

doc/go_spec.html

@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Language version go1.25 (Feb 25, 2025)",
+	"Subtitle": "Language version go1.26 (Oct 1, 2025)",
 	"Path": "/ref/spec"
 }-->
 

doc/next/6-stdlib/99-minor/errors/51945.md

@@ -0,0 +1,2 @@
+The new [AsType] function is a generic version of [As]. It is type-safe, faster,
+and, in most cases, easier to use.

doc/next/6-stdlib/99-minor/net/http/httputil/73161.md

@@ -0,0 +1,11 @@
+The [ReverseProxy.Director] configuration field is deprecated
+in favor of [ReverseProxy.Rewrite].
+
+A malicious client can remove headers added by a `Director` function
+by designating those headers as hop-by-hop. Since there is no way to address
+this problem within the scope of the `Director` API, we added a new
+`Rewrite` hook in Go 1.20. `Rewrite` hooks are provided with both the
+unmodified inbound request received by the proxy and the outbound request
+which will be sent by the proxy.
+
+Since the `Director` hook is fundamentally unsafe, we are now deprecating it.

src/cmd/cgo/internal/testcshared/cshared_test.go

@@ -8,6 +8,7 @@ import (
 	"bufio"
 	"bytes"
 	"cmd/cgo/internal/cgotest"
+	"cmp"
 	"debug/elf"
 	"debug/pe"
 	"encoding/binary"
@@ -272,7 +273,7 @@ func createHeaders() error {
 		// which results in the linkers output implib getting overwritten at each step. So instead build the
 		// import library the traditional way, using a def file.
 		err = os.WriteFile("libgo.def",
-			[]byte("LIBRARY libgo.dll\nEXPORTS\n\tDidInitRun\n\tDidMainRun\n\tDivu\n\tFromPkg\n\t_cgo_dummy_export\n"),
+			[]byte("LIBRARY libgo.dll\nEXPORTS\n\tDidInitRun\n\tDidMainRun\n\tDivu\n\tFromPkg\n"),
 			0644)
 		if err != nil {
 			return fmt.Errorf("unable to write def file: %v", err)
@@ -375,9 +376,23 @@ func TestExportedSymbols(t *testing.T) {
 	}
 }
 
-func checkNumberOfExportedFunctionsWindows(t *testing.T, prog string, exportedFunctions int, wantAll bool) {
+func checkNumberOfExportedSymbolsWindows(t *testing.T, exportedSymbols int, wantAll bool) {
+	t.Parallel()
 	tmpdir := t.TempDir()
 
+	prog := `
+package main
+import "C"
+func main() {}
+`
+
+	for i := range exportedSymbols {
+		prog += fmt.Sprintf(`
+//export GoFunc%d
+func GoFunc%d() {}
+`, i, i)
+	}
+
 	srcfile := filepath.Join(tmpdir, "test.go")
 	objfile := filepath.Join(tmpdir, "test.dll")
 	if err := os.WriteFile(srcfile, []byte(prog), 0666); err != nil {
@@ -443,18 +458,19 @@ func checkNumberOfExportedFunctionsWindows(t *testing.T, prog string, exportedFu
 		t.Fatalf("binary.Read failed: %v", err)
 	}
 
-	// Only the two exported functions and _cgo_dummy_export should be exported.
+	exportedSymbols = cmp.Or(exportedSymbols, 1) // _cgo_stub_export is exported if there are no other symbols exported
+
 	// NumberOfNames is the number of functions exported with a unique name.
 	// NumberOfFunctions can be higher than that because it also counts
 	// functions exported only by ordinal, a unique number asigned by the linker,
 	// and linkers might add an unknown number of their own ordinal-only functions.
 	if wantAll {
-		if e.NumberOfNames <= uint32(exportedFunctions) {
-			t.Errorf("got %d exported names, want > %d", e.NumberOfNames, exportedFunctions)
+		if e.NumberOfNames <= uint32(exportedSymbols) {
+			t.Errorf("got %d exported names, want > %d", e.NumberOfNames, exportedSymbols)
 		}
 	} else {
-		if e.NumberOfNames > uint32(exportedFunctions) {
-			t.Errorf("got %d exported names, want <= %d", e.NumberOfNames, exportedFunctions)
+		if e.NumberOfNames != uint32(exportedSymbols) {
+			t.Errorf("got %d exported names, want %d", e.NumberOfNames, exportedSymbols)
 		}
 	}
 }
@@ -470,43 +486,14 @@ func TestNumberOfExportedFunctions(t *testing.T) {
 
 	t.Parallel()
 
-	const prog0 = `
-package main
-
-import "C"
-
-func main() {
-}
-`
-
-	const prog2 = `
-package main
-
-import "C"
-
-//export GoFunc
-func GoFunc() {
-	println(42)
-}
-
-//export GoFunc2
-func GoFunc2() {
-	println(24)
-}
-
-func main() {
-}
-`
-	// All programs export _cgo_dummy_export, so add 1 to the expected counts.
-	t.Run("OnlyExported/0", func(t *testing.T) {
-		checkNumberOfExportedFunctionsWindows(t, prog0, 0+1, false)
-	})
-	t.Run("OnlyExported/2", func(t *testing.T) {
-		checkNumberOfExportedFunctionsWindows(t, prog2, 2+1, false)
-	})
-	t.Run("All", func(t *testing.T) {
-		checkNumberOfExportedFunctionsWindows(t, prog2, 2+1, true)
-	})
+	for i := range 3 {
+		t.Run(fmt.Sprintf("OnlyExported/%d", i), func(t *testing.T) {
+			checkNumberOfExportedSymbolsWindows(t, i, false)
+		})
+		t.Run(fmt.Sprintf("All/%d", i), func(t *testing.T) {
+			checkNumberOfExportedSymbolsWindows(t, i, true)
+		})
+	}
 }
 
 // test1: shared library can be dynamically loaded and exported symbols are accessible.

src/cmd/cgo/internal/testout/out_test.go

@@ -0,0 +1,144 @@
+// Copyright 2025 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.
+
+package out_test
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"internal/testenv"
+	"internal/goarch"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type methodAlign struct {
+	Method string
+	Align  int
+}
+
+var wantAligns = map[string]int{
+	"ReturnEmpty":         1,
+	"ReturnOnlyUint8":     1,
+	"ReturnOnlyUint16":    2,
+	"ReturnOnlyUint32":    4,
+	"ReturnOnlyUint64":    goarch.PtrSize,
+	"ReturnOnlyInt":       goarch.PtrSize,
+	"ReturnOnlyPtr":       goarch.PtrSize,
+	"ReturnByteSlice":     goarch.PtrSize,
+	"ReturnString":        goarch.PtrSize,
+	"InputAndReturnUint8": 1,
+	"MixedTypes":          goarch.PtrSize,
+}
+
+// TestAligned tests that the generated _cgo_export.c file has the wanted
+// align attributes for struct types used as arguments or results of
+// //exported functions.
+func TestAligned(t *testing.T) {
+	testenv.MustHaveGoRun(t)
+	testenv.MustHaveCGO(t)
+
+	testdata, err := filepath.Abs("testdata")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	objDir := t.TempDir()
+
+	cmd := testenv.Command(t, testenv.GoToolPath(t), "tool", "cgo",
+		"-objdir", objDir,
+		filepath.Join(testdata, "aligned.go"))
+	cmd.Stderr = new(bytes.Buffer)
+
+	err = cmd.Run()
+	if err != nil {
+		t.Fatalf("%#q: %v\n%s", cmd, err, cmd.Stderr)
+	}
+
+	haveAligns, err := parseAlign(filepath.Join(objDir, "_cgo_export.c"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Check that we have all the wanted methods
+	if len(haveAligns) != len(wantAligns) {
+		t.Fatalf("have %d methods with aligned, want %d", len(haveAligns), len(wantAligns))
+	}
+
+	for i := range haveAligns {
+		method := haveAligns[i].Method
+		haveAlign := haveAligns[i].Align
+
+		wantAlign, ok := wantAligns[method]
+		if !ok {
+			t.Errorf("method %s: have aligned %d, want missing entry", method, haveAlign)
+		} else if haveAlign != wantAlign {
+			t.Errorf("method %s: have aligned %d, want %d", method, haveAlign, wantAlign)
+		}
+	}
+}
+
+func parseAlign(filename string) ([]methodAlign, error) {
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open file: %w", err)
+	}
+	defer file.Close()
+
+	var results []methodAlign
+	scanner := bufio.NewScanner(file)
+
+	// Regex to match function declarations like "struct MethodName_return MethodName("
+	funcRegex := regexp.MustCompile(`^struct\s+(\w+)_return\s+(\w+)\(`)
+	// Regex to match simple function declarations like "GoSlice MethodName("
+	simpleFuncRegex := regexp.MustCompile(`^Go\w+\s+(\w+)\(`)
+	// Regex to match void-returning exported functions like "void ReturnEmpty("
+	voidFuncRegex := regexp.MustCompile(`^void\s+(\w+)\(`)
+	// Regex to match align attributes like "__attribute__((aligned(8)))"
+	alignRegex := regexp.MustCompile(`__attribute__\(\(aligned\((\d+)\)\)\)`)
+
+	var currentMethod string
+
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+
+		// Check if this line declares a function with struct return type
+		if matches := funcRegex.FindStringSubmatch(line); matches != nil {
+			currentMethod = matches[2] // Extract the method name
+		} else if matches := simpleFuncRegex.FindStringSubmatch(line); matches != nil {
+			// Check if this line declares a function with simple return type (like GoSlice)
+			currentMethod = matches[1] // Extract the method name
+		} else if matches := voidFuncRegex.FindStringSubmatch(line); matches != nil {
+			// Check if this line declares a void-returning function
+			currentMethod = matches[1] // Extract the method name
+		}
+
+		// Check if this line contains align information
+		if alignMatches := alignRegex.FindStringSubmatch(line); alignMatches != nil && currentMethod != "" {
+			alignStr := alignMatches[1]
+			align, err := strconv.Atoi(alignStr)
+			if err != nil {
+				// Skip this entry if we can't parse the align as integer
+				currentMethod = ""
+				continue
+			}
+			results = append(results, methodAlign{
+				Method: currentMethod,
+				Align:  align,
+			})
+			currentMethod = "" // Reset for next method
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("error reading file: %w", err)
+	}
+
+	return results, nil
+}

src/cmd/cgo/internal/testout/testdata/aligned.go

@@ -0,0 +1,63 @@
+// Copyright 2025 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.
+
+package main
+
+import "C"
+
+//export ReturnEmpty
+func ReturnEmpty() {
+	return
+}
+
+//export ReturnOnlyUint8
+func ReturnOnlyUint8() (uint8, uint8, uint8) {
+	return 1, 2, 3
+}
+
+//export ReturnOnlyUint16
+func ReturnOnlyUint16() (uint16, uint16, uint16) {
+	return 1, 2, 3
+}
+
+//export ReturnOnlyUint32
+func ReturnOnlyUint32() (uint32, uint32, uint32) {
+	return 1, 2, 3
+}
+
+//export ReturnOnlyUint64
+func ReturnOnlyUint64() (uint64, uint64, uint64) {
+	return 1, 2, 3
+}
+
+//export ReturnOnlyInt
+func ReturnOnlyInt() (int, int, int) {
+	return 1, 2, 3
+}
+
+//export ReturnOnlyPtr
+func ReturnOnlyPtr() (*int, *int, *int) {
+	a, b, c := 1, 2, 3
+	return &a, &b, &c
+}
+
+//export ReturnString
+func ReturnString() string {
+	return "hello"
+}
+
+//export ReturnByteSlice
+func ReturnByteSlice() []byte {
+	return []byte{1, 2, 3}
+}
+
+//export InputAndReturnUint8
+func InputAndReturnUint8(a, b, c uint8) (uint8, uint8, uint8) {
+	return a, b, c
+}
+
+//export MixedTypes
+func MixedTypes(a uint8, b uint16, c uint32, d uint64, e int, f *int) (uint8, uint16, uint32, uint64, int, *int) {
+	return a, b, c, d, e, f
+}