typeparams

Documentation

Overview

Package typeparams provides functions to work indirectly with type parameter data stored in go/ast and go/types objects, while these API are guarded by a build constraint.

This package exists to make it easier for tools to work with generic code, while also compiling against older Go versions.

Index

• Constants
• Variables
• func ForFuncType(n *ast.FuncType) *ast.FieldList
• func ForTypeSpec(n *ast.TypeSpec) *ast.FieldList
• func GetInstances(info *types.Info) map[*ast.Ident]Instance
• func InitInstanceInfo(info *types.Info)
• func Instantiate(ctxt *Context, typ types.Type, targs []types.Type, validate bool) (types.Type, error)
• func IsComparable(iface *types.Interface) bool
• func IsImplicit(iface *types.Interface) bool
• func IsMethodSet(iface *types.Interface) bool
• func MarkImplicit(iface *types.Interface)
• func NamedTypeOrigin(named *types.Named) types.Type
• func NewSignatureType(recv *types.Var, recvTypeParams, typeParams []*TypeParam, ...) *types.Signature
• func NormalizeInterface(iface *types.Interface) (*types.Interface, error)
• func PackIndexExpr(x ast.Expr, lbrack token.Pos, indices []ast.Expr, rbrack token.Pos) ast.Expr
• func SetForNamed(n *types.Named, tparams []*TypeParam)
• func SetTypeParamConstraint(tparam *TypeParam, constraint types.Type)
• type Context
• type IndexExprData
  • func GetIndexExprData(n ast.Node) *IndexExprData
• type IndexListExpr
• type Instance
• type Term
  • func NewTerm(tilde bool, typ types.Type) *Term
  • func StructuralTerms(typ types.Type) ([]*Term, error)
• type TypeList
  • func NamedTypeArgs(named *types.Named) *TypeList
• type TypeParam
  • func NewTypeParam(name *types.TypeName, constraint types.Type) *TypeParam
• type TypeParamList
  • func ForNamed(named *types.Named) *TypeParamList
  • func ForSignature(sig *types.Signature) *TypeParamList
  • func RecvTypeParams(sig *types.Signature) *TypeParamList
• type Union
  • func NewUnion(terms []*Term) *Union

Constants

const Enabled = true

Enabled reports whether type parameters are enabled in the current build environment.

Variables

var ErrEmptyTypeSet = errors.New("empty type set")

Functions

func ForFuncType

func ForFuncType(n *ast.FuncType) *ast.FieldList

ForFuncType returns n.TypeParams.

func ForTypeSpec

func ForTypeSpec(n *ast.TypeSpec) *ast.FieldList

ForTypeSpec returns n.TypeParams.

func GetInstances

func GetInstances(info *types.Info) map[*ast.Ident]Instance

GetInstances returns info.Instances.

func InitInstanceInfo

func InitInstanceInfo(info *types.Info)

InitInstanceInfo initializes info to record information about type and function instances.

func Instantiate

func Instantiate(ctxt *Context, typ types.Type, targs []types.Type, validate bool) (types.Type, error)

Instantiate calls types.Instantiate.

func IsComparable

func IsComparable(iface *types.Interface) bool

IsComparable calls iface.IsComparable().

func IsImplicit

func IsImplicit(iface *types.Interface) bool

IsImplicit calls iface.IsImplicit().

func IsMethodSet

func IsMethodSet(iface *types.Interface) bool

IsMethodSet calls iface.IsMethodSet().

func MarkImplicit

func MarkImplicit(iface *types.Interface)

MarkImplicit calls iface.MarkImplicit().

func NamedTypeOrigin

func NamedTypeOrigin(named *types.Named) types.Type

NamedTypeOrigin returns named.Orig().

func NewSignatureType

func NewSignatureType(recv *types.Var, recvTypeParams, typeParams []*TypeParam, params, results *types.Tuple, variadic bool) *types.Signature

NewSignatureType calls types.NewSignatureType.

func NormalizeInterface

func NormalizeInterface(iface *types.Interface) (*types.Interface, error)

NormalizeInterface returns the normal form of the interface iface, or nil if iface has an empty type set (i.e. there are no types that satisfy iface). If the resulting interface is non-nil, it will be identical to iface.

An error is returned if the interface type is invalid, or too complicated to reasonably normalize (for example, contains unions with more than a hundred terms).

An interface is in normal form if and only if:

• it has 0 or 1 embedded types.
• its embedded type is either a types.Union or has a concrete (non-interface) underlying type
• if the embedded type is a union, each term of the union has a concrete underlying type, and no terms may be removed without changing the type set of the interface

func PackIndexExpr

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

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

func SetTypeParamConstraint(tparam *TypeParam, constraint types.Type)

SetTypeParamConstraint calls tparam.SetConstraint(constraint).

Types

type Context

type Context = types.Context

Context is an alias for types.Context.

type IndexExprData

type IndexExprData struct {
	X       ast.Expr   // expression
	Lbrack  token.Pos  // position of "["
	Indices []ast.Expr // index expressions
	Rbrack  token.Pos  // position of "]"
}

A IndexExprData holds data from both ast.IndexExpr and the new ast.MultiIndexExpr, which was introduced in Go 1.18.

func GetIndexExprData

func GetIndexExprData(n ast.Node) *IndexExprData

GetIndexExprData extracts data from AST nodes that represent index expressions.

For an ast.IndexExpr, the resulting IndexExprData will have 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, GetIndexExprData returns nil. TODO(rfindley): remove this function in favor of using the alias below.

type IndexListExpr

type IndexListExpr = ast.IndexListExpr

IndexListExpr is an alias for ast.IndexListExpr.

type Instance

type Instance = types.Instance

Instance is an alias for types.Instance.

type Term

type Term = types.Term

Term is an alias for types.Term.

func NewTerm

func NewTerm(tilde bool, typ types.Type) *Term

NewTerm calls types.NewTerm.

func StructuralTerms

func StructuralTerms(typ types.Type) ([]*Term, error)

StructuralTerms returns the normalized structural type restrictions of a type, if any. For types that are not type parameters, it returns term slice containing a single non-tilde term holding the given type. For type parameters, it returns the normalized term list of the type parameter's constraint. See NormalizeInterface for more information on the normal form of a constraint interface.

StructuralTerms returns an error if the structural term list cannot be computed. If the type set of typ is empty, it returns ErrEmptyTypeSet.

type TypeList

type TypeList = types.TypeList

TypeList is an alias for types.TypeList

func NamedTypeArgs

func NamedTypeArgs(named *types.Named) *TypeList

NamedTypeArgs returns named.TypeArgs().

type TypeParam

type TypeParam = types.TypeParam

TypeParam is an alias for types.TypeParam

func NewTypeParam

func NewTypeParam(name *types.TypeName, constraint types.Type) *TypeParam

NewTypeParam calls types.NewTypeParam.

type TypeParamList

type TypeParamList = types.TypeParamList

TypeParamList is an alias for types.TypeParamList

func ForNamed

func ForNamed(named *types.Named) *TypeParamList

ForNamed extracts the (possibly empty) type parameter object list from named.

func ForSignature

func ForSignature(sig *types.Signature) *TypeParamList

ForSignature returns sig.TypeParams()

func RecvTypeParams

func RecvTypeParams(sig *types.Signature) *TypeParamList

RecvTypeParams returns sig.RecvTypeParams().

type Union

type Union = types.Union

Union is an alias for types.Union

func NewUnion

func NewUnion(terms []*Term) *Union

NewUnion calls types.NewUnion.