decls

Documentation

Overview

Package decls provides helpers for creating variable and function declarations.

Index

• Variables
• func NewAbstractType(name string, paramTypes ...*exprpb.Type) *exprpb.Type
• func NewFunction(name string, overloads ...*exprpb.Decl_FunctionDecl_Overload) *exprpb.Decl
• func NewFunctionType(resultType *exprpb.Type, argTypes ...*exprpb.Type) *exprpb.Type
• func NewIdent(name string, t *exprpb.Type, v *exprpb.Constant) *exprpb.Decl
• func NewInstanceOverload(id string, argTypes []*exprpb.Type, resultType *exprpb.Type) *exprpb.Decl_FunctionDecl_Overload
• func NewListType(elem *exprpb.Type) *exprpb.Type
• func NewMapType(key *exprpb.Type, value *exprpb.Type) *exprpb.Type
• func NewObjectType(typeName string) *exprpb.Type
• func NewOverload(id string, argTypes []*exprpb.Type, resultType *exprpb.Type) *exprpb.Decl_FunctionDecl_Overload
• func NewParameterizedInstanceOverload(id string, argTypes []*exprpb.Type, resultType *exprpb.Type, ...) *exprpb.Decl_FunctionDecl_Overload
• func NewParameterizedOverload(id string, argTypes []*exprpb.Type, resultType *exprpb.Type, ...) *exprpb.Decl_FunctionDecl_Overload
• func NewPrimitiveType(primitive exprpb.Type_PrimitiveType) *exprpb.Type
• func NewTypeParamType(name string) *exprpb.Type
• func NewTypeType(nested *exprpb.Type) *exprpb.Type
• func NewWellKnownType(wellKnown exprpb.Type_WellKnownType) *exprpb.Type
• func NewWrapperType(wrapped *exprpb.Type) *exprpb.Type
• type Group
• type Scopes
  • func NewScopes() *Scopes
  • func (s *Scopes) AddFunction(fn *exprpb.Decl)
  • func (s *Scopes) AddIdent(decl *exprpb.Decl)
  • func (s *Scopes) FindFunction(name string) *exprpb.Decl
  • func (s *Scopes) FindIdent(name string) *exprpb.Decl
  • func (s *Scopes) FindIdentInScope(name string) *exprpb.Decl
  • func (s *Scopes) Pop()
  • func (s *Scopes) Push()

Variables

var (
	// Error type used to communicate issues during type-checking.
	Error = &exprpb.Type{
		TypeKind: &exprpb.Type_Error{
			Error: &emptypb.Empty{}}}

	// Dyn is a top-type used to represent any value.
	Dyn = &exprpb.Type{
		TypeKind: &exprpb.Type_Dyn{
			Dyn: &emptypb.Empty{}}}
)

var (
	Bool   = NewPrimitiveType(exprpb.Type_BOOL)
	Bytes  = NewPrimitiveType(exprpb.Type_BYTES)
	Double = NewPrimitiveType(exprpb.Type_DOUBLE)
	Int    = NewPrimitiveType(exprpb.Type_INT64)
	Null   = &exprpb.Type{
		TypeKind: &exprpb.Type_Null{
			Null: structpb.NullValue_NULL_VALUE}}
	String = NewPrimitiveType(exprpb.Type_STRING)
	Uint   = NewPrimitiveType(exprpb.Type_UINT64)
)

Commonly used types.

var (
	Any       = NewWellKnownType(exprpb.Type_ANY)
	Duration  = NewWellKnownType(exprpb.Type_DURATION)
	Timestamp = NewWellKnownType(exprpb.Type_TIMESTAMP)
)

Well-known types. TODO: Replace with an abstract type registry.

Functions

func NewAbstractType

func NewAbstractType(name string, paramTypes ...*exprpb.Type) *exprpb.Type

NewAbstractType creates an abstract type declaration which references a proto message name and may also include type parameters.

func NewFunction

func NewFunction(name string,
	overloads ...*exprpb.Decl_FunctionDecl_Overload) *exprpb.Decl

NewFunction creates a named function declaration with one or more overloads.

func NewFunctionType

func NewFunctionType(resultType *exprpb.Type,
	argTypes ...*exprpb.Type) *exprpb.Type

NewFunctionType creates a function invocation contract, typically only used by type-checking steps after overload resolution.

func NewIdent

func NewIdent(name string, t *exprpb.Type, v *exprpb.Constant) *exprpb.Decl

NewIdent creates a named identifier declaration with an optional literal value.

Literal values are typically only associated with enum identifiers.

func NewInstanceOverload

func NewInstanceOverload(id string, argTypes []*exprpb.Type,
	resultType *exprpb.Type) *exprpb.Decl_FunctionDecl_Overload

NewInstanceOverload creates a instance function overload contract.

func NewListType

func NewListType(elem *exprpb.Type) *exprpb.Type

NewListType generates a new list with elements of a certain type.

func NewMapType

func NewMapType(key *exprpb.Type, value *exprpb.Type) *exprpb.Type

NewMapType generates a new map with typed keys and values.

func NewObjectType

func NewObjectType(typeName string) *exprpb.Type

NewObjectType creates an object type for a qualified type name.

func NewOverload

func NewOverload(id string, argTypes []*exprpb.Type,
	resultType *exprpb.Type) *exprpb.Decl_FunctionDecl_Overload

NewOverload creates a function overload declaration which contains a unique overload id as well as the expected argument and result types. Overloads must be aggregated within a Function declaration.

func NewParameterizedInstanceOverload

func NewParameterizedInstanceOverload(id string,
	argTypes []*exprpb.Type,
	resultType *exprpb.Type,
	typeParams []string) *exprpb.Decl_FunctionDecl_Overload

NewParameterizedInstanceOverload creates a parametric function instance overload type.

func NewParameterizedOverload

func NewParameterizedOverload(id string,
	argTypes []*exprpb.Type,
	resultType *exprpb.Type,
	typeParams []string) *exprpb.Decl_FunctionDecl_Overload

NewParameterizedOverload creates a parametric function overload type.

func NewPrimitiveType

func NewPrimitiveType(primitive exprpb.Type_PrimitiveType) *exprpb.Type

NewPrimitiveType creates a type for a primitive value. See the var declarations for Int, Uint, etc.

func NewTypeParamType

func NewTypeParamType(name string) *exprpb.Type

NewTypeParamType creates a type corresponding to a named, contextual parameter.

func NewTypeType

func NewTypeType(nested *exprpb.Type) *exprpb.Type

NewTypeType creates a new type designating a type.

func NewWellKnownType

func NewWellKnownType(wellKnown exprpb.Type_WellKnownType) *exprpb.Type

NewWellKnownType creates a type corresponding to a protobuf well-known type value.

func NewWrapperType

func NewWrapperType(wrapped *exprpb.Type) *exprpb.Type

NewWrapperType creates a wrapped primitive type instance. Wrapped types are roughly equivalent to a nullable, or optionally valued type.

Types

type Group

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

Group is a set of Decls that is pushed on or popped off a Scopes as a unit. Contains separate namespaces for idenifier and function Decls. (Should be named "Scope" perhaps?)

type Scopes

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

Scopes represents nested Decl environments. A Scopes structure is a stack of Groups (the highest array index is the top of stack), with the top of the stack being the "innermost" scope, and the bottom being the "outermost" scope. Each group is a mapping of names to Decls in the ident and function namespaces. Lookups are performed such that bindings in inner scopes shadow those in outer scopes.

func NewScopes

func NewScopes() *Scopes

NewScopes creates a new, empty Scopes. Some operations can't be safely performed until a Group is added with Push.

func (*Scopes) AddFunction

func (s *Scopes) AddFunction(fn *exprpb.Decl)

AddFunction adds the function Decl in the outermost scope. Any previous entry for a function of the same name is overwritten. Scopes must have at least one group.

func (*Scopes) AddIdent

func (s *Scopes) AddIdent(decl *exprpb.Decl)

AddIdent adds the ident Decl in the outermost scope. Any previous entry for an ident of the same name is overwritten. Scopes must have at least one group.

func (*Scopes) FindFunction

func (s *Scopes) FindFunction(name string) *exprpb.Decl

FindFunction finds the first function Decl with a matching name in Scopes. The search is performed from innermost to outermost. Returns nil if no such function in Scopes.

func (*Scopes) FindIdent

func (s *Scopes) FindIdent(name string) *exprpb.Decl

FindIdent finds the first ident Decl with a matching name in Scopes. The search is performed from innermost to outermost. Returns nil if not such ident in Scopes.

func (*Scopes) FindIdentInScope

func (s *Scopes) FindIdentInScope(name string) *exprpb.Decl

FindIdentInScope returns the named ident binding in the innermost scope. Returns nil if no such binding exists. Scopes must have at least one group.

func (*Scopes) Pop

func (s *Scopes) Pop()

Pop removes the innermost Group from Scopes. Scopes should have at least one Group.

func (*Scopes) Push

func (s *Scopes) Push()

Push adds an empty Group as the new innermost scope.