chore: simplify and modernize for Go 1.27 (#2627)

Follow-up to the Go 1.27 upgrade in a411024, applying what the new
release makes available.

## Modernizers

`go fix` gained `slicesbackward`, `embedlit` and `unsafefuncs`, and
renamed `waitgroup` to `waitgroupgo`. Applied across both modules, with
two exceptions:

- The extgen parsers are left alone: `embedlit` rewrites their composite
literals into a shape that reads worse than the original.
- `go fix` skips files that import `"C"`, so the root package never got
the transformations applied everywhere else. Those are done by hand in a
separate commit.

## Standard library

- `splitRemoteAddr` uses `strings.CutLast`, new in 1.27. Its not-found
return is exactly what the old `else` branch assigned, so the branch
disappears.
- The manual `unsafe.Pointer`/`uintptr` arithmetic in `types.go` and
`frankenphp.go` becomes `unsafe.Add`. The old form is only valid inside
a single expression and silently breaks if a later refactor splits the
line.
- `errors.As` becomes `errors.AsType`, dropping the throwaway target
values.
- Eleven copies of the register-or-panic block in `metrics.go` collapse
into one `mustRegister` helper.

## Tests

`internal/state` moves to `testing/synctest`. `synctest.Wait` returns
once every subscriber goroutine is durably blocked, so the subscriber
count is exact rather than polled for up to a second. This also makes
the `WaitForStateWithTimeout` give-up path worth covering, since the
bubble's fake clock fires its one second timeout instantly.

The other timing tests stay as they are. `regularRequestChan` is a
package global that live PHP thread goroutines receive from, so a
bubbled sender can have its send stolen by an out-of-bubble thread, and
PHP threads are C threads, which never count as durably blocked.
Bubbling them would buy flakiness, not determinism.

A new test uses the `goroutineleak` profile, GA in 1.27, to catch a
thread, scaling ticker or watcher goroutine that outlives `Shutdown`
with nothing left to wake it. Currently reports zero leaks across a full
`Init`/`Shutdown` cycle.

`/debug/pprof/goroutineleak` needs no code to expose:
`net/http/pprof.Index` dispatches profiles by name, so it is already
live on the admin endpoint. Verified against a running server. It
reports one leaked goroutine there, but the same one appears with no
`php_server` configured at all, so it is Caddy/runtime baseline rather
than ours.

## Drive-by

`internal/state` had a bare `import "C"` with no C preamble and no calls
into C, which forced a pure Go package through cgo. Removed.

## No action needed

`encoding/json/v2` backing `encoding/json` and the size-specialized
allocator are both in the 1.27 baseline and active automatically. The
stricter jsonv2 defaults ship only with an explicit `encoding/json/v2`
import, so v1 semantics are unchanged: duplicate keys still accepted,
invalid UTF-8 still replaced rather than rejected.

Author: dunglas

caddy/caddy_test.go

@@ -903,7 +903,7 @@ func TestPhpServerWorkerMatchPoolCount(t *testing.T) {
 	require.NoError(t, err, "failed to read metrics")
 
 	var pools []string
-	for _, line := range strings.Split(metrics.String(), "\n") {
+	for line := range strings.SplitSeq(metrics.String(), "\n") {
 		if !strings.HasPrefix(line, "frankenphp_total_workers{worker=") {
 			continue
 		}
@@ -1830,7 +1830,7 @@ func TestOpcacheReset(t *testing.T) {
 	wg := sync.WaitGroup{}
 	numRequests := 500
 	wg.Add(numRequests)
-	for i := 0; i < numRequests; i++ {
+	for i := range numRequests {
 
 		// introduce a delay every 10 requests
 		if i%10 == 0 {
@@ -2138,7 +2138,7 @@ func TestSymlinkWorkerBehavior(t *testing.T) {
 			`, "caddyfile")
 
 		// Make multiple requests - each should increment the counter
-		for i := 0; i < 5; i++ {
+		for i := range 5 {
 			tester.AssertGetResponse("http://localhost:"+testPort+"/index.php", http.StatusOK, fmt.Sprintf("Request: %d\n", i))
 		}
 	})

caddy/config_test.go

@@ -254,7 +254,7 @@ func TestCreateUniqueWorkerNames(t *testing.T) {
 	filename := "../testdata/worker-with-env.php"
 	absFileName, _ := filepath.Abs(filename)
 	names := make([]string, 6)
-	for i := 0; i < 3; i++ {
+	for i := range 3 {
 		names[i] = app.createUniqueWorkerName(workerConfig{
 			FileName: filename,
 			Name:     "custom-worker-name",

caddy/go.mod

@@ -19,8 +19,6 @@ require (
 	github.com/stretchr/testify v1.11.1
 )
 
-require github.com/smallstep/go-attestation v0.4.9 // indirect
-
 require (
 	cel.dev/expr v0.25.2 // indirect
 	cloud.google.com/go/auth v0.20.0 // indirect
@@ -141,6 +139,7 @@ require (
 	github.com/slackhq/nebula v1.10.3 // indirect
 	github.com/smallstep/certificates v0.30.2 // indirect
 	github.com/smallstep/cli-utils v0.12.2 // indirect
+	github.com/smallstep/go-attestation v0.4.9 // indirect
 	github.com/smallstep/linkedca v0.25.0 // indirect
 	github.com/smallstep/nosql v0.8.0 // indirect
 	github.com/smallstep/pkcs7 v0.2.1 // indirect

caddy/module.go

@@ -227,7 +227,7 @@ func (f *FrankenPHPModule) ServeHTTP(w http.ResponseWriter, r *http.Request, _ c
 
 	err := f.server.ServeHTTP(w, r, opts...)
 
-	if err != nil && !errors.As(err, &frankenphp.ErrRejected{}) {
+	if _, rejected := errors.AsType[frankenphp.ErrRejected](err); err != nil && !rejected {
 		return caddyhttp.Error(http.StatusInternalServerError, err)
 	}
 

cgi.go

@@ -253,7 +253,7 @@ func splitPos(path string, splitPath []string) int {
 
 		for i := 0; i <= pathLen-splitLen; i++ {
 			match := true
-			for j := 0; j < splitLen; j++ {
+			for j := range splitLen {
 				c := path[i+j]
 				if c >= utf8.RuneSelf {
 					match = false
@@ -363,12 +363,8 @@ func splitRemoteAddr(remoteAddr string) (ip, port string) {
 		return host, p
 	}
 
-	if idx := strings.LastIndex(remoteAddr, ":"); idx > -1 {
-		ip = remoteAddr[:idx]
-		port = remoteAddr[idx+1:]
-	} else {
-		ip = remoteAddr
-	}
+	// CutLast yields (remoteAddr, "") when there is no colon, i.e. no port.
+	ip, port, _ = strings.CutLast(remoteAddr, ":")
 
 	if len(ip) >= 2 && ip[0] == '[' && ip[len(ip)-1] == ']' {
 		ip = ip[1 : len(ip)-1]

cli_test.go

@@ -21,8 +21,7 @@ func TestExecuteScriptCLI(t *testing.T) {
 	stdoutStderr, err := cmd.CombinedOutput()
 	assert.Error(t, err)
 
-	var exitError *exec.ExitError
-	if errors.As(err, &exitError) {
+	if exitError, ok := errors.AsType[*exec.ExitError](err); ok {
 		assert.Equal(t, 3, exitError.ExitCode())
 	}
 
@@ -60,8 +59,7 @@ func TestExecuteCLIPHPInfo(t *testing.T) {
 	if frankenphp.Version().VersionID < 80600 {
 		assert.Error(t, err)
 
-		var exitError *exec.ExitError
-		if errors.As(err, &exitError) {
+		if exitError, ok := errors.AsType[*exec.ExitError](err); ok {
 			assert.Equal(t, 1, exitError.ExitCode())
 		}
 

context.go

@@ -236,8 +236,8 @@ func (fc *frankenPHPContext) reject(err error) {
 		return
 	}
 
-	re := &ErrRejected{}
-	if !errors.As(err, re) {
+	re, ok := errors.AsType[ErrRejected](err)
+	if !ok {
 		// Should never happen
 		panic("only instance of ErrRejected can be passed to reject")
 	}

frankenphp.go

@@ -320,7 +320,7 @@ func Init(options ...Option) error {
 	}
 
 	regularThreads = make([]*phpThread, 0, opt.numThreads-workerThreadCount)
-	for i := 0; i < opt.numThreads-workerThreadCount; i++ {
+	for range opt.numThreads - workerThreadCount {
 		convertToRegularThread(getInactivePHPThread())
 	}
 
@@ -533,7 +533,7 @@ func splitRawHeader(rawHeader *C.char, length int) (string, string) {
 	}
 
 	// anything left is the header value
-	valuePtr := (*C.char)(unsafe.Pointer(uintptr(unsafe.Pointer(rawHeader)) + uintptr(j)))
+	valuePtr := (*C.char)(unsafe.Add(unsafe.Pointer(rawHeader), j))
 	headerValue := C.GoStringN(valuePtr, C.int(length-j))
 
 	return headerKey, headerValue

frankenphp_test.go

@@ -87,7 +87,7 @@ func runTest(t *testing.T, test func(func(http.ResponseWriter, *http.Request), *
 		assert.NoError(t, err)
 
 		err = frankenphp.ServeHTTP(w, req)
-		if err != nil && !errors.As(err, &frankenphp.ErrRejected{}) {
+		if _, rejected := errors.AsType[frankenphp.ErrRejected](err); err != nil && !rejected {
 			assert.Fail(t, fmt.Sprintf("Received unexpected error:\n%+v", err))
 		}
 	}

goroutineleak_test.go

@@ -0,0 +1,61 @@
+package frankenphp
+
+import (
+	"bytes"
+	"net/http/httptest"
+	"runtime/pprof"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// leakedGoroutines runs a leak-detection GC cycle and returns how many goroutines
+// it found blocked forever on a channel or mutex that no running goroutine can
+// still reach, along with their stacks.
+//
+// Profile.Count only reports the result of the previous detection cycle, so the
+// profile has to be written first even when only the count is wanted.
+func leakedGoroutines(t *testing.T) (int, string) {
+	t.Helper()
+
+	profile := pprof.Lookup("goroutineleak")
+	require.NotNil(t, profile, "the goroutineleak profile is only available since Go 1.27")
+
+	var stacks bytes.Buffer
+	require.NoError(t, profile.WriteTo(&stacks, 1))
+
+	return profile.Count(), stacks.String()
+}
+
+// TestNoGoroutinesAreLeakedByAFullServerLifecycle boots PHP threads, serves requests
+// through a worker and a regular thread, then shuts everything down.
+//
+// Shutdown has to unblock every goroutine it started, so a goroutine still parked on
+// an unreachable channel afterwards means a thread, a scaling ticker or a watcher
+// outlived Shutdown with nothing left to wake it. The count is compared against a
+// baseline rather than against zero: tests share a process, so earlier tests may have
+// left leaks of their own behind.
+func TestNoGoroutinesAreLeakedByAFullServerLifecycle(t *testing.T) {
+	before, _ := leakedGoroutines(t)
+
+	require.NoError(t, Init(
+		WithNumThreads(2),
+		WithMaxThreads(4),
+		WithWorkers("worker", testDataPath+"/index.php", 1, WithWorkerMaxFailures(0)),
+	))
+
+	for range 5 {
+		r := httptest.NewRequest("GET", "http://localhost/index.php", nil)
+		req, err := NewRequestWithContext(r, WithRequestDocumentRoot(testDataPath, false))
+		require.NoError(t, err)
+		require.NoError(t, ServeHTTP(httptest.NewRecorder(), req))
+	}
+
+	Shutdown()
+
+	after, stacks := leakedGoroutines(t)
+	t.Logf("leaked goroutines: %d before, %d after", before, after)
+
+	assert.LessOrEqual(t, after, before, "goroutines leaked across an Init/Shutdown cycle:\n%s", stacks)
+}