ast

type AssignStmt struct {
	Range token.Range
	Tok   token.Token
	Var   Assigneable // the variable to assign to
	Rhs   Expression  // literal assign value
}

type AssignStmtVisitor interface {
	BaseVisitor
	VisitAssignStmt(*AssignStmt)
}

type Assigneable interface {
	Expression
	// contains filtered or unexported methods
}

type Ast struct {
	Statements []Statement   // the top level statements
	Comments   []token.Token // all the comments in the source code
	Symbols    *SymbolTable
	Faulty     bool // set if the ast has any errors (doesn't matter what from which phase they came)
}

type BadDecl struct {
	Tok token.Token
	Err ddperror.Error
	Mod *Module
}

type BadDeclVisitor interface {
	BaseVisitor
	VisitBadDecl(*BadDecl)
}

type BadExpr struct {
	Tok token.Token
	Err ddperror.Error
}

type BadExprVisitor interface {
	BaseVisitor
	VisitBadExpr(*BadExpr)
}

type BadStmt struct {
	Tok token.Token
	Err ddperror.Error
}

type BadStmtVisitor interface {
	BaseVisitor
	VisitBadStmt(*BadStmt)
}

type BaseVisitor interface {
	BaseVisitor() // dummy function for the interface
}

type BinaryExpr struct {
	Range    token.Range
	Tok      token.Token
	Lhs      Expression
	Operator BinaryOperator
	Rhs      Expression
}

type BinaryExprVisitor interface {
	BaseVisitor
	VisitBinaryExpr(*BinaryExpr)
}

type BinaryOperator int

type BlockStmt struct {
	Range      token.Range
	Colon      token.Token
	Statements []Statement
	Symbols    *SymbolTable
}

type BlockStmtVisitor interface {
	BaseVisitor
	VisitBlockStmt(*BlockStmt)
}

type BoolLit struct {
	Literal token.Token
	Value   bool
}

type BoolLitVisitor interface {
	BaseVisitor
	VisitBoolLit(*BoolLit)
}

type CastExpr struct {
	Range token.Range
	Type  ddptypes.Type
	Lhs   Expression
}

type CastExprVisitor interface {
	BaseVisitor
	VisitCastExpr(*CastExpr)
}

type CharLit struct {
	Literal token.Token
	Value   rune
}

type CharLitVisitor interface {
	BaseVisitor
	VisitCharLit(*CharLit)
}

type ConditionalVisitor interface {
	ShouldVisit(Node) bool
}

type DeclStmt struct {
	Decl Declaration
}

type DeclStmtVisitor interface {
	BaseVisitor
	VisitDeclStmt(*DeclStmt)
}

type Declaration interface {
	Node

	Name() string    // returns the name of the declaration or "" for BadDecls
	Public() bool    // returns wether the declaration is public. always false for BadDecls
	Module() *Module // returns the module from which the declaration comes
	// contains filtered or unexported methods
}

type ExprStmt struct {
	Expr Expression
}

type ExprStmtVisitor interface {
	BaseVisitor
	VisitExprStmt(*ExprStmt)
}

type Expression interface {
	Node
	// contains filtered or unexported methods
}

type FloatLit struct {
	Literal token.Token
	Value   float64 // the parsed float
}

type FloatLitVisitor interface {
	BaseVisitor
	VisitFloatLit(*FloatLit)
}

type ForRangeStmt struct {
	Range       token.Range
	For         token.Token // Für
	Initializer *VarDecl    // InitVal is the same pointer as In
	In          Expression  // the string/list to range over
	Body        *BlockStmt
}

type ForRangeStmtVisitor interface {
	BaseVisitor
	VisitForRangeStmt(*ForRangeStmt)
}

type ForStmt struct {
	Range       token.Range
	For         token.Token // Für
	Initializer *VarDecl    // Zahl (name) von (Initializer.InitVal)
	To          Expression  // bis (To)
	StepSize    Expression  // Schrittgröße
	Body        *BlockStmt
}

type ForStmtVisitor interface {
	BaseVisitor
	VisitForStmt(*ForStmt)
}

type FullVisitor interface {
	BaseVisitor

	BadDeclVisitor
	VarDeclVisitor
	FuncDeclVisitor

	BadExprVisitor
	IdentVisitor
	IndexingVisitor
	IntLitVisitor
	FloatLitVisitor
	BoolLitVisitor
	CharLitVisitor
	StringLitVisitor
	ListLitVisitor
	UnaryExprVisitor
	BinaryExprVisitor
	TernaryExprVisitor
	CastExprVisitor
	GroupingVisitor
	FuncCallVisitor

	BadStmtVisitor
	DeclStmtVisitor
	ExprStmtVisitor
	ImportStmtVisitor
	AssignStmtVisitor
	BlockStmtVisitor
	IfStmtVisitor
	WhileStmtVisitor
	ForStmtVisitor
	ForRangeStmtVisitor
	ReturnStmtVisitor
}

type FuncAlias struct {
	Tokens   []token.Token                     // tokens of the alias
	Original token.Token                       // the original string
	Func     *FuncDecl                         // the function it refers to (if it is used outside a FuncDecl)
	Args     map[string]ddptypes.ParameterType // types of the arguments (used for funcCall parsing)
}

type FuncCall struct {
	Range token.Range
	Tok   token.Token // first token of the call
	Name  string      // name of the function
	// the function declaration this call refers to
	// is set by the parser, or nil if the name was not found
	Func *FuncDecl
	Args map[string]Expression
}

type FuncCallVisitor interface {
	BaseVisitor
	VisitFuncCall(*FuncCall)
}

type FuncDecl struct {
	Range         token.Range
	Comment       *token.Token             // optional comment (also contained in ast.Comments)
	Tok           token.Token              // Die
	NameTok       token.Token              // token of the name
	IsPublic      bool                     // wether the function is marked with öffentliche
	Mod           *Module                  // the module in which the function was declared
	ParamNames    []token.Token            // x, y und z
	ParamTypes    []ddptypes.ParameterType // type, and wether the argument is a reference
	ParamComments []*token.Token           // comments for the parameters, the slice or its elements may be nil
	Type          ddptypes.Type            // Zahl Kommazahl nichts ...
	Body          *BlockStmt               // nil for extern functions
	ExternFile    token.Token              // string literal with filepath (only pesent if Body is nil)
	Aliases       []FuncAlias
}

type FuncDeclVisitor interface {
	BaseVisitor
	VisitFuncDecl(*FuncDecl)
}

type Grouping struct {
	Range  token.Range
	LParen token.Token // (
	Expr   Expression
}

type GroupingVisitor interface {
	BaseVisitor
	VisitGrouping(*Grouping)
}

type Ident struct {
	Literal token.Token
	// the variable declaration this identifier refers to
	// is set by the resolver, or nil if the name was not found
	Declaration *VarDecl
}

type IdentVisitor interface {
	BaseVisitor
	VisitIdent(*Ident)
}

type IfStmt struct {
	Range     token.Range
	If        token.Token // wenn/aber
	Condition Expression
	Then      Statement
	Else      Statement
}

type IfStmtVisitor interface {
	BaseVisitor
	VisitIfStmt(*IfStmt)
}

type ImportStmt struct {
	Range token.Range
	// the string literal which specified the filename
	FileName token.Token
	// the module that was imported because of this
	// nil if it does not exist or a similar error occured while importing
	Module *Module
	// slice of identifiers which specify
	// the individual symbols imported
	// if nil, all symbols are imported
	ImportedSymbols []token.Token
}

type ImportStmtVisitor interface {
	BaseVisitor
	VisitImportStmt(*ImportStmt)
}

type Indexing struct {
	Lhs   Assigneable // variable Name
	Index Expression
}

type IndexingVisitor interface {
	BaseVisitor
	VisitIndexing(*Indexing)
}

type IntLit struct {
	Literal token.Token
	Value   int64
}

type IntLitVisitor interface {
	BaseVisitor
	VisitIntLit(*IntLit)
}

type ListLit struct {
	Tok   token.Token
	Range token.Range
	// type of the empty list if Values is nil
	// the typechecker fills this field if Values is non-nil
	Type   ddptypes.Type
	Values []Expression // the values in the Literal
	// if Values, Count and Value are nil, the list is empty
	Count Expression // for big list initializations
	Value Expression // the default value for big list initializations
}

type ListLitVisitor interface {
	BaseVisitor
	VisitListLit(*ListLit)
}

type Module struct {
	// the absolute filepath from which the module comes
	FileName string
	// the token which specified the relative FileName
	// if the module was imported and not the main Module
	FileNameToken *token.Token
	// all the imported modules
	Imports []*ImportStmt
	// a set which contains all files needed
	// to link the final executable
	// contains .c, .lib, .a and .o files
	ExternalDependencies map[string]struct{}
	// the Ast of the Module
	Ast *Ast
	// map of references to all public functions and variables
	PublicDecls map[string]Declaration
}

type Node interface {
	fmt.Stringer
	Token() token.Token
	GetRange() token.Range
	Accept(FullVisitor)
}

type Operator interface {
	String() string
	Operator() // dummy function for the interface
}

type ReturnStmt struct {
	Range  token.Range
	Return token.Token // Gib
	Func   string
	Value  Expression // nil for void return
}

type ReturnStmtVisitor interface {
	BaseVisitor
	VisitReturnStmt(*ReturnStmt)
}

type ScopeVisitor interface {
	UpdateScope(*SymbolTable)
}

type Statement interface {
	Node
	// contains filtered or unexported methods
}

type StringLit struct {
	Literal token.Token
	Value   string // the evaluated string
}

type StringLitVisitor interface {
	BaseVisitor
	VisitStringLit(*StringLit)
}

type SymbolTable struct {
	Enclosing    *SymbolTable           // enclosing scope (nil in the global scope)
	Declarations map[string]Declaration // map of all variables and functions
}

type TernaryExpr struct {
	Range    token.Range
	Tok      token.Token
	Lhs      Expression
	Mid      Expression
	Rhs      Expression
	Operator TernaryOperator
}

type TernaryExprVisitor interface {
	BaseVisitor
	VisitTernaryExpr(*TernaryExpr)
}

type TernaryOperator int

type UnaryExpr struct {
	Range    token.Range
	Tok      token.Token
	Operator UnaryOperator
	Rhs      Expression
}

type UnaryExprVisitor interface {
	BaseVisitor
	VisitUnaryExpr(*UnaryExpr)
}

type UnaryOperator int

type VarDecl struct {
	Range    token.Range
	Comment  *token.Token  // optional comment (also contained in ast.Comments)
	Type     ddptypes.Type // type of the variable
	NameTok  token.Token   // identifier name
	IsPublic bool          // wether the function is marked with öffentliche
	// wether the variable was declared in the global scope
	// used pretty much only in the compiler
	IsGlobal bool
	Mod      *Module    // the module in which the variable was declared
	InitVal  Expression // initial value
}

type VarDeclVisitor interface {
	BaseVisitor
	VisitVarDecl(*VarDecl)
}

type WhileStmt struct {
	Range     token.Range
	While     token.Token // solange, mache, mal
	Condition Expression
	Body      Statement
}

type WhileStmtVisitor interface {
	BaseVisitor
	VisitWhileStmt(*WhileStmt)
}