type genericType … // Instantiate instantiates the type orig with the given type arguments targs. // orig must be an *Alias, *Named, or *Signature type. If there is no error, // the resulting Type is an instantiated type of the same kind (*Alias, *Named // or *Signature, respectively). // // Methods attached to a *Named type are also instantiated, and associated with // a new *Func that has the same position as the original method, but nil function // scope. // // If ctxt is non-nil, it may be used to de-duplicate the instance against // previous instances with the same identity. As a special case, generic // *Signature origin types are only considered identical if they are pointer // equivalent, so that instantiating distinct (but possibly identical) // signatures will yield different instances. The use of a shared context does // not guarantee that identical instances are deduplicated in all cases. // // If validate is set, Instantiate verifies that the number of type arguments // and parameters match, and that the type arguments satisfy their respective // type constraints. If verification fails, the resulting error may wrap an // *ArgumentError indicating which type argument did not satisfy its type parameter // constraint, and why. // // If validate is not set, Instantiate does not verify the type argument count // or whether the type arguments satisfy their constraints. Instantiate is // guaranteed to not return an error, but may panic. Specifically, for // *Signature types, Instantiate will panic immediately if the type argument // count is incorrect; for *Named types, a panic may occur later inside the // *Named API. func Instantiate(ctxt *Context, orig Type, targs []Type, validate bool) (Type, error) { … } // instance instantiates the given original (generic) function or type with the // provided type arguments and returns the resulting instance. If an identical // instance exists already in the given contexts, it returns that instance, // otherwise it creates a new one. // // If expanding is non-nil, it is the Named instance type currently being // expanded. If ctxt is non-nil, it is the context associated with the current // type-checking pass or call to Instantiate. At least one of expanding or ctxt // must be non-nil. // // For Named types the resulting instance may be unexpanded. // // check may be nil (when not type-checking syntax); pos is used only only if check is non-nil. func (check *Checker) instance(pos syntax.Pos, orig genericType, targs []Type, expanding *Named, ctxt *Context) (res Type) { … } // validateTArgLen checks that the number of type arguments (got) matches the // number of type parameters (want); if they don't match an error is reported. // If validation fails and check is nil, validateTArgLen panics. func (check *Checker) validateTArgLen(pos syntax.Pos, name string, want, got int) bool { … } // check may be nil; pos is used only if check is non-nil. func (check *Checker) verify(pos syntax.Pos, tparams []*TypeParam, targs []Type, ctxt *Context) (int, error) { … } // implements checks if V implements T. The receiver may be nil if implements // is called through an exported API call such as AssignableTo. If constraint // is set, T is a type constraint. // // If the provided cause is non-nil, it may be set to an error string // explaining why V does not implement (or satisfy, for constraints) T. func (check *Checker) implements(V, T Type, constraint bool, cause *string) bool { … } // mentions reports whether type T "mentions" typ in an (embedded) element or term // of T (whether typ is in the type set of T or not). For better error messages. func mentions(T, typ Type) bool { … }
Codebase Browser
go