Enabled reports whether type parameters are enabled in the current build environment.
const Enabled = true
var ErrEmptyTypeSet = errors.New("empty type set")
func CoreType(T types.Type) types.Type
CoreType returns the core type of T or nil if T does not have a core type.
See https://go.dev/ref/spec#Core_types for the definition of a core type.
func ForFuncType(n *ast.FuncType) *ast.FieldList
ForFuncType returns n.TypeParams.
func ForTypeSpec(n *ast.TypeSpec) *ast.FieldList
ForTypeSpec returns n.TypeParams.
func GenericAssignableTo(ctxt *Context, V, T types.Type) bool
GenericAssignableTo is a generalization of types.AssignableTo that implements the following rule for uninstantiated generic types:
If V and T are generic named types, then V is considered assignable to T if, for every possible instantation of V[A_1, ..., A_N], the instantiation T[A_1, ..., A_N] is valid and V[A_1, ..., A_N] implements T[A_1, ..., A_N].
If T has structural constraints, they must be satisfied by V.
For example, consider the following type declarations:
type Interface[T any] interface {
Accept(T)
}
type Container[T any] struct {
Element T
}
func (c Container[T]) Accept(t T) { c.Element = t }
In this case, GenericAssignableTo reports that instantiations of Container are assignable to the corresponding instantiation of Interface.
func GetInstances(info *types.Info) map[*ast.Ident]Instance
GetInstances returns info.Instances.
func InitInstanceInfo(info *types.Info)
InitInstanceInfo initializes info to record information about type and function instances.
func Instantiate(ctxt *Context, typ types.Type, targs []types.Type, validate bool) (types.Type, error)
Instantiate calls types.Instantiate.
func IsComparable(iface *types.Interface) bool
IsComparable calls iface.IsComparable().
func IsImplicit(iface *types.Interface) bool
IsImplicit calls iface.IsImplicit().
func IsMethodSet(iface *types.Interface) bool
IsMethodSet calls iface.IsMethodSet().
func IsTypeParam(t types.Type) bool
IsTypeParam reports whether t is a type parameter.
func MarkImplicit(iface *types.Interface)
MarkImplicit calls iface.MarkImplicit().
func NamedTypeOrigin(named *types.Named) types.Type
NamedTypeOrigin returns named.Orig().
func NewSignatureType(recv *types.Var, recvTypeParams, typeParams []*TypeParam, params, results *types.Tuple, variadic bool) *types.Signature
NewSignatureType calls types.NewSignatureType.
func OriginMethod(fn *types.Func) *types.Func
OriginMethod returns the origin method associated with the method fn. For methods on a non-generic receiver base type, this is just fn. However, for methods with a generic receiver, OriginMethod returns the corresponding method in the method set of the origin type.
As a special case, if fn is not a method (has no receiver), OriginMethod returns fn.
func PackIndexExpr(x ast.Expr, lbrack token.Pos, indices []ast.Expr, rbrack token.Pos) ast.Expr
PackIndexExpr returns an *ast.IndexExpr or *ast.IndexListExpr, depending on the cardinality of indices. Calling PackIndexExpr with len(indices) == 0 will panic.
func SetForNamed(n *types.Named, tparams []*TypeParam)
SetForNamed sets the type params tparams on n. Each tparam must be of dynamic type *types.TypeParam.
func SetTypeParamConstraint(tparam *TypeParam, constraint types.Type)
SetTypeParamConstraint calls tparam.SetConstraint(constraint).
func UnpackIndexExpr(n ast.Node) (x ast.Expr, lbrack token.Pos, indices []ast.Expr, rbrack token.Pos)
UnpackIndexExpr extracts data from AST nodes that represent index expressions.
For an ast.IndexExpr, the resulting indices slice will contain exactly one index expression. For an ast.IndexListExpr (go1.18+), it may have a variable number of index expressions.
For nodes that don't represent index expressions, the first return value of UnpackIndexExpr will be nil.
Context is an alias for types.Context.
type Context = types.Context
func NewContext() *Context
NewContext calls types.NewContext.
IndexListExpr is an alias for ast.IndexListExpr.
type IndexListExpr = ast.IndexListExpr
Instance is an alias for types.Instance.
type Instance = types.Instance
Term is an alias for types.Term.
type Term = types.Term
func InterfaceTermSet(iface *types.Interface) ([]*Term, error)
InterfaceTermSet computes the normalized terms for a constraint interface, returning an error if the term set cannot be computed or is empty. In the latter case, the error will be ErrEmptyTypeSet.
See the documentation of StructuralTerms for more information on normalization.
func NewTerm(tilde bool, typ types.Type) *Term
NewTerm calls types.NewTerm.
func StructuralTerms(tparam *TypeParam) ([]*Term, error)
StructuralTerms returns a slice of terms representing the normalized structural type restrictions of a type parameter, if any.
Structural type restrictions of a type parameter are created via non-interface types embedded in its constraint interface (directly, or via a chain of interface embeddings). For example, in the declaration
type T[P interface{~int; m()}] int
the structural restriction of the type parameter P is ~int.
With interface embedding and unions, the specification of structural type restrictions may be arbitrarily complex. For example, consider the following:
type A interface{ ~string|~[]byte }
type B interface{ int|string }
type C interface { ~string|~int }
type T[P interface{ A|B; C }] int
In this example, the structural type restriction of P is ~string|int: A|B expands to ~string|~[]byte|int|string, which reduces to ~string|~[]byte|int, which when intersected with C (~string|~int) yields ~string|int.
StructuralTerms computes these expansions and reductions, producing a "normalized" form of the embeddings. A structural restriction is normalized if it is a single union containing no interface terms, and is minimal in the sense that removing any term changes the set of types satisfying the constraint. It is left as a proof for the reader that, modulo sorting, there is exactly one such normalized form.
Because the minimal representation always takes this form, StructuralTerms returns a slice of tilde terms corresponding to the terms of the union in the normalized structural restriction. An error is returned if the constraint interface is invalid, exceeds complexity bounds, or has an empty type set. In the latter case, StructuralTerms returns ErrEmptyTypeSet.
StructuralTerms makes no guarantees about the order of terms, except that it is deterministic.
func UnionTermSet(union *Union) ([]*Term, error)
UnionTermSet computes the normalized terms for a union, returning an error if the term set cannot be computed or is empty. In the latter case, the error will be ErrEmptyTypeSet.
See the documentation of StructuralTerms for more information on normalization.
TypeList is an alias for types.TypeList
type TypeList = types.TypeList
func NamedTypeArgs(named *types.Named) *TypeList
NamedTypeArgs returns named.TypeArgs().
TypeParam is an alias for types.TypeParam
type TypeParam = types.TypeParam
func NewTypeParam(name *types.TypeName, constraint types.Type) *TypeParam
NewTypeParam calls types.NewTypeParam.
TypeParamList is an alias for types.TypeParamList
type TypeParamList = types.TypeParamList
func ForNamed(named *types.Named) *TypeParamList
ForNamed extracts the (possibly empty) type parameter object list from named.
func ForSignature(sig *types.Signature) *TypeParamList
ForSignature returns sig.TypeParams()
func RecvTypeParams(sig *types.Signature) *TypeParamList
RecvTypeParams returns sig.RecvTypeParams().
Union is an alias for types.Union
type Union = types.Union
func NewUnion(terms []*Term) *Union
NewUnion calls types.NewUnion.
| Name | Synopsis |
|---|---|
| .. | |