qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-26 08:27:56 -07:00
Code Releases Activity

cmd/compile/internal/types2: review of api_test.go

Browse Source 
The changes between (equivalent, and reviewed) go/types/api_test.go
and api_test.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker, the addition of the
TestConvertibleTo and TestAssignableTo tests, and adjustments to test
prefixes (genericPkg, brokenPkg to be in line with go/types).

There are several differences to go/types/api_test.go:
- use of syntax rather than go/ast package
- use of the parseSrc helper function
- TestTypesInfo test entries reflect different handling of untyped nil
- TestInferredInfo is (for go1.17) in another file controlled by a build
  constraint in go/types
- TestSelection test is currently skipped (types2 position information
  is not accurate enough)
- TestScopeLookupParent doesn't have access to a scanner and instead
  relies on syntax.CommentsDo.
- Broken packages are assumed to contain generic code for the tests.

Change-Id: Ic14e6fb9d6bef5416df39e465b5994de76f84097
Reviewed-on: https://go-review.googlesource.com/c/go/+/304131
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
This commit is contained in:
Robert Griesemer 2021-03-23 12:44:17 -07:00
parent 34ef294b76
commit ffa9983b99
2 changed files with 103 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

150
src/cmd/compile/internal/types2/api_test.go
View File

@ -1,4 +1,3 @@
// UNREVIEWED
// Copyright 2013 The Go Authors. All rights reserved. // Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
@ -22,9 +21,21 @@ func unimplemented() {
panic("unimplemented") panic("unimplemented")
} }
// genericPkg is a source prefix for packages that contain generic code.
const genericPkg = "package generic_"
// brokenPkg is a source prefix for packages that are not expected to parse
// or type-check cleanly. They are always parsed assuming that they contain
// generic code.
const brokenPkg = "package broken_"
func parseSrc(path, src string) (*syntax.File, error) { func parseSrc(path, src string) (*syntax.File, error) {
var mode syntax.Mode
if strings.HasPrefix(src, genericPkg) || strings.HasPrefix(src, brokenPkg) {
mode = syntax.AllowGenerics
}
errh := func(error) {} // dummy error handler so that parsing continues in presence of errors errh := func(error) {} // dummy error handler so that parsing continues in presence of errors
return syntax.Parse(syntax.NewFileBase(path), strings.NewReader(src), errh, nil, syntax.AllowGenerics) return syntax.Parse(syntax.NewFileBase(path), strings.NewReader(src), errh, nil, mode)
} }
func pkgFor(path, source string, info *Info) (*Package, error) { func pkgFor(path, source string, info *Info) (*Package, error) {
@ -182,9 +193,6 @@ func TestValuesInfo(t *testing.T) {
} }
func TestTypesInfo(t *testing.T) { func TestTypesInfo(t *testing.T) {
// Test sources that are not expected to typecheck must start with the broken prefix.
const broken = "package broken_"
var tests = []struct { var tests = []struct {
src string src string
expr string // expression expr string // expression
@ -315,37 +323,37 @@ func TestTypesInfo(t *testing.T) {
}, },
// tests for broken code that doesn't parse or type-check // tests for broken code that doesn't parse or type-check
{broken + `x0; func _() { var x struct {f string}; x.f := 0 }`, `x.f`, `string`}, {brokenPkg + `x0; func _() { var x struct {f string}; x.f := 0 }`, `x.f`, `string`},
{broken + `x1; func _() { var z string; type x struct {f string}; y := &x{q: z}}`, `z`, `string`}, {brokenPkg + `x1; func _() { var z string; type x struct {f string}; y := &x{q: z}}`, `z`, `string`},
{broken + `x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a, f: b,}}`, `b`, `string`}, {brokenPkg + `x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a, f: b,}}`, `b`, `string`},
{broken + `x3; var x = panic("");`, `panic`, `func(interface{})`}, {brokenPkg + `x3; var x = panic("");`, `panic`, `func(interface{})`},
{`package x4; func _() { panic("") }`, `panic`, `func(interface{})`}, {`package x4; func _() { panic("") }`, `panic`, `func(interface{})`},
{broken + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`}, {brokenPkg + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
// parameterized functions // parameterized functions
{`package p0; func f[T any](T); var _ = f[int]`, `f`, `func[T₁ interface{}](T₁)`}, {genericPkg + `p0; func f[T any](T); var _ = f[int]`, `f`, `func[T₁ interface{}](T₁)`},
{`package p1; func f[T any](T); var _ = f[int]`, `f[int]`, `func(int)`}, {genericPkg + `p1; func f[T any](T); var _ = f[int]`, `f[int]`, `func(int)`},
{`package p2; func f[T any](T); func _() { f(42) }`, `f`, `func[T₁ interface{}](T₁)`}, {genericPkg + `p2; func f[T any](T); func _() { f(42) }`, `f`, `func[T₁ interface{}](T₁)`},
{`package p3; func f[T any](T); func _() { f(42) }`, `f(42)`, `()`}, {genericPkg + `p3; func f[T any](T); func _() { f(42) }`, `f(42)`, `()`},
// type parameters // type parameters
{`package t0; type t[] int; var _ t`, `t`, `t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t {genericPkg + `t0; type t[] int; var _ t`, `t`, `generic_t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t
{`package t1; type t[P any] int; var _ t[int]`, `t`, `t1.t[P₁ interface{}]`}, {genericPkg + `t1; type t[P any] int; var _ t[int]`, `t`, `generic_t1.t[P₁ interface{}]`},
{`package t2; type t[P interface{}] int; var _ t[int]`, `t`, `t2.t[P₁ interface{}]`}, {genericPkg + `t2; type t[P interface{}] int; var _ t[int]`, `t`, `generic_t2.t[P₁ interface{}]`},
{`package t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `t3.t[P₁, Q₂ interface{}]`}, {genericPkg + `t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `generic_t3.t[P₁, Q₂ interface{}]`},
{broken + `t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `broken_t4.t[P₁, Q₂ interface{m()}]`}, {brokenPkg + `t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `broken_t4.t[P₁, Q₂ interface{m()}]`},
// instantiated types must be sanitized // instantiated types must be sanitized
{`package g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `g0.t[int]`}, {genericPkg + `g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `generic_g0.t[int]`},
// issue 45096 // issue 45096
{`package issue45096; func _[T interface{ type int8, int16, int32 }](x T) { _ = x < 0 }`, `0`, `T₁`}, {genericPkg + `issue45096; func _[T interface{ type int8, int16, int32 }](x T) { _ = x < 0 }`, `0`, `T₁`},
} }
for _, test := range tests { for _, test := range tests {
info := Info{Types: make(map[syntax.Expr]TypeAndValue)} info := Info{Types: make(map[syntax.Expr]TypeAndValue)}
var name string var name string
if strings.HasPrefix(test.src, broken) { if strings.HasPrefix(test.src, brokenPkg) {
var err error var err error
name, err = mayTypecheck(t, "TypesInfo", test.src, &info) name, err = mayTypecheck(t, "TypesInfo", test.src, &info)
if err == nil { if err == nil {
@ -383,103 +391,103 @@ func TestInferredInfo(t *testing.T) {
targs []string targs []string
sig string sig string
}{ }{
{`package p0; func f[T any](T); func _() { f(42) }`, {genericPkg + `p0; func f[T any](T); func _() { f(42) }`,
`f`, `f`,
[]string{`int`}, []string{`int`},
`func(int)`, `func(int)`,
}, },
{`package p1; func f[T any](T) T; func _() { f('@') }`, {genericPkg + `p1; func f[T any](T) T; func _() { f('@') }`,
`f`, `f`,
[]string{`rune`}, []string{`rune`},
`func(rune) rune`, `func(rune) rune`,
}, },
{`package p2; func f[T any](...T) T; func _() { f(0i) }`, {genericPkg + `p2; func f[T any](...T) T; func _() { f(0i) }`,
`f`, `f`,
[]string{`complex128`}, []string{`complex128`},
`func(...complex128) complex128`, `func(...complex128) complex128`,
}, },
{`package p3; func f[A, B, C any](A, *B, []C); func _() { f(1.2, new(string), []byte{}) }`, {genericPkg + `p3; func f[A, B, C any](A, *B, []C); func _() { f(1.2, new(string), []byte{}) }`,
`f`, `f`,
[]string{`float64`, `string`, `byte`}, []string{`float64`, `string`, `byte`},
`func(float64, *string, []byte)`, `func(float64, *string, []byte)`,
}, },
{`package p4; func f[A, B any](A, *B, ...[]B); func _() { f(1.2, new(byte)) }`, {genericPkg + `p4; func f[A, B any](A, *B, ...[]B); func _() { f(1.2, new(byte)) }`,
`f`, `f`,
[]string{`float64`, `byte`}, []string{`float64`, `byte`},
`func(float64, *byte, ...[]byte)`, `func(float64, *byte, ...[]byte)`,
}, },
// we don't know how to translate these but we can type-check them // we don't know how to translate these but we can type-check them
{`package q0; type T struct{}; func (T) m[P any](P); func _(x T) { x.m(42) }`, {genericPkg + `q0; type T struct{}; func (T) m[P any](P); func _(x T) { x.m(42) }`,
`x.m`, `x.m`,
[]string{`int`}, []string{`int`},
`func(int)`, `func(int)`,
}, },
{`package q1; type T struct{}; func (T) m[P any](P) P; func _(x T) { x.m(42) }`, {genericPkg + `q1; type T struct{}; func (T) m[P any](P) P; func _(x T) { x.m(42) }`,
`x.m`, `x.m`,
[]string{`int`}, []string{`int`},
`func(int) int`, `func(int) int`,
}, },
{`package q2; type T struct{}; func (T) m[P any](...P) P; func _(x T) { x.m(42) }`, {genericPkg + `q2; type T struct{}; func (T) m[P any](...P) P; func _(x T) { x.m(42) }`,
`x.m`, `x.m`,
[]string{`int`}, []string{`int`},
`func(...int) int`, `func(...int) int`,
}, },
{`package q3; type T struct{}; func (T) m[A, B, C any](A, *B, []C); func _(x T) { x.m(1.2, new(string), []byte{}) }`, {genericPkg + `q3; type T struct{}; func (T) m[A, B, C any](A, *B, []C); func _(x T) { x.m(1.2, new(string), []byte{}) }`,
`x.m`, `x.m`,
[]string{`float64`, `string`, `byte`}, []string{`float64`, `string`, `byte`},
`func(float64, *string, []byte)`, `func(float64, *string, []byte)`,
}, },
{`package q4; type T struct{}; func (T) m[A, B any](A, *B, ...[]B); func _(x T) { x.m(1.2, new(byte)) }`, {genericPkg + `q4; type T struct{}; func (T) m[A, B any](A, *B, ...[]B); func _(x T) { x.m(1.2, new(byte)) }`,
`x.m`, `x.m`,
[]string{`float64`, `byte`}, []string{`float64`, `byte`},
`func(float64, *byte, ...[]byte)`, `func(float64, *byte, ...[]byte)`,
}, },
{`package r0; type T[P any] struct{}; func (_ T[P]) m[Q any](Q); func _[P any](x T[P]) { x.m(42) }`, {genericPkg + `r0; type T[P any] struct{}; func (_ T[P]) m[Q any](Q); func _[P any](x T[P]) { x.m(42) }`,
`x.m`, `x.m`,
[]string{`int`}, []string{`int`},
`func(int)`, `func(int)`,
}, },
// TODO(gri) record method type parameters in syntax.FuncType so we can check this // TODO(gri) record method type parameters in syntax.FuncType so we can check this
// {`package r1; type T interface{ m[P any](P) }; func _(x T) { x.m(4.2) }`, // {genericPkg + `r1; type T interface{ m[P any](P) }; func _(x T) { x.m(4.2) }`,
// `x.m`, // `x.m`,
// []string{`float64`}, // []string{`float64`},
// `func(float64)`, // `func(float64)`,
// }, // },
{`package s1; func f[T any, P interface{type *T}](x T); func _(x string) { f(x) }`, {genericPkg + `s1; func f[T any, P interface{type *T}](x T); func _(x string) { f(x) }`,
`f`, `f`,
[]string{`string`, `*string`}, []string{`string`, `*string`},
`func(x string)`, `func(x string)`,
}, },
{`package s2; func f[T any, P interface{type *T}](x []T); func _(x []int) { f(x) }`, {genericPkg + `s2; func f[T any, P interface{type *T}](x []T); func _(x []int) { f(x) }`,
`f`, `f`,
[]string{`int`, `*int`}, []string{`int`, `*int`},
`func(x []int)`, `func(x []int)`,
}, },
{`package s3; type C[T any] interface{type chan<- T}; func f[T any, P C[T]](x []T); func _(x []int) { f(x) }`, {genericPkg + `s3; type C[T any] interface{type chan<- T}; func f[T any, P C[T]](x []T); func _(x []int) { f(x) }`,
`f`, `f`,
[]string{`int`, `chan<- int`}, []string{`int`, `chan<- int`},
`func(x []int)`, `func(x []int)`,
}, },
{`package s4; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]](x []T); func _(x []int) { f(x) }`, {genericPkg + `s4; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]](x []T); func _(x []int) { f(x) }`,
`f`, `f`,
[]string{`int`, `chan<- int`, `chan<- []*chan<- int`}, []string{`int`, `chan<- int`, `chan<- []*chan<- int`},
`func(x []int)`, `func(x []int)`,
}, },
{`package t1; func f[T any, P interface{type *T}]() T; func _() { _ = f[string] }`, {genericPkg + `t1; func f[T any, P interface{type *T}]() T; func _() { _ = f[string] }`,
`f`, `f`,
[]string{`string`, `*string`}, []string{`string`, `*string`},
`func() string`, `func() string`,
}, },
{`package t2; type C[T any] interface{type chan<- T}; func f[T any, P C[T]]() []T; func _() { _ = f[int] }`, {genericPkg + `t2; type C[T any] interface{type chan<- T}; func f[T any, P C[T]]() []T; func _() { _ = f[int] }`,
`f`, `f`,
[]string{`int`, `chan<- int`}, []string{`int`, `chan<- int`},
`func() []int`, `func() []int`,
}, },
{`package t3; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T; func _() { _ = f[int] }`, {genericPkg + `t3; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T; func _() { _ = f[int] }`,
`f`, `f`,
[]string{`int`, `chan<- int`, `chan<- []*chan<- int`}, []string{`int`, `chan<- int`, `chan<- []*chan<- int`},
`func() []int`, `func() []int`,
@ -551,10 +559,10 @@ func TestDefsInfo(t *testing.T) {
// generic types must be sanitized // generic types must be sanitized
// (need to use sufficiently nested types to provoke unexpanded types) // (need to use sufficiently nested types to provoke unexpanded types)
{`package g0; type t[P any] P; const x = t[int](42)`, `x`, `const g0.x g0.t[int]`}, {genericPkg + `g0; type t[P any] P; const x = t[int](42)`, `x`, `const generic_g0.x generic_g0.t[int]`},
{`package g1; type t[P any] P; var x = t[int](42)`, `x`, `var g1.x g1.t[int]`}, {genericPkg + `g1; type t[P any] P; var x = t[int](42)`, `x`, `var generic_g1.x generic_g1.t[int]`},
{`package g2; type t[P any] P; type x struct{ f t[int] }`, `x`, `type g2.x struct{f g2.t[int]}`}, {genericPkg + `g2; type t[P any] P; type x struct{ f t[int] }`, `x`, `type generic_g2.x struct{f generic_g2.t[int]}`},
{`package g3; type t[P any] P; func f(x struct{ f t[string] }); var g = f`, `g`, `var g3.g func(x struct{f g3.t[string]})`}, {genericPkg + `g3; type t[P any] P; func f(x struct{ f t[string] }); var g = f`, `g`, `var generic_g3.g func(x struct{f generic_g3.t[string]})`},
} }
for _, test := range tests { for _, test := range tests {
@ -596,10 +604,10 @@ func TestUsesInfo(t *testing.T) {
// generic types must be sanitized // generic types must be sanitized
// (need to use sufficiently nested types to provoke unexpanded types) // (need to use sufficiently nested types to provoke unexpanded types)
{`package g0; func _() { _ = x }; type t[P any] P; const x = t[int](42)`, `x`, `const g0.x g0.t[int]`}, {genericPkg + `g0; func _() { _ = x }; type t[P any] P; const x = t[int](42)`, `x`, `const generic_g0.x generic_g0.t[int]`},
{`package g1; func _() { _ = x }; type t[P any] P; var x = t[int](42)`, `x`, `var g1.x g1.t[int]`}, {genericPkg + `g1; func _() { _ = x }; type t[P any] P; var x = t[int](42)`, `x`, `var generic_g1.x generic_g1.t[int]`},
{`package g2; func _() { type _ x }; type t[P any] P; type x struct{ f t[int] }`, `x`, `type g2.x struct{f g2.t[int]}`}, {genericPkg + `g2; func _() { type _ x }; type t[P any] P; type x struct{ f t[int] }`, `x`, `type generic_g2.x struct{f generic_g2.t[int]}`},
{`package g3; func _() { _ = f }; type t[P any] P; func f(x struct{ f t[string] })`, `f`, `func g3.f(x struct{f g3.t[string]})`}, {genericPkg + `g3; func _() { _ = f }; type t[P any] P; func f(x struct{ f t[string] })`, `f`, `func generic_g3.f(x struct{f generic_g3.t[string]})`},
} }
for _, test := range tests { for _, test := range tests {
@ -1560,6 +1568,50 @@ func F(){
} }
} }
func TestConvertibleTo(t *testing.T) {
for _, test := range []struct {
v, t Type
want bool
}{
{Typ[Int], Typ[Int], true},
{Typ[Int], Typ[Float32], true},
{newDefined(Typ[Int]), Typ[Int], true},
{newDefined(new(Struct)), new(Struct), true},
{newDefined(Typ[Int]), new(Struct), false},
{Typ[UntypedInt], Typ[Int], true},
// Untyped string values are not permitted by the spec, so the below
// behavior is undefined.
{Typ[UntypedString], Typ[String], true},
} {
if got := ConvertibleTo(test.v, test.t); got != test.want {
t.Errorf("ConvertibleTo(%v, %v) = %t, want %t", test.v, test.t, got, test.want)
}
}
}
func TestAssignableTo(t *testing.T) {
for _, test := range []struct {
v, t Type
want bool
}{
{Typ[Int], Typ[Int], true},
{Typ[Int], Typ[Float32], false},
{newDefined(Typ[Int]), Typ[Int], false},
{newDefined(new(Struct)), new(Struct), true},
{Typ[UntypedBool], Typ[Bool], true},
{Typ[UntypedString], Typ[Bool], false},
// Neither untyped string nor untyped numeric assignments arise during
// normal type checking, so the below behavior is technically undefined by
// the spec.
{Typ[UntypedString], Typ[String], true},
{Typ[UntypedInt], Typ[Int], true},
} {
if got := AssignableTo(test.v, test.t); got != test.want {
t.Errorf("AssignableTo(%v, %v) = %t, want %t", test.v, test.t, got, test.want)
}
}
}
func TestIdentical_issue15173(t *testing.T) { func TestIdentical_issue15173(t *testing.T) {
// Identical should allow nil arguments and be symmetric. // Identical should allow nil arguments and be symmetric.
for _, test := range []struct { for _, test := range []struct {

4
src/cmd/compile/internal/types2/typestring_test.go
View File

@ -111,7 +111,7 @@ var dependentTestTypes = []testEntry{
// interfaces // interfaces
dup(`interface{io.Reader; io.Writer}`), dup(`interface{io.Reader; io.Writer}`),
dup(`interface{m() int; io.Writer}`), dup(`interface{m() int; io.Writer}`),
{`interface{m() interface{T}}`, `interface{m() interface{p.T}}`}, {`interface{m() interface{T}}`, `interface{m() interface{generic_p.T}}`},
} }
func TestTypeString(t *testing.T) { func TestTypeString(t *testing.T) {
@ -122,7 +122,7 @@ func TestTypeString(t *testing.T) {
tests = append(tests, dependentTestTypes...) tests = append(tests, dependentTestTypes...)
for _, test := range tests { for _, test := range tests {
src := `package p; import "io"; type _ io.Writer; type T ` + test.src src := `package generic_p; import "io"; type _ io.Writer; type T ` + test.src
pkg, err := makePkg(src) pkg, err := makePkg(src)
if err != nil { if err != nil {
t.Errorf("%s: %s", src, err) t.Errorf("%s: %s", src, err)