baseType := r.typ()
// The imported instantiated type doesn't include any methods, so
// we must always use the methods of the base (orig) type.
- t := types2.Instantiate(pos, baseType, targs)
+ var check *types2.Checker // TODO provide a non-nil *Checker
+ t := check.Instantiate(pos, baseType, targs, nil, false)
return t
case unionType:
obj, targs := r.obj()
name := obj.(*types2.TypeName)
if len(targs) != 0 {
- return r.p.check.InstantiateLazy(syntax.Pos{}, name.Type(), targs)
+ return r.p.check.InstantiateLazy(syntax.Pos{}, name.Type(), targs, false)
}
return name.Type()
}
// instantiation should succeed (no endless recursion)
- res := Instantiate(nopos, T, []Type{Typ[Int]})
+ // even with a nil *Checker
+ var check *Checker
+ res := check.Instantiate(nopos, T, []Type{Typ[Int]}, nil, false)
// instantiated type should point to itself
if res.Underlying().(*Pointer).Elem() != res {
}
// instantiate function signature
- res := check.instantiate(x.Pos(), sig, targs, poslist).(*Signature)
+ res := check.Instantiate(x.Pos(), sig, targs, poslist, true).(*Signature)
assert(res.tparams == nil) // signature is not generic anymore
if inferred {
check.recordInferred(inst, targs, res)
}
// compute result signature
- rsig = check.instantiate(call.Pos(), sig, targs, nil).(*Signature)
+ rsig = check.Instantiate(call.Pos(), sig, targs, nil, true).(*Signature)
assert(rsig.tparams == nil) // signature is not generic anymore
check.recordInferred(call, targs, rsig)
base *Named // parameterized type to be instantiated
targs []Type // type arguments
poslist []syntax.Pos // position of each targ; for error reporting only
+ verify bool // if set, constraint satisfaction is verified
value Type // base[targs...] after instantiation or Typ[Invalid]; nil if not yet set
}
func (t *instance) expand() Type {
v := t.value
if v == nil {
- v = t.check.instantiate(t.pos, t.base, t.targs, t.poslist)
+ v = t.check.Instantiate(t.pos, t.base, t.targs, t.poslist, t.verify)
if v == nil {
v = Typ[Invalid]
}
"fmt"
)
-// Instantiate instantiates the type typ with the given type arguments.
-// typ must be a *Named or a *Signature type, it must be generic, and
-// its number of type parameters must match the number of provided type
-// arguments. The result is a new, instantiated (not generic) type of
-// the same kind (either a *Named or a *Signature). The type arguments
-// are not checked against the constraints of the type parameters.
-// Any methods attached to a *Named are simply copied; they are not
-// instantiated.
-func Instantiate(pos syntax.Pos, typ Type, targs []Type) (res Type) {
- // TODO(gri) This code is basically identical to the prolog
- // in Checker.instantiate. Factor.
- var tparams []*TypeName
- switch t := typ.(type) {
- case *Named:
- tparams = t.TParams()
- case *Signature:
- tparams = t.tparams
- defer func() {
- // If we had an unexpected failure somewhere don't panic below when
- // asserting res.(*Signature). Check for *Signature in case Typ[Invalid]
- // is returned.
- if _, ok := res.(*Signature); !ok {
- return
- }
- // If the signature doesn't use its type parameters, subst
- // will not make a copy. In that case, make a copy now (so
- // we can set tparams to nil w/o causing side-effects).
- if t == res {
- copy := *t
- res = ©
- }
- // After instantiating a generic signature, it is not generic
- // anymore; we need to set tparams to nil.
- res.(*Signature).tparams = nil
- }()
-
- default:
- panic(fmt.Sprintf("%v: cannot instantiate %v", pos, typ))
- }
-
- // the number of supplied types must match the number of type parameters
- if len(targs) != len(tparams) {
- panic(fmt.Sprintf("%v: got %d arguments but %d type parameters", pos, len(targs), len(tparams)))
- }
-
- if len(tparams) == 0 {
- return typ // nothing to do (minor optimization)
- }
-
- smap := makeSubstMap(tparams, targs)
- return (*Checker)(nil).subst(pos, typ, smap)
-}
-
// InstantiateLazy is like Instantiate, but avoids actually
// instantiating the type until needed.
-func (check *Checker) InstantiateLazy(pos syntax.Pos, typ Type, targs []Type) (res Type) {
+func (check *Checker) InstantiateLazy(pos syntax.Pos, typ Type, targs []Type, verify bool) (res Type) {
base := asNamed(typ)
if base == nil {
panic(fmt.Sprintf("%v: cannot instantiate %v", pos, typ))
}
return &instance{
- check: check,
- pos: pos,
- base: base,
- targs: targs,
+ check: check,
+ pos: pos,
+ base: base,
+ targs: targs,
+ verify: verify,
}
}
{Chan{}, 12, 24},
{Named{}, 84, 160},
{TypeParam{}, 28, 48},
- {instance{}, 52, 96},
+ {instance{}, 56, 104},
{top{}, 0, 0},
// Objects
return tpar
}
-func (check *Checker) instantiate(pos syntax.Pos, typ Type, targs []Type, poslist []syntax.Pos) (res Type) {
- if check.conf.Trace {
+// Instantiate instantiates the type typ with the given type arguments
+// targs. To check type constraint satisfaction, verify must be set.
+// pos and posList correspond to the instantiation and type argument
+// positions respectively; posList may be nil or shorter than the number
+// of type arguments provided.
+// typ must be a *Named or a *Signature type, and its number of type
+// parameters must match the number of provided type arguments.
+// The receiver (check) may be nil if and only if verify is not set.
+// The result is a new, instantiated (not generic) type of the same kind
+// (either a *Named or a *Signature).
+// Any methods attached to a *Named are simply copied; they are not
+// instantiated.
+func (check *Checker) Instantiate(pos syntax.Pos, typ Type, targs []Type, posList []syntax.Pos, verify bool) (res Type) {
+ if verify && check == nil {
+ panic("cannot have nil receiver if verify is set")
+ }
+
+ if check != nil && check.conf.Trace {
check.trace(pos, "-- instantiating %s with %s", typ, typeListString(targs))
check.indent++
defer func() {
}()
}
- assert(len(poslist) <= len(targs))
+ assert(len(posList) <= len(targs))
// TODO(gri) What is better here: work with TypeParams, or work with TypeNames?
var tparams []*TypeName
// anymore; we need to set tparams to nil.
res.(*Signature).tparams = nil
}()
-
default:
- check.dump("%v: cannot instantiate %v", pos, typ)
- unreachable() // only defined types and (defined) functions can be generic
-
+ // only types and functions can be generic
+ panic(fmt.Sprintf("%v: cannot instantiate %v", pos, typ))
}
// the number of supplied types must match the number of type parameters
if len(targs) != len(tparams) {
// TODO(gri) provide better error message
- check.errorf(pos, "got %d arguments but %d type parameters", len(targs), len(tparams))
- return Typ[Invalid]
+ if check != nil {
+ check.errorf(pos, "got %d arguments but %d type parameters", len(targs), len(tparams))
+ return Typ[Invalid]
+ }
+ panic(fmt.Sprintf("%v: got %d arguments but %d type parameters", pos, len(targs), len(tparams)))
}
if len(tparams) == 0 {
smap := makeSubstMap(tparams, targs)
// check bounds
- for i, tname := range tparams {
- // best position for error reporting
- pos := pos
- if i < len(poslist) {
- pos = poslist[i]
- }
- // stop checking bounds after the first failure
- if !check.satisfies(pos, targs[i], tname.typ.(*TypeParam), smap) {
- break
+ if verify {
+ for i, tname := range tparams {
+ // best position for error reporting
+ pos := pos
+ if i < len(posList) {
+ pos = posList[i]
+ }
+ // stop checking bounds after the first failure
+ if !check.satisfies(pos, targs[i], tname.typ.(*TypeParam), smap) {
+ break
+ }
}
}
// create a new type instance rather than instantiate the type
// TODO(gri) should do argument number check here rather than
// when instantiating the type?
+ // TODO(gri) use InstantiateLazy here (cleanup)
typ := new(instance)
def.setUnderlying(typ)
typ.check = check
typ.pos = x.Pos()
typ.base = base
+ typ.verify = true
// evaluate arguments (always)
typ.targs = check.typeList(targs)