ast

type Alias interface {
	// tokens of the alias
	GetTokens() []token.Token
	// tokens of the alias but as slice of *token.Token and without the EOF
	// this is the slice that is used as keys in the AliasTrie
	GetKey() []*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 AliasTrie = *at.Trie[*token.Token, Alias]

type Annotator Visitor

type AssignStmt struct {
	Range   token.Range
	Tok     token.Token
	Var     Assigneable   // the variable to assign to
	VarType ddptypes.Type // filled in by the typechecker, to keep information about typedefs
	Rhs     Expression    // literal assign value
	RhsType ddptypes.Type // filled in by the typechecker, to keep information about typedefs
}

type AssignStmtVisitor interface {
	Visitor
	VisitAssignStmt(*AssignStmt) VisitResult
}

type AssignStmtVisitorFunc func(*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)
	// contains filtered or unexported fields
}

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

type BadDeclVisitor interface {
	Visitor
	VisitBadDecl(*BadDecl) VisitResult
}

type BadDeclVisitorFunc func(*BadDecl) VisitResult

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

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

type BadExprVisitorFunc func(*BadExpr) VisitResult

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

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

type BadStmtVisitorFunc func(*BadStmt) VisitResult

type BaseVisitor struct {
	// the current module being visited
	CurrentModule *Module
	// the current scope
	CurrentScope SymbolTable
	// Condition to check if a node should be visited
	// if nil, all nodes are visited
	VisitCondition func(Node) bool
}

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

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

type BinaryExprVisitor interface {
	Visitor
	VisitBinaryExpr(*BinaryExpr) VisitResult
}

type BinaryExprVisitorFunc func(*BinaryExpr) VisitResult

type BinaryOperator int

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

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

type BlockStmtVisitorFunc func(*BlockStmt) VisitResult

type BoolLit struct {
	Literal token.Token
	Value   bool
}

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

type BoolLitVisitorFunc func(*BoolLit) VisitResult

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

type BreakContinueStmtVisitor interface {
	Visitor
	VisitBreakContinueStmt(*BreakContinueStmt) VisitResult
}

type BreakContinueStmtVisitorFunc func(*BreakContinueStmt) VisitResult

type CastAssigneable struct {
	Range      token.Range
	TargetType ddptypes.Type
	Lhs        Assigneable
}

type CastAssigneableVisitor interface {
	Visitor
	VisitCastAssigneable(*CastAssigneable) VisitResult
}

type CastAssigneableVisitorFunc func(*CastAssigneable) VisitResult

type CastExpr struct {
	Range        token.Range
	TargetType   ddptypes.Type
	Lhs          Expression
	OverloadedBy *OperatorOverload
}

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

type CastExprVisitorFunc func(*CastExpr) VisitResult

type CastOperator int

type CharLit struct {
	Literal token.Token
	Value   rune
}

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

type CharLitVisitorFunc func(*CharLit) VisitResult

type ConditionalVisitor interface {
	Visitor
	// Condition to check if a node should be visited
	ShouldVisit(Node) bool
}

type ConstDecl struct {
	Range      token.Range
	Mod        *Module       // the module in which the variable was declared
	CommentTok *token.Token  // optional comment (also contained in ast.Comments)
	Type       ddptypes.Type // type of the variable
	NameTok    token.Token   // identifier name
	Val        Literal
	IsPublic   bool // wether the function is marked with öffentliche
}

type ConstDeclVisitor interface {
	Visitor
	VisitConstDecl(*ConstDecl) VisitResult
}

type ConstDeclVisitorFunc func(*ConstDecl) VisitResult

type DeclStmt struct {
	Decl Declaration
}

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

type DeclStmtVisitorFunc func(*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 {
	Visitor
	VisitExprStmt(*ExprStmt) VisitResult
}

type ExprStmtVisitorFunc func(*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 {
	Visitor
	VisitFieldAccess(*FieldAccess) VisitResult
}

type FieldAccessVisitorFunc func(*FieldAccess) VisitResult

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

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

type FloatLitVisitorFunc func(*FloatLit) VisitResult

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

type ForRangeStmtVisitor interface {
	Visitor
	VisitForRangeStmt(*ForRangeStmt) VisitResult
}

type ForRangeStmtVisitorFunc func(*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 {
	Visitor
	VisitForStmt(*ForStmt) VisitResult
}

type ForStmtVisitorFunc func(*ForStmt) VisitResult

type FullVisitor interface {
	Visitor

	BadDeclVisitor
	ConstDeclVisitor
	VarDeclVisitor
	FuncDeclVisitor
	FuncDefVisitor
	StructDeclVisitor
	TypeAliasDeclVisitor
	TypeDefDeclVisitor

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

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

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)
	Negated  bool                              // if the alias has been negated
	// contains filtered or unexported fields
}

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 {
	Visitor
	VisitFuncCall(*FuncCall) VisitResult
}

type FuncCallVisitorFunc func(*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
	IsExternVisible      bool                      // wether the function is marked as extern visible
	Mod                  *Module                   // the module in which the function was declared
	Parameters           []ParameterInfo           // name, type and comments of parameters
	ReturnType           ddptypes.Type             // return Type, Zahl Kommazahl nichts ...
	ReturnTypeRange      token.Range               // range of the return type (mainly used by the LSP)
	Body                 *BlockStmt                // nil for extern functions or forward declarations
	Def                  *FuncDef                  // non-nil for forward declarations
	ExternFile           token.Token               // string literal with filepath (only pesent if Body is nil)
	Operator             Operator                  // the operator this function overloads, or nil if it does not overload an operator
	Generic              *GenericFuncInfo          // only filled if the function was declared as generic
	GenericInstantiation *GenericInstantiationInfo // non-nil if this decl is a instantiation of a generic function
	Aliases              []*FuncAlias
}

type FuncDeclVisitor interface {
	Visitor
	VisitFuncDecl(*FuncDecl) VisitResult
}

type FuncDeclVisitorFunc func(*FuncDecl) VisitResult

type FuncDef struct {
	Range token.Range
	Tok   token.Token // Die
	Func  *FuncDecl
	Body  *BlockStmt
}

type FuncDefVisitor interface {
	Visitor
	VisitFuncDef(*FuncDef) VisitResult
}

type FuncDefVisitorFunc func(*FuncDef) VisitResult

type GenericContext struct {
	Symbols   SymbolTable
	Aliases   AliasTrie
	Operators map[Operator][]*FuncDecl
}

type GenericFuncInfo struct {
	Types          map[string]ddptypes.GenericType // all declared generic types
	Tokens         []token.Token                   // tokens of the body that need to be parsed, nil if the function is extern
	Context        GenericContext                  // context up to the point where the function was declared
	Instantiations map[*Module][]*FuncDecl         // all existing instantiations for a given module
}

type GenericInstantiationInfo struct {
	GenericDecl *FuncDecl                // the parent decl
	Types       map[string]ddptypes.Type // the unified instantiated types
}

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

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

type GroupingVisitorFunc func(*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 Declaration
}

type IdentVisitor interface {
	Visitor
	VisitIdent(*Ident) VisitResult
}

type IdentVisitorFunc func(*Ident) VisitResult

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

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

type IfStmtVisitorFunc func(*IfStmt) VisitResult

type ImportStmt struct {
	Range token.Range
	// wether the statement imported a directory
	IsDirectoryImport bool
	// wether the statement was a recursive import
	// only true if IsDirectoryImport is also true
	IsRecursive bool
	// the string literal which specified the filename
	FileName token.Token
	// all modules that were imported because of this statement
	// nil if it does not exist or a similar error occured while importing
	Modules []*Module
	// slice of identifiers which specify
	// the individual symbols imported
	// if nil, all symbols are imported
	ImportedSymbols []token.Token
}

type ImportStmtVisitor interface {
	Visitor
	VisitImportStmt(*ImportStmt) VisitResult
}

type ImportStmtVisitorFunc func(*ImportStmt) VisitResult

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

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

type IndexingVisitorFunc func(*Indexing) VisitResult

type IntLit struct {
	Literal token.Token
	Value   int64
}

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

type IntLitVisitorFunc func(*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 {
	Visitor
	VisitListLit(*ListLit) VisitResult
}

type ListLitVisitorFunc func(*ListLit) VisitResult

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

type Metadata struct {
	// Attachements stored by kind
	Attachments map[MetadataKind]MetadataAttachment
}

type MetadataAttachment interface {
	String() string
	// kind of the attachement (e.g. "range", "constant_info", "type_info", etc. or any custom string)
	// should be a unique string for each kind of metadata as it is the key in the
	// attachments map
	Kind() MetadataKind
}

type MetadataKind string

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
	// First token in the file if present, or nil otherwise
	Comment *token.Token
	// 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
	// map of all overloads for all operators
	Operators OperatorOverloadMap
}

type ModuleSetter interface {
	Visitor
	// called before a module is visited
	SetModule(*Module)
}

type Node interface {
	fmt.Stringer

	Token() token.Token
	GetRange() token.Range
	Accept(FullVisitor) VisitResult
	// contains filtered or unexported methods
}

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

type OperatorOverload struct {
	Decl *FuncDecl             // the function that overloads the operator
	Args map[string]Expression // the parsed (assigneable) arguments for the operator
}

type OperatorOverloadMap = map[Operator][]*FuncDecl

type ParameterInfo struct {
	Name      token.Token            // the name token of the parameter
	Type      ddptypes.ParameterType // the type of the parameter or default value if there was an error during parsing
	TypeRange token.Range            // range of the type (mainly for the LSP)
	Comment   *token.Token           // the comment token, or nil if none was present
}

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

type ReturnStmtVisitor interface {
	Visitor
	VisitReturnStmt(*ReturnStmt) VisitResult
}

type ReturnStmtVisitorFunc func(*ReturnStmt) VisitResult

type ScopeSetter interface {
	Visitor
	// called before entering a scope in the AST
	SetScope(SymbolTable)
}

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

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

type StringLitVisitor interface {
	Visitor
	VisitStringLit(*StringLit) VisitResult
}

type StringLitVisitorFunc func(*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)
	// contains filtered or unexported fields
}

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.Type  // the type resulting from this decl
	Aliases []*StructAlias // the constructors of the struct
}

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

type StructDeclVisitorFunc func(*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 actual struct type which may be instantiated from a generic
	// and therefore different than Struct.Type
	Type *ddptypes.StructType
	// 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 {
	Visitor
	VisitStructLiteral(*StructLiteral) VisitResult
}

type StructLiteralVisitorFunc func(*StructLiteral) VisitResult

type SymbolTable interface {
	// returns the enclosing scope (nil in the global scope)
	Enclosing() SymbolTable
	// returns the declaration corresponding to name and wether it exists
	// if the symbol existed, the second bool is true, if it is a variable and false if it is a funciton
	// call like this: decl, exists, isVar := LookupDecl(name)
	LookupDecl(name string) (Declaration, bool, bool)
	// inserts a declaration into the scope if it didn't exist yet
	// and returns wether it already existed
	// BadDecls are ignored
	InsertDecl(name string, decl Declaration) bool
	// returns the given type if present, else nil
	//
	//	Type, ok := table.LookupType(name)
	LookupType(name string) (ddptypes.Type, bool)
}

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

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

type TernaryExprVisitorFunc func(*TernaryExpr) VisitResult

type TernaryOperator int

type TodoStmt struct {
	Tok token.Token // ...
}

type TodoStmtVisitor interface {
	Visitor
	VisitTodoStmt(*TodoStmt) VisitResult
}

type TodoStmtVisitorFunc func(*TodoStmt) VisitResult

type TypeAliasDecl struct {
	Range           token.Range
	CommentTok      *token.Token // optional comment
	Tok             token.Token  // Wir
	NameTok         token.Token  // token of the name
	IsPublic        bool
	Mod             *Module
	Underlying      ddptypes.Type       // the underlying type
	UnderlyingRange token.Range         // range of the underlying type (mainly used by the LSP)
	Type            *ddptypes.TypeAlias // the resulting  TypeAlias type
}

type TypeAliasDeclVisitor interface {
	Visitor
	VisitTypeAliasDecl(*TypeAliasDecl) VisitResult
}

type TypeAliasDeclVisitorFunc func(*TypeAliasDecl) VisitResult

type TypeCheck struct {
	Range     token.Range
	Tok       token.Token
	CheckType ddptypes.Type
	Lhs       Expression
}

type TypeCheckVisitor interface {
	Visitor
	VisitTypeCheck(*TypeCheck) VisitResult
}

type TypeCheckVisitorFunc func(*TypeCheck) VisitResult

type TypeDefDecl struct {
	Range           token.Range
	CommentTok      *token.Token // optional comment
	Tok             token.Token  // Wir
	NameTok         token.Token  // token of the name
	IsPublic        bool
	Mod             *Module
	Underlying      ddptypes.Type     // the underlying type
	UnderlyingRange token.Range       // range of the underlying type (mainly used by the LSP)
	Type            *ddptypes.TypeDef // the resulting  TypeDef type
}

type TypeDefDeclVisitor interface {
	Visitor
	VisitTypeDefDecl(*TypeDefDecl) VisitResult
}

type TypeDefDeclVisitorFunc func(*TypeDefDecl) VisitResult

type TypeOpExpr struct {
	Range    token.Range
	Tok      token.Token
	Operator TypeOperator
	Rhs      ddptypes.Type
}

type TypeOpExprVisitor interface {
	Visitor
	VisitTypeOpExpr(*TypeOpExpr) VisitResult
}

type TypeOpExprVisitorFunc func(*TypeOpExpr) VisitResult

type TypeOperator int

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

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

type UnaryExprVisitorFunc func(*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
	TypeRange       token.Range   // range of the type (mainly used by the LSP)
	IsPublic        bool          // whether the function is marked with öffentliche
	IsExternVisible bool          // whether the variable is marked as extern visible
	IsGlobal        bool          // whether this is a global variable
	Mod             *Module       // the module in which the variable was declared
	InitVal         Expression    // initial value
	InitType        ddptypes.Type // type of InitVal, filled in by the typechecker, used to keep information about typedefs
}

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

type VarDeclVisitorFunc func(*VarDecl) VisitResult

type VisitResult uint8

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

type VisitorSetter interface {
	Visitor
	SetVisitor(FullVisitor)
}

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

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

type WhileStmtVisitorFunc func(*WhileStmt) VisitResult