diff options
author | Dan Scales <danscales@google.com> | 2021-03-03 13:33:27 -0800 |
---|---|---|
committer | Dan Scales <danscales@google.com> | 2021-03-09 16:37:52 +0000 |
commit | a70eb2c9f2e3d52116b90a21ce10718356197ee5 (patch) | |
tree | 4c08d16c903d381bf773a594fd7a093c2bec24f5 /src/cmd/compile/internal/types/type.go | |
parent | 034fffdb490ade3cbccd79eacdb9370850ef51d1 (diff) | |
download | go-a70eb2c9f2e3d52116b90a21ce10718356197ee5.tar.gz go-a70eb2c9f2e3d52116b90a21ce10718356197ee5.zip |
cmd/compile: get instantiated generic types working with interfaces
Get instantiatiated generic types working with interfaces, including
typechecking assignments to interfaces and instantiating all the methods
properly. To get it all working, this change includes:
- Add support for substituting in interfaces in subster.typ()
- Fill in the info for the methods for all instantiated generic types,
so those methods will be available for later typechecking (by the old
typechecker) when assigning an instantiated generic type to an
interface. We also want those methods available so we have the list
when we want to instantiate all methods of an instantiated type. We
have both for instantiated types encountered during the initial noder
phase, and for instantiated types created during stenciling of a
function/method.
- When we first create a fully-instantiated generic type (whether
during initial noder2 pass or while instantiating a method/function),
add it to a list so that all of its methods will also be
instantiated. This is needed so that an instantiated type can be
assigned to an interface.
- Properly substitute type names in the names of instantiated methods.
- New accessor methods for types.Type.RParam.
- To deal with generic types which are empty structs (or just don't use
their type params anywhere), we want to set HasTParam if a named type
has any type params that are not fully instantiated, even if the
type param is not used in the type.
- In subst.typ() and elsewhere, always set sym.Def for a new forwarding
type we are creating, so we always create a single unique type for
each generic type instantiation. This handles recursion within a
type, and also recursive relationships across many types or methods.
We remove the seen[] hashtable, which was serving the same purpose,
but for subst.typ() only. We now handle all kinds of recursive types.
- We don't seem to need to force types.CheckSize() on
created/substituted generic types anymore, so commented out for now.
- Add an RParams accessor to types2.Signature, and also a new
exported types2.AsSignature() function.
Change-Id: If6c5dd98427b20bfe9de3379cc16f83df9c9b632
Reviewed-on: https://go-review.googlesource.com/c/go/+/298449
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
Diffstat (limited to 'src/cmd/compile/internal/types/type.go')
-rw-r--r-- | src/cmd/compile/internal/types/type.go | 38 |
1 files changed, 36 insertions, 2 deletions
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go index b0516a8259..d76d9b409f 100644 --- a/src/cmd/compile/internal/types/type.go +++ b/src/cmd/compile/internal/types/type.go @@ -177,10 +177,16 @@ type Type struct { flags bitset8 - // Type params (in order) of this named type that need to be instantiated. + // For defined (named) generic types, the list of type params (in order) + // of this type that need to be instantiated. For fully-instantiated + // generic types, this is the targs used to instantiate them (which are + // used when generating the corresponding instantiated methods). rparams + // is only set for named types that are generic or are fully-instantiated + // from a generic type. + // TODO(danscales): for space reasons, should probably be a pointer to a // slice, possibly change the name of this field. - RParams []*Type + rparams []*Type } func (*Type) CanBeAnSSAAux() {} @@ -236,6 +242,26 @@ func (t *Type) Pos() src.XPos { return src.NoXPos } +func (t *Type) RParams() []*Type { + return t.rparams +} + +func (t *Type) SetRParams(rparams []*Type) { + t.rparams = rparams + if t.HasTParam() { + return + } + // HasTParam should be set if any rparam is or has a type param. This is + // to handle the case of a generic type which doesn't reference any of its + // type params (e.g. most commonly, an empty struct). + for _, rparam := range rparams { + if rparam.HasTParam() { + t.SetHasTParam(true) + break + } + } +} + // NoPkg is a nil *Pkg value for clarity. // It's intended for use when constructing types that aren't exported // and thus don't need to be associated with any package. @@ -1702,6 +1728,13 @@ func NewBasic(kind Kind, obj Object) *Type { func NewInterface(pkg *Pkg, methods []*Field) *Type { t := New(TINTER) t.SetInterface(methods) + for _, f := range methods { + // f.Type could be nil for a broken interface declaration + if f.Type != nil && f.Type.HasTParam() { + t.SetHasTParam(true) + break + } + } if anyBroke(methods) { t.SetBroke(true) } @@ -1754,6 +1787,7 @@ func NewSignature(pkg *Pkg, recv *Field, tparams, params, results []*Field) *Typ unzeroFieldOffsets(params) unzeroFieldOffsets(results) ft.Receiver = funargs(recvs, FunargRcvr) + // TODO(danscales): just use nil here (save memory) if no tparams ft.TParams = funargs(tparams, FunargTparams) ft.Params = funargs(params, FunargParams) ft.Results = funargs(results, FunargResults) |