mirror of
https://github.com/golang/go
synced 2024-11-22 21:30:02 -07:00
0807986fe6
When doing constraint type inference, we must consider whether the
constraint's core type is precise (no tilde) or imprecise (tilde,
or not a single specific type). In the latter case, we cannot infer
an unknown type argument from the (imprecise) core type because there
are infinitely many possible types. For instance, given
[E ~byte]
if we don't know E, we cannot infer that E must be byte (it could be
myByte, etc.). On the other hand, if we do know the type argument,
say for S in this example:
[S ~[]E, E any]
we must consider the underlying type of S when matching against ~[]E
because we have a tilde.
Because constraint type inference may infer type arguments that were
not eligible initially (because they were unknown and the core type
is imprecise), we must iterate the process until nothing changes any-
more. For instance, given
[S ~[]E, M ~map[string]S, E any]
where we initially only know the type argument for M, we must ignore
S (and E) at first. After one iteration of constraint type inference,
S is known at which point we can infer E as well.
The change is large-ish but the actual functional changes are small:
- There's a new method "unknowns" to determine the number of as of yet
unknown type arguments.
- The adjCoreType function has been adjusted to also return tilde
and single-type information. This is now conveniently returned
as (*term, bool), and the function has been renamed to coreTerm.
- The original constraint type inference loop has been adjusted to
consider tilde information.
- This adjusted original constraint type inference loop has been
nested in another loop for iteration, together with some minimal
logic to control termination.
The remaining changes are modifications to tests:
- There's a substantial new test for this issue.
- Several existing test cases were adjusted to accomodate the
fact that they inferred incorrect types: tildes have been
removed throughout. Most of these tests are for pathological
cases.
- A couple of tests were adjusted where there was a difference
between the go/types and types2 version.
Fixes #51229.
Change-Id: If0bf5fb70ec22913b5a2da89adbf8a27fbc921d9
Reviewed-on: https://go-review.googlesource.com/c/go/+/387977
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
55 lines
916 B
Go
55 lines
916 B
Go
// run
|
|
|
|
// Copyright 2021 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.
|
|
|
|
// Smoke test for constraint literals with elided interface
|
|
// per issue #48424.
|
|
|
|
package main
|
|
|
|
func identity[T int](x T) T {
|
|
return x
|
|
}
|
|
|
|
func min[T int | string](x, y T) T {
|
|
if x < y {
|
|
return x
|
|
}
|
|
return y
|
|
}
|
|
|
|
func max[T ~int | ~float64](x, y T) T {
|
|
if x > y {
|
|
return x
|
|
}
|
|
return y
|
|
}
|
|
|
|
func main() {
|
|
if identity(1) != 1 {
|
|
panic("identity(1) failed")
|
|
}
|
|
|
|
if min(2, 3) != 2 {
|
|
panic("min(2, 3) failed")
|
|
}
|
|
|
|
if min("foo", "bar") != "bar" {
|
|
panic(`min("foo", "bar") failed`)
|
|
}
|
|
|
|
if max(2, 3) != 3 {
|
|
panic("max(2, 3) failed")
|
|
}
|
|
}
|
|
|
|
// Some random type parameter lists with elided interfaces.
|
|
|
|
type (
|
|
_[T struct{}] struct{}
|
|
_[M map[K]V, K comparable, V any] struct{}
|
|
_[_ interface{} | int] struct{}
|
|
)
|