ast

package
v0.0.0-...-1d296a1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 1, 2023 License: MIT Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AnnotatedNode 

type AnnotatedNode struct {
	VarName  string
	Location string
	Types    types.TypeNode
	IsDefine bool
	Lexeme   lexer.Lexeme
	Node     Node
}

VisitorMetaData is what the visitor will return to represent the conclusion of it work on a node

func (AnnotatedNode) Accept 

func (a AnnotatedNode) Accept(v Visitor) (Node, error)

func (AnnotatedNode) GetType 

func (a AnnotatedNode) GetType() types.TypeNode

type AnnotatedNodeFolder 

type AnnotatedNodeFolder interface {
	FoldAnnotatedNode(n *AnnotatedNode) (Node, error)
}

type AnnotatedNodeVisitor 

type AnnotatedNodeVisitor interface {
	VisitAnnotatedNode(n *AnnotatedNode) (Node, error)
}

type AssignmentNode 

type AssignmentNode struct {
	AssignTo Node
	Value    Node
	Lexeme   lexer.Lexeme
}

AssignmentNode is a node that represents an asignment operator

func (*AssignmentNode) Accept 

func (a *AssignmentNode) Accept(v Visitor) (Node, error)

Accept visits the node

func (*AssignmentNode) GetType 

func (a *AssignmentNode) GetType() types.TypeNode

type AssignmentNodeFolder 

type AssignmentNodeFolder interface {
	FoldAssignmentNode(n *AssignmentNode) (Node, error)
}

type AssignmentNodeVisitor 

type AssignmentNodeVisitor interface {
	VisitAssignmentNode(n *AssignmentNode) (Node, error)
}

type BoolOp 

type BoolOp struct {
	LeftSide  Node
	RightSide Node
	Condition string
	Lexeme    lexer.Lexeme
}

BoolOp represents a boolean operation ('||' and '&&')

func (*BoolOp) Accept 

func (a *BoolOp) Accept(v Visitor) (Node, error)

Accept visits the node

func (*BoolOp) GetType 

func (a *BoolOp) GetType() types.TypeNode

type BoolOpFolder 

type BoolOpFolder interface {
	FoldBoolOp(n *BoolOp) (Node, error)
}

type BoolOpVisitor 

type BoolOpVisitor interface {
	VisitBoolOp(n *BoolOp) (Node, error)
}

type Comparison 

type Comparison struct {
	LeftSide  Node
	RightSide Node
	Operation string
	Lexeme    lexer.Lexeme
}

Comparison represents a comparison operator

func (*Comparison) Accept 

func (a *Comparison) Accept(v Visitor) (Node, error)

Accept visits the node

func (*Comparison) GetType 

func (a *Comparison) GetType() types.TypeNode

type ComparisonFolder 

type ComparisonFolder interface {
	FoldComparison(n *Comparison) (Node, error)
}

type ComparisonVisitor 

type ComparisonVisitor interface {
	VisitComparison(n *Comparison) (Node, error)
}

type Constant 

type Constant struct {
	Value  string
	Raw    []byte
	Lexeme lexer.Lexeme
	Type   types.TypeNode
}

Constant represents a constant definition

func (*Constant) Accept 

func (a *Constant) Accept(v Visitor) (Node, error)

Accept visits the node

func (*Constant) GetType 

func (a *Constant) GetType() types.TypeNode

type ConstantFolder 

type ConstantFolder interface {
	FoldConstant(n *Constant) (Node, error)
}

type ConstantVisitor 

type ConstantVisitor interface {
	VisitConstant(n *Constant) (Node, error)
}

type ContinueNode 

type ContinueNode struct {
	WithValue Node
	Lexeme    lexer.Lexeme
}

func (*ContinueNode) Accept 

func (c *ContinueNode) Accept(v Visitor) (Node, error)

func (*ContinueNode) GetType 

func (c *ContinueNode) GetType() types.TypeNode

type ContinueNodeVisitor 

type ContinueNodeVisitor interface {
	VisitContinueNode(n *ContinueNode) (Node, error)
}

type DeclNode 

type DeclNode struct {
	Lexeme     lexer.Lexeme
	Varname    *VarName
	IsConstant bool
}

DeclNode is a node that

func (*DeclNode) Accept 

func (d *DeclNode) Accept(v Visitor) (Node, error)

Accept does nothing

func (*DeclNode) AddChild 

func (d *DeclNode) AddChild(c Node) error

AddChild just sets the

func (*DeclNode) GetType 

func (d *DeclNode) GetType() types.TypeNode

type DeclNodeFolder 

type DeclNodeFolder interface {
	FoldDeclNode(n *DeclNode) (Node, error)
}

type DeclNodeVisitor 

type DeclNodeVisitor interface {
	VisitDeclNode(n *DeclNode) (Node, error)
}

type DecoratorNode 

type DecoratorNode struct {
	Name      *VarName
	Lexeme    lexer.Lexeme
	Decorates Node
}

func (*DecoratorNode) Accept 

func (d *DecoratorNode) Accept(v Visitor) (Node, error)

func (*DecoratorNode) GetType 

func (d *DecoratorNode) GetType() types.TypeNode

type DecoratorNodeFolder 

type DecoratorNodeFolder interface {
	FoldDecoratorNode(n *DecoratorNode) (Node, error)
}

type DecoratorNodeVisitor 

type DecoratorNodeVisitor interface {
	VisitDecoratorNode(n *DecoratorNode) (Node, error)
}

type DotNode 

type DotNode struct {
	Lexeme  lexer.Lexeme
	VarName Node
	Access  Node
}

func (*DotNode) Accept 

func (d *DotNode) Accept(v Visitor) (Node, error)

func (*DotNode) GetType 

func (d *DotNode) GetType() types.TypeNode

type DotNodeFolder 

type DotNodeFolder interface {
	FoldDotNode(n *DotNode) (Node, error)
}

type DotNodeVisitor 

type DotNodeVisitor interface {
	VisitDotNode(n *DotNode) (Node, error)
}

type ExtendsNode 

type ExtendsNode struct {
	Name   *VarName
	Extend *VarName
	Adds   types.TypeNode
}

ExtendsNode represents an extension to a node

func (*ExtendsNode) Accept 

func (e *ExtendsNode) Accept(v Visitor) (Node, error)

func (*ExtendsNode) GetType 

func (e *ExtendsNode) GetType() types.TypeNode

type ExtendsNodeVisitor 

type ExtendsNodeVisitor interface {
	VisitExtendsNode(n *ExtendsNode) (Node, error)
}

type Folder 

type Folder interface {
	AnnotatedNodeFolder
	AssignmentNodeFolder
	BoolOpFolder
	ComparisonFolder
	ConstantFolder
	DeclNodeFolder
	DecoratorNodeFolder
	DotNodeFolder
	FunctionCallNodeFolder
	FunctionDefinitionNodeFolder
	IfNodeFolder
	ImplementsNodeFolder
	ImportNodeFolder
	IndexNodeFolder
	InstantiateNodeFolder
	InternalNodeFolder
	MatchNodeFolder
	MathOpNodeFolder
	MethodDefinitionFolder
	PackageFolder
	PipeNodeFolder
	ProgramFolder
	ReturnNodeFolder
	ShapeNodeFolder
	SliceNodeFolder
	TypeNodeFolder
	VarNameFolder
	WhenNodeFolder
}

type FunctionCallNode 

type FunctionCallNode struct {
	Arguments  []Node
	Definition Node
	Type       types.TypeNode
	Lexeme     lexer.Lexeme
}

FunctionCallNode represents a function call

func (*FunctionCallNode) Accept 

func (f *FunctionCallNode) Accept(v Visitor) (Node, error)

Accept visits the node

func (*FunctionCallNode) GetType 

func (f *FunctionCallNode) GetType() types.TypeNode

type FunctionCallNodeFolder 

type FunctionCallNodeFolder interface {
	FoldFunctionCallNode(n *FunctionCallNode) (Node, error)
}

type FunctionCallNodeVisitor 

type FunctionCallNodeVisitor interface {
	VisitFunctionCallNode(n *FunctionCallNode) (Node, error)
}

type FunctionDefinitionNode 

type FunctionDefinitionNode struct {
	Arguments        []*VarName
	Body             Node
	Returns          types.TypeNode
	Lexeme           lexer.Lexeme
	GenericTypeNames []*VarName
}

FunctionDefinitionNode represents a function definition

func (*FunctionDefinitionNode) Accept 

func (f *FunctionDefinitionNode) Accept(v Visitor) (Node, error)

Accept visits the node

func (*FunctionDefinitionNode) GetFnType 

func (f *FunctionDefinitionNode) GetFnType() (*types.FnType, error)

GetType returns the function type

func (*FunctionDefinitionNode) GetType 

func (f *FunctionDefinitionNode) GetType() types.TypeNode

type FunctionDefinitionNodeFolder 

type FunctionDefinitionNodeFolder interface {
	FoldFunctionDefinitionNode(n *FunctionDefinitionNode) (Node, error)
}

type FunctionDefinitionNodeVisitor 

type FunctionDefinitionNodeVisitor interface {
	VisitFunctionDefinitionNode(n *FunctionDefinitionNode) (Node, error)
}

type GenericVisitor 

type GenericVisitor interface {
	VisitAnyNode(n Node) (Node, error)
}

type HandleCaseNode 

type HandleCaseNode struct {
	VariableName string
	Type         types.TypeNode
	Case         Node
	Lexeme       lexer.Lexeme
}

func (*HandleCaseNode) Accept 

func (t *HandleCaseNode) Accept(v Visitor) (Node, error)

func (*HandleCaseNode) GetType 

func (t *HandleCaseNode) GetType() types.TypeNode

type HandleCaseNodeVisitor 

type HandleCaseNodeVisitor interface {
	VisitHandleCaseNode(n *HandleCaseNode) (Node, error)
}

type IfNode 

type IfNode struct {
	Condition Node
	Body      Node
	ElseIfs   []*IfNode
	Else      Node
	ReturnTo  string
	Lexeme    lexer.Lexeme
}

IfNode represens an if statemet

func (*IfNode) Accept 

func (i *IfNode) Accept(v Visitor) (Node, error)

Accept implements a node

func (*IfNode) GetType 

func (i *IfNode) GetType() types.TypeNode

type IfNodeFolder 

type IfNodeFolder interface {
	FoldIfNode(n *IfNode) (Node, error)
}

type IfNodeVisitor 

type IfNodeVisitor interface {
	VisitIfNode(n *IfNode) (Node, error)
}

type ImplementsNode 

type ImplementsNode struct {
	Implements []*VarName
	Lexeme     lexer.Lexeme
	Type       *TypeNode
}

func (*ImplementsNode) Accept 

func (i *ImplementsNode) Accept(v Visitor) (Node, error)

func (*ImplementsNode) GetType 

func (i *ImplementsNode) GetType() types.TypeNode

type ImplementsNodeFolder 

type ImplementsNodeFolder interface {
	FoldImplementsNode(n *ImplementsNode) (Node, error)
}

type ImplementsNodeVisitor 

type ImplementsNodeVisitor interface {
	VisitImplementsNode(n *ImplementsNode) (Node, error)
}

type ImportNode 

type ImportNode struct {
	ExportName string `IMPORT @VARNAME`
	ImportAs   string `('as' @VARNAME)?`
	Source     string `'from' @STRINGVAL`
	Lexeme     lexer.Lexeme
	NextImport *ImportNode
}

ImportNode represents an import statement

func (*ImportNode) Accept 

func (i *ImportNode) Accept(v Visitor) (Node, error)

Accept a visitor

func (*ImportNode) GetType 

func (i *ImportNode) GetType() types.TypeNode

type ImportNodeFolder 

type ImportNodeFolder interface {
	FoldImportNode(n *ImportNode) (Node, error)
}

type ImportNodeVisitor 

type ImportNodeVisitor interface {
	VisitImportNode(n *ImportNode) (Node, error)
}

type IndexNode 

type IndexNode struct {
	Varname Node
	Index   Node
	Lexeme  lexer.Lexeme
}

IndexNode is the index node

func (*IndexNode) Accept 

func (i *IndexNode) Accept(v Visitor) (Node, error)

Accept a visitor

func (*IndexNode) GetType 

func (i *IndexNode) GetType() types.TypeNode

type IndexNodeFolder 

type IndexNodeFolder interface {
	FoldIndexNode(n *IndexNode) (Node, error)
}

type IndexNodeVisitor 

type IndexNodeVisitor interface {
	VisitIndexNode(n *IndexNode) (Node, error)
}

type InstantiateNode 

type InstantiateNode struct {
	FunctionCallNode *FunctionCallNode
	Type             types.TypeNode
}

func (*InstantiateNode) Accept 

func (i *InstantiateNode) Accept(v Visitor) (Node, error)

func (*InstantiateNode) GetType 

func (i *InstantiateNode) GetType() types.TypeNode

type InstantiateNodeFolder 

type InstantiateNodeFolder interface {
	FoldInstantiateNode(n *InstantiateNode) (Node, error)
}

type InstantiateNodeVisitor 

type InstantiateNodeVisitor interface {
	VisitInstantiateNode(n *InstantiateNode) (Node, error)
}

type InternalNode 

type InternalNode struct {
	Lexeme     lexer.Lexeme
	Expression Node
}

ExportNode represents an export statement

func (*InternalNode) Accept 

func (e *InternalNode) Accept(v Visitor) (Node, error)

Accept visits the node

func (*InternalNode) GetType 

func (e *InternalNode) GetType() types.TypeNode

type InternalNodeFolder 

type InternalNodeFolder interface {
	FoldInternalNode(n *InternalNode) (Node, error)
}

type InternalNodeVisitor 

type InternalNodeVisitor interface {
	VisitInternalNode(n *InternalNode) (Node, error)
}

type MatchNode 

type MatchNode struct {
	Match     Node
	WhenCases []*WhenNode
	Lexeme    lexer.Lexeme
}

func (*MatchNode) Accept 

func (m *MatchNode) Accept(v Visitor) (Node, error)

func (*MatchNode) GetType 

func (m *MatchNode) GetType() types.TypeNode

type MatchNodeFolder 

type MatchNodeFolder interface {
	FoldMatchNode(n *MatchNode) (Node, error)
}

type MatchNodeVisitor 

type MatchNodeVisitor interface {
	VisitMatchNode(n *MatchNode) (Node, error)
}

type MathOpNode 

type MathOpNode struct {
	LeftSide  Node
	RightSide Node
	Operation string
	Lexeme    lexer.Lexeme
}

MathOpNode is a struct representing a type of Mathematical operation ('+', '-', '/', '*') ! <Leftside> [math operation] <RightSide>

func (*MathOpNode) Accept 

func (m *MathOpNode) Accept(v Visitor) (Node, error)

Accept accepts the Visitor

func (*MathOpNode) GetType 

func (m *MathOpNode) GetType() types.TypeNode

type MathOpNodeFolder 

type MathOpNodeFolder interface {
	FoldMathOpNode(n *MathOpNode) (Node, error)
}

type MathOpNodeVisitor 

type MathOpNodeVisitor interface {
	VisitMathOpNode(n *MathOpNode) (Node, error)
}

type MethodDefinition 

type MethodDefinition struct {
	FuncDef    *FunctionDefinitionNode
	TypeName   *VarName
	MethodName *VarName
	Lexeme     lexer.Lexeme
}

MethodDefinition Represents a method definition on a function

func (*MethodDefinition) Accept 

func (m *MethodDefinition) Accept(v Visitor) (Node, error)

func (*MethodDefinition) GetType 

func (m *MethodDefinition) GetType() types.TypeNode

type MethodDefinitionFolder 

type MethodDefinitionFolder interface {
	FoldMethodDefinition(n *MethodDefinition) (Node, error)
}

type MethodDefinitionVisitor 

type MethodDefinitionVisitor interface {
	VisitMethodDefinition(n *MethodDefinition) (Node, error)
}

type Node 

type Node interface {
	// Accept allows a visitor to traverse the tree
	Accept(Visitor) (Node, error)
	GetType() types.TypeNode
}

Node represents a Node in the AST

type Package 

type Package struct {
	Lexeme lexer.Lexeme
	Name   string
}

func (*Package) Accept 

func (p *Package) Accept(v Visitor) (Node, error)

func (*Package) GetType 

func (p *Package) GetType() types.TypeNode

type PackageFolder 

type PackageFolder interface {
	FoldPackage(n *Package) (Node, error)
}

type PackageVisitor 

type PackageVisitor interface {
	VisitPackage(n *Package) (Node, error)
}

type PipeNode 

type PipeNode struct {
	LeftSide  Node
	RightSide Node
	Lexeme    lexer.Lexeme
}

PipeNode reperesent a node that is a pipe operator

func (*PipeNode) Accept 

func (p *PipeNode) Accept(v Visitor) (Node, error)

Accept accepts the visitor

func (*PipeNode) GetType 

func (p *PipeNode) GetType() types.TypeNode

type PipeNodeFolder 

type PipeNodeFolder interface {
	FoldPipeNode(n *PipeNode) (Node, error)
}

type PipeNodeVisitor 

type PipeNodeVisitor interface {
	VisitPipeNode(n *PipeNode) (Node, error)
}

type Program 

type Program struct {
	Imports []*ImportNode `@@*`
	Nodes   []Node
	Lexeme  lexer.Lexeme
}

Program is the Root node in a file

func (*Program) Accept 

func (s *Program) Accept(v Visitor) (Node, error)

Accept Accepts a vistor

func (*Program) GetType 

func (s *Program) GetType() types.TypeNode

type ProgramFolder 

type ProgramFolder interface {
	FoldProgram(n *Program) (Node, error)
}

type ProgramVisitor 

type ProgramVisitor interface {
	VisitProgram(n *Program) (Node, error)
}

type ReturnNode 

type ReturnNode struct {
	Expression Node
	Lexeme     lexer.Lexeme
}

ReturnNode Represents a return statement

func (*ReturnNode) Accept 

func (r *ReturnNode) Accept(v Visitor) (Node, error)

Accept allows the vistor to visit

func (*ReturnNode) GetType 

func (r *ReturnNode) GetType() types.TypeNode

type ReturnNodeFolder 

type ReturnNodeFolder interface {
	FoldReturnNode(n *ReturnNode) (Node, error)
}

type ReturnNodeVisitor 

type ReturnNodeVisitor interface {
	VisitReturnNode(n *ReturnNode) (Node, error)
}

type ShapeNode 

type ShapeNode struct {
	Fields       map[string]Node
	Lexeme       lexer.Lexeme
	GenericNames []*VarName
}

func (*ShapeNode) Accept 

func (s *ShapeNode) Accept(v Visitor) (Node, error)

func (*ShapeNode) GetType 

func (s *ShapeNode) GetType() types.TypeNode

type ShapeNodeFolder 

type ShapeNodeFolder interface {
	FoldShapeNode(n *ShapeNode) (Node, error)
}

type ShapeNodeVisitor 

type ShapeNodeVisitor interface {
	VisitShapeNode(n *ShapeNode) (Node, error)
}

type SignalNode 

type SignalNode struct {
	Level        string
	ValueToRaise Node
	Lexeme       lexer.Lexeme
}

func (*SignalNode) Accept 

func (s *SignalNode) Accept(v Visitor) (Node, error)

func (*SignalNode) GetType 

func (s *SignalNode) GetType() types.TypeNode

type SignalNodeVisitor 

type SignalNodeVisitor interface {
	VisitSignalNode(n *SignalNode) (Node, error)
}

type SliceNode 

type SliceNode struct {
	Varname Node
	Start   Node
	End     Node
	Step    Node
	Lexeme  lexer.Lexeme
}

SliceNode Represnets the slice node

func (*SliceNode) Accept 

func (r *SliceNode) Accept(v Visitor) (Node, error)

Accept allows the vistor to visit

func (*SliceNode) GetType 

func (r *SliceNode) GetType() types.TypeNode

type SliceNodeFolder 

type SliceNodeFolder interface {
	FoldSliceNode(n *SliceNode) (Node, error)
}

type SliceNodeVisitor 

type SliceNodeVisitor interface {
	VisitSliceNode(n *SliceNode) (Node, error)
}

type SymbolData 

type SymbolData struct {
	Name       string
	Type       *TypeNode
	IsConstant bool
	IsNew      bool
}

SymbolData is some data for the symbol in our symbol table

type TryNode 

type TryNode struct {
	Tries       Node
	HandleCases []*HandleCaseNode
	Lexeme      lexer.Lexeme
}

func (*TryNode) Accept 

func (t *TryNode) Accept(v Visitor) (Node, error)

func (*TryNode) GetType 

func (t *TryNode) GetType() types.TypeNode

type TryNodeVisitor 

type TryNodeVisitor interface {
	VisitTryNode(n *TryNode) (Node, error)
}

type TypeNode 

type TypeNode struct {
	Types        types.TypeNode
	Lexeme       lexer.Lexeme
	VarName      *VarName
	Extends      bool
	GenericTypes []*VarName
}

TypeNode represents a type node

func (*TypeNode) Accept 

func (t *TypeNode) Accept(v Visitor) (Node, error)

Accept a type visitor

func (*TypeNode) GetType 

func (t *TypeNode) GetType() types.TypeNode

func (*TypeNode) IsPointer 

func (t *TypeNode) IsPointer() bool

IsPointer denotes whether a type is a pointer or not

func (*TypeNode) IsValidType 

func (t *TypeNode) IsValidType(tp types.TypeNode) bool

IsValidType Makes sure that a given type stisifies the gaurd

type TypeNodeFolder 

type TypeNodeFolder interface {
	FoldTypeNode(n *TypeNode) (Node, error)
}

type TypeNodeVisitor 

type TypeNodeVisitor interface {
	VisitTypeNode(n *TypeNode) (Node, error)
}

type VarName 

type VarName struct {
	Name   string
	Type   types.TypeNode
	Lexeme lexer.Lexeme
}

VarName Represents a name for a variable

func (*VarName) Accept 

func (vn *VarName) Accept(v Visitor) (Node, error)

Accept does nothing

func (*VarName) GetType 

func (vn *VarName) GetType() types.TypeNode

type VarNameFolder 

type VarNameFolder interface {
	FoldVarName(n *VarName) (Node, error)
}

type VarNameVisitor 

type VarNameVisitor interface {
	VisitVarName(n *VarName) (Node, error)
}

type Visitor 

type Visitor interface {
	AnnotatedNodeVisitor
	AssignmentNodeVisitor
	BoolOpVisitor
	ComparisonVisitor
	ConstantVisitor
	ContinueNodeVisitor
	DeclNodeVisitor
	DecoratorNodeVisitor
	DotNodeVisitor
	ExtendsNodeVisitor
	FunctionCallNodeVisitor
	FunctionDefinitionNodeVisitor
	HandleCaseNodeVisitor
	IfNodeVisitor
	ImplementsNodeVisitor
	ImportNodeVisitor
	IndexNodeVisitor
	InstantiateNodeVisitor
	InternalNodeVisitor
	MatchNodeVisitor
	MathOpNodeVisitor
	MethodDefinitionVisitor
	PackageVisitor
	PipeNodeVisitor
	ProgramVisitor
	ReturnNodeVisitor
	ShapeNodeVisitor
	SignalNodeVisitor
	SliceNodeVisitor
	TryNodeVisitor
	TypeNodeVisitor
	VarNameVisitor
	WhenNodeVisitor

	GenericVisitor
}

type WhenNode 

type WhenNode struct {
	Case     Node
	Evaluate Node
	Lexeme   lexer.Lexeme
}

func (*WhenNode) Accept 

func (w *WhenNode) Accept(v Visitor) (Node, error)

func (*WhenNode) GetType 

func (m *WhenNode) GetType() types.TypeNode

type WhenNodeFolder 

type WhenNodeFolder interface {
	FoldWhenNode(n *WhenNode) (Node, error)
}

type WhenNodeVisitor 

type WhenNodeVisitor interface {
	VisitWhenNode(n *WhenNode) (Node, error)
}

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.