package gotypes

import "github.com/mmcloughlin/avo/gotypes"

Package gotypes provides helpers for interacting with Go types within avo functions.

Index ¶

• Variables
• type Basic
• type Component
• func NewComponent(t types.Type, addr operand.Mem) Component
• type Signature
• func LookupSignature(pkg *types.Package, name string) (*Signature, error)
• func NewSignature(pkg *types.Package, sig *types.Signature) *Signature
• func NewSignatureVoid() *Signature
• func ParseSignature(expr string) (*Signature, error)
• func ParseSignatureInPackage(pkg *types.Package, expr string) (*Signature, error)
• func (s *Signature) Bytes() int
• func (s *Signature) Params() *Tuple
• func (s *Signature) Results() *Tuple
• func (s *Signature) String() string
• type Tuple
• func (t *Tuple) At(i int) Component
• func (t *Tuple) Bytes() int
• func (t *Tuple) Lookup(name string) Component

Examples ¶

• ParseSignature

Variables ¶

var PointerSize = Sizes.Sizeof(types.Typ[types.UnsafePointer])

PointerSize is the size of a pointer on amd64.

var Sizes = types.SizesFor("gc", "amd64")

Sizes provides type sizes used by the standard Go compiler on amd64.

Types ¶

type Basic ¶

type Basic struct {
	Addr operand.Mem
	Type *types.Basic
}

Basic represents a primitive/basic type at a given memory address.

type Component ¶

type Component interface {
	// When the component has no further sub-components, Resolve will return a
	// reference to the components type and memory address. If there was an error
	// during any previous calls to Component methods, they will be returned at
	// resolution time.
	Resolve() (*Basic, error)
	Dereference(r reg.Register) Component // dereference a pointer
	Base() Component                      // base pointer of a string or slice
	Len() Component                       // length of a string or slice
	Cap() Component                       // capacity of a slice
	Real() Component                      // real part of a complex value
	Imag() Component                      // imaginary part of a complex value
	Index(int) Component                  // index into an array
	Field(string) Component               // access a struct field
}

Component provides access to sub-components of a Go type.

func NewComponent ¶

func NewComponent(t types.Type, addr operand.Mem) Component

NewComponent builds a component for the named type at the given address.

type Signature ¶

type Signature struct {
	// contains filtered or unexported fields
}

Signature represents a Go function signature.

func LookupSignature ¶

func LookupSignature(pkg *types.Package, name string) (*Signature, error)

LookupSignature returns the signature of the named function in the provided package.

func NewSignature ¶

func NewSignature(pkg *types.Package, sig *types.Signature) *Signature

NewSignature constructs a Signature.

func NewSignatureVoid ¶

func NewSignatureVoid() *Signature

NewSignatureVoid builds the void signature "func()".

func ParseSignature ¶

func ParseSignature(expr string) (*Signature, error)

ParseSignature builds a Signature by parsing a Go function type expression. The function type must reference builtin types only; see ParseSignatureInPackage if custom types are required.

package main

import (
	"fmt"

	"github.com/mmcloughlin/avo/gotypes"
)

func main() {
	s, err := gotypes.ParseSignature("func(s string, n int) string")
	fmt.Println(s)
	fmt.Println(err)
}

(s string, n int) string
<nil>

func ParseSignatureInPackage ¶

func ParseSignatureInPackage(pkg *types.Package, expr string) (*Signature, error)

ParseSignatureInPackage builds a Signature by parsing a Go function type expression. The expression may reference types in the provided package.

func (*Signature) Bytes ¶

func (s *Signature) Bytes() int

Bytes returns the total size of the function arguments and return values.

func (*Signature) Params ¶

func (s *Signature) Params() *Tuple

Params returns the function signature argument types.

func (*Signature) Results ¶

func (s *Signature) Results() *Tuple

Results returns the function return types.

func (*Signature) String ¶

func (s *Signature) String() string

String writes Signature as a string. This does not include the "func" keyword.

type Tuple ¶

type Tuple struct {
	// contains filtered or unexported fields
}

Tuple represents a tuple of variables, such as function arguments or results.

func (*Tuple) At ¶

func (t *Tuple) At(i int) Component

At returns the variable at index i.

func (*Tuple) Bytes ¶

func (t *Tuple) Bytes() int

Bytes returns the size of the Tuple. This may include additional padding.

func (*Tuple) Lookup ¶

func (t *Tuple) Lookup(name string) Component

Lookup returns the variable with the given name.

Source Files ¶

components.go doc.go signature.go