common

type AnnotationFlags struct {
	IsOverride bool // marks methods that should override a parent implementation
}

type AnnotationInfo struct {
	Name  string
	Flags AnnotationFlags
}

type ArityError struct {
	Expected int
	Got      int
}

type BreakSentinel struct{}

type Builtin struct {
	Name        string
	IsClass     bool
	IsInterface bool
	IsEnum      bool
	IsRecord    bool
	IsPrimitive bool
	IsFunction  bool
	// Cached definitions to avoid repeated env lookups
	ClassDef     *ClassDefinition
	TypeDef      *ast.Type
	InterfaceDef *InterfaceDefinition
	EnumDef      *EnumDefinition
	RecordDef    *RecordDefinition
	FunctionDef  *FunctionDefinition
}

type Channel struct {
	Ch chan any // Exported for reflection in select
	// contains filtered or unexported fields
}

type ClassConstructor struct {
	Definition *ClassDefinition
	Func       Func
}

type ClassDefinition struct {
	Name         string
	Aliases      []string
	Type         *ast.Type // Unified type representation
	Parent       *ClassDefinition
	Implements   []*InterfaceDefinition // Changed from []string to proper references
	IsAbstract   bool
	AccessLevel  string // "public", "private", "protected"
	IsSealed     bool
	Permits      []*ClassDefinition     // Resolved permits (lazy resolution)
	PermitNames  []PrebuildedDefinition // Unresolved permits (stored at declaration time)
	FileName     string                 // file where class is defined
	PackageName  string                 // package/directory where class is defined
	Fields       map[string]FieldInfo
	Methods      map[string][]MethodInfo // Support overloading: multiple methods with same name
	Constructors []ConstructorInfo       // Support overloading: multiple constructors
	StaticFields map[string]any
	// Generic type support
	TypeParams []GenericType // Generic type parameters (e.g., [T, E extends Comparable])
	IsGeneric  bool          // Whether this class is generic
	// Pre-bound method templates for faster instantiation
	// Maps method name to pre-compiled method function
	MethodTemplates map[string]Func // Cached method templates (created once, reused for all instances)
}

type ClassInstance struct {
	ClassName    string
	Fields       map[string]any
	Methods      map[string]Func
	ParentClass  *ClassDefinition
	GenericTypes []GenericType
	// Method lookup cache - speeds up repeated method calls by 2-3x
	MethodCache map[string]Func // Caches resolved method functions
}

type ConstructorInfo struct {
	Params      []ast.Parameter
	Body        []ast.Stmt
	BuiltinImpl Func // Optional builtin implementation
}

type ContinueSentinel struct{}

type EnumConstructor struct {
	Definition *EnumDefinition
	EnumObject map[string]any
}

type EnumDefinition struct {
	Name         string
	Type         *ast.Type // Unified type representation
	AccessLevel  string
	FileName     string
	PackageName  string
	Methods      map[string][]MethodInfo // Support overloading: multiple methods with same name
	Values       map[string]*EnumValueInstance
	Fields       map[string]FieldInfo
	Constructors []ConstructorInfo // Support overloading: multiple constructors
	IsSealed     bool
	Permits      []*ClassDefinition     // Resolved permits (lazy resolution)
	PermitNames  []PrebuildedDefinition // Unresolved permits (stored at declaration time)
}

type EnumValueInstance struct {
	Definition *EnumDefinition
	Name       string
	Ordinal    int
	Fields     map[string]any
	Methods    map[string]Func
}

type Env struct {
	Parent           *Env
	Vars             map[string]any
	Consts           map[string]bool
	Finals           map[string]bool
	Defers           []func() error      // stack of deferred calls (LIFO)
	FileName         string              // current file being executed
	PackageName      string              // current package/directory
	CurrentLine      int                 // current line number being executed (1-based)
	CurrentColumn    int                 // current column number being executed (1-based)
	CodeContext      []string            // context lines: [line-2, line-1, current line]
	SourceLines      []string            // all source lines (for hint generation)
	PositionStack    []PositionInfo      // stack of positions for better stack traces
	ImportedClasses  map[string]string   // className -> packageName, tracks imported classes
	ImportedPackages map[string]struct{} // packageName -> struct{}, tracks imported packages

	// Fast variable slots for common loop variables (0-9 represent i, j, k, etc.)
	// Uses array access instead of map lookup for ~2-3x faster access
	FastSlots [10]any        // Indexed slots for common variables
	SlotMap   map[string]int // Maps variable name to slot index (empty when not using slots)
}

type FieldInfo struct {
	Name      string
	Type      *ast.Type // Type using unified type system
	Modifiers []string
	InitValue any
	IsStatic  bool
	IsPrivate bool
}

type Func func(env *Env, args []any) (any, error)

type FunctionDefinition struct {
	Name        string
	Func        Func
	Params      []ast.Parameter // Function parameters with types
	ReturnType  *ast.Type       // Return type (can be inferred)
	AccessLevel string          // "public", "private", "protected"
	Modifiers   []string
	FileName    string // file where function is defined
	PackageName string // package/directory where function is defined
}

type GenericBound struct {
	Name       ast.Type
	Variance   string // "in" (contravariance), "out" (covariance), or "" (invariant)
	IsVariadic bool
	Extends    *ClassDefinition
	Implements *InterfaceDefinition
}

type GenericType struct {
	Bounds []GenericBound
}

type IndexError struct {
	Index int
	Size  int
}

type InterfaceDefinition struct {
	Name         string
	Type         *ast.Type                    // Unified type representation
	Methods      map[string][]MethodSignature // Support overloading: multiple methods with same name
	IsSealed     bool
	Permits      []*ClassDefinition     // Resolved permits (lazy resolution)
	PermitNames  []PrebuildedDefinition // Unresolved permits (stored at declaration time)
	StaticFields map[string]any
	AccessLevel  string
	FileName     string // file where interface is defined
	PackageName  string // package/directory where interface is defined
}

type LambdaDefinition struct {
	Func       Func            // The actual lambda function
	Params     []ast.Parameter // Lambda parameters with types
	ReturnType *ast.Type       // Return type (can be inferred)
}

type MethodInfo struct {
	Name        string
	Params      []ast.Parameter
	ReturnType  *ast.Type // Return type using unified type system
	Body        []ast.Stmt
	Modifiers   []string
	IsAbstract  bool
	IsStatic    bool
	IsPrivate   bool
	BuiltinImpl Func // Optional builtin implementation
}

type MethodSignature struct {
	Name        string
	Params      []ast.Parameter
	ReturnType  *ast.Type // Return type using unified type system
	HasDefault  bool
	DefaultBody []ast.Stmt
}

type Modifier int

type ParameterInfo = ast.Parameter

type PositionInfo struct {
	File   string
	Line   int
	Column int
}

type PrebuildedDefinition struct {
	Name        string
	PackageName string
}

type PrivacyLevel int

type RecordDefinition struct {
	Name        string
	Type        *ast.Type // Unified type representation
	AccessLevel string
	FileName    string
	PackageName string
	Components  []ast.RecordComponent
	Methods     map[string][]MethodInfo // Support overloading: multiple methods with same name
}

type RecordInstance struct {
	Definition *RecordDefinition
	Values     map[string]any
	Methods    map[string]Func
}

type RuntimeError struct {
	Message string
	Context string
}

type TypeError struct {
	Message string
}

type UndefinedError struct {
	Name string
}

type VarKind string