// Lux AST — Self-hosted Abstract Syntax Tree definitions
//
// Direct translation of src/ast.rs into Lux ADTs.
// These types represent the parsed structure of a Lux program.
//
// Naming conventions to avoid collisions:
//   Ex = Expr variant, Pat = Pattern, Te = TypeExpr
//   Td = TypeDef, Vf = VariantFields, Op = Operator
//   Decl = Declaration, St = Statement

// === Source Location ===

type Span = | Span(Int, Int)

// === Identifiers ===

type Ident = | Ident(String, Span)

// === Visibility ===

type Visibility = | Public | Private

// === Schema Evolution ===

type Version = | Version(Int, Span)

type VersionConstraint =
    | VcExact(Version)
    | VcAtLeast(Version)
    | VcLatest(Span)

// === Behavioral Types ===

type BehavioralProperty =
    | BpPure
    | BpTotal
    | BpIdempotent
    | BpDeterministic
    | BpCommutative

// === Trait Bound (needed before WhereClause) ===

type TraitBound = | TraitBound(Ident, List<TypeExpr>, Span)

// === Trait Constraint (needed before WhereClause) ===

type TraitConstraint = | TraitConstraint(Ident, List<TraitBound>, Span)

// === Where Clauses ===

type WhereClause =
    | WcProperty(Ident, BehavioralProperty, Span)
    | WcResult(Expr, Span)
    | WcTrait(TraitConstraint)

// === Module Path ===

type ModulePath = | ModulePath(List<Ident>, Span)

// === Import ===

// path, alias, items, wildcard, span
type ImportDecl = | ImportDecl(ModulePath, Option<Ident>, Option<List<Ident>>, Bool, Span)

// === Program ===

type Program = | Program(List<ImportDecl>, List<Declaration>)

// === Declarations ===

type Declaration =
    | DeclFunction(FunctionDecl)
    | DeclEffect(EffectDecl)
    | DeclType(TypeDecl)
    | DeclHandler(HandlerDecl)
    | DeclLet(LetDecl)
    | DeclTrait(TraitDecl)
    | DeclImpl(ImplDecl)

// === Parameter ===

type Parameter = | Parameter(Ident, TypeExpr, Span)

// === Effect Operation ===

type EffectOp = | EffectOp(Ident, List<Parameter>, TypeExpr, Span)

// === Record Field ===

type RecordField = | RecordField(Ident, TypeExpr, Span)

// === Variant Fields ===

type VariantFields =
    | VfUnit
    | VfTuple(List<TypeExpr>)
    | VfRecord(List<RecordField>)

// === Variant ===

type Variant = | Variant(Ident, VariantFields, Span)

// === Migration ===

type Migration = | Migration(Version, Expr, Span)

// === Handler Impl ===

// op_name, params, resume, body, span
type HandlerImpl = | HandlerImpl(Ident, List<Ident>, Option<Ident>, Expr, Span)

// === Impl Method ===

// name, params, return_type, body, span
type ImplMethod = | ImplMethod(Ident, List<Parameter>, Option<TypeExpr>, Expr, Span)

// === Trait Method ===

// name, type_params, params, return_type, default_impl, span
type TraitMethod = | TraitMethod(Ident, List<Ident>, List<Parameter>, TypeExpr, Option<Expr>, Span)

// === Type Expressions ===

type TypeExpr =
    | TeNamed(Ident)
    | TeApp(TypeExpr, List<TypeExpr>)
    | TeFunction(List<TypeExpr>, TypeExpr, List<Ident>)
    | TeTuple(List<TypeExpr>)
    | TeRecord(List<RecordField>)
    | TeUnit
    | TeVersioned(TypeExpr, VersionConstraint)

// === Literal ===

type LiteralKind =
    | LitInt(Int)
    | LitFloat(String)
    | LitString(String)
    | LitChar(Char)
    | LitBool(Bool)
    | LitUnit

type Literal = | Literal(LiteralKind, Span)

// === Binary Operators ===

type BinaryOp =
    | OpAdd | OpSub | OpMul | OpDiv | OpMod
    | OpEq | OpNe | OpLt | OpLe | OpGt | OpGe
    | OpAnd | OpOr
    | OpPipe | OpConcat

// === Unary Operators ===

type UnaryOp = | OpNeg | OpNot

// === Statements ===

type Statement =
    | StExpr(Expr)
    | StLet(Ident, Option<TypeExpr>, Expr, Span)

// === Match Arms ===

type MatchArm = | MatchArm(Pattern, Option<Expr>, Expr, Span)

// === Patterns ===

type Pattern =
    | PatWildcard(Span)
    | PatVar(Ident)
    | PatLiteral(Literal)
    | PatConstructor(Ident, List<Pattern>, Span)
    | PatRecord(List<(Ident, Pattern)>, Span)
    | PatTuple(List<Pattern>, Span)

// === Function Declaration ===
// visibility, doc, name, type_params, params, return_type, effects, properties, where_clauses, body, span
type FunctionDecl = | FunctionDecl(Visibility, Option<String>, Ident, List<Ident>, List<Parameter>, TypeExpr, List<Ident>, List<BehavioralProperty>, List<WhereClause>, Expr, Span)

// === Effect Declaration ===
// doc, name, type_params, operations, span
type EffectDecl = | EffectDecl(Option<String>, Ident, List<Ident>, List<EffectOp>, Span)

// === Type Declaration ===
// visibility, doc, name, type_params, version, definition, migrations, span
type TypeDecl = | TypeDecl(Visibility, Option<String>, Ident, List<Ident>, Option<Version>, TypeDef, List<Migration>, Span)

// === Handler Declaration ===
// name, params, effect, implementations, span
type HandlerDecl = | HandlerDecl(Ident, List<Parameter>, Ident, List<HandlerImpl>, Span)

// === Let Declaration ===
// visibility, doc, name, typ, value, span
type LetDecl = | LetDecl(Visibility, Option<String>, Ident, Option<TypeExpr>, Expr, Span)

// === Trait Declaration ===
// visibility, doc, name, type_params, super_traits, methods, span
type TraitDecl = | TraitDecl(Visibility, Option<String>, Ident, List<Ident>, List<TraitBound>, List<TraitMethod>, Span)

// === Impl Declaration ===
// type_params, constraints, trait_name, trait_args, target_type, methods, span
type ImplDecl = | ImplDecl(List<Ident>, List<TraitConstraint>, Ident, List<TypeExpr>, TypeExpr, List<ImplMethod>, Span)

// === Expressions ===

type Expr =
    | ExLiteral(Literal)
    | ExVar(Ident)
    | ExBinaryOp(BinaryOp, Expr, Expr, Span)
    | ExUnaryOp(UnaryOp, Expr, Span)
    | ExCall(Expr, List<Expr>, Span)
    | ExEffectOp(Ident, Ident, List<Expr>, Span)
    | ExField(Expr, Ident, Span)
    | ExTupleIndex(Expr, Int, Span)
    | ExLambda(List<Parameter>, Option<TypeExpr>, List<Ident>, Expr, Span)
    | ExLet(Ident, Option<TypeExpr>, Expr, Expr, Span)
    | ExIf(Expr, Expr, Expr, Span)
    | ExMatch(Expr, List<MatchArm>, Span)
    | ExBlock(List<Statement>, Expr, Span)
    | ExRecord(Option<Expr>, List<(Ident, Expr)>, Span)
    | ExTuple(List<Expr>, Span)
    | ExList(List<Expr>, Span)
    | ExRun(Expr, List<(Ident, Expr)>, Span)
    | ExResume(Expr, Span)