cmd/compile: Bad error message on missing type constraint

[varungandhi-src]

What version of Go are you using (go version)?

$ go version
1.19

Does this issue reproduce with the latest release?

Yes

What operating system and processor architecture are you using (go env)?

go env Output

$ go env
GO111MODULE=""
GOARCH="arm64"
GOBIN=""
GOCACHE="/Users/varun/Library/Caches/go-build"
GOENV="/Users/varun/Library/Application Support/go/env"
GOEXE=""
GOEXPERIMENT=""
GOFLAGS=""
GOHOSTARCH="arm64"
GOHOSTOS="darwin"
GOINSECURE=""
GOMODCACHE="/Users/varun/go/pkg/mod"
GONOPROXY=""
GONOSUMDB=""
GOOS="darwin"
GOPATH="/Users/varun/go"
GOPRIVATE=""
GOPROXY="https://proxy.golang.org,direct"
GOROOT="/Users/varun/.asdf/installs/golang/1.19/go"
GOSUMDB="sum.golang.org"
GOTMPDIR=""
GOTOOLDIR="/Users/varun/.asdf/installs/golang/1.19/go/pkg/tool/darwin_arm64"
GOVCS=""
GOVERSION="go1.19"
GCCGO="gccgo"
AR="ar"
CC="clang"
CXX="clang++"
CGO_ENABLED="1"
GOMOD="/Users/varun/Code/scip/go.mod"
GOWORK=""
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"
GOGCCFLAGS="-fPIC -arch arm64 -pthread -fno-caret-diagnostics -Qunused-arguments -fmessage-length=0 -fdebug-prefix-map=/var/folders/tr/gylnxkts3bn0gyhhlrv8z9_m0000gn/T/go-build325381962=/tmp/go-build -gno-record-gcc-switches -fno-common"

What did you do?

Try to compile this file:

type X[T] struct {
	t T
}
func main() {}

What did you expect to see?

A useful error message, something like: (IDK if 'constraint' is the right verbiage)

./tmp.go:2:8: missing type constraint for 'T'; explicitly specify 'T any' if T doesn't have any constraints

There shouldn't be an error on line 3 because it is not useful.

What did you see instead?

An error which doesn't clearly indicate the problem:

./tmp.go:2:8: undeclared name T for array length
./tmp.go:3:4: undefined: T

[prattmic]

cc @griesemer @findleyr

[griesemer]

Sorry, but this is working as intended. What you wrote is an array declaration (and if you use an IDE it may even format it accordingly):

type X [T]struct {
	t T
}

This is an array of structs. It reports an error because the length T is not defined, but if T existed as in:

const T = 10
type X [T]struct {
	t T
}

you'd just get an error for the field (T is not a type). The compiler cannot reasonably know (or "guess") that you meant a generic type X instead. The error message could perhaps also say something like: missing type constraint? but the compiler doesn't usually try to guess because it might just guess wrong.

And exactly because we are aware of this potential problem, the error message is explicitly saying undefined T for array length (emphasis on array length). This makes it clear that you have declared an array.

[griesemer]

See also #51145.

[varungandhi-src]

Sorry, but this is working as intended. What you wrote is an array declaration (and if you use an IDE it may even format it accordingly):

Even the IDE formats it (and the error message indicates something), it is not obvious as to why this is getting parsed as an array instead of a generic type. In other languages (Java, TypeScript, Rust etc.), one generally doesn't need to explicitly specify the equivalent of an any constraint (if no constraint is specified, the type parameter is unconstrained), so it's not necessarily obvious that the missing constraint is the source of the problem.

The compiler cannot reasonably know (or "guess") that you meant a generic type X instead.

IIUC, the error is happening during name resolution (it is complaining about a missing definition), which means the code was already parsed. When emitting the error, would it possible to check that the next token (or the start of the next node in the parse tree), see if it is a struct, and if it is, then emit a hint for the missing any? I would guess that there is a much higher likelihood that you forgot to write any (one missing token) rather than meaning to write an array type (multiple missing tokens)...

[griesemer]

type X [T]someType

was always an array declaration in Go (for the last 15 years), it's not new syntax. Go is not other languages (where arrays may look differently). Maybe it's not obvious, which is why the array message explicitly says array length.

Yes, the error is happening during name resolution - because the code has already been parsed as an array declaration (because that is what it is, syntactically). Checking the next token doesn't help because

type X [T]struct{}

is a syntactically correct array declaration. The parser cannot know if T was defined and where. The type checker cannot assume that if T is not defined it's not an array declaration: the error might well be that T should have been defined.

About the likelihood of the error: I don't know that it's more common to have a generic type than an array type now. Note that there are no missing tokens in the array case, there's just a missing declaration (perhaps in a separate, missing file).

Anyway, I filed #56064.

[gopherbot]

Change https://go.dev/cl/439476 mentions this issue: go/types, types2: better error for generic type decl. with missing constraint

[gopherbot]

Change https://go.dev/cl/439559 mentions this issue: go/types, types2: better error for generic type decl. with missing constraint