Double indirection on error that will never satisfy errors.As lint

[stefanvanburen]

package main

import (
	"errors"
	"fmt"
)

type testError struct {
	msg string
}

func (te testError) Error() string { return te.msg }

func main() {
	te := testError{msg: "hello"}
	var terr *testError
	if errors.As(te, &terr) {
		fmt.Println(terr)
	} else {
		fmt.Println("errors.As failed")
	}
}

go.dev/play link

In this example, Error is defined on the concrete testError type (instead of the more idiomatic pointer receiver). Below, matching the error starting with a pointer and then indirecting that pointer in the errors.As call won't work, because the pointer given to errors.As is to a *testError (not satisfying the Error interface) instead of testError. It seems like a lint could be added that checks for this case.

go vet has the -errorsas analysis, but doesn't catch this case, and I'm not currently finding prior art on a lint of this type. (It could be not possible due to something I'm not thinking of.)

For a concrete example, I was recently bit by this while doing an error.As check on an http2.StreamError, which implements Error on the concrete type.