ast

type Alias interface {
	// tokens of the alias
	GetTokens() []token.Token
	// the original string
	GetOriginal() token.Token
	// *FuncDecl or *StructDecl
	Decl() Declaration
	// types of the arguments (used for funcCall parsing)
	GetArgs() map[string]ddptypes.ParameterType
}

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) VisitResult
}

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) VisitResult
}

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

type BadExprVisitor interface {
	BaseVisitor
	VisitBadExpr(*BadExpr) VisitResult
}

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

type BadStmtVisitor interface {
	BaseVisitor
	VisitBadStmt(*BadStmt) VisitResult
}

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) VisitResult
}

type BinaryOperator int

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

type BlockStmtVisitor interface {
	BaseVisitor
	VisitBlockStmt(*BlockStmt) VisitResult
}

type BoolLit struct {
	Literal token.Token
	Value   bool
}

type BoolLitVisitor interface {
	BaseVisitor
	VisitBoolLit(*BoolLit) VisitResult
}

type BreakContineStmtVisitor interface {
	BaseVisitor
	VisitBreakContinueStmt(*BreakContinueStmt) VisitResult
}

type BreakContinueStmt struct {
	Range token.Range
	Tok   token.Token // VERLASSE for break, otherwise continue
}

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

type CastExprVisitor interface {
	BaseVisitor
	VisitCastExpr(*CastExpr) VisitResult
}

type CharLit struct {
	Literal token.Token
	Value   rune
}

type CharLitVisitor interface {
	BaseVisitor
	VisitCharLit(*CharLit) VisitResult
}

type ConditionalVisitor interface {
	ShouldVisit(Node) bool
}

type DeclStmt struct {
	Decl Declaration
}

type DeclStmtVisitor interface {
	BaseVisitor
	VisitDeclStmt(*DeclStmt) VisitResult
}

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
	Comment() *token.Token // returns a optional comment
	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) VisitResult
}

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

type FieldAccess struct {
	Rhs   Assigneable // variable Name or other indexing
	Field *Ident      // the field name
}

type FieldAccessVisitor interface {
	BaseVisitor
	VisitFieldAccess(*FieldAccess) VisitResult
}

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

type FloatLitVisitor interface {
	BaseVisitor
	VisitFloatLit(*FloatLit) VisitResult
}

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) VisitResult
}

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) VisitResult
}

type FullVisitor interface {
	BaseVisitor

	BadDeclVisitor
	VarDeclVisitor
	FuncDeclVisitor
	StructDeclVisitor

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

	BadStmtVisitor
	DeclStmtVisitor
	ExprStmtVisitor
	ImportStmtVisitor
	AssignStmtVisitor
	BlockStmtVisitor
	IfStmtVisitor
	WhileStmtVisitor
	ForStmtVisitor
	ForRangeStmtVisitor
	BreakContineStmtVisitor
	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) VisitResult
}

type FuncDecl struct {
	Range         token.Range
	CommentTok    *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            // return 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) VisitResult
}

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

type GroupingVisitor interface {
	BaseVisitor
	VisitGrouping(*Grouping) VisitResult
}

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) VisitResult
}

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

type IfStmtVisitor interface {
	BaseVisitor
	VisitIfStmt(*IfStmt) VisitResult
}

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) VisitResult
}

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

type IndexingVisitor interface {
	BaseVisitor
	VisitIndexing(*Indexing) VisitResult
}

type IntLit struct {
	Literal token.Token
	Value   int64
}

type IntLitVisitor interface {
	BaseVisitor
	VisitIntLit(*IntLit) VisitResult
}

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.ListType
	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) VisitResult
}

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, variables and structs
	PublicDecls map[string]Declaration
}

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

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) VisitResult
}

type ScopeVisitor interface {
	UpdateScope(*SymbolTable)
}

type SetupableVisitor interface {
	BaseVisitor
	// called before the first node is visited
	// the passed visitor is the actual implementation that forwards the visits
	// and can be saved to customize visit order
	//
	// should return true if the visitor should start visiting
	Setup(FullVisitor) bool
}

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) VisitResult
}

type StructAlias struct {
	Tokens   []token.Token            // tokens of the alias
	Original token.Token              // the original string
	Struct   *StructDecl              // the struct decl it refers to
	Args     map[string]ddptypes.Type // types of the arguments (only those that the alias needs)
}

type StructDecl struct {
	Range      token.Range
	CommentTok *token.Token // optional comment (also contained in ast.Comments)
	Tok        token.Token  // Wir
	NameTok    token.Token  // token of the name
	IsPublic   bool         // wether the struct decl is marked with öffentliche
	Mod        *Module      // the module in which the struct was declared
	// Field declarations of the struct in order of declaration
	// only contains *VarDecl and *BadDecl s
	Fields  []Declaration
	Type    *ddptypes.StructType // the type resulting from this decl
	Aliases []*StructAlias       // the constructors of the struct
}

type StructDeclVisitor interface {
	BaseVisitor
	VisitStructDecl(*StructDecl) VisitResult
}

type StructLiteral struct {
	Range token.Range
	Tok   token.Token // first token of the literal
	// the struct declaration this literal refers to
	// is set by the parser, or nil if the name was not found
	Struct *StructDecl
	// the arguments passed to the literal
	// this does not include all struct fields,
	// only the ones needed by the alias used
	Args map[string]Expression
}

type StructLiteralVisitor interface {
	BaseVisitor
	VisitStructLiteral(*StructLiteral) VisitResult
}

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

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

type TernaryExprVisitor interface {
	BaseVisitor
	VisitTernaryExpr(*TernaryExpr) VisitResult
}

type TernaryOperator int

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

type UnaryExprVisitor interface {
	BaseVisitor
	VisitUnaryExpr(*UnaryExpr) VisitResult
}

type UnaryOperator int

type VarDecl struct {
	Range      token.Range
	CommentTok *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
	Mod        *Module       // the module in which the variable was declared
	InitVal    Expression    // initial value
}

type VarDeclVisitor interface {
	BaseVisitor
	VisitVarDecl(*VarDecl) VisitResult
}

type VisitResult uint8

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

type WhileStmtVisitor interface {
	BaseVisitor
	VisitWhileStmt(*WhileStmt) VisitResult
}