Fable2Python.Transforms.fs

module rec Fable.Transforms.Python.Transforms

open System
open System.Collections.Generic
open System.Text.RegularExpressions

open Fable
open Fable.AST
open Fable.Py
open Fable.Transforms.Python.AST
open Fable.Transforms
open Fable.Transforms.Python.Types
open Fable.Transforms.Python.Util
open Fable.Transforms.Python.Annotation
open Fable.Transforms.Python.Reflection

open Lib
open Util

/// Wrap an expression in option.erase() to convert Option[T] -> T | None.
/// This is zero runtime overhead - erase() is an identity function for type checkers.
let wrapInOptionErase (com: IPythonCompiler) ctx (expr: Expression) =
    libCall com ctx None "option" "erase" [ expr ]


/// Find identifiers used in an expression that have been narrowed in the context
let findNarrowedIdentsUsedInExpr (ctx: Context) (expr: Fable.Expr) : (string * Fable.Type) list =
    ctx.NarrowedTypes
    |> Map.toList
    |> List.filter (fun (name, _) -> isIdentUsed name expr)

/// Immediately Invoked Function Expression
/// When narrowed types are in scope, pass them as arguments to avoid closure capture issues
/// with type narrowing (Pyright can't see that a captured variable has been narrowed)
let iife (com: IPythonCompiler) ctx (expr: Fable.Expr) =
    // Find identifiers that are both used in the expression and have narrowed types
    let narrowedIdents = findNarrowedIdentsUsedInExpr ctx expr

    match narrowedIdents with
    | [] ->
        // No narrowed types, use the original approach
        let args, body, returnType, typeParams =
            Annotation.transformFunctionWithAnnotations com ctx None [] expr

        let afe, stmts =
            makeArrowFunctionExpression com ctx None (Some expr.Type) args body returnType typeParams

        Expression.call (afe, []), stmts
    | narrowedIdents ->
        // Create Fable.Ident arguments for the narrowed identifiers using makeTypedIdent
        let fableArgs =
            narrowedIdents
            |> List.map (fun (name, narrowedType) -> makeTypedIdent narrowedType name)

        // Transform the function with the narrowed arguments
        let args, body, returnType, typeParams =
            Annotation.transformFunctionWithAnnotations com ctx None fableArgs expr

        let afe, stmts =
            makeArrowFunctionExpression com ctx None (Some expr.Type) args body returnType typeParams

        // Create call arguments from the narrowed identifier names
        let callArgs =
            narrowedIdents
            |> List.map (fun (name, _) -> com.GetIdentifierAsExpr(ctx, Naming.toPythonNaming name))

        Expression.call (afe, callArgs), stmts

let transformImport (com: IPythonCompiler) ctx (_r: SourceLocation option) (name: string) (moduleName: string) =
    let name, parts =
        let parts = Array.toList (name.Split('.'))
        parts.Head, parts.Tail

    com.GetImportExpr(ctx, moduleName, name) |> getParts com ctx parts

let getMemberArgsAndBody (com: IPythonCompiler) ctx kind hasSpread (args: Fable.Ident list) (body: Fable.Expr) =
    // printfn "getMemberArgsAndBody: %A" hasSpread
    let funcName, genTypeParams, args, body =
        match kind, args with
        | Attached(isStatic = false), thisArg :: args ->
            let genTypeParams =
                Set.difference (Annotation.getGenericTypeParams [ thisArg.Type ]) ctx.ScopedTypeParams

            let body =
                if isIdentUsed thisArg.Name body then
                    let thisArgType =
                        match thisArg.Type with
                        | Replacements.Util.IsByRefType com typ -> typ
                        | typ -> typ

                    let thisArg = { thisArg with Type = thisArgType }
                    let thisKeyword = Fable.IdentExpr { thisArg with Name = "self" }

                    Fable.Let(thisArg, thisKeyword, body)
                else
                    body

            None, genTypeParams, args, body
        | Attached(isStatic = true), _
        | ClassConstructor, _ -> None, ctx.ScopedTypeParams, args, body
        | NonAttached funcName, _ -> Some funcName, Set.empty, args, body
        | _ -> None, Set.empty, args, body

    let ctx =
        { ctx with ScopedTypeParams = Set.union ctx.ScopedTypeParams genTypeParams }

    let args, body, returnType, _typeParams =
        Annotation.transformFunctionWithAnnotations com ctx funcName args body

    let args = adjustArgsForSpread hasSpread args

    args, body, returnType

let getUnionCaseName (uci: Fable.UnionCase) =
    match uci.CompiledName with
    | Some cname -> cname
    | None -> uci.Name

/// Attribute holding the precomputed singleton instance of a zero-field union case (see transformUnion).
let unionCaseSingletonAttrName = "singleton"
let unionCaseSingletonAttr = Identifier unionCaseSingletonAttrName

/// Gets the unique case class name by prefixing with the union type name.
/// This prevents collisions when different union types have cases with the same name.
/// Library types (Result, Choice) use simple case names without prefix.
/// The optional entityName parameter should be the compiled entity name (with module scope).
let getUnionCaseClassName
    (com: IPythonCompiler)
    (ent: Fable.Entity)
    (uci: Fable.UnionCase)
    (entityName: string option)
    =
    let caseName = getUnionCaseName uci
    // Library types use simple names (Ok, Error, Choice1Of2, etc.) for backwards compatibility
    if usesSimpleCaseNames ent.FullName then
        caseName
    else
        // Use provided entity name or compute from entity reference
        let unionName =
            match entityName with
            | Some name -> name
            | None -> FSharp2Fable.Helpers.getEntityDeclarationName com ent.Ref

        $"%s{unionName}_%s{caseName}"

/// Resolves the expression referring to a union case's class (constructor / type),
/// handling both library types (Result, Choice - simple names from fable_library)
/// and user-defined unions (full case class name, imported from another module if needed).
let getUnionCaseRef (com: IPythonCompiler) ctx (entRef: Fable.EntityRef) (ent: Fable.Entity) (uci: Fable.UnionCase) =
    if isLibraryUnionType entRef.FullName then
        let caseName = getUnionCaseName uci
        // Result uses "result" module, Choice uses "choice" module
        let moduleName =
            if entRef.FullName = Types.result then
                "result"
            else
                "choice"

        libValue com ctx moduleName caseName
    else
        // User-defined union - use full case class name (UnionName_CaseName)
        let caseClassName = getUnionCaseClassName com ent uci None

        match entRef.SourcePath with
        | Some path when path <> com.CurrentFile ->
            // Import from another module
            let importPath = Path.getRelativeFileOrDirPath false com.CurrentFile false path
            com.GetImportExpr(ctx, importPath, caseClassName)
        | _ ->
            // Local - just get identifier
            com.GetIdentifierAsExpr(ctx, caseClassName)

let getUnionExprTag (com: IPythonCompiler) ctx r (fableExpr: Fable.Expr) =
    Expression.withStmts {
        let! expr = com.TransformAsExpr(ctx, fableExpr)
        let! finalExpr = getExpr com ctx r expr (Expression.stringConstant "tag")
        return finalExpr
    }

let wrapIntExpression typ (e: Expression) =
    match e, typ with
    | Expression.Constant _, _ -> e
    | _ -> e

let wrapExprInBlockWithReturn (e, stmts) = stmts @ [ Statement.return' e ]

let makeArrowFunctionExpression
    com
    ctx
    (name: string option)
    (bodyType: Fable.Type option)
    (args: Arguments)
    (body: Statement list)
    returnType
    (typeParams: TypeParam list)
    : Expression * Statement list
    =
    let isAsync =
        match bodyType with
        | Some typ -> isTaskType typ
        | None -> false

    let args =
        match args.PosOnlyArgs, args.Args with
        | [], [] ->
            let ta = com.GetImportExpr(ctx, getLibPath com "util", "Unit")

            Arguments.arguments (args = [ Arg.arg ("__unit", annotation = ta) ], defaults = [ Expression.tuple [] ])
        | _ -> args

    let allDefaultsAreNone =
        args.Defaults
        |> List.forall (
            function
            | Expression.Name { Id = Identifier "None" } -> true
            | _ -> false
        )

    let allArgs = args.PosOnlyArgs @ args.Args

    let (|ImmediatelyApplied|_|) =
        function
        | Expression.Call {
                              Func = callee
                              Args = appliedArgs
                          } when allArgs.Length = appliedArgs.Length && allDefaultsAreNone ->
            // To be sure we're not running side effects when deleting the function check the callee is an identifier
            match callee with
            | Expression.Name _ ->
                let parameters = allArgs |> List.map (fun a -> (Expression.name a.Arg))

                List.zip parameters appliedArgs
                |> List.forall (
                    function
                    | Expression.Name({ Id = Identifier name1 }), Expression.Name({ Id = Identifier name2 }) ->
                        name1 = name2
                    | _ -> false
                )
                |> function
                    | true -> Some callee
                    | false -> None
            | _ -> None
        | _ -> None

    match body with
    // Check if we can remove the function
    | [ Statement.Return { Value = Some(ImmediatelyApplied(callExpr)) } ] -> callExpr, []
    | _ ->
        let ident =
            name
            |> Option.map Identifier
            |> Option.defaultWith (fun _ -> Helpers.getUniqueIdentifier "_arrow")

        let func =
            if isAsync then
                createFunctionWithTypeParams ident args body [] returnType None typeParams true
            else
                createFunctionWithTypeParams ident args body [] returnType None typeParams false

        Expression.name ident, [ func ]

/// Check if a Fable type is a Task type (should generate async def)
let isTaskType (typ: Fable.Type) =
    match typ with
    | Fable.DeclaredType(ent, _) -> ent.FullName = Types.taskGeneric
    | _ -> false

let createFunction name args body decoratorList returnType (comment: string option) =
    createFunctionWithTypeParams name args body decoratorList returnType comment [] false

let createAsyncFunction name args body decoratorList returnType (comment: string option) =
    createFunctionWithTypeParams name args body decoratorList returnType comment [] true

let createFunctionWithTypeParams
    name
    args
    body
    decoratorList
    returnType
    (comment: string option)
    (typeParams: TypeParam list)
    (isAsync: bool)
    =
    if isAsync then
        Statement.asyncFunctionDef (
            name = name,
            args = args,
            body = Helpers.wrapReturnWithAwait body,
            decoratorList = decoratorList,
            returns = Helpers.unwrapTaskType returnType,
            typeParams = typeParams,
            ?comment = comment
        )
    else
        Statement.functionDef (
            name = name,
            args = args,
            body = body,
            decoratorList = decoratorList,
            returns = returnType,
            typeParams = typeParams,
            ?comment = comment
        )

let makeFunction name (args: Arguments, body: Expression, decoratorList, returnType) : Statement =
    // printfn "makeFunction: %A" name
    let body = wrapExprInBlockWithReturn (body, [])
    createFunction name args body decoratorList returnType None

let makeFunctionExpression
    (com: IPythonCompiler)
    ctx
    name
    (args, body: Expression, decoratorList, returnType: Expression)
    : Expression * Statement list
    =
    let ctx = { ctx with BoundVars = ctx.BoundVars.EnterScope() }

    let name =
        name
        |> Option.map (fun name -> com.GetIdentifier(ctx, name))
        |> Option.defaultValue (Helpers.getUniqueIdentifier "_expr")

    let func = makeFunction name (args, body, decoratorList, returnType)
    Expression.name name, [ func ]

let optimizeTailCall (com: IPythonCompiler) (ctx: Context) range (tc: ITailCallOpportunity) args =
    let rec checkCrossRefs tempVars allArgs =
        function
        | [] -> tempVars
        | (argId, _arg) :: rest ->
            let found =
                allArgs
                |> List.exists (
                    deepExists (
                        function
                        | Fable.IdentExpr i -> argId = i.Name
                        | _ -> false
                    )
                )

            let tempVars =
                if found then
                    let tempVarName = Util.getUniqueNameInDeclarationScope ctx (argId + "_tmp")

                    Map.add argId tempVarName tempVars
                else
                    tempVars

            checkCrossRefs tempVars allArgs rest

    ctx.OptimizeTailCall()

    let zippedArgs =
        List.zip (tc.Args |> List.map (fun { Arg = Identifier id } -> id)) args

    let tempVars = checkCrossRefs Map.empty args zippedArgs

    let tempVarReplacements = tempVars |> Map.map (fun _ v -> makeIdentExpr v)

    [
        // First declare temp variables
        for KeyValue(argId, tempVar) in tempVars do
            yield! varDeclaration ctx (com.GetIdentifierAsExpr(ctx, tempVar)) None (com.GetIdentifierAsExpr(ctx, argId))
        // Then assign argument expressions to the original argument identifiers
        // See https://github.com/fable-compiler/Fable/issues/1368#issuecomment-434142713
        for argId, arg in zippedArgs do
            let arg = FableTransforms.replaceValues tempVarReplacements arg
            let arg, stmts = com.TransformAsExpr(ctx, arg)

            yield!
                stmts
                @ (assign None (com.GetIdentifierAsExpr(ctx, argId)) arg |> exprAsStatement ctx)
        yield Statement.continue' (?loc = range)
    ]

let transformCast (com: IPythonCompiler) (ctx: Context) t e : Expression * Statement list =
    // printfn "transformCast: %A" (t, e)
    match t, e with
    | IEnumerableOfKeyValuePair(kvpEnt) ->
        // Call .items() on the dictionary and wrap with to_enumerable for IEnumerable_1 compatibility
        let dictExpr, stmts = com.TransformAsExpr(ctx, e)

        let itemsCall =
            Expression.attribute (value = dictExpr, attr = Identifier "items", ctx = Load)

        let itemsExpr = Expression.call (itemsCall, [])
        // Wrap with to_enumerable to get IEnumerable_1
        libCall com ctx None "util" "to_enumerable" [ itemsExpr ], stmts
    // Optimization for (numeric) array or list literals casted to seq
    // Done at the very end of the compile pipeline to get more opportunities
    // of matching cast and literal expressions after resolving pipes, inlining...
    | Fable.DeclaredType(ent, [ _ ]), _ ->
        match ent.FullName, e with
        | Types.ienumerableGeneric, Replacements.Util.ArrayOrListLiteral(exprs, _typ) ->
            let expr, stmts =
                exprs |> List.map (fun e -> com.TransformAsExpr(ctx, e)) |> Helpers.unzipArgs

            let xs = Expression.list expr
            libCall com ctx None "util" "to_enumerable" [ xs ], stmts

        // Wrap ResizeArray (Python list) when cast to IEnumerable
        // Python lists don't implement IEnumerable_1, so they need wrapping
        // Optimization: If ResizeArray was created via of_seq from IEnumerable, use the original arg
        | Types.ienumerableGeneric, _ when
            match e.Type with
            | Fable.Array(_, Fable.ArrayKind.ResizeArray) -> true
            | Fable.DeclaredType(entRef, _) when entRef.FullName = Types.resizeArray -> true
            | _ -> false
            ->
            let listExpr, stmts = com.TransformAsExpr(ctx, e)
            // Check if the expression is of_seq(arg) - if so, use arg directly (already IEnumerable)
            match listExpr with
            | Expression.Call {
                                  Func = Expression.Name { Id = Identifier "of_seq" }
                                  Args = [ innerArg ]
                              } ->
                // Skip both of_seq and to_enumerable - use original IEnumerable directly
                innerArg, stmts
            | _ -> libCall com ctx None "util" "to_enumerable" [ listExpr ], stmts

        | _ -> com.TransformAsExpr(ctx, e)
    | Fable.Number(Float32, _), _ ->
        let cons = libValue com ctx "core" "float32"
        let value, stmts = com.TransformAsExpr(ctx, e)
        Expression.call (cons, [ value ], ?loc = None), stmts
    // Int32 is a plain Python `int`, so casting to it is a no-op -- unless the source
    // is one of the wrapper widths. `Replacements.toInt` emits a bare `TypeCast` for
    // every widening conversion (`needToCast` is false), so this is where e.g.
    // `int (x: sbyte)` sheds its `Int8`. Leaving the wrapper in place would keep the
    // arithmetic at the source width: `Int8(100) + 100` wraps to -56.
    | Fable.Number(Int32, _), _ ->
        match e.Type with
        // Already a plain `int` at runtime
        | Fable.Number((Int32 | BigInt | NativeInt | UNativeInt), _) -> com.TransformAsExpr(ctx, e)
        | Fable.Number _ ->
            let value, stmts = com.TransformAsExpr(ctx, e)
            libCall com ctx None "core" "int32" [ value ], stmts
        | _ -> com.TransformAsExpr(ctx, e)
    // Float64 is a plain Python `float`, and the same reasoning applies:
    // `Replacements.toFloat` emits a bare `TypeCast` for every numeric source that is
    // not bigint/decimal/int64, so `float (x: float32)` would otherwise stay a
    // `Float32` and keep computing in single precision. Every wrapper implements
    // `__float__`, so the builtin is enough and stays a single C-level call.
    | Fable.Number(Float64, _), _ ->
        match e.Type with
        | Fable.Number(Float64, _) -> com.TransformAsExpr(ctx, e)
        | Fable.Number _ ->
            let value, stmts = com.TransformAsExpr(ctx, e)
            Expression.call (Expression.name "float", [ value ], ?loc = None), stmts
        | _ -> com.TransformAsExpr(ctx, e)
    | _ -> com.TransformAsExpr(ctx, e)

let transformCurry (com: IPythonCompiler) (ctx: Context) expr arity : Expression * Statement list =
    com.TransformAsExpr(ctx, Replacements.Api.curryExprAtRuntime com arity expr)


let transformValue (com: IPythonCompiler) (ctx: Context) r value : Expression * Statement list =
    match value with
    | Fable.BaseValue(None, _) -> Expression.identifier "super()", []
    | Fable.BaseValue(Some boundIdent, _) -> identAsExpr com ctx boundIdent, []
    | Fable.ThisValue _ -> Expression.identifier "self", []
    | Fable.TypeInfo(t, _) -> transformTypeInfo com ctx r Map.empty t
    | Fable.Null t ->
        match t with
        | Fable.Unit -> Expression.none, []
        | _ ->
            // Cast None to the expected type to satisfy the type checker
            let ta, stmts = Annotation.typeAnnotation com ctx None t
            wrapNoneInCast com ctx Expression.none ta, stmts
    | Fable.UnitConstant -> undefined r, []
    | Fable.BoolConstant x -> Expression.boolConstant (x, ?loc = r), []
    | Fable.CharConstant x -> Expression.stringConstant (string<char> x, ?loc = r), []
    | Fable.StringConstant x -> Expression.stringConstant (x, ?loc = r), []
    | Fable.StringTemplate(_, parts, values) ->
        match parts with
        | [] -> makeStrConst ""
        | [ part ] -> makeStrConst part
        | part :: parts ->
            let acc = makeStrConst part

            (acc, List.zip values parts)
            ||> List.fold (fun acc (MaybeCasted(value), part) ->
                let value =
                    match value.Type with
                    | Fable.String -> value
                    // Float64 is a plain Python `float`, whose `str` renders a whole
                    // double as "5.0" where .NET renders "5".
                    | Fable.Number(Float64, _) ->
                        Replacements.Util.Helper.LibCall(com, "exceptions", "to_string", Fable.String, [ value ])
                    | _ -> Helpers.toString value

                let acc = makeBinOp None Fable.String acc value BinaryPlus

                makeBinOp None Fable.String acc (makeStrConst part) BinaryPlus
            )
        |> transformAsExpr com ctx
    | Fable.NumberConstant(v, _) ->
        match v with
        | Fable.NumberValue.Int8 x -> makeInteger com ctx r value.Type "int8" x
        | Fable.NumberValue.UInt8 x -> makeInteger com ctx r value.Type "uint8" x
        | Fable.NumberValue.Int16 x -> makeInteger com ctx r value.Type "int16" x
        | Fable.NumberValue.UInt16 x -> makeInteger com ctx r value.Type "uint16" x
        // Int32 is represented as a plain Python `int`, so a literal is just a literal
        | Fable.NumberValue.Int32 x -> Expression.intConstant (x, ?loc = r), []
        | Fable.NumberValue.UInt32 x -> makeInteger com ctx r value.Type "uint32" x
        | Fable.NumberValue.Int64 x -> makeInteger com ctx r value.Type "int64" x
        | Fable.NumberValue.UInt64 x -> makeInteger com ctx r value.Type "uint64" x
        // | Fable.NumberValue.Int128(u,l) -> Expression.intConstant (System.Int128(u,l), ?loc = r), []
        // | Fable.NumberValue.UInt128(u,l) -> Expression.intConstant (System.UInt128(u,l), ?loc = r), []
        | Fable.NumberValue.BigInt x -> Expression.intConstant (x, ?loc = r), []
        | Fable.NumberValue.NativeInt x -> Expression.intConstant (x, ?loc = r), []
        | Fable.NumberValue.UNativeInt x -> Expression.intConstant (x, ?loc = r), []
        // TODO: special consts also need attention
        | Fable.NumberValue.Float64 x when x = infinity -> com.GetImportExpr(ctx, "math", "inf"), []
        | Fable.NumberValue.Float64 x when x = -infinity ->
            Expression.unaryOp (UnaryMinus, com.GetImportExpr(ctx, "math", "inf")), []
        | Fable.NumberValue.Float64 x when Double.IsNaN(x) -> com.GetImportExpr(ctx, "math", "nan"), []
        | Fable.NumberValue.Float16 x -> makeFloat com ctx r value.Type "float32" (float x)
        | Fable.NumberValue.Float32 x -> makeFloat com ctx r value.Type "float32" (float x)
        | Fable.NumberValue.Float64 x -> Expression.floatConstant (float x, ?loc = r), []
        | Fable.NumberValue.Decimal x -> Py.Replacements.makeDecimal com r value.Type x |> transformAsExpr com ctx
        | _ -> addErrorAndReturnNull com r $"Numeric literal is not supported: %A{v}", []
    | Fable.NewArray(newKind, typ, kind) ->
        // printfn "NewArray: %A" (typ)

        match newKind with
        | Fable.ArrayValues values -> makeArray com ctx values kind typ
        | Fable.ArrayAlloc size -> makeArrayAllocated com ctx typ kind size
        | Fable.ArrayFrom expr -> makeArrayFrom com ctx typ kind expr

    | Fable.NewTuple(vals, _) -> makeTuple com ctx vals
    // Optimization for bundle size: compile list literals as List.ofArray
    | Fable.NewList(headAndTail, elementType) ->
        let rec getItems acc =
            function
            | None -> List.rev acc, None
            | Some(head, Fable.Value(Fable.NewList(tail, _), _)) -> getItems (head :: acc) tail
            | Some(head, tail) -> List.rev (head :: acc), Some tail

        match getItems [] headAndTail with
        | [], None -> libCall com ctx r "list" "empty" [], []
        | [ TransformExpr com ctx (expr, stmts) ], None -> libCall com ctx r "list" "singleton" [ expr ], stmts
        | exprs, None ->
            let expr, stmts = makeArray com ctx exprs Fable.MutableArray elementType
            [ expr ] |> libCall com ctx r "list" "ofArray", stmts
        | [ TransformExpr com ctx (head, stmts) ], Some(TransformExpr com ctx (tail, stmts')) ->
            libCall com ctx r "list" "cons" [ head; tail ], stmts @ stmts'
        | exprs, Some(TransformExpr com ctx (tail, stmts)) ->
            let expr, stmts' = makeArray com ctx exprs Fable.MutableArray elementType
            [ expr; tail ] |> libCall com ctx r "list" "ofArrayWithTail", stmts @ stmts'
    | Fable.NewOption(value, t, _) ->
        match value with
        | Some(TransformExpr com ctx (e, stmts)) ->
            if mustWrapOption t then
                libCall com ctx r "option" "some" [ e ], stmts
            else
                e, stmts
        | None -> undefined r, []
    | Fable.NewRecord(values, ent, _genArgs) ->
        let ent = com.GetEntity(ent)

        let values, stmts =
            List.map (fun x -> com.TransformAsExpr(ctx, x)) values |> Helpers.unzipArgs

        let consRef, stmts' = ent |> pyConstructor com ctx
        Expression.call (consRef, values, ?loc = r), stmts @ stmts'
    | Fable.NewAnonymousRecord(values, fieldNames, _genArgs, _isStruct) ->
        let values, stmts =
            values |> List.map (fun x -> com.TransformAsExpr(ctx, x)) |> Helpers.unzipArgs

        List.zip (List.ofArray fieldNames) values |> makePyObject, stmts
    | Fable.NewUnion(values, tag, entRef, _genArgs) ->
        let ent = com.GetEntity(entRef)

        let values, stmts =
            List.map (fun x -> com.TransformAsExpr(ctx, x)) values |> Helpers.unzipArgs

        // Get the union case
        let uci = ent.UnionCases |> List.item tag
        let caseRef = getUnionCaseRef com ctx entRef ent uci

        // fsc represents a union case with no fields as a single shared instance, so e.g.
        // `LanguagePrimitives.PhysicalEquality X.A X.A` is true. Mirror that by reusing the
        // precomputed singleton instead of constructing a new instance.
        if not (isLibraryUnionType entRef.FullName) && List.isEmpty uci.UnionCaseFields then
            Expression.attribute (caseRef, unionCaseSingletonAttr), stmts
        else
            Expression.call (caseRef, values, ?loc = r), stmts
    | _ -> failwith $"transformValue: value %A{value} not supported!"

let extractBaseExprFromBaseCall (com: IPythonCompiler) (ctx: Context) (baseType: Fable.DeclaredType option) baseCall =
    // printfn "extractBaseExprFromBaseCall: %A" (baseCall, baseType)
    match baseCall, baseType with
    | Some(Fable.Call(baseRef, info, _, _)), _ ->
        let baseExpr, stmts =
            match baseRef with
            | Fable.IdentExpr id -> com.GetIdentifierAsExpr(ctx, id.Name), []
            | _ -> transformAsExpr com ctx baseRef

        let expr, keywords, stmts' = transformCallArgs com ctx info true

        Some(baseExpr, (expr, keywords, stmts @ stmts'))
    | Some(Fable.ObjectExpr([], Fable.Unit, None)), _ ->
        let range = baseCall |> Option.bind (fun x -> x.Range)

        let name =
            baseType
            |> Option.map (fun t -> t.Entity.FullName)
            |> Option.defaultValue "unknown type"

        $"Ignoring base call for %s{name}" |> addWarning com [] range

        None
    | Some(Fable.Value _), Some baseType ->
        // let baseEnt = com.GetEntity(baseType.Entity)
        // let entityName = FSharp2Fable.Helpers.getEntityDeclarationName com baseType.Entity
        // let entityType = FSharp2Fable.Util.getEntityType baseEnt
        // let baseRefId = makeTypedIdent entityType entityName
        // let baseExpr = (baseRefId |> typedIdent com ctx) :> Expression
        // Some (baseExpr, []) // default base constructor
        let range = baseCall |> Option.bind (fun x -> x.Range)

        $"Ignoring base call for %s{baseType.Entity.FullName}"
        |> addWarning com [] range

        None
    | Some _, _ ->
        let range = baseCall |> Option.bind (fun x -> x.Range)

        "Unexpected base call expression, please report" |> addError com [] range

        None
    | None, _ -> None

let transformObjectExpr
    (com: IPythonCompiler)
    ctx
    (members: Fable.ObjectExprMember list)
    typ
    baseCall
    : Expression * Statement list
    =
    // printfn "transformObjectExpr: %A" typ

    // A generic class nested in another generic class cannot use same type variables. (PEP-484)
    let ctx = { ctx with TypeParamsScope = ctx.TypeParamsScope + 1 }

    // Check if any member body uses ThisValue from an outer scope (e.g., inside a constructor).
    // ThisValue specifically represents `self` in a constructor/method context.
    // Note: IsThisArgument identifiers are captured via default arguments (x: Any=x),
    // so we only need to handle explicit ThisValue here.
    let usesOuterThis =
        members
        |> List.exists (fun memb ->
            memb.Body
            |> deepExists (
                function
                | Fable.Value(Fable.ThisValue _, _) -> true
                | _ -> false
            )
        )

    // Only generate capture statement if outer this is actually used.
    // This allows inner class methods to reference the outer instance via "_this"
    // while using standard "self" for the inner instance (satisfies Pylance).
    let thisCaptureStmts =
        if usesOuterThis then
            let anyType = stdlibModuleAnnotation com ctx "typing" "Any" []

            [
                Statement.assign (Expression.name "_this", anyType, value = Expression.name "self")
            ]
        else
            []

    // Replace ThisValue in the body with an identifier reference to "_this"
    // This ensures that outer self references correctly bind to the captured variable
    let replaceThisValue (body: Fable.Expr) =
        if usesOuterThis then
            body
            |> visitFromInsideOut (
                function
                | Fable.Value(Fable.ThisValue typ, r) ->
                    Fable.IdentExpr
                        {
                            Name = "_this"
                            Type = typ
                            IsMutable = false
                            IsThisArgument = false
                            IsCompilerGenerated = true
                            Range = r
                            IsInlineIfLambda = false
                        }
                | e -> e
            )
        else
            body

    let makeMethod prop hasSpread (fableArgs: Fable.Ident list) (fableBody: Fable.Expr) decorators =
        let fableBody = replaceThisValue fableBody

        let args, body, returnType =
            getMemberArgsAndBody com ctx (Attached(isStatic = false)) hasSpread fableArgs fableBody

        let name =
            let name =
                match prop with
                | "ToString" -> "__str__"
                | _ -> prop

            com.GetIdentifier(ctx, Naming.toPythonNaming name)

        let self = Arg.arg "self"
        let args = { args with Args = self :: args.Args }

        // Calculate type parameters for generic object expression methods
        let argTypes = fableArgs |> List.map _.Type

        let typeParams =
            Annotation.calculateMethodTypeParams com ctx argTypes fableBody.Type

        createFunctionWithTypeParams name args body decorators returnType None typeParams false

    let interfaces, stmts =
        match typ with
        | Fable.Any -> [], [] // Don't inherit from Any
        | Fable.DeclaredType(entRef, genArgs) ->
            // Map interface names to ABC base class names for inheritance
            // Use ABC base classes instead of Protocols for proper method resolution
            let name = Helpers.removeNamespace entRef.FullName
            let fullName = entRef.FullName

            // Map interface names to ABC base class(es) using shared helper
            match Bases.getAbcClassesForInterface name fullName with
            | Some classes ->
                let exprs =
                    classes
                    |> List.map (fun abcName -> Bases.makeAbcBaseExpr com ctx abcName genArgs)

                exprs, []
            | None ->
                // Fall back to regular type annotation for non-mapped interfaces
                let ta, stmts = Annotation.typeAnnotation com ctx None typ
                [ ta ], stmts
        | _ ->
            let ta, stmts = Annotation.typeAnnotation com ctx None typ
            [ ta ], stmts

    /// Transform an interface method into a method statement (not a property)
    let transformInterfaceMethod (memb: Fable.ObjectExprMember) =
        let args, body =
            match memb.Body with
            | Fable.Delegate(args, body, _, _) -> args, body
            | Fable.Lambda(arg, body, _) -> [ arg ], body
            | _ -> memb.Args, memb.Body

        // Replace ThisValue with this_ identifier for outer self references
        let body = replaceThisValue body

        let args', body', returnType =
            getMemberArgsAndBody com ctx (NonAttached memb.Name) false args body

        let name = com.GetIdentifier(ctx, Naming.toPythonNaming memb.Name)
        let self = Arg.arg "self"
        let args' = { args' with Args = self :: args'.Args }

        let argTypes = args |> List.map _.Type
        let typeParams = Annotation.calculateMethodTypeParams com ctx argTypes body.Type

        createFunctionWithTypeParams name args' body' [] returnType None typeParams false

    let members =
        members
        |> List.collect (fun memb ->
            let info = com.GetMember(memb.MemberRef)

            if not memb.IsMangled && (info.IsGetter || info.IsValue) then
                if Bases.isInterfaceMethod com typ memb.Name then
                    [ transformInterfaceMethod memb ]
                else
                    let decorators = [ Expression.name "property" ]
                    [ makeMethod memb.Name false memb.Args memb.Body decorators ]
            elif not memb.IsMangled && info.IsSetter then
                let decorators = [ Expression.name $"%s{memb.Name}.setter" ]
                [ makeMethod memb.Name false memb.Args memb.Body decorators ]
            else
                [ makeMethod memb.Name info.HasSpread memb.Args memb.Body [] ]
        )

    let _baseExpr, classMembers =
        baseCall
        |> extractBaseExprFromBaseCall com ctx None
        |> Option.map (fun (baseExpr, (baseArgs, _kw, _stmts)) ->
            let consBody = [ callSuperAsStatement baseArgs ]
            let args = Arguments.empty
            let classCons = makeClassConstructor args false None com ctx consBody
            Some baseExpr, classCons @ members
        )
        |> Option.defaultValue (None, members)
        |> (fun (expr, memb) -> expr |> Option.toList, memb)

    let classBody =
        match classMembers with
        | [] -> [ Pass ]
        | _ -> classMembers

    let name = Helpers.getUniqueIdentifier "ObjectExpr"

    let stmt = Statement.classDef (name, body = classBody, bases = interfaces)

    Expression.call (Expression.name name), thisCaptureStmts @ [ stmt ] @ stmts


let transformCallArgs
    (com: IPythonCompiler)
    ctx
    (callInfo: Fable.CallInfo)
    (isBaseConstructorCall: bool)
    : Expression list * Keyword list * Statement list
    =

    let args =
        FSharp2Fable.Util.dropUnitCallArg com callInfo.Args callInfo.SignatureArgTypes callInfo.MemberRef

    let paramsInfo =
        callInfo.MemberRef |> Option.bind com.TryGetMember |> Option.map getParamsInfo

    // Enhanced handling for constructor calls with named arguments
    let isConstructorCall =
        List.contains "new" callInfo.Tags && not isBaseConstructorCall

    let getCallArgs paramsInfo args =
        paramsInfo
        |> Option.map (splitNamedArgs args)
        |> function
            | None -> args, None, []
            | Some(args, None) -> args, None, []
            | Some(args, Some namedArgs) ->
                let objArg, stmts =
                    namedArgs
                    |> List.choose (fun (param, value) ->
                        match param.Name, value with
                        | Some keyword, Fable.Value(Fable.NewOption(value, _, _), _) ->
                            value |> Option.map (fun value -> keyword, value)
                        | Some keyword, value -> Some(keyword, value)
                        | None, _ -> None
                    )
                    |> List.map (fun (keyword, value) ->
                        let value, stmts = com.TransformAsExpr(ctx, value)
                        (keyword, value), stmts
                    )
                    |> List.unzip
                    |> fun (kv, stmts) ->
                        kv
                        |> List.map (fun (keyword, value) ->
                            Keyword.keyword (Identifier(Naming.toPythonNaming keyword), value)
                        ),
                        stmts |> List.collect id

                args, Some objArg, stmts

    let args, objArg, stmts =
        match paramsInfo, isConstructorCall with
        | Some info, true when args.Length <= info.Parameters.Length && args.Length > 0 ->
            // For constructor calls, check if we should use keyword arguments
            // Only apply if we have parameter names for all arguments
            let relevantParams = List.take args.Length info.Parameters

            let hasAllParameterNames = relevantParams |> List.forall (fun p -> p.Name.IsSome)

            if hasAllParameterNames then
                // Try to create keyword arguments for constructor calls
                let keywordArgs =
                    List.zip relevantParams args
                    |> List.choose (fun (param, arg) ->
                        match param.Name with
                        | Some paramName -> Some(paramName, arg)
                        | None -> None
                    )

                if keywordArgs.Length = args.Length then
                    // All parameters have names, convert to keyword arguments
                    let objArg, stmts =
                        keywordArgs
                        |> List.map (fun (kw, value) ->
                            let value, stmts = com.TransformAsExpr(ctx, value)
                            (kw, value), stmts
                        )
                        |> List.unzip
                        |> fun (kv, stmts) ->
                            kv
                            |> List.map (fun (keyword, value) ->
                                Keyword.keyword (Identifier(Naming.toPythonNaming keyword), value)
                            ),
                            stmts |> List.collect id

                    [], Some objArg, stmts
                else
                    // Fallback to regular handling
                    getCallArgs paramsInfo args
            else
                // Fallback to regular handling when not all parameters have names
                getCallArgs paramsInfo args
        | _ ->
            // Regular handling for non-constructor calls
            getCallArgs paramsInfo args

    let hasSpread =
        paramsInfo |> Option.map (fun i -> i.HasSpread) |> Option.defaultValue false

    // Helper to transform an arg and wrap with widen() if needed
    let transformArgWithWiden (sigType: Fable.Type option) (argExpr: Fable.Expr) =
        let expr, stmts = com.TransformAsExpr(ctx, argExpr)

        if needsOptionWidenForArg sigType argExpr then
            let widen = com.TransformImport(ctx, "widen", getLibPath com "option")
            Expression.call (widen, [ expr ]), stmts
        else
            expr, stmts

    let args, stmts' =
        match args with
        | [] -> [], []
        | args when hasSpread ->
            match List.rev args with
            | [] -> [], []
            | Replacements.Util.ArrayOrListLiteral(spreadArgs, _) :: rest ->
                let rest = List.rev rest |> List.map (fun e -> com.TransformAsExpr(ctx, e))

                rest @ List.map (fun e -> com.TransformAsExpr(ctx, e)) spreadArgs
                |> Helpers.unzipArgs
            | last :: rest ->
                let rest, stmts =
                    List.rev rest
                    |> List.map (fun e -> com.TransformAsExpr(ctx, e))
                    |> Helpers.unzipArgs

                let expr, stmts' = com.TransformAsExpr(ctx, last)
                rest @ [ Expression.starred expr ], stmts @ stmts'
        | args ->
            // Transform args with widen() where needed based on signature types
            args
            |> List.mapi (fun i e ->
                let sigType = List.tryItem i callInfo.SignatureArgTypes
                transformArgWithWiden sigType e
            )
            |> Helpers.unzipArgs

    match objArg with
    | None -> args, [], stmts @ stmts'
    | Some objArg -> args, objArg, stmts @ stmts'

let resolveExpr (ctx: Context) _t strategy pyExpr : Statement list =
    // printfn "resolveExpr: %A" (pyExpr, strategy)
    match strategy with
    | None
    | Some ReturnUnit -> exprAsStatement ctx pyExpr
    // TODO: Where to put these int wrappings? Add them also for function arguments?
    | Some(ResourceManager strategy) -> resolveExpr ctx _t strategy pyExpr
    | Some(Return _) -> [ Statement.return' pyExpr ]
    | Some(Assign left) -> exprAsStatement ctx (assign None left pyExpr)
    | Some(Target left) -> exprAsStatement ctx (assign None (left |> Expression.identifier) pyExpr)

let transformOperation (com: IPythonCompiler) ctx range (t: Fable.Type) opKind tags : Expression * Statement list =
    // Int32 is a plain Python `int`, so results that can leave the 32-bit range are
    // normalized back into it. See `Util.isInt32WrapOp` for why one wrap per
    // expression tree is equivalent to one per operation.
    let isInt32 =
        match t with
        | Fable.Number(Int32, _) -> true
        | _ -> false

    // Float64 is a plain Python `float`, which IS an IEEE double, so arithmetic needs
    // no adjustment. Only division by zero and remainder diverge.
    let isFloat64 =
        match t with
        | Fable.Number(Float64, _) -> true
        | _ -> false

    /// A literal divisor that is known not to be zero lets `/` stay a bare operator.
    let isNonZeroLiteral (e: Fable.Expr) =
        match e with
        | Fable.Value(Fable.NumberConstant(v, _), _) ->
            match v with
            | Fable.NumberValue.Float64 x -> x <> 0.0 && not (Double.IsNaN x)
            | Fable.NumberValue.Int32 x -> x <> 0
            | _ -> false
        | _ -> false

    match opKind with
    | Fable.Unary(op, (operand: Fable.Expr)) ->
        let expr, stmts = com.TransformAsExpr(ctx, operand)

        // Only negation can leave the range, at Int32.MinValue. `~` maps in-range to
        // in-range, and `+` is the identity.
        let needsWrap = isInt32 && op = UnaryMinus

        let expr =
            if needsWrap then
                stripInt32Wrap com ctx expr
            else
                expr

        let result = Expression.unaryOp (op, expr, ?loc = range)

        (if needsWrap then
             wrapInt32 com ctx range result
         else
             result),
        stmts
    | Fable.Binary(op, left, right: Fable.Expr) ->
        let typ = right.Type
        let left_typ = left.Type
        let leftFable, rightFable = left, right

        // `<<` shifts the left operand only; the shift count is a separate value.
        let wrapsResult =
            isInt32
            && match op with
               | BinaryPlus
               | BinaryMinus
               | BinaryMultiply
               | BinaryShiftLeft -> true
               | _ -> false

        let left, stmts = com.TransformAsExpr(ctx, left)
        let right, stmts' = com.TransformAsExpr(ctx, right)

        // Strip an operand's own wrap only when this node re-applies one, and only
        // when the *Fable* operand is one of the nodes this module wraps.
        let left =
            if wrapsResult && isInt32WrapOp leftFable then
                stripInt32Wrap com ctx left
            else
                left

        let right =
            if wrapsResult && op <> BinaryShiftLeft && isInt32WrapOp rightFable then
                stripInt32Wrap com ctx right
            else
                right

        // .NET masks a shift count to the width of the type, so `1 <<< 32` is 1.
        // Python applies the count as given, and raises ValueError if it is negative.
        let right =
            let isShift =
                match op with
                | BinaryShiftLeft
                | BinaryShiftRightSignPropagating
                | BinaryShiftRightZeroFill -> true
                | _ -> false

            if not (isInt32 && isShift) then
                right
            else
                match right with
                | Expression.Constant(value = IntLiteral v) ->
                    match v with
                    | :? int as i -> Expression.intConstant (i &&& 31)
                    | _ -> Expression.binOp (right, BitAnd, Expression.intConstant 31)
                | _ -> Expression.binOp (right, BitAnd, Expression.intConstant 31)

        // `op` is shadowed inside `binOp` by the Python operator, so resolve the guard
        // against the Fable node out here.
        let rangeGuard =
            if wrapsResult then
                tryInt32RangeGuard op leftFable rightFable
            else
                None

        // When no operand test is available -- neither side is a literal, or the moving
        // side is something costlier than a name -- bind the result once and test that
        // instead. The test is on the *result*, so it is correct whatever the operands
        // hold; `bothOperandsNormalized` is purely about whether it pays. Only worth it
        // where overflow is the exception rather than the rule, so it is limited to a
        // single `+`/`-` over two already-normalized operands: that is one bit of
        // possible overflow, where hash mixing and the like build up far more and would
        // pay the test on every evaluation without saving the call.
        //
        // The binding is an assignment expression, which is a `SyntaxError` inside a
        // comprehension's iterable, so an `[<Emit>]` macro argument keeps the call.
        let resultGuard =
            let bothOperandsNormalized =
                int32ExprBitWidth leftFable = 32 && int32ExprBitWidth rightFable = 32

            match op with
            | (BinaryPlus | BinaryMinus) when
                wrapsResult
                && rangeGuard.IsNone
                && bothOperandsNormalized
                && not ctx.InEmitMacroArgument
                ->
                getUniqueNameInDeclarationScope ctx "tmp" |> Some
            | _ -> None

        let binOp (op: BinaryOperator) =
            let result = Expression.binOp (left, op, right, ?loc = range)

            (match rangeGuard, resultGuard, wrapsResult with
             | Some(identIsLeft, cmp, threshold), _, _ ->
                 let ident =
                     if identIsLeft then
                         left
                     else
                         right

                 let test =
                     Expression.compare (ident, [ cmp ], [ Expression.intConstant threshold ], ?loc = range)

                 Expression.ifExp (test, result, wrapInt32 com ctx range result, ?loc = range)
             | None, Some name, _ ->
                 let tmp = com.GetIdentifierAsExpr(ctx, name)

                 // `-2147483648 <= (tmp := <op>) <= 2147483647`. The binding sits in the
                 // test because a conditional expression evaluates its condition first.
                 let test =
                     Expression.compare (
                         Expression.intConstant -2147483648,
                         [ LtE; LtE ],
                         [ Expression.namedExpr (tmp, result); Expression.intConstant 2147483647 ],
                         ?loc = range
                     )

                 Expression.ifExp (test, tmp, wrapInt32 com ctx range tmp, ?loc = range)
             | None, None, true -> wrapInt32 com ctx range result
             | None, None, false -> result),
            stmts @ stmts'

        let compare op =
            Expression.compare (left, [ op ], [ right ], ?loc = range), stmts @ stmts'

        let (|IsNone|_|) =
            function
            | Name { Id = Identifier "None" } -> Some()
            | _ -> None

        let strict =
            match tags with
            | Fable.Tags.Contains "strict" -> true
            | _ -> false

        match op, strict with
        | BinaryEqual, true ->
            match left, right with
            // Use == with literals
            | Constant _, _ -> compare Eq
            | _, Constant _ -> compare Eq
            | _ -> compare Is
        | BinaryEqual, false ->
            match left, right with
            // Use == with literals
            | Constant _, _ -> compare Eq
            | _, Constant _ -> compare Eq
            // Use `is` with None (except literals)
            | _, IsNone -> compare Is
            | IsNone, _ -> compare Is
            // Use == for the rest
            | _ -> compare Eq
        | BinaryUnequal, true ->
            match left, right with
            // Use == with literals
            | Constant _, _ -> compare NotEq
            | _, Constant _ -> compare NotEq
            | _ -> compare IsNot
        | BinaryUnequal, false ->
            match left, right with
            // Use != with literals
            | Constant _, _ -> compare NotEq
            | _, Constant _ -> compare NotEq
            // Use `is not` with None (except literals)
            | _, IsNone -> compare IsNot
            | IsNone, _ -> compare IsNot
            // Use != for the rest
            | _ -> compare NotEq
        | BinaryLess, _ -> compare Lt
        | BinaryLessOrEqual, _ -> compare LtE
        | BinaryGreater, _ -> compare Gt
        | BinaryGreaterOrEqual, _ -> compare GtE
        | BinaryDivide, _ ->
            // For integer division, we need to use the // operator
            match typ with
            // Int32 is a plain Python `int`, whose `//` floors where .NET truncates
            // toward zero: `-7 // 2` is -4 in Python and -3 in .NET. `int(a / b)`
            // truncates, and is exact here -- for int32 operands the true quotient is
            // never within a rounding error of an integer it should not reach.
            | Fable.Number(Int32, _) when isInt32 ->
                Expression.call (
                    Expression.name "int",
                    [ Expression.binOp (left, Div, right, ?loc = range) ],
                    ?loc = range
                ),
                stmts @ stmts'
            | Fable.Number(Int8, _)
            | Fable.Number(Int16, _)
            | Fable.Number(Int32, _)
            | Fable.Number(Int64, _)
            | Fable.Number(UInt8, _)
            | Fable.Number(UInt16, _)
            | Fable.Number(UInt32, _)
            | Fable.Number(UInt64, _) ->
                // In .NET we only get floor division for left integers on the left
                match left_typ with
                | Fable.Number(Float32, _)
                | Fable.Number(Float64, _) -> Expression.binOp (left, Div, right, ?loc = range), stmts @ stmts'
                | _ -> Expression.binOp (left, FloorDiv, right, ?loc = range), stmts @ stmts'
            // Python raises ZeroDivisionError where .NET yields +/-inf or nan
            | Fable.Number(Float64, _) when isFloat64 && not (isNonZeroLiteral rightFable) ->
                libCall com ctx range "core" "op_division_float64" [ left; right ], stmts @ stmts'
            | _ -> Expression.binOp (left, op, right, ?loc = range), stmts @ stmts'
        | BinaryModulus, _ when isFloat64 ->
            // Python's float `%` takes the sign of the divisor, .NET's takes the sign
            // of the dividend, and Python raises on a zero divisor where .NET gives nan.
            libCall com ctx range "core" "op_remainder_float64" [ left; right ], stmts @ stmts'
        | BinaryModulus, _ when isInt32 ->
            // Python's `%` takes the sign of the divisor, .NET's takes the sign of the
            // dividend: `-5 % 3` is 1 in Python and -2 in .NET.
            libCall com ctx range "core" "op_remainder_int32" [ left; right ], stmts @ stmts'
        | _ -> binOp op

    | Fable.Logical(op, TransformExpr com ctx (left, stmts), TransformExpr com ctx (right, stmts')) ->
        Expression.boolOp (op, [ left; right ], ?loc = range), stmts @ stmts'

let transformEmit (com: IPythonCompiler) ctx range (info: Fable.EmitInfo) =
    let macro = info.Macro
    let callInfo = info.CallInfo

    // The macro text is spliced around the arguments verbatim, and a macro is free to
    // put one inside a comprehension -- `[x for i, x in enumerate(f($0, $1))]` and the
    // like -- where an assignment expression is a `SyntaxError` rather than a value.
    // Nothing anywhere under such an argument may use one, hence a context flag rather
    // than a check on this node. `for` is what makes a comprehension a comprehension,
    // so a macro without it cannot contain one; a macro with it in some other role
    // just gives up an optimization.
    let argCtx =
        if Regex.IsMatch(macro, @"\bfor\b") then
            { ctx with InEmitMacroArgument = true }
        else
            ctx

    let thisArg, stmts =
        callInfo.ThisArg
        |> Option.map (fun e -> com.TransformAsExpr(argCtx, e))
        |> Option.toList
        |> Helpers.unzipArgs

    let exprs, kw, stmts' = transformCallArgs com argCtx callInfo false

    if macro.StartsWith("functools", StringComparison.Ordinal) then
        com.GetImportExpr(ctx, "functools") |> ignore

    let args = exprs |> List.append thisArg

    // Handle EmitMethod, EmitConstructor and other emit macros that need keywords
    match kw with
    | [] ->
        // No keywords, use regular emit expression
        emitExpression range macro args, stmts @ stmts'
    | _ ->
        // Handle emit patterns with keywords
        match tryParseEmitMethodMacro macro with
        | Some methodName ->
            match thisArg with
            | obj :: _ ->
                let methodCall = Expression.attribute (obj, Identifier methodName)
                callFunction range methodCall exprs kw, stmts @ stmts'
            | [] ->
                // Fallback to emit if no this arg
                emitExpression range macro args, stmts @ stmts'
        | None ->
            // Try EmitConstructor pattern
            match tryParseEmitConstructorMacro macro with
            | Some() ->
                match thisArg with
                | constructorExpr :: _ ->
                    // Handle EmitConstructor with keywords: new Constructor(keywords)
                    callFunction range constructorExpr exprs kw, stmts @ stmts'
                | [] ->
                    // Fallback to emit if no constructor expression
                    emitExpression range macro args, stmts @ stmts'
            | None ->
                // For other emit patterns with keywords, fallback to emit (might lose keywords)
                emitExpression range macro args, stmts @ stmts'

/// Unwrap to_enumerable from a Python expression if present
/// make_dict can handle Python iterables directly, so we can skip the wrapper
let unwrapToEnumerable (expr: Expression) =
    match expr with
    | Expression.Call {
                          Func = Expression.Name { Id = Identifier "to_enumerable" }
                          Args = [ innerArg ]
                      } -> innerArg
    | _ -> expr

let transformCall (com: IPythonCompiler) ctx range callee (callInfo: Fable.CallInfo) : Expression * Statement list =
    // printfn "transformCall: %A" (callee, callInfo)

    // Optimization: Unwrap to_enumerable for make_dict calls since make_dict can handle Python iterables directly
    match callee with
    | Fable.Import({
                       Selector = "make_dict"
                       Kind = Fable.LibraryImport _
                   },
                   _,
                   _) ->
        let callee', stmts = com.TransformAsExpr(ctx, callee)
        let args, kw, stmts' = transformCallArgs com ctx callInfo false
        // Unwrap to_enumerable from the argument if present
        let args = args |> List.map unwrapToEnumerable
        callFunction range callee' args kw, stmts @ stmts'

    // Optimization: a fixed-width conversion re-truncates the bits its operand's own
    // `int32(...)` wrap kept, so the wrap is dead. See `Util.tryRedundantInt32Wrap`.
    | RedundantInt32Wrap com callInfo elision ->
        let callee', stmts = com.TransformAsExpr(ctx, callee)

        // An inner conversion is already a Fable node, so it is dropped before being
        // transformed -- which keeps the `core.int32` it would have emitted from being
        // registered as an import and then left unreferenced. Arity and argument kind
        // are unchanged: one non-unit fixed-width integer either way. An arithmetic
        // tree is only normalized once transformed, so that wrap comes off after.
        let callInfo =
            match elision with
            | UseInnerOperand operand -> { callInfo with Args = [ operand ] }
            | StripTransformedWrap -> callInfo

        let args, kw, stmts' = transformCallArgs com ctx callInfo false

        let args =
            match elision with
            | UseInnerOperand _ -> args
            | StripTransformedWrap -> args |> List.map (stripInt32Wrap com ctx)

        callFunction range callee' args kw, stmts @ stmts'
    | _ ->

        let callee', stmts = com.TransformAsExpr(ctx, callee)

        let args, kw, stmts' = transformCallArgs com ctx callInfo false

        match callee, callInfo.ThisArg with
        | Fable.Get(expr, Fable.FieldGet { Name = "Dispose" }, _, _), _ ->
            let expr, stmts'' = com.TransformAsExpr(ctx, expr)

            libCall com ctx range "util" "dispose" [ expr ], stmts @ stmts' @ stmts''
        | Fable.Get(expr, Fable.FieldGet { Name = "set" }, _, _), _ ->
            // printfn "Type: %A" expr.Type
            Expression.withStmts {
                let! right = com.TransformAsExpr(ctx, callInfo.Args.Head)
                let! arg = com.TransformAsExpr(ctx, callInfo.Args.Tail.Head)
                let! value = com.TransformAsExpr(ctx, expr)
                return! Expression.none, [ Statement.assign ([ Expression.subscript (value, right) ], arg) ]
            }
        | Fable.Get(_, Fable.FieldGet { Name = "sort" }, _, _), _ -> callFunction range callee' [] kw, stmts @ stmts'

        | _, Some(TransformExpr com ctx (thisArg, stmts'')) ->
            callFunction range callee' (thisArg :: args) kw, stmts @ stmts' @ stmts''
        | _, None when List.contains "new" callInfo.Tags ->
            Expression.call (callee', args, kw, ?loc = range), stmts @ stmts'
        | _, None -> callFunction range callee' args kw, stmts @ stmts'

let transformCurriedApply com ctx range (TransformExpr com ctx (applied, stmts)) args =
    ((applied, stmts), args)
    ||> List.fold (fun (applied, stmts) arg ->
        let args, argStmts =
            match arg with
            // TODO: If arg type is unit but it's an expression with potential
            // side-effects, we need to extract it and execute it before the call

            // TODO: discardUnitArg may still be needed in some cases
            | Fable.Value(Fable.UnitConstant, _) -> [], []
            | Fable.IdentExpr ident when ident.Type = Fable.Unit -> [], []
            | arg ->
                let argExpr, transformStmts = com.TransformAsExpr(ctx, arg)
                // When a Call or CurriedApply result is passed as an argument,
                // check if we need to erase Option[T] to T | None
                let argExpr =
                    if needsOptionEraseForBinding arg arg.Type then
                        wrapInOptionErase com ctx argExpr
                    else
                        argExpr

                [ argExpr ], transformStmts

        callFunction range applied args [], stmts @ argStmts
    )

/// Extract the expected return type from a return strategy, unwrapping ResourceManager if needed
let rec private getExpectedReturnType (strategy: ReturnStrategy option) =
    match strategy with
    | Some(Return(Some expectedType)) -> Some expectedType
    | Some(ResourceManager inner) -> getExpectedReturnType inner
    | _ -> None

let transformCallAsStatements com ctx range t returnStrategy callee callInfo =
    let argsLen (i: Fable.CallInfo) =
        List.length i.Args
        + (if Option.isSome i.ThisArg then
               1
           else
               0)
    // Warn when there's a recursive call that couldn't be optimized?
    match returnStrategy, ctx.TailCallOpportunity with
    | Some(Return _ | ReturnUnit), Some tc when tc.IsRecursiveRef(callee) && argsLen callInfo = List.length tc.Args ->
        let args =
            match callInfo.ThisArg with
            | Some thisArg -> thisArg :: callInfo.Args
            | None -> callInfo.Args

        optimizeTailCall com ctx range tc args
    | _ ->
        let expr, stmts = transformCall com ctx range callee callInfo
        // Check if we need to cast Option[T] to T | None for return statements
        // Also handles ResourceManager-wrapped return strategies (e.g., inside `with` blocks)
        let expr =
            match getExpectedReturnType returnStrategy with
            | Some expectedType ->
                // Create a temporary Fable.Call to check if erase is needed
                let callExpr = Fable.Call(callee, callInfo, t, range)

                if needsOptionEraseForReturn callExpr expectedType then
                    wrapInOptionErase com ctx expr
                else
                    expr
            | None -> expr

        stmts @ (expr |> resolveExpr ctx t returnStrategy)

let transformCurriedApplyAsStatements com ctx range t returnStrategy callee args =
    // Warn when there's a recursive call that couldn't be optimized?
    match returnStrategy, ctx.TailCallOpportunity with
    | Some(Return _ | ReturnUnit), Some tc when tc.IsRecursiveRef(callee) && List.sameLength args tc.Args ->
        optimizeTailCall com ctx range tc args
    | _ ->
        let expr, stmts = transformCurriedApply com ctx range callee args
        stmts @ (expr |> resolveExpr ctx t returnStrategy)

let transformBody (_com: IPythonCompiler) ctx _ret (body: Statement list) : Statement list =
    match body with
    | [] -> [ Pass ]
    | _ ->
        let nonLocals, body = getNonLocals ctx body
        nonLocals @ body

// When expecting a block, it's usually not necessary to wrap it
// in a lambda to isolate its variable context
let transformBlock (com: IPythonCompiler) ctx ret (expr: Fable.Expr) : Statement list =
    let block =
        com.TransformAsStatements(ctx, ret, expr)
        |> List.choose Helpers.isProductiveStatement

    match block with
    | [] -> [ Pass ]
    | _ -> block |> transformBody com ctx ret

/// Get the Python expression for an exception type
let private getExceptionTypeExpr (com: IPythonCompiler) ctx =
    function
    | Fable.DeclaredType(entRef, _) -> Annotation.tryPyConstructor com ctx (com.GetEntity(entRef))
    | _ -> None

let transformTryCatch com (ctx: Context) r returnStrategy (body, catch: (Fable.Ident * Fable.Expr) option, finalizer) =
    // try .. catch statements cannot be tail call optimized
    let ctx = { ctx with TailCallOpportunity = None }

    let makeHandler exnType handlerBody (param: Fable.Ident) identifier =
        let (Identifier identName) = identifier

        // Python's `except E as name:` deletes `name` at the end of the except block.
        // If the exception variable is used (e.g., captured in a deferred closure), copy
        // it to a safe local with a unique name that Python won't delete, and rename all
        // body references to use the safe copy.
        if isIdentUsed param.Name handlerBody then
            let safeIdentName = getUniqueNameInDeclarationScope ctx (identName + "_")
            let safeParam = { param with Name = safeIdentName }

            let renamedBody =
                FableTransforms.replaceValues (Map [ param.Name, Fable.IdentExpr safeParam ]) handlerBody

            let transformedBody = transformBlock com ctx returnStrategy renamedBody
            // Annotated assignment: ex_: ExceptionType = ex
            let saveStmt =
                Statement.assign (identAsExpr com ctx safeParam, exnType, value = Expression.name identName)

            ExceptHandler.exceptHandler (``type`` = Some exnType, name = identifier, body = saveStmt :: transformedBody)
        else
            let transformedBody = transformBlock com ctx returnStrategy handlerBody
            ExceptHandler.exceptHandler (``type`` = Some exnType, name = identifier, body = transformedBody)

    let handlers, handlerStmts =
        match catch with
        | None -> None, []
        | Some(param, catchBody) ->
            let identifier = ident com ctx param

            let extractedHandlers, fallback =
                ExceptionHandling.extractExceptionHandlers catchBody

            match extractedHandlers with
            | [] ->
                // No type tests found, use Exception to match F#/.NET semantics.
                // Users can explicitly catch KeyboardInterrupt, SystemExit, GeneratorExit
                // using type tests if needed.
                let handler =
                    makeHandler (Expression.identifier "Exception") catchBody param identifier

                Some [ handler ], []

            | _ ->
                // Generate separate except clauses for each exception type
                let handlers, stmts =
                    extractedHandlers
                    |> List.choose (fun (typ, handlerBody) ->
                        getExceptionTypeExpr com ctx typ
                        |> Option.map (fun (exnTypeExpr, stmts) ->
                            makeHandler exnTypeExpr handlerBody param identifier, stmts
                        )
                    )
                    |> List.unzip

                // Add fallback handler if fallback is not just a reraise
                // Use Exception to match F#/.NET semantics
                let fallbackHandlers =
                    match fallback with
                    | Some fallbackExpr when not (ExceptionHandling.isReraise fallbackExpr) ->
                        [
                            makeHandler (Expression.identifier "Exception") fallbackExpr param identifier
                        ]
                    | _ -> []

                Some(handlers @ fallbackHandlers), List.concat stmts

    let finalizer, finalizerStmts =
        finalizer
        |> Option.map (fun fin ->
            transformBlock com ctx None fin
            |> List.partition (
                function
                | Statement.NonLocal _
                | Statement.Global _ -> false
                | _ -> true
            )
        )
        |> Option.defaultValue ([], [])

    handlerStmts
    @ finalizerStmts
    @ [
        Statement.try' (
            transformBlock com ctx returnStrategy body,
            ?handlers = handlers,
            finalBody = finalizer,
            ?loc = r
        )
    ]

/// Helper function to generate a cast statement for type narrowing.
/// Disabled: The isinstance() check in the if-guard already provides Pyright with
/// sufficient type narrowing. Generating `value = cast(T, value)` causes Python
/// UnboundLocalError when inside closures (e.g., task CE bodies), because the
/// assignment makes Python treat the variable as local throughout the function.
let makeCastStatement (_com: IPythonCompiler) _ctx (_ident: Fable.Ident) (_typ: Fable.Type) = []

let rec transformIfStatement (com: IPythonCompiler) ctx r ret guardExpr thenStmnt elseStmnt =
    // Create refined context for then/else branches based on guard type
    let thenCtx, elseCtx = getNarrowedContexts ctx guardExpr

    let expr, stmts = com.TransformAsExpr(ctx, guardExpr)

    match expr with
    | Constant(value = BoolLiteral value) ->
        let e =
            if value then
                thenStmnt
            else
                elseStmnt

        stmts @ com.TransformAsStatements(ctx, ret, e)
    | guardExprPy ->
        let thenStmnt, stmts' =
            let thenBlockStmts = transformBlock com thenCtx ret thenStmnt

            // Add cast statement at the beginning of then branch for type tests
            let thenStmtsWithCast =
                match guardExpr with
                | Fable.Test(Fable.IdentExpr ident, Fable.TypeTest typ, _) ->
                    let castStmts = makeCastStatement com ctx ident typ
                    castStmts @ thenBlockStmts
                | _ -> thenBlockStmts

            thenStmtsWithCast
            |> List.partition (
                function
                | Statement.NonLocal _
                | Statement.Global _ -> false
                | _ -> true
            )

        let ifStatement, stmts'' =
            let block, stmts =
                transformBlock com elseCtx ret elseStmnt
                |> List.partition (
                    function
                    | Statement.NonLocal _
                    | Statement.Global _ -> false
                    | _ -> true
                )

            match block with
            | [] -> Statement.if' (guardExprPy, thenStmnt, ?loc = r), stmts
            | [ elseStmnt ] -> Statement.if' (guardExprPy, thenStmnt, [ elseStmnt ], ?loc = r), stmts
            | statements -> Statement.if' (guardExprPy, thenStmnt, statements, ?loc = r), stmts

        stmts @ stmts' @ stmts'' @ [ ifStatement ]


let transformGet (com: IPythonCompiler) ctx range typ (fableExpr: Fable.Expr) kind =
    // printfn "transformGet: %A" kind
    // printfn "transformGet: %A" (fableExpr.Type)

    match kind with
    | Fable.ExprGet(TransformExpr com ctx (prop, stmts)) ->
        let expr, stmts' =
            Expression.withStmts {
                let! expr = com.TransformAsExpr(ctx, fableExpr)
                let! finalExpr = getExpr com ctx range expr prop
                return finalExpr
            }

        expr, stmts @ stmts'

    | Fable.FieldGet i ->
        // Use effective type for field naming (considers type refinement)
        let narrowedType =
            match fableExpr with
            | Fable.IdentExpr ident -> getNarrowedType ctx ident |> Replacements.Util.getIdentValueType com ident
            | _ -> fableExpr.Type

        let fieldName = Util.applyFieldNaming com narrowedType i.Name true

        let fableExpr =
            match fableExpr with
            // If we're accessing a virtual member with default implementation (see #701)
            // from base class, we can use `super` in JS so we don't need the bound this arg
            | Fable.Value(Fable.BaseValue(_, t), r) -> Fable.Value(Fable.BaseValue(None, t), r)
            | _ -> fableExpr

        let expr, stmts = com.TransformAsExpr(ctx, fableExpr)

        let subscript =
            match fableExpr.Type with
            | Fable.AnonymousRecordType _ -> true
            | Fable.GenericParam(_, _, [ Fable.Constraint.HasMember(_, false) ]) -> true
            | _ -> false
        // printfn "Fable.FieldGet: %A" (fieldName, fableExpr.Type)
        get com ctx range expr fieldName subscript, stmts

    | Fable.ListHead ->
        // get range (com.TransformAsExpr(ctx, fableExpr)) "head"
        let expr, stmts = com.TransformAsExpr(ctx, fableExpr)
        libCall com ctx range "list" "head" [ expr ], stmts

    | Fable.ListTail ->
        // get range (com.TransformAsExpr(ctx, fableExpr)) "tail"
        let expr, stmts = com.TransformAsExpr(ctx, fableExpr)
        libCall com ctx range "list" "tail" [ expr ], stmts

    | Fable.TupleIndex index ->
        match fableExpr with
        // TODO: Check the erased expressions don't have side effects?
        | Fable.Value(Fable.NewTuple(exprs, _), _) -> com.TransformAsExpr(ctx, List.item index exprs)
        | TransformExpr com ctx (expr, stmts) ->
            let expr, stmts' = getExpr com ctx range expr (Expression.intConstant index)
            expr, stmts @ stmts'

    | Fable.OptionValue ->
        let expr, stmts = com.TransformAsExpr(ctx, fableExpr)

        if mustWrapOption typ then
            libCall com ctx range "option" "value" [ expr ], stmts
        else
            // For concrete types, Python erases Option[T] to T | None.
            // Use option.value() when the expression is a function call (not narrowable by Pyright)
            // but skip it for idents (Pyright can narrow via isinstance/is not None checks)
            match fableExpr with
            | Fable.IdentExpr _ -> expr, stmts
            | _ -> libCall com ctx range "option" "value" [ expr ], stmts

    | Fable.UnionTag ->
        let expr, stmts = getUnionExprTag com ctx range fableExpr
        expr, stmts

    | Fable.UnionField i ->
        Expression.withStmts {
            let! baseExpr = com.TransformAsExpr(ctx, fableExpr)
            // Read the field directly by name (`x.width_`) instead of going through the
            // `.fields` property (`x.fields[i]`), which rebuilds an Array on every access.
            let ent = com.GetEntity(i.Entity)
            let uci = ent.UnionCases |> List.item i.CaseIndex
            let field = uci.UnionCaseFields |> List.item i.FieldIndex
            let fieldName = field.Name |> Naming.toFieldSnakeCase |> Helpers.clean
            // `fableExpr` is statically typed as the union base, which doesn't declare this
            // field, so tell Pyright which case class we're reading from via the library's
            // `narrow` helper (a no-op at runtime). Keeping the "cast" inside `narrow`
            // leaves generated code cast-free and preserves reportUnnecessaryCast.
            let caseRef = getUnionCaseRef com ctx i.Entity ent uci
            let narrow = libValue com ctx "union" "narrow"
            let narrowedExpr = Expression.call (narrow, [ caseRef; baseExpr ])

            let! finalExpr =
                getExpr com ctx range narrowedExpr (Expression.stringConstant fieldName)

            return finalExpr
        }

let transformSet (com: IPythonCompiler) ctx range fableExpr typ (value: Fable.Expr) kind =
    // Normal handling for all assignments - StaticPropertyMeta will handle static properties
    //printfn "transformSet: %A" kind
    let expr, stmts = com.TransformAsExpr(ctx, fableExpr)

    let value, stmts' =
        let value, st = com.TransformAsExpr(ctx, value)
        value |> wrapIntExpression typ, st

    let ret, stmts'' =
        match kind with
        | Fable.ValueSet -> expr, []
        | Fable.ExprSet(TransformExpr com ctx (e, stmts'')) ->
            let expr, stmts''' = getExpr com ctx None expr e
            expr, stmts'' @ stmts'''
        | Fable.FieldSet fieldName ->
            // Try to get the naming convention from the narrowed type (considers type refinement)
            let narrowedType =
                match fableExpr with
                | Fable.IdentExpr ident -> getNarrowedType ctx ident
                | _ -> fableExpr.Type

            let finalFieldName = Util.applyFieldNaming com narrowedType fieldName false
            let cleanFieldName = finalFieldName |> Helpers.clean
            get com ctx None expr cleanFieldName false, []

    assign range ret value, stmts @ stmts' @ stmts''

let transformBindingExprBody (com: IPythonCompiler) (ctx: Context) (var: Fable.Ident) (value: Fable.Expr) =
    match value with
    | Function(args, body) ->
        let name = Some var.Name

        let args', body', returnType, typeParams =
            Annotation.transformFunctionWithAnnotations com ctx name args body

        makeArrowFunctionExpression com ctx name (Some body.Type) args' body' returnType typeParams
    | _ ->
        let expr, stmt = com.TransformAsExpr(ctx, value)
        expr |> wrapIntExpression value.Type, stmt

let transformBindingAsExpr (com: IPythonCompiler) ctx (var: Fable.Ident) (value: Fable.Expr) =
    // printfn "transformBindingAsExpr: %A" (var, value)
    let expr, stmts = transformBindingExprBody com ctx var value
    expr |> assign None (identAsExpr com ctx var), stmts

let transformBindingAsStatements (com: IPythonCompiler) ctx (var: Fable.Ident) (value: Fable.Expr) =
    let varType = Replacements.Util.getIdentValueType com var var.Type
    let shouldTreatAsStatement = isPyStatement ctx false value
    let needsErase = needsOptionEraseForBinding value var.Type
    // Skip type annotation to avoid Option[T] vs T | None mismatch issues with Pyright:
    // 1. When extracting from invariant containers (Array, List) with Options
    // 2. When assigning from a wrapped option after None check (narrowing issue)
    let skipAnnotation =
        valueExtractsFromInvariantContainer value var.Type
        || isWrappedOptionNarrowingAssignment value

    if shouldTreatAsStatement then
        let varName, varExpr = Expression.name var.Name, identAsExpr com ctx var

        ctx.BoundVars.Bind(var.Name)

        if skipAnnotation then
            // No type annotation - let Python infer from function return type
            let body = com.TransformAsStatements(ctx, Some(Assign varExpr), value)
            body
        else
            let ta, stmts = Annotation.typeAnnotation com ctx None varType
            let decl = Statement.assign (varName, ta)
            let body = com.TransformAsStatements(ctx, Some(Assign varExpr), value)
            stmts @ [ decl ] @ body
    else
        let expr, stmts = transformBindingExprBody com ctx var value
        let varName = com.GetIdentifierAsExpr(ctx, Naming.toPythonNaming var.Name)

        if skipAnnotation then
            // No type annotation - let Python infer from function return type
            let decl = varDeclaration ctx varName None expr
            stmts @ decl
        else
            let ta, stmts' = Annotation.typeAnnotation com ctx None varType
            // Erase Option wrapper if needed (zero runtime overhead, just for type checker)
            let expr' =
                if needsErase then
                    wrapInOptionErase com ctx expr
                else
                    expr

            let value' = wrapNoneInCast com ctx expr' ta
            let decl = varDeclaration ctx varName (Some ta) value'
            stmts @ stmts' @ decl

let transformTest (com: IPythonCompiler) ctx range kind expr : Expression * Statement list =
    match kind with
    | Fable.TypeTest t -> transformTypeTest com ctx range expr t

    | Fable.OptionTest nonEmpty ->
        let op =
            if nonEmpty then
                IsNot
            else
                Is

        let expr, stmts = com.TransformAsExpr(ctx, expr)

        Expression.compare (expr, [ op ], [ Expression.none ], ?loc = range), stmts

    | Fable.ListTest nonEmpty ->
        let expr, stmts = com.TransformAsExpr(ctx, expr)
        let expr = libCall com ctx range "list" "isEmpty" [ expr ]

        if nonEmpty then
            Expression.unaryOp (UnaryNot, expr, ?loc = range), stmts
        else
            expr, stmts

    | Fable.UnionCaseTest tag ->
        let expected = ofInt com ctx tag
        let actual, stmts = getUnionExprTag com ctx None expr

        Expression.compare (actual, [ Eq ], [ expected ], ?loc = range), stmts

let transformSwitch (com: IPythonCompiler) ctx _useBlocks returnStrategy evalExpr cases defaultCase : Statement list =
    let cases =
        cases
        |> List.collect (fun (guards, expr) ->
            // Remove empty branches
            match returnStrategy, expr, guards with
            | None, Fable.Value(Fable.UnitConstant, _), _
            | _, _, [] -> []
            | _, _, guards ->
                let guards, lastGuard = List.splitLast guards

                let guards =
                    guards
                    |> List.map (fun e ->
                        let expr, stmts = com.TransformAsExpr(ctx, e)
                        (stmts, Some expr)
                    )

                let caseBody = com.TransformAsStatements(ctx, returnStrategy, expr)

                let caseBody =
                    match returnStrategy with
                    | Some(Return _) -> caseBody
                    | _ -> List.append caseBody [ Statement.break' () ]

                let expr, stmts = com.TransformAsExpr(ctx, lastGuard)
                guards @ [ (stmts @ caseBody, Some expr) ]
        )

    let cases =
        match defaultCase with
        | Some expr ->
            let defaultCaseBody = com.TransformAsStatements(ctx, returnStrategy, expr)

            cases @ [ (defaultCaseBody, None) ]
        | None -> cases

    let value, stmts = com.TransformAsExpr(ctx, evalExpr)

    let rec ifThenElse
        (fallThrough: Expression option)
        (cases: (Statement list * Expression option) list)
        : Statement list
        =
        match cases with
        | [] -> []
        | (body, test) :: cases ->
            match test with
            | None -> body
            | Some test ->
                let expr = Expression.compare (left = value, ops = [ Eq ], comparators = [ test ])

                let test =
                    match fallThrough with
                    | Some ft -> Expression.boolOp (op = Or, values = [ ft; expr ])
                    | _ -> expr

                // Check for fallthrough
                if body.IsEmpty then
                    ifThenElse (Some test) cases
                else
                    // Remove any break statements from body
                    let body =
                        body
                        |> List.filter (
                            function
                            | Statement.Break -> false
                            | _ -> true
                        )
                        |> Util.ensureNonEmptyBody

                    let nonLocals, body = getNonLocals ctx body

                    let nonLocals, orElse =
                        ifThenElse None cases |> List.append nonLocals |> getNonLocals ctx

                    nonLocals @ [ Statement.if' (test = test, body = body, orelse = orElse) ]

    let result = cases |> ifThenElse None

    match result with
    | [] -> []
    | ifStmt -> stmts @ ifStmt

let matchTargetIdentAndValues idents values =
    if List.isEmpty idents then
        []
    elif List.sameLength idents values then
        List.zip idents values
    else
        failwith "Target idents/values lengths differ"

let getDecisionTargetAndBoundValues (com: IPythonCompiler) (ctx: Context) targetIndex boundValues =
    let idents, target = getDecisionTarget ctx targetIndex
    let identsAndValues = matchTargetIdentAndValues idents boundValues

    if not com.Options.DebugMode then
        let bindings, replacements =
            (([], Map.empty), identsAndValues)
            ||> List.fold (fun (bindings, replacements) (ident, expr) ->
                // Only inline if the expression has no side effects AND is referenced at most once.
                // If referenced multiple times, we should bind to a variable to avoid duplicating
                // the expression (which can cause issues like accessing properties on literals).
                let refCount = FableTransforms.countReferencesUntil 2 ident.Name target

                if canHaveSideEffects com expr || refCount > 1 then
                    (ident, expr) :: bindings, replacements
                else
                    bindings, Map.add ident.Name expr replacements
            )

        let target = FableTransforms.replaceValues replacements target
        target, List.rev bindings
    else
        target, identsAndValues

let transformDecisionTreeSuccessAsExpr (com: IPythonCompiler) (ctx: Context) targetIndex boundValues =
    let target, bindings =
        getDecisionTargetAndBoundValues com ctx targetIndex boundValues

    match bindings with
    | [] -> com.TransformAsExpr(ctx, target)
    | bindings ->
        let target =
            List.rev bindings |> List.fold (fun e (i, v) -> Fable.Let(i, v, e)) target

        com.TransformAsExpr(ctx, target)

let exprAsStatement (ctx: Context) (expr: Expression) : Statement list =
    // printfn "exprAsStatement: %A" expr
    match expr with
    // A single None will be removed (i.e transformCall may return None)
    | Name { Id = Identifier "None" } -> []
    | NamedExpr({
                    Target = target
                    Value = value
                    Loc = _
                }) ->
        let nonLocals =
            match target with
            | Expression.Name { Id = id } -> ctx.BoundVars.NonLocals([ id ]) |> Statement.nonLocal |> List.singleton
            | _ -> []

        // printfn "Nonlocals: %A" nonLocals
        nonLocals @ [ Statement.assign ([ target ], value) ]
    | _ -> [ Statement.expr expr ]

let transformDecisionTreeSuccessAsStatements
    (com: IPythonCompiler)
    (ctx: Context)
    returnStrategy
    targetIndex
    boundValues
    : Statement list
    =
    match returnStrategy with
    | Some(Target targetId) as _target ->
        let idents, _ = getDecisionTarget ctx targetIndex

        let assignments =
            matchTargetIdentAndValues idents boundValues
            |> List.collect (fun (id, TransformExpr com ctx (value, stmts)) ->
                let stmts' = assign None (identAsExpr com ctx id) value |> exprAsStatement ctx

                stmts @ stmts'
            )

        let targetAssignment =
            assign None (targetId |> Expression.name) (ofInt com ctx targetIndex)
            |> exprAsStatement ctx

        targetAssignment @ assignments
    | ret ->
        let target, bindings =
            getDecisionTargetAndBoundValues com ctx targetIndex boundValues

        let bindings =
            bindings
            |> Seq.collect (fun (i, v) -> transformBindingAsStatements com ctx i v)
            |> Seq.toList

        bindings @ com.TransformAsStatements(ctx, ret, target)

let transformDecisionTreeAsSwitch expr =
    let (|Equals|_|) =
        function
        | Fable.Operation(Fable.Binary(BinaryEqual, left, right), _, _, _) ->
            // Return (evalExpr, caseExpr) where evalExpr is the thing being matched (identifier)
            // and caseExpr is the constant value
            // Try constant on right side first (more common: x == 1)
            match right with
            | Fable.Value((Fable.CharConstant _ | Fable.StringConstant _ | Fable.NumberConstant _), _) ->
                Some(left, right) // left is identifier, right is constant
            | _ ->
                // Try constant on left side (less common: 1 == x)
                match left with
                | Fable.Value((Fable.CharConstant _ | Fable.StringConstant _ | Fable.NumberConstant _), _) ->
                    Some(right, left) // right is identifier, left is constant
                | _ -> None
        | Fable.Test(expr, Fable.UnionCaseTest tag, _) ->
            let evalExpr =
                Fable.Get(expr, Fable.UnionTag, Fable.Number(Int32, Fable.NumberInfo.Empty), None)

            let right = makeIntConst tag
            Some(evalExpr, right)
        | _ -> None

    let sameEvalExprs evalExpr1 evalExpr2 =
        match evalExpr1, evalExpr2 with
        | Fable.IdentExpr i1, Fable.IdentExpr i2
        | Fable.Get(Fable.IdentExpr i1, Fable.UnionTag, _, _), Fable.Get(Fable.IdentExpr i2, Fable.UnionTag, _, _) ->
            i1.Name = i2.Name
        | _ -> false

    let rec checkInner cases evalExpr =
        function
        | Fable.IfThenElse(Equals(evalExpr2, caseExpr),
                           Fable.DecisionTreeSuccess(targetIndex, boundValues, _),
                           treeExpr,
                           _) when sameEvalExprs evalExpr evalExpr2 ->
            match treeExpr with
            | Fable.DecisionTreeSuccess(defaultTargetIndex, defaultBoundValues, _) ->
                let cases = (caseExpr, targetIndex, boundValues) :: cases |> List.rev
                Some(evalExpr, cases, (defaultTargetIndex, defaultBoundValues))
            | treeExpr -> checkInner ((caseExpr, targetIndex, boundValues) :: cases) evalExpr treeExpr
        | _ -> None

    match expr with
    | Fable.IfThenElse(Equals(evalExpr, caseExpr), Fable.DecisionTreeSuccess(targetIndex, boundValues, _), treeExpr, _) ->
        match checkInner [ caseExpr, targetIndex, boundValues ] evalExpr treeExpr with
        | Some(evalExpr, cases, defaultCase) -> Some(evalExpr, cases, defaultCase)
        | None -> None
    | _ -> None

// Re-export from Util for local use
let fableValueToPattern = MatchStatements.fableValueToPattern

/// Transforms bound values into binding statements by zipping idents with values.
/// Returns empty list if lengths don't match (defensive).
let private transformBindings com ctx (idents: Fable.Ident list) (boundValues: Fable.Expr list) =
    if List.length idents = List.length boundValues then
        List.zip idents boundValues
        |> List.collect (fun (ident, value) -> transformBindingAsStatements com ctx ident value)
    else
        []

/// Builds a default (wildcard) match case for the given target index.
let private buildDefaultMatchCase
    (com: IPythonCompiler)
    (ctx: Context)
    returnStrategy
    (targets: (Fable.Ident list * Fable.Expr) list)
    defaultIndex
    =
    let _idents, targetExpr = targets |> List.item defaultIndex
    let body = com.TransformAsStatements(ctx, returnStrategy, targetExpr)
    MatchCase.matchCase (Pattern.matchWildcard (), body)

/// Transforms a single guard case (debug mode) into a Python MatchCase with guard expression.
/// Returns None if the guard contains statements (not expressible as a Python guard).
let private transformDebugModeGuardCase
    (com: IPythonCompiler)
    (ctx: Context)
    returnStrategy
    (targets: (Fable.Ident list * Fable.Expr) list)
    (subjectName: string)
    (_subj, param, guardBody, targetIndex, _boundValues)
    =
    let idents, targetExpr = targets.[targetIndex]

    // Use the target's bound identifier for the pattern if available
    let patternIdent =
        match idents with
        | [ ident ] -> ident
        | _ -> param

    // Substitute param references with patternIdent in guard body if needed
    let guardBody' =
        if param.Name <> patternIdent.Name then
            FableTransforms.replaceValues (Map.ofList [ param.Name, Fable.IdentExpr patternIdent ]) guardBody
        else
            guardBody

    let guard, guardStmts = com.TransformAsExpr(ctx, guardBody')

    // Guards with statements cannot be expressed in Python match
    if not (List.isEmpty guardStmts) then
        None
    else
        let name = com.GetIdentifier(ctx, patternIdent.Name)
        let pattern = MatchAs(None, Some name)

        let targetExpr' =
            MatchStatements.unwrapRedundantLets subjectName patternIdent targetExpr

        let body = com.TransformAsStatements(ctx, returnStrategy, targetExpr')
        Some(MatchCase.matchCase (pattern, body, guard))

/// Transforms a single inlined guard case (release mode) into a Python MatchCase with guard expression.
/// In release mode, guards are inlined directly as comparison operations.
/// Returns None if the guard contains statements (not expressible as a Python guard).
let private transformReleaseModeGuardCase
    (com: IPythonCompiler)
    (ctx: Context)
    returnStrategy
    (targets: (Fable.Ident list * Fable.Expr) list)
    (subjectIdent: Fable.Ident)
    (guardCondition: Fable.Expr, targetIndex: int, _boundValues: Fable.Expr list)
    =
    let idents, targetExpr = targets.[targetIndex]

    // Use the target's bound identifier for the pattern if available
    let patternIdent =
        match idents with
        | [ ident ] -> ident
        | _ -> subjectIdent

    // Transform the guard condition
    let guard, guardStmts = com.TransformAsExpr(ctx, guardCondition)

    // Guards with statements cannot be expressed in Python match
    if not (List.isEmpty guardStmts) then
        None
    else
        let name = com.GetIdentifier(ctx, patternIdent.Name)
        let pattern = MatchAs(None, Some name)

        let targetExpr' =
            MatchStatements.unwrapRedundantLets subjectIdent.Name patternIdent targetExpr

        let body = com.TransformAsStatements(ctx, returnStrategy, targetExpr')
        Some(MatchCase.matchCase (pattern, body, guard))

/// Transforms debug mode guard pattern cases into a Python match statement.
let private transformDebugModeGuardPatternAsMatch
    (com: IPythonCompiler)
    (ctx: Context)
    returnStrategy
    (targets: (Fable.Ident list * Fable.Expr) list)
    (subjectIdent: Fable.Ident)
    guardCases
    (defaultIndex, _defaultBoundValues)
    =
    let ctx = { ctx with DecisionTargets = targets }

    let matchCases =
        guardCases
        |> List.map (transformDebugModeGuardCase com ctx returnStrategy targets subjectIdent.Name)

    // All cases must convert successfully
    if matchCases |> List.exists Option.isNone then
        None
    else
        let matchCases = matchCases |> List.choose id
        let defaultCase = buildDefaultMatchCase com ctx returnStrategy targets defaultIndex
        let allCases = matchCases @ [ defaultCase ]
        let subjectExpr, stmts = com.TransformAsExpr(ctx, Fable.IdentExpr subjectIdent)
        let liftedNonLocals, allCases = allCases |> getNonLocalsFromMatchCases ctx
        let matchStmt = Statement.match' (subjectExpr, allCases)
        Some(stmts @ liftedNonLocals @ [ matchStmt ])

/// Transforms release mode (inlined) guard pattern cases into a Python match statement.
let private transformReleaseModeGuardPatternAsMatch
    (com: IPythonCompiler)
    (ctx: Context)
    returnStrategy
    (targets: (Fable.Ident list * Fable.Expr) list)
    (subjectIdent: Fable.Ident)
    (guardCases: MatchStatements.InlinedGuardCase list)
    (defaultIndex, _defaultBoundValues)
    =
    let ctx = { ctx with DecisionTargets = targets }

    let matchCases =
        guardCases
        |> List.map (transformReleaseModeGuardCase com ctx returnStrategy targets subjectIdent)

    // All cases must convert successfully
    if matchCases |> List.exists Option.isNone then
        None
    else
        let matchCases = matchCases |> List.choose id
        let defaultCase = buildDefaultMatchCase com ctx returnStrategy targets defaultIndex
        let allCases = matchCases @ [ defaultCase ]
        let subjectExpr, stmts = com.TransformAsExpr(ctx, Fable.IdentExpr subjectIdent)
        let liftedNonLocals, allCases = allCases |> getNonLocalsFromMatchCases ctx
        let matchStmt = Statement.match' (subjectExpr, allCases)
        Some(stmts @ liftedNonLocals @ [ matchStmt ])

/// Transforms switch-like pattern cases into a Python match statement.
let private transformSwitchPatternAsMatch
    (com: IPythonCompiler)
    (ctx: Context)
    returnStrategy
    (targets: (Fable.Ident list * Fable.Expr) list)
    evalExpr
    cases
    (defaultIndex, _defaultBoundValues)
    =
    // Check if all cases have empty bound values (simple value matching)
    let allSimpleValueCases =
        cases |> List.forall (fun (_, _, boundValues) -> List.isEmpty boundValues)

    if not allSimpleValueCases then
        None
    else
        // Try to convert all case expressions to patterns
        let convertedCases =
            cases
            |> List.choose (fun (caseExpr, targetIndex, _boundValues) ->
                match fableValueToPattern caseExpr with
                | Some pattern -> Some(pattern, targetIndex)
                | None -> None
            )

        // Check if all cases were successfully converted
        if List.length convertedCases <> List.length cases then
            None
        else
            let ctx = { ctx with DecisionTargets = targets }

            // Group cases by target index to create or-patterns. Drop cases routing to the
            // default's target since the always-emitted wildcard already covers them (#4649).
            let groupedCases =
                convertedCases
                |> List.groupBy snd
                |> List.choose (fun (targetIndex, patterns) ->
                    if targetIndex = defaultIndex then
                        None
                    else
                        let patterns = patterns |> List.map fst

                        let pattern =
                            match patterns with
                            | [ single ] -> single
                            | multiple -> MatchOr multiple

                        Some(pattern, targetIndex)
                )

            // Build match cases
            let matchCases =
                groupedCases
                |> List.map (fun (pattern, targetIndex) ->
                    let _idents, targetExpr = targets.[targetIndex]
                    let body = com.TransformAsStatements(ctx, returnStrategy, targetExpr)
                    MatchCase.matchCase (pattern, body)
                )

            // Build default case (wildcard) and always append it last
            let defaultCase = buildDefaultMatchCase com ctx returnStrategy targets defaultIndex
            let allCases = matchCases @ [ defaultCase ]

            // Transform the evaluation expression
            let subject, stmts = com.TransformAsExpr(ctx, evalExpr)

            // Build the match statement, lifting nonlocals out of case bodies
            let liftedNonLocals, allCases = allCases |> getNonLocalsFromMatchCases ctx
            let matchStmt = Statement.match' (subject, allCases)

            Some(stmts @ liftedNonLocals @ [ matchStmt ])

/// Transforms a tuple Option pattern into a Python match statement.
/// Generates: match (x, y): case (None, _): ... case (_, None): ... case _: ...
let private transformTupleOptionPatternAsMatch
    (com: IPythonCompiler)
    (ctx: Context)
    returnStrategy
    (targets: (Fable.Ident list * Fable.Expr) list)
    (result: MatchStatements.TupleOptionPatternResult)
    : Statement list option
    =
    let ctx = { ctx with DecisionTargets = targets }

    // Build the tuple subject expression
    let subjectExprs, subjectStmts =
        result.TestedVars
        |> List.map (fun ident -> com.TransformAsExpr(ctx, Fable.IdentExpr ident))
        |> List.unzip

    let subjectStmts = List.concat subjectStmts
    let subject = Expression.tuple subjectExprs

    // Build None cases: case (None, _), case (_, None), etc.
    let noneCases =
        result.TestedVars
        |> List.mapi (fun i _ ->
            // Create pattern like (_, None, _) where None is at position i
            let patterns =
                result.TestedVars
                |> List.mapi (fun j _ ->
                    if i = j then
                        MatchSingleton NoneLiteral
                    else
                        Pattern.matchWildcard ()
                )

            let pattern = MatchSequence patterns

            // Get the None target body
            let _, noneExpr = targets.[result.NoneTargetIndex]
            let noneBody = com.TransformAsStatements(ctx, returnStrategy, noneExpr)
            MatchCase.matchCase (pattern, Util.ensureNonEmptyBody noneBody)
        )

    // Build success case (wildcard - all are Some)
    // Need to bind the extracted values before executing the target body
    let successIdents, successExpr = targets.[result.SuccessTargetIndex]
    let bindingStmts = transformBindings com ctx successIdents result.SuccessBoundValues
    let successBodyStmts = com.TransformAsStatements(ctx, returnStrategy, successExpr)
    let successBody = Util.ensureNonEmptyBody (bindingStmts @ successBodyStmts)
    let successCase = MatchCase.matchCase (Pattern.matchWildcard (), successBody)

    // Combine all cases, lifting nonlocals out of case bodies
    let allCases = noneCases @ [ successCase ]
    let liftedNonLocals, allCases = allCases |> getNonLocalsFromMatchCases ctx
    let matchStmt = Statement.match' (subject, allCases)

    Some(subjectStmts @ liftedNonLocals @ [ matchStmt ])

/// Transform a tuple boolean+guard pattern into a Python match statement.
/// Handles patterns like: match tuple with | true, _, i when i > -1 -> ... | _ -> ...
/// Generates: match tuple: case [True, _, i] if i > threshold: ... case _: ...
let private transformTupleBoolGuardPatternAsMatch
    (com: IPythonCompiler)
    (ctx: Context)
    returnStrategy
    (targets: (Fable.Ident list * Fable.Expr) list)
    (result: MatchStatements.TupleBoolGuardPatternResult)
    : Statement list option
    =
    let ctx = { ctx with DecisionTargets = targets }

    // Get tuple arity from the type
    let tupleArity =
        match result.TupleType with
        | Fable.Tuple(types, _) -> List.length types
        | _ -> 3 // Default to 3 if we can't determine

    // Transform the tuple expression
    let tupleExpr, tupleStmts = com.TransformAsExpr(ctx, result.TupleExpr)

    // Helper to replace tuple[idx] with a captured variable in an expression
    let replaceGuardTupleAccess (guardIdx: int) (varName: string) (expr: Fable.Expr) : Fable.Expr =
        let rec replace expr =
            match expr with
            | Fable.Get(tupleExpr', Fable.TupleIndex idx, typ, _) when idx = guardIdx ->
                match tupleExpr', result.TupleExpr with
                | Fable.IdentExpr id1, Fable.IdentExpr id2 when id1.Name = id2.Name ->
                    makeTypedIdent typ varName |> Fable.IdentExpr
                | _ -> expr
            | Fable.Operation(Fable.Binary(op, left, right), tags, typ, range) ->
                Fable.Operation(Fable.Binary(op, replace left, replace right), tags, typ, range)
            | _ -> expr

        replace expr

    // Transform each guard case into a match case
    let transformCase (caseIdx: int) (case: MatchStatements.TupleBoolGuardCase) : MatchCase option =
        match case.GuardIndex, case.GuardExpr with
        | Some guardIdx, Some guardExpr ->
            // Generate unique variable name for this case
            let guardVarName = getUniqueNameInDeclarationScope ctx $"i_%d{caseIdx}"
            let guardVarIdent = Identifier guardVarName

            // Build pattern: [True, _, captured_var] or similar
            let patterns =
                [ 0 .. tupleArity - 1 ]
                |> List.map (fun i ->
                    if i = result.BoolIndex then
                        MatchSingleton(BoolLiteral result.BoolValue)
                    elif i = guardIdx then
                        MatchAs(None, Some guardVarIdent)
                    else
                        Pattern.matchWildcard ()
                )

            let pattern = MatchSequence patterns

            // Transform guard, replacing tuple access with captured variable
            let guardExpr' = replaceGuardTupleAccess guardIdx guardVarName guardExpr
            let guard, guardStmts = com.TransformAsExpr(ctx, guardExpr')

            if not (List.isEmpty guardStmts) then
                None // Guard has statements, can't convert
            else
                // Transform target body
                let targetIdents, targetExpr = targets.[case.TargetIndex]
                let bindingStmts = transformBindings com ctx targetIdents case.BoundValues
                let bodyStmts = com.TransformAsStatements(ctx, returnStrategy, targetExpr)
                let body = Util.ensureNonEmptyBody (bindingStmts @ bodyStmts)
                Some(MatchCase.matchCase (pattern, body, guard))
        | _ -> None

    // Try to transform all cases
    let matchCases = result.Cases |> List.mapi transformCase |> List.choose id

    // Check if all cases converted successfully
    if List.length matchCases <> List.length result.Cases then
        None
    else
        // Transform default target body
        let defaultIdents, defaultExpr = targets.[result.DefaultTargetIndex]

        let defaultBindingStmts =
            transformBindings com ctx defaultIdents result.DefaultBoundValues

        let defaultBodyStmts = com.TransformAsStatements(ctx, returnStrategy, defaultExpr)
        let defaultBody = Util.ensureNonEmptyBody (defaultBindingStmts @ defaultBodyStmts)
        let defaultCase = MatchCase.matchCase (Pattern.matchWildcard (), defaultBody)
        let allCases = matchCases @ [ defaultCase ]
        let liftedNonLocals, allCases = allCases |> getNonLocalsFromMatchCases ctx
        let matchStmt = Statement.match' (tupleExpr, allCases)
        Some(tupleStmts @ liftedNonLocals @ [ matchStmt ])

/// Transform a decision tree into a Python match statement.
/// Returns None if the pattern is too complex for match statement conversion.
let transformDecisionTreeAsMatch
    (com: IPythonCompiler)
    (ctx: Context)
    returnStrategy
    (targets: (Fable.Ident list * Fable.Expr) list)
    (treeExpr: Fable.Expr)
    : Statement list option
    =
    // First try switch-like patterns (constant matching)
    match transformDecisionTreeAsSwitch treeExpr with
    | Some(evalExpr, cases, defaultCase) ->
        transformSwitchPatternAsMatch com ctx returnStrategy targets evalExpr cases defaultCase
    | None ->
        // Try guard pattern matching (e.g., | n when n > 10 -> ...)
        match MatchStatements.tryExtractGuardPattern treeExpr with
        | Some(MatchStatements.DebugModeGuards(subjectIdent, guardCases, defaultCase)) ->
            transformDebugModeGuardPatternAsMatch com ctx returnStrategy targets subjectIdent guardCases defaultCase
        | Some(MatchStatements.ReleaseModeGuards(subjectIdent, guardCases, defaultCase)) ->
            transformReleaseModeGuardPatternAsMatch com ctx returnStrategy targets subjectIdent guardCases defaultCase
        | None ->
            // Try tuple Option pattern: match (x, y) with | Some a, Some b -> ... | _ -> None
            match MatchStatements.tryExtractTupleOptionPattern treeExpr with
            | Some result -> transformTupleOptionPatternAsMatch com ctx returnStrategy targets result
            | None ->
                // Try tuple boolean+guard pattern: match tuple with | true, _, i when i > -1 -> ...
                match MatchStatements.tryExtractTupleBoolGuardPattern treeExpr with
                | Some result -> transformTupleBoolGuardPatternAsMatch com ctx returnStrategy targets result
                | None -> None

let transformDecisionTreeAsExpr (com: IPythonCompiler) (ctx: Context) targets expr : Expression * Statement list =
    // TODO: Check if some targets are referenced multiple times
    let ctx = { ctx with DecisionTargets = targets }
    com.TransformAsExpr(ctx, expr)

let groupSwitchCases t (cases: (Fable.Expr * int * Fable.Expr list) list) (defaultIndex, defaultBoundValues) =
    cases
    |> List.groupBy (fun (_, idx, boundValues) ->
        // Try to group cases with some target index and empty bound values
        // If bound values are non-empty use also a non-empty Guid to prevent grouping
        if List.isEmpty boundValues then
            idx, Guid.Empty
        else
            idx, Guid.NewGuid()
    )
    |> List.map (fun ((idx, _), cases) ->
        let caseExprs = cases |> List.map Tuple3.item1
        // If there are multiple cases, it means boundValues are empty
        // (see `groupBy` above), so it doesn't mind which one we take as reference
        let boundValues = cases |> List.head |> Tuple3.item3
        caseExprs, Fable.DecisionTreeSuccess(idx, boundValues, t)
    )
    |> function
        | [] -> []
        // Check if the last case can also be grouped with the default branch, see #2357
        | cases when List.isEmpty defaultBoundValues ->
            match List.splitLast cases with
            | cases, (_, Fable.DecisionTreeSuccess(idx, [], _)) when idx = defaultIndex -> cases
            | _ -> cases
        | cases -> cases

let getTargetsWithMultipleReferences expr =
    let rec findSuccess (targetRefs: Map<int, int>) =
        function
        | [] -> targetRefs
        | expr :: exprs ->
            match expr with
            // We shouldn't actually see this, but shortcircuit just in case
            | Fable.DecisionTree _ -> findSuccess targetRefs exprs
            | Fable.DecisionTreeSuccess(idx, _, _) ->
                let count = Map.tryFind idx targetRefs |> Option.defaultValue 0

                let targetRefs = Map.add idx (count + 1) targetRefs
                findSuccess targetRefs exprs
            | expr ->
                let exprs2 = getSubExpressions expr
                findSuccess targetRefs (exprs @ exprs2)

    findSuccess Map.empty [ expr ]
    |> Seq.choose (fun kv ->
        if kv.Value > 1 then
            Some kv.Key
        else
            None
    )
    |> Seq.toList

/// When several branches share target create first a switch to get the target index and bind value
/// and another to execute the actual target
let transformDecisionTreeWithTwoSwitches
    (com: IPythonCompiler)
    ctx
    returnStrategy
    (targets: (Fable.Ident list * Fable.Expr) list)
    treeExpr
    =
    // Use the "two switches" pattern: first switch determines target index and binds values,
    // second switch executes the actual target code.
    // Declare target and bound idents
    let targetId =
        getUniqueNameInDeclarationScope ctx "pattern_matching_result" |> makeIdent

    // Collect all bound idents - these are initialized to None
    let boundIdents =
        targets
        |> List.collect (fun (idents, _) -> idents)
        |> List.distinctBy (fun id -> id.Name)

    // Generate: (pattern_matching_result, v1, v2, ...) = nullable[int32, T1, T2, ...]()
    // This tells Pyright the types while allowing initial None values
    let nullableFunc = libValue com ctx "util" "nullable"

    // Collect type annotations and any prerequisite statements
    let int32Type = Fable.Number(Int32, Fable.NumberInfo.Empty)

    let allTypes = int32Type :: (boundIdents |> List.map (fun id -> id.Type))

    let typeAnnotations, typeStmts =
        allTypes
        |> List.map (fun t -> Annotation.typeAnnotation com ctx None t)
        |> List.unzip

    // Build nullable[T1, T2, ...]()
    let typeSubscript =
        match typeAnnotations with
        | [ single ] -> single
        | multiple -> Expression.tuple multiple

    let nullableCall =
        Expression.call (Expression.subscript (nullableFunc, typeSubscript), [])

    // Build the tuple of target names for unpacking: (pattern_matching_result, v1, v2) = nullable[...]()
    let allIdents =
        (ident com ctx targetId) :: (boundIdents |> List.map (ident com ctx))

    let targetNames = allIdents |> List.map Expression.name
    // Wrap in a tuple to get tuple unpacking (a, b, c) = ... instead of chained a = b = c = ...
    let targetTuple = Expression.tuple targetNames

    let multiVarDecl =
        (typeStmts |> List.concat)
        @ [ Statement.assign ([ targetTuple ], nullableCall) ]

    let switch2 =
        // Make the last case a default case to ensure exhaustive matching
        // This fixes type errors where pyright thinks not all paths return a value
        let allCases =
            targets |> List.mapi (fun i (_, target) -> [ makeIntConst i ], target)

        match List.tryLast allCases with
        | Some(_, lastTarget) when allCases.Length > 1 ->
            let cases = allCases |> List.take (allCases.Length - 1)
            transformSwitch com ctx true returnStrategy (targetId |> Fable.IdentExpr) cases (Some lastTarget)
        | _ -> transformSwitch com ctx true returnStrategy (targetId |> Fable.IdentExpr) allCases None

    // Transform decision tree
    let targetAssign = Target(ident com ctx targetId)
    let ctx = { ctx with DecisionTargets = targets }

    match transformDecisionTreeAsSwitch treeExpr with
    | Some(evalExpr, cases, (defaultIndex, defaultBoundValues)) ->
        let cases =
            groupSwitchCases (Fable.Number(Int32, Fable.NumberInfo.Empty)) cases (defaultIndex, defaultBoundValues)

        let defaultCase =
            Fable.DecisionTreeSuccess(defaultIndex, defaultBoundValues, Fable.Number(Int32, Fable.NumberInfo.Empty))

        let switch1 =
            transformSwitch com ctx false (Some targetAssign) evalExpr cases (Some defaultCase)

        multiVarDecl @ switch1 @ switch2
    | None ->
        let decisionTree = com.TransformAsStatements(ctx, Some targetAssign, treeExpr)

        multiVarDecl @ decisionTree @ switch2

let transformDecisionTreeAsStatements
    (com: IPythonCompiler)
    (ctx: Context)
    returnStrategy
    (targets: (Fable.Ident list * Fable.Expr) list)
    (treeExpr: Fable.Expr)
    : Statement list
    =
    // If some targets are referenced multiple times, hoist bound idents,
    // resolve the decision index and compile the targets as a switch
    let targetsWithMultiRefs =
        if com.Options.Language = TypeScript then
            [] // no hoisting when compiled with types
        else
            getTargetsWithMultipleReferences treeExpr

    match targetsWithMultiRefs with
    | [] ->
        // Try to transform as a Python match statement first (Python 3.10+)
        match transformDecisionTreeAsMatch com ctx returnStrategy targets treeExpr with
        | Some matchStmts -> matchStmts
        | None ->
            // Fall back to if/elif/else transformation
            let ctx = { ctx with DecisionTargets = targets }

            match transformDecisionTreeAsSwitch treeExpr with
            | Some(evalExpr, cases, (defaultIndex, defaultBoundValues)) ->
                let t = treeExpr.Type

                let cases =
                    cases
                    |> List.map (fun (caseExpr, targetIndex, boundValues) ->
                        [ caseExpr ], Fable.DecisionTreeSuccess(targetIndex, boundValues, t)
                    )

                let defaultCase = Fable.DecisionTreeSuccess(defaultIndex, defaultBoundValues, t)

                transformSwitch com ctx true returnStrategy evalExpr cases (Some defaultCase)
            | None -> com.TransformAsStatements(ctx, returnStrategy, treeExpr)
    | targetsWithMultiRefs ->
        // If the bound idents are not referenced in the target, remove them
        let targets =
            targets
            |> List.map (fun (idents, expr) ->
                idents
                |> List.exists (fun i -> isIdentUsed i.Name expr)
                |> function
                    | true -> idents, expr
                    | false -> [], expr
            )

        let hasAnyTargetWithMultiRefsBoundValues =
            targetsWithMultiRefs
            |> List.exists (fun idx -> targets[idx] |> fst |> List.isEmpty |> not)

        if not hasAnyTargetWithMultiRefsBoundValues then
            // Try to transform as a Python match statement first (supports or-patterns)
            match transformDecisionTreeAsMatch com ctx returnStrategy targets treeExpr with
            | Some matchStmts -> matchStmts
            | None ->
                // Fall back to if/elif/else transformation
                match transformDecisionTreeAsSwitch treeExpr with
                | Some(evalExpr, cases, (defaultIndex, defaultBoundValues)) ->
                    let t = treeExpr.Type

                    let cases = groupSwitchCases t cases (defaultIndex, defaultBoundValues)

                    let ctx = { ctx with DecisionTargets = targets }

                    let defaultCase = Fable.DecisionTreeSuccess(defaultIndex, defaultBoundValues, t)

                    transformSwitch com ctx true returnStrategy evalExpr cases (Some defaultCase)
                | None -> transformDecisionTreeWithTwoSwitches com ctx returnStrategy targets treeExpr
        else
            transformDecisionTreeWithTwoSwitches com ctx returnStrategy targets treeExpr

let transformSequenceExpr (com: IPythonCompiler) ctx (exprs: Fable.Expr list) : Expression * Statement list =
    // printfn "transformSequenceExpr"
    let ctx = { ctx with BoundVars = ctx.BoundVars.EnterScope() }

    let body =
        exprs
        |> List.collecti (fun i e ->
            let expr, stmts = com.TransformAsExpr(ctx, e)
            // Return the last expression
            if i = exprs.Length - 1 then
                stmts @ [ Statement.return' expr ]
            else
                stmts @ exprAsStatement ctx expr
        )
        |> transformBody com ctx None

    let name = Helpers.getUniqueIdentifier "_expr"

    let func =
        Statement.functionDef (name = name, args = Arguments.arguments [], body = body)

    let name = Expression.name name
    Expression.call name, [ func ]

let transformSequenceExpr'
    (_com: IPythonCompiler)
    ctx
    (exprs: Expression list)
    (stmts: Statement list)
    : Expression * Statement list
    =
    // printfn "transformSequenceExpr2', exprs: %A" exprs.Length
    // printfn "ctx: %A" ctx.BoundVars
    let ctx = { ctx with BoundVars = ctx.BoundVars.EnterScope() }

    let body =
        exprs
        |> List.collecti (fun i expr ->
            // Return the last expression
            if i = exprs.Length - 1 then
                stmts @ [ Statement.return' expr ]
            else
                exprAsStatement ctx expr
        )

    let name = Helpers.getUniqueIdentifier "_expr"

    let func =
        Statement.functionDef (name = name, args = Arguments.arguments [], body = body)

    let name = Expression.name name
    Expression.call name, [ func ]

let rec transformAsExpr (com: IPythonCompiler) ctx (expr: Fable.Expr) : Expression * Statement list =
    // printfn "transformAsExpr: %A" expr
    match expr with
    | Fable.Unresolved(_, _, r) -> addErrorAndReturnNull com r "Unexpected unresolved expression", []
    | Fable.TypeCast(e, t) -> transformCast com ctx t e
    | Fable.Value(kind, r) -> transformValue com ctx r kind
    | Fable.IdentExpr id -> identAsExpr com ctx id, []
    | Fable.Import({
                       Selector = selector
                       Path = path
                   },
                   _,
                   r) ->
        // printfn "Fable.Import: %A" (selector, path)
        transformImport com ctx r selector path, []

    | Fable.Test(expr, kind, range) -> transformTest com ctx range kind expr

    | Fable.Lambda(arg, body, name) ->
        let args', body', returnType, typeParams =
            Annotation.transformFunctionWithAnnotations com ctx name [ arg ] body

        makeArrowFunctionExpression com ctx name (Some body.Type) args' body' returnType typeParams

    | Fable.Delegate(args, body, name, _) ->
        let args', body', returnType, typeParams =
            Annotation.transformFunctionWithAnnotations com ctx name args body

        makeArrowFunctionExpression com ctx name (Some body.Type) args' body' returnType typeParams

    | Fable.ObjectExpr([], typ, None) ->
        // Check if the type is an interface
        match typ with
        | Fable.DeclaredType(entRef, _) ->
            let ent = com.GetEntity(entRef)

            if ent.IsInterface then
                // Use cast with SimpleNamespace for interfaces to avoid type errors
                let cast = com.GetImportExpr(ctx, "typing", "cast")
                let simpleNamespace = com.GetImportExpr(ctx, "types", "SimpleNamespace")
                let typeAnnotation, _ = Annotation.typeAnnotation com ctx None typ
                Expression.call (cast, [ typeAnnotation; Expression.call (simpleNamespace, []) ]), []
            else
                Expression.dict (), []
        | _ -> Expression.dict (), []
    | Fable.ObjectExpr(members, typ, baseCall) ->
        // printfn "members: %A" (members, typ)
        transformObjectExpr com ctx members typ baseCall

    | Fable.Call(Fable.Get(expr, Fable.FieldGet { Name = "has" }, _, _), info, _, _range) ->
        Expression.withStmts {
            let! left = com.TransformAsExpr(ctx, info.Args.Head)
            let! value = com.TransformAsExpr(ctx, expr)
            return Expression.compare (left, [ ComparisonOperator.In ], [ value ])
        }

    | Fable.Call(Fable.Get(expr, Fable.FieldGet { Name = "slice" }, _, _), info, _, _range) ->
        transformAsSlice com ctx expr info

    | Fable.Call(Fable.Get(expr, Fable.FieldGet { Name = "to_array" }, _, _), info, _, _range) ->
        transformAsArray com ctx expr info

    | Fable.Call(Fable.Get(expr, Fable.FieldGet { Name = "Equals" }, _, _), { Args = [ arg ] }, _, _range) ->
        Expression.withStmts {
            let! left = com.TransformAsExpr(ctx, expr)
            let! right = com.TransformAsExpr(ctx, arg)
            return Expression.compare (left, [ Eq ], [ right ])
        }

    | Fable.Call(callee, info, _, range) -> transformCall com ctx range callee info

    | Fable.CurriedApply(callee, args, _, range) -> transformCurriedApply com ctx range callee args

    | Fable.Operation(kind, tags, t, range) -> transformOperation com ctx range t kind tags

    | Fable.Get(expr, kind, typ, range) -> transformGet com ctx range typ expr kind

    // Handle TypeTest and OptionTest for type narrowing
    | Fable.IfThenElse(Fable.Test(expr, testKind, r), thenExpr, elseExpr, _r) when
        (match testKind with
         | Fable.TypeTest _
         | Fable.OptionTest _ -> true
         | _ -> false)
        ->
        let guardExpr = Fable.Test(expr, testKind, r)
        let thenCtx, elseCtx = getNarrowedContexts ctx guardExpr

        let finalExpr, stmts =
            Expression.withStmts {
                let! guardExprCompiled = transformTest com ctx r testKind expr
                let! thenExprCompiled = com.TransformAsExpr(thenCtx, thenExpr)
                let! elseExprCompiled = com.TransformAsExpr(elseCtx, elseExpr)
                return Expression.ifExp (guardExprCompiled, thenExprCompiled, elseExprCompiled)
            }

        finalExpr, stmts

    | Fable.IfThenElse(TransformExpr com ctx (guardExpr, stmts),
                       TransformExpr com ctx (thenExpr, stmts'),
                       TransformExpr com ctx (elseExpr, stmts''),
                       _r) -> Expression.ifExp (guardExpr, thenExpr, elseExpr), stmts @ stmts' @ stmts''

    | Fable.DecisionTree(expr, targets) -> transformDecisionTreeAsExpr com ctx targets expr

    | Fable.DecisionTreeSuccess(idx, boundValues, _) -> transformDecisionTreeSuccessAsExpr com ctx idx boundValues

    | Fable.Set(expr, kind, typ, value, range) ->
        let expr', stmts = transformSet com ctx range expr typ value kind
        // printfn "transformAsExpr: Fable.Set: %A" expr
        match expr' with
        | Expression.NamedExpr {
                                   Target = target
                                   Value = _
                                   Loc = _
                               } ->
            let nonLocals =
                match target with
                | Expression.Name { Id = id } -> [ ctx.BoundVars.NonLocals([ id ]) |> Statement.nonLocal ]
                | _ -> []

            expr', nonLocals @ stmts
        | _ -> expr', stmts

    | Fable.Let(_ident, _value, _body) ->
        // printfn "Fable.Let: %A" (ident, value, body)
        iife com ctx expr

    | Fable.LetRec(bindings, body) ->
        if ctx.HoistVars(List.map fst bindings) then
            Expression.withStmts {
                let values, stmts =
                    bindings
                    |> List.map (fun (id, value) -> transformBindingAsExpr com ctx id value)
                    |> List.unzip
                    |> fun (e, s) -> e, List.collect id s

                let! expr = com.TransformAsExpr(ctx, body)
                let! finalExpr = transformSequenceExpr' com ctx (values @ [ expr ]) []
                return! finalExpr, stmts
            }
        else
            iife com ctx expr

    | Fable.Sequential exprs -> transformSequenceExpr com ctx exprs

    | Fable.Emit(info, _, range) ->
        if info.IsStatement then
            iife com ctx expr
        else
            transformEmit com ctx range info

    // These cannot appear in expression position in Python, must be wrapped in a lambda
    | Fable.WhileLoop _
    | Fable.ForLoop _
    | Fable.TryCatch _ -> iife com ctx expr
    | Fable.Extended(instruction, _) ->
        match instruction with
        | Fable.Curry(e, arity) -> transformCurry com ctx e arity
        | Fable.Throw _
        | Fable.Debugger -> iife com ctx expr
    | Fable.Quote(body, _isTyped, _r) ->
        let emitted = QuotationEmitter.emitQuotedExpr com body
        transformAsExpr com ctx emitted

let transformAsSlice (com: IPythonCompiler) ctx expr (info: Fable.CallInfo) : Expression * Statement list =
    Expression.withStmts {
        let! left = com.TransformAsExpr(ctx, expr)

        let args, stmts =
            Expression.mapWith (fun arg -> com.TransformAsExpr(ctx, arg)) info.Args

        let slice =
            match args with
            | [] -> Expression.slice ()
            | [ lower ] -> Expression.slice (lower = lower)
            | [ Expression.Name { Id = Identifier "None" }; upper ] -> Expression.slice (upper = upper)
            | [ lower; upper ] -> Expression.slice (lower = lower, upper = upper)
            | _ -> failwith $"Array slice with %d{args.Length} not supported"

        return! Expression.subscript (left, slice), stmts
    }

let transformAsArray (com: IPythonCompiler) ctx expr (info: Fable.CallInfo) : Expression * Statement list =
    // printfn "transformAsArray: %A" (expr, info)
    let value, stmts = com.TransformAsExpr(ctx, expr)

    match expr.Type with
    | Fable.Type.Array(typ, Fable.ArrayKind.ResizeArray) ->
        // Expression.call (array, Expression.stringConstant l :: [ value ]), stmts
        makeArray com ctx [ expr ] Fable.ArrayKind.ResizeArray typ
    | _ -> transformAsSlice com ctx expr info

/// Active pattern to detect F# `use` statements compiled as TryCatch with Dispose
/// This helps us to transform F# `use` (i.e. TryCatch) as Python `with` statements
[<return: Struct>]
let (|UsePattern|_|) (body: Fable.Expr) =
    match body with
    | Fable.TryCatch(tryBody,
                     None,
                     Some(Fable.IfThenElse(_,
                                           Fable.Call(Fable.Get(Fable.TypeCast(Fable.IdentExpr { Name = disposeName }, _),
                                                                Fable.FieldGet { Name = "Dispose" },
                                                                _,
                                                                _),
                                                      _,
                                                      _,
                                                      _),
                                           _,
                                           _)),
                     _) -> ValueSome(disposeName, tryBody)
    | _ -> ValueNone

let rec transformAsStatements (com: IPythonCompiler) ctx returnStrategy (expr: Fable.Expr) : Statement list =
    // printfn "transformAsStatements: %A" expr
    match expr with
    | Fable.Unresolved(_, _, r) ->
        addError com [] r "Unexpected unresolved expression"
        []

    | Fable.Extended(kind, _r) ->
        match kind with
        | Fable.Curry(e, arity) ->
            let expr, stmts = transformCurry com ctx e arity

            stmts @ (expr |> resolveExpr ctx e.Type returnStrategy)
        | Fable.Throw(expr, _) ->
            match expr with
            | None -> failwith "TODO: rethrow"
            | Some(TransformExpr com ctx (e, stmts)) -> stmts @ [ Statement.raise e ]
        | Fable.Debugger ->
            [
                Statement.assert' (Expression.boolOp (op = Or, values = [ Expression.boolConstant true ]))
            ]

    | Fable.TypeCast(e, t) ->
        let expr, stmts = transformCast com ctx t e
        stmts @ (expr |> resolveExpr ctx t returnStrategy)

    | Fable.Value(kind, r) ->
        let expr, stmts = transformValue com ctx r kind

        stmts @ (expr |> resolveExpr ctx kind.Type returnStrategy)

    | Fable.IdentExpr id ->
        let narrowedType = getNarrowedType ctx id
        let expr = identAsExpr com ctx id
        expr |> resolveExpr ctx narrowedType returnStrategy

    | Fable.Import({
                       Selector = selector
                       Path = path
                       Kind = _kind
                   },
                   t,
                   r) -> transformImport com ctx r selector path |> resolveExpr ctx t returnStrategy

    | Fable.Test(expr, kind, range) ->
        let expr, stmts = transformTest com ctx range kind expr

        stmts @ (expr |> resolveExpr ctx Fable.Boolean returnStrategy)

    | Fable.Lambda(arg, body, name) ->
        let args', body', returnType, typeParams =
            transformFunctionWithAnnotations com ctx name [ arg ] body

        let expr', stmts =
            makeArrowFunctionExpression com ctx name (Some body.Type) args' body' returnType typeParams

        stmts @ (expr' |> resolveExpr ctx expr.Type returnStrategy)

    | Fable.Delegate(args, body, name, _) ->
        let args', body', returnType, typeParams =
            transformFunctionWithAnnotations com ctx name args body

        let expr', stmts =
            makeArrowFunctionExpression com ctx name (Some body.Type) args' body' returnType typeParams

        stmts @ (expr' |> resolveExpr ctx expr.Type returnStrategy)

    | Fable.ObjectExpr([], _, None) -> [] // Remove empty object expression
    | Fable.ObjectExpr(members, typ, baseCall) ->
        let expr, stmts = transformObjectExpr com ctx members typ baseCall
        stmts @ (expr |> resolveExpr ctx typ returnStrategy)

    | Fable.Call(Fable.Get(expr, Fable.FieldGet { Name = "slice" }, _, _), info, typ, _range) ->
        let expr, stmts = transformAsSlice com ctx expr info
        stmts @ resolveExpr ctx typ returnStrategy expr
    | Fable.Call(Fable.Get(expr, Fable.FieldGet { Name = "to_array" }, _, _), info, typ, _range) ->
        let expr, stmts = transformAsArray com ctx expr info
        stmts @ resolveExpr ctx typ returnStrategy expr
    | Fable.Call(callee, info, typ, range) -> transformCallAsStatements com ctx range typ returnStrategy callee info

    | Fable.CurriedApply(callee, args, typ, range) ->
        transformCurriedApplyAsStatements com ctx range typ returnStrategy callee args

    | Fable.Emit(info, t, range) ->
        let e, stmts = transformEmit com ctx range info

        if info.IsStatement then
            stmts @ [ Statement.expr e ] // Ignore the return strategy
        else
            stmts @ resolveExpr ctx t returnStrategy e

    | Fable.Operation(kind, tags, t, range) ->
        let expr, stmts = transformOperation com ctx range t kind tags
        stmts @ (expr |> resolveExpr ctx t returnStrategy)

    | Fable.Get(expr, kind, t, range) ->
        let expr, stmts = transformGet com ctx range t expr kind
        stmts @ (expr |> resolveExpr ctx t returnStrategy)

    // Transform F# `use` i.e TryCatch as Python `with`
    // We wrap the value in Disposable(...) to provide context manager support
    // for IDisposable objects that don't have __enter__/__exit__ methods
    | Fable.Let(ident, value, UsePattern(disposeName, tryBody)) when ident.Name = disposeName ->
        let id = Identifier ident.Name
        let body = transformBlock com ctx (Some(ResourceManager returnStrategy)) tryBody

        let value, stmts = com.TransformAsExpr(ctx, value)

        // Wrap value in Disposable(...) to provide context manager support
        let disposable = libValue com ctx "util" "Disposable"
        let wrappedValue = Expression.call (disposable, [ value ])

        let items = [ WithItem.withItem (wrappedValue, Expression.name id) ]
        stmts @ [ Statement.with' (items, body) ]

    | Fable.Let(ident, value, body) ->
        let binding = transformBindingAsStatements com ctx ident value

        List.append binding (transformAsStatements com ctx returnStrategy body)

    | Fable.LetRec(bindings, body) ->
        let bindings =
            bindings
            |> Seq.collect (fun (i, v) -> transformBindingAsStatements com ctx i v)
            |> Seq.toList

        List.append bindings (transformAsStatements com ctx returnStrategy body)

    | Fable.Set(expr, kind, typ, value, range) ->
        let expr', stmts = transformSet com ctx range expr typ value kind
        // printfn "transformAsStatements: Fable.Set: %A" (expr', value)
        match expr' with
        | Expression.NamedExpr({
                                   Target = target
                                   Value = value
                                   Loc = _
                               }) ->
            let nonLocals, ta, taForCast =
                match target with
                | Expression.Name { Id = id } ->
                    let nonLocals = [ ctx.BoundVars.NonLocals([ id ]) |> Statement.nonLocal ]

                    nonLocals, None, None
                | Expression.Attribute { Value = Expression.Name { Id = Identifier "self" } } ->
                    // Uncurry field types to match runtime behavior (class fields store uncurried functions)
                    let uncurriedType = FableTransforms.uncurryType typ
                    let ta, stmts = Annotation.typeAnnotation com ctx None uncurriedType
                    stmts, Some ta, Some ta
                | Expression.Attribute _ ->
                    // For non-self attribute assignments, we still need the type for casting None
                    let ta, stmts = Annotation.typeAnnotation com ctx None typ
                    stmts, None, Some ta
                | _ -> [], None, None

            let assignment =
                match ta, taForCast with
                | Some ta, _ ->
                    let value' = wrapNoneInCast com ctx value ta
                    [ Statement.assign (target, ta, value') ]
                | None, Some ta ->
                    // No type annotation on assignment, but still wrap None in cast
                    let value' = wrapNoneInCast com ctx value ta
                    [ Statement.assign ([ target ], value') ]
                | _ -> [ Statement.assign ([ target ], value) ]

            nonLocals @ stmts @ assignment
        | _ -> stmts @ (expr' |> resolveExpr ctx expr.Type returnStrategy)
    | Fable.IfThenElse(guardExpr,
                       Fable.Expr.Extended(Fable.ExtendedSet.Debugger, _),
                       Fable.Expr.Value(Fable.ValueKind.Null Fable.Type.Unit, None),
                       r) ->
        // Rewrite `if (guard) { Debugger; null }` to assert (guard)
        let guardExpr', stmts = transformAsExpr com ctx guardExpr
        stmts @ [ Statement.assert' guardExpr' ]
    // Two-case union pattern: if shape.tag == 0 then ... else ...
    // Transform to: match shape.tag: case 0: ... case _: ...
    | Fable.IfThenElse(Fable.Test(unionExpr, Fable.UnionCaseTest tag, _), thenExpr, elseExpr, _r) ->
        let tagExpr =
            Fable.Get(unionExpr, Fable.UnionTag, Fable.Number(Int32, Fable.NumberInfo.Empty), None)

        let subject, subjectStmts = com.TransformAsExpr(ctx, tagExpr)

        let thenBody =
            com.TransformAsStatements(ctx, returnStrategy, thenExpr)
            |> Util.ensureNonEmptyBody

        let elseBody =
            com.TransformAsStatements(ctx, returnStrategy, elseExpr)
            |> Util.ensureNonEmptyBody

        let tagPattern = MatchValue(Expression.intConstant tag)
        let wildcardPattern = Pattern.matchWildcard ()
        let thenNonLocals, thenBody = getNonLocals ctx thenBody
        let elseNonLocals, elseBody = getNonLocals ctx elseBody
        let thenCase = MatchCase.matchCase (tagPattern, thenBody)
        let elseCase = MatchCase.matchCase (wildcardPattern, elseBody)
        let matchStmt = Statement.match' (subject, [ thenCase; elseCase ])
        subjectStmts @ thenNonLocals @ elseNonLocals @ [ matchStmt ]
    | Fable.IfThenElse(guardExpr, thenExpr, elseExpr, r) ->
        let asStatement =
            match returnStrategy with
            | None
            | Some ReturnUnit -> true
            | Some(Target _) -> true // Compile as statement so values can be bound
            | Some(Assign _) -> (isPyStatement ctx false thenExpr) || (isPyStatement ctx false elseExpr)
            | Some(ResourceManager _) -> true
            | Some(Return _) ->
                Option.isSome ctx.TailCallOpportunity
                || (isPyStatement ctx false thenExpr)
                || (isPyStatement ctx false elseExpr)

        if asStatement then
            transformIfStatement com ctx r returnStrategy guardExpr thenExpr elseExpr
        else
            // Create refined context for then/else branches based on guard type
            let thenCtx, elseCtx = getNarrowedContexts ctx guardExpr

            let expr, stmts =
                Expression.withStmts {
                    let! guardExpr' = transformAsExpr com ctx guardExpr
                    let! thenExpr' = transformAsExpr com thenCtx thenExpr
                    let! elseExpr' = transformAsExpr com elseCtx elseExpr
                    return Expression.ifExp (guardExpr', thenExpr', elseExpr', ?loc = r)
                }

            stmts @ (expr |> resolveExpr ctx thenExpr.Type returnStrategy)

    | Fable.Sequential statements ->
        let lasti = (List.length statements) - 1

        statements
        |> List.mapiToArray (fun i statement ->
            let ret =
                if i < lasti then
                    None
                else
                    returnStrategy

            com.TransformAsStatements(ctx, ret, statement)
        )
        |> List.concat

    | Fable.TryCatch(body, catch, finalizer, r) -> transformTryCatch com ctx r returnStrategy (body, catch, finalizer)

    | Fable.DecisionTree(expr, targets) -> transformDecisionTreeAsStatements com ctx returnStrategy targets expr

    | Fable.DecisionTreeSuccess(idx, boundValues, _) ->
        transformDecisionTreeSuccessAsStatements com ctx returnStrategy idx boundValues

    | Fable.WhileLoop(TransformExpr com ctx (guard, stmts), body, range) ->
        stmts
        @ [ Statement.while' (guard, transformBlock com ctx None body, ?loc = range) ]

    | Fable.ForLoop(var,
                    TransformExpr com ctx (start, _stmts),
                    TransformExpr com ctx (limit, _stmts'),
                    body,
                    isUp,
                    _range) ->
        let step =
            Expression.intConstant (
                if isUp then
                    1
                else
                    -1
            )

        let iter = libCall com ctx None "util" "range" [ start; limit; step ]

        let body = transformBlock com ctx None body
        let target = com.GetIdentifierAsExpr(ctx, var.Name)

        [ Statement.for' (target = target, iter = iter, body = body) ]

    | Fable.Quote(body, _isTyped, _r) ->
        let emitted = QuotationEmitter.emitQuotedExpr com body
        transformAsStatements com ctx returnStrategy emitted

let transformFunction
    com
    ctx
    name
    (args: Fable.Ident list)
    (body: Fable.Expr)
    (repeatedGenerics: Set<string>)
    : Arguments * Statement list
    =
    let tailcallChance =
        Option.map (fun name -> NamedTailCallOpportunity(com, ctx, name, args) :> ITailCallOpportunity) name

    let args = FSharp2Fable.Util.discardUnitArg args

    /// Removes `_mut` or `_mut_1` suffix from the identifier name
    let cleanName (input: string) =
        Regex.Replace(input, @"_mut(_\d+)?$", "")

    // Names of this function's own arguments. TCO capture parameters must not
    // collide with these, otherwise we emit a duplicate argument (see #4610).
    let ownArgNames =
        args
        |> List.map (fun id ->
            let (Identifier name) = ident com ctx id
            name
        )
        |> Set.ofList

    // For Python we need to append the TC-arguments to any declared (arrow) function inside the while-loop of the
    // TCO. We will set them as default values to themselves e.g `i=i` to capture the value and not the variable.
    let tcArgs, tcDefaults =
        match ctx.TailCallOpportunity with
        | Some tc ->
            tc.Args
            |> List.choose (fun arg ->
                let (Identifier name) = arg.Arg
                let name = cleanName name

                match name with
                | "tupled_arg_m" -> None // Remove these arguments (not sure why)
                // Don't capture a TCO variable as a default parameter when this
                // function already declares an argument with the same name: the
                // local argument shadows the outer one and a duplicate parameter
                // is a Python syntax error. See #4610.
                | _ when ownArgNames.Contains name -> None
                // Only capture TCO variables actually referenced in the function body.
                // This avoids unnecessary default parameters on nested lambdas that don't
                // use the outer TCO variables. See #3877.
                | _ when not (isIdentUsed name body) -> None
                | _ ->
                    let annotation =
                        // Cleanup type annotations to avoid non-repeated generics
                        match arg.Annotation with
                        | Some(Expression.Name { Id = Identifier _name }) -> arg.Annotation
                        | Some(Expression.Subscript {
                                                        Value = value
                                                        Slice = Expression.Name { Id = Identifier name }
                                                    }) when name.StartsWith("_", StringComparison.Ordinal) ->
                            Expression.subscript (value, stdlibModuleAnnotation com ctx "typing" "Any" [])
                            |> Some
                        | _ -> Some(stdlibModuleAnnotation com ctx "typing" "Any" [])

                    (Arg.arg (name, ?annotation = annotation), Expression.name name) |> Some
            )
            |> List.unzip
        | _ -> [], []

    let declaredVars = ResizeArray()
    let mutable isTailCallOptimized = false

    let argTypes = args |> List.map (fun id -> id.Type)
    // Only track actually-declared (repeated) generic params in ScopedTypeParams.
    // With PEP 695, type params are lexically scoped, so only params that appear
    // in the function's [] declaration should be tracked. Non-repeated params
    // (erased to Any) must not enter scope or inner functions will reference them.
    let newTypeParams = Set.difference repeatedGenerics ctx.ScopedTypeParams

    let ctx =
        { ctx with
            TailCallOpportunity = tailcallChance
            HoistVars =
                fun ids ->
                    declaredVars.AddRange(ids)
                    true
            OptimizeTailCall = fun () -> isTailCallOptimized <- true
            BoundVars = ctx.BoundVars.EnterScope()
            ScopedTypeParams = Set.union ctx.ScopedTypeParams newTypeParams
        }

    let body =
        if body.Type = Fable.Unit then
            transformBlock com ctx (Some ReturnUnit) body
        elif isPyStatement ctx (Option.isSome tailcallChance) body then
            transformBlock com ctx (Some(Return(Some body.Type))) body
        else
            let expr, stmts = transformAsExpr com ctx body
            // Check if we need to erase Option[T] to T | None for return expressions
            let expr =
                if needsOptionEraseForReturn body body.Type then
                    wrapInOptionErase com ctx expr
                else
                    expr

            stmts @ [ Statement.return' expr ]

    // Check if the last argument is unit or generic param (could be unit)
    // This determines if a single-arg function should have a default value
    let isUnitOrGeneric =
        List.tryLast args
        |> Option.map (fun arg ->
            match arg.Type with
            | Fable.GenericParam _
            | Fable.Unit -> true
            | _ -> false
        )
        |> Option.defaultValue false

    let args, defaults, body =
        match isTailCallOptimized, tailcallChance with
        | true, Some tc ->
            // Replace args, see NamedTailCallOpportunity constructor
            let args' =
                List.zip args tc.Args
                |> List.map (fun (id, { Arg = Identifier tcArg }) ->
                    let id2 = com.GetIdentifier(ctx, tcArg)
                    let ta, _ = Annotation.makeArgTypeAnnotation com ctx repeatedGenerics id
                    Arg.arg (id2, annotation = ta)
                )

            let varDecls =
                List.zip args tc.Args
                |> List.map (fun (id, { Arg = Identifier tcArg }) ->
                    ident com ctx id, Some(com.GetIdentifierAsExpr(ctx, tcArg))
                )
                |> multiVarDeclaration ctx

            let body = varDecls @ body
            // Make sure we don't get trapped in an infinite loop, see #1624
            let body = body @ [ Statement.break' () ]

            args', [], Statement.while' (Expression.boolConstant true, body) |> List.singleton
        | _ ->
            // Make sure unit and Option arguments get default values of None
            // Option defaults support F# optional parameters (?x) which have Option type
            let defaults =
                args
                |> List.map (fun arg ->
                    match arg.Type with
                    | Fable.Any
                    | Fable.Unit
                    | Fable.Option _ -> Some Expression.none
                    | _ -> None
                )

            let args' =
                args
                |> List.map (fun id ->
                    let ta, _ = Annotation.makeArgTypeAnnotation com ctx repeatedGenerics id
                    Arg.arg (ident com ctx id, annotation = ta)
                )

            // Extract defaults for Python function signature
            let finalDefaults =
                defaults
                |> List.rev
                |> List.takeWhile Option.isSome
                |> List.choose id
                |> List.rev

            args', finalDefaults, body

    let arguments =
        let unitDefault = libValue com ctx "util" "UNIT"

        match args, isUnitOrGeneric, tcArgs with
        // No args and no tail-call args: add __unit parameter
        | [], _, [] ->
            let unitType = com.GetImportExpr(ctx, getLibPath com "util", "Unit")

            Arguments.arguments (
                args = [ Arg.arg (Identifier("__unit"), annotation = unitType) ],
                defaults = [ unitDefault ]
            )
        // No args but has tail-call args: skip __unit, tcArgs are sufficient
        | [], _, _ -> Arguments.arguments (args = tcArgs, defaults = tcDefaults)
        // Single generic/unit arg with no tail-call args: keep it with () default
        | [ arg ], true, [] -> Arguments.arguments (args = args, defaults = [ unitDefault ])
        // Single generic/unit arg with tail-call args: keep arg (body may reference it)
        | [ arg ], true, _ -> Arguments.arguments (args @ tcArgs, defaults = unitDefault :: tcDefaults)
        | _ -> Arguments.arguments (args @ tcArgs, defaults = defaults @ tcDefaults)

    arguments, body

// Declares a Python entry point, i.e `if __name__ == "__main__"`
let declareEntryPoint (com: IPythonCompiler) (ctx: Context) (funcExpr: Expression) =
    com.GetImportExpr(ctx, "sys") |> ignore

    let args =
        emitExpression None "sys.argv[1:]" []
        |> fun expr -> arrayExpr com ctx expr Fable.ImmutableArray Fable.String

    let test =
        Expression.compare (
            Expression.name "__name__",
            [ ComparisonOperator.Eq ],
            [ Expression.stringConstant "__main__" ]
        )

    let mainCall = Expression.call (funcExpr, [ args ])

    // Propagate the entry point's return value as the process exit code.
    // int(...) coercion is required because fable-library-python's Int32 is not an int subclass.
    let main =
        emitExpression None "sys.exit(int($0))" [ mainCall ]
        |> Statement.expr
        |> List.singleton

    Statement.if' (test, main)

let declareModuleMember (com: IPythonCompiler) ctx _isPublic (membName: Identifier) typ (expr: Expression) =
    let (Identifier name) = membName

    if com.OutputType = OutputType.Library then
        com.AddExport name |> ignore

    let name = Expression.name membName
    varDeclaration ctx name typ expr

let makeEntityTypeParams (com: IPythonCompiler) ctx (ent: Fable.Entity) : TypeParam list =
    getEntityGenParams ent |> makeTypeParams com ctx

let getUnionFieldsAsIdents (_com: IPythonCompiler) _ctx (_ent: Fable.Entity) =
    let tagId = makeTypedIdent (Fable.Number(Int32, Fable.NumberInfo.Empty)) "tag"

    let fieldsId = makeTypedIdent (Fable.Array(Fable.Any, Fable.MutableArray)) "fields"

    [| tagId; fieldsId |]

let getEntityFieldsAsIdents (com: IPythonCompiler) (ent: Fable.Entity) =
    let entityNamingConvention =
        if shouldUseRecordFieldNaming ent then
            Naming.toFieldSnakeCase
        else
            Naming.toPythonNaming

    ent.FSharpFields
    |> Seq.choose (fun field ->
        if field.IsStatic then
            None
        else
            let name =
                (entityNamingConvention field.Name, Naming.NoMemberPart)
                ||> Naming.sanitizeIdent (fun _ -> false)

            let typ = field.FieldType

            Some { makeTypedIdent typ name with IsMutable = field.IsMutable }
    )
    |> Seq.toArray

let getEntityFieldsAsProps (com: IPythonCompiler) ctx (ent: Fable.Entity) =
    if ent.IsFSharpUnion then
        getUnionFieldsAsIdents com ctx ent |> Array.map (identAsExpr com ctx)
    else
        let namingConvention =
            if shouldUseRecordFieldNaming ent then
                Naming.toFieldSnakeCase
            else
                Naming.toPythonNaming

        ent.FSharpFields
        |> Seq.map (fun field ->
            let name = field.Name |> namingConvention

            let cleanName =
                (name, Naming.NoMemberPart) ||> Naming.sanitizeIdent Naming.pyBuiltins.Contains

            Expression.name cleanName
        )
        |> Seq.toArray

let declareDataClassType
    (com: IPythonCompiler)
    (ctx: Context)
    (ent: Fable.Entity)
    (entName: string)
    (consArgs: Arguments)
    (_isOptional: bool)
    (_consBody: Statement list)
    (baseExpr: Expression option)
    (classMembers: Statement list)
    _slotMembers
    =
    let name = com.GetIdentifier(ctx, entName)

    // Record slots follow Python naming conventions, but structured formatting must
    // retain the original F# field names. Keep the names on the generated class so
    // the runtime can pair them with the slots without attempting a lossy conversion.
    let fsharpFieldNames =
        ent.FSharpFields
        |> List.filter (fun field -> not field.IsStatic)
        |> List.map (fun field -> Expression.stringConstant field.Name)
        |> Expression.tuple

    let fsharpFieldNamesMember =
        Statement.assign ([ Expression.name ("__fable_field_names__", Store) ], fsharpFieldNames)

    // Generate field annotations from entity's FSharpFields to properly uncurry function types.
    // Record/dataclass fields store functions uncurried at runtime, so we need to uncurry
    // lambda types in the type annotations to match.
    let props =
        ent.FSharpFields
        |> List.filter (fun field -> not field.IsStatic)
        |> List.mapi (fun i field ->
            // Get the argument name from consArgs (preserves the Python naming convention)
            let argName =
                if i < consArgs.Args.Length then
                    consArgs.Args.[i].Arg
                else
                    // Fallback to field name if consArgs doesn't have enough args
                    com.GetIdentifier(ctx, field.Name |> Naming.toFieldSnakeCase |> Helpers.clean)

            // Uncurry lambda types for field annotations since fields store uncurried functions
            let fieldType =
                match field.FieldType with
                | Fable.LambdaType _ -> FableTransforms.uncurryType field.FieldType
                | _ -> field.FieldType

            let annotation, _ = Annotation.typeAnnotation com ctx None fieldType

            Statement.assign (Expression.name argName, annotation = annotation)
        )


    let typeParams = makeEntityTypeParams com ctx ent

    // For record types (dataclasses), the Record base class already provides:
    // - StringableBase (__str__, __repr__ from ToString)
    // - EquatableBase (__eq__, __ne__ from Equals)
    // - ComparableBase (__lt__, __le__, __gt__, __ge__ from CompareTo)
    //
    // We only need to add EnumerableBase for IEnumerable interfaces (for iteration support)
    let allowedInterfaces = [ "IEnumerable_1" ]

    let interfaceBases =
        ent.AllInterfaces
        |> List.ofSeq
        |> List.choose (fun int ->
            let name = Helpers.removeNamespace (int.Entity.FullName)

            if not (allowedInterfaces |> List.contains name) then
                None
            else
                // Filter out self-referential generic arguments to avoid forward reference errors
                let genericArgs =
                    int.GenericArgs
                    |> List.filter (fun genArg ->
                        match genArg with
                        | Fable.DeclaredType({ FullName = fullName }, _) ->
                            Naming.toPascalCase (Helpers.removeNamespace fullName) <> entName
                        | _ -> true
                    )

                // Generate the EnumerableBase reference from bases module
                if List.isEmpty genericArgs then
                    libValue com ctx "bases" "EnumerableBase" |> Some
                else
                    let typeArgs =
                        genericArgs
                        |> List.map (fun genArg ->
                            let arg, _ = Annotation.typeAnnotation com ctx None genArg
                            arg
                        )

                    Expression.subscript (libValue com ctx "bases" "EnumerableBase", Expression.tuple typeArgs)
                    |> Some
        )

    let bases = (baseExpr |> Option.toList) @ interfaceBases

    // Add a __hash__ method to the class
    let hashMethod =
        // Hashing of data classes in python does not support inheritance, so we need to implement
        // this method manually.
        Statement.functionDef (
            Identifier "__hash__",
            Arguments.arguments [ Arg.arg "self" ],
            body =
                [
                    Statement.return' (
                        Expression.call (
                            Expression.name "int",
                            [
                                Expression.call (
                                    Expression.attribute (
                                        value = Expression.name "self",
                                        attr = Identifier "GetHashCode",
                                        ctx = Load
                                    ),
                                    []
                                )
                            ]
                        )
                    )
                ],
            returns = Expression.name "int"
        )

    // Generate ClassVar annotations for static fields so that Pyright recognizes
    // the class-level attributes assigned by the static constructor (_cctor).
    // With slots=True, unannotated class attributes are not allowed.
    let staticFieldAnnotations =
        ent.FSharpFields
        |> List.choose (fun field ->
            if
                field.IsStatic
                && not (field.Name.StartsWith("init@", System.StringComparison.Ordinal))
            then
                let fieldName = field.Name.TrimEnd('@') |> Naming.toPythonNaming
                let ta, _ = Annotation.typeAnnotation com ctx None field.FieldType
                let classVar = com.GetImportExpr(ctx, "typing", "ClassVar")
                let classVarAnnotation = Expression.subscript (classVar, ta)
                Some(Statement.annAssign (Expression.name fieldName, annotation = classVarAnnotation))
            else
                None
        )

    let classBody =
        let body =
            [
                yield fsharpFieldNamesMember
                yield! staticFieldAnnotations
                yield! props
                yield! classMembers
                yield hashMethod
            ]

        match body with
        | [] -> [ Statement.ellipsis ]
        | _ -> body

    let dataClass = com.GetImportExpr(ctx, "dataclasses", "dataclass")

    let decorators =
        [
            Expression.call (
                dataClass,
                kw =
                    [
                        Keyword.keyword (Identifier "eq", Expression.boolConstant false)
                        Keyword.keyword (Identifier "repr", Expression.boolConstant false)
                        Keyword.keyword (Identifier "slots", Expression.boolConstant true)
                    ]
            )
        ]

    [
        Statement.classDef (name, body = classBody, decoratorList = decorators, bases = bases, typeParams = typeParams)
    ]

let transformClassAttributes
    (com: IPythonCompiler)
    (ctx: Context)
    (ent: Fable.Entity)
    (classAttributes: ClassAttributes option)
    (extractedInitialValues: (string * Fable.MemberDecl * Expression) list)
    : Statement list
    =
    match classAttributes with
    | Some parms when parms.Style = ClassStyle.Attributes ->
        // Generate class attributes for attached members (deduplicate by property name)
        ent.MembersFunctionsAndValues
        |> Seq.filter (fun memb -> memb.IsInstance && (memb.IsGetter || memb.IsSetter))
        |> Seq.groupBy (fun memb -> memb.DisplayName)
        |> Seq.map (fun (propertyName, members) ->
            // Use the getter's return type for the class attribute type annotation
            let getter = members |> Seq.find (fun memb -> memb.IsGetter)
            let ta, _ = Annotation.typeAnnotation com ctx None getter.ReturnParameter.Type

            if parms.Init then
                // For attributes style with init, class attributes should only have type annotations
                // Default values are handled by the constructor parameters
                Statement.annAssign (Expression.name (propertyName |> Naming.toPropertyNaming), annotation = ta)
            else
                // For attributes style with init=false, avoid emitting initializers that reference
                // constructor parameters (e.g., Age: int = Age) because no __init__ is generated and
                // libraries like Pydantic will synthesize it. Keep literal/call defaults like Field("...").
                let defaultValueOpt =
                    extractedInitialValues
                    |> List.tryFind (fun (propName, _getterMemb, _defaultValue) ->
                        propName = (propertyName |> Naming.toPropertyNaming)
                    )
                    |> Option.map (fun (_propName, _getterMemb, defaultValue) -> defaultValue)

                match defaultValueOpt with
                // Skip defaults that are just bare names (likely ctor params), emit only annotation
                | Some(Name _) ->
                    Statement.annAssign (Expression.name (propertyName |> Naming.toPropertyNaming), annotation = ta)
                // If we have a non-name default (e.g., Field("Name")), keep it
                | Some defaultValue ->
                    Statement.annAssign (
                        Expression.name (propertyName |> Naming.toPropertyNaming),
                        annotation = ta,
                        value = defaultValue
                    )
                // Otherwise, emit only the annotation (no default)
                | None ->
                    Statement.annAssign (Expression.name (propertyName |> Naming.toPropertyNaming), annotation = ta)
        )
        |> List.ofSeq
    | _ -> []

/// Generate class-level annotations for static fields.
/// This is needed because static let bindings in F# are compiled to a static constructor
/// that assigns to class attributes, but Python type checkers (Pylance/Pyright) require
/// class-level declarations for these attributes to be recognized (per PEP 526).
let generateStaticFieldAnnotations (com: IPythonCompiler) (ctx: Context) (ent: Fable.Entity) : Statement list =
    ent.FSharpFields
    |> List.choose (fun field ->
        // Filter out compiler-generated fields (e.g., "init@110-1" from tuple patterns)
        // which contain special characters not valid in Python identifiers
        if field.IsStatic && not (field.Name.Contains("@")) then
            let fieldName = field.Name |> Naming.toPythonNaming
            let ta, _ = Annotation.typeAnnotation com ctx None field.FieldType
            Some(Statement.annAssign (Expression.name fieldName, annotation = ta))
        else
            None
    )

let declareClassType
    (com: IPythonCompiler)
    (ctx: Context)
    (ent: Fable.Entity)
    (entName: string)
    (consArgs: Arguments)
    (isOptional: bool)
    (consBody: Statement list)
    (baseExpr: Expression option)
    (classMembers: Statement list)
    (slotMembers: Statement list)
    (classAttributes: ClassAttributes option)
    (attachedMembers: Fable.MemberDecl list)
    (extractedInitialValues: (string * Fable.MemberDecl * Expression) list)
    =
    // printfn "declareClassType: %A" consBody
    let typeParams = makeEntityTypeParams com ctx ent

    let fieldTypes =
        if ent.IsValueType then
            Some(ent.FSharpFields |> List.map (fun f -> f.FieldType))
        else
            None

    // Generate class constructor if init is enabled
    let classCons =
        match classAttributes with
        | Some parms when not parms.Init -> [] // Skip constructor when init=false
        | _ -> makeClassConstructor consArgs isOptional fieldTypes com ctx consBody

    let classFields = slotMembers // TODO: annotations

    // Generate class-level annotations for static fields (e.g., from static let bindings)
    let staticFieldAnnotations = generateStaticFieldAnnotations com ctx ent

    // Generate class attributes if using attributes style
    let classAttributes =
        transformClassAttributes com ctx ent classAttributes extractedInitialValues

    let classMembers = classCons @ classMembers

    let classBody =
        let body =
            [
                yield! classFields
                yield! staticFieldAnnotations
                yield! classAttributes
                yield! classMembers
            ]

        match body with
        | [] -> [ Statement.ellipsis ]
        | _ -> body

    let interfaces, stmts =
        // We only use a few interfaces as base classes. The rest is handled as Python protocols (PEP 544) to avoid a massive
        // inheritance tree that will prevent Python of finding a consistent method resolution order.
        // Note: IEquatable_1 and IComparable are NOT mapped to ABC bases because:
        // 1. Union/Record/ValueType already have Equals/CompareTo in their base classes
        // 2. Regular classes get mangled method names that don't match ABC abstract methods
        // 3. Use Py.Equatable/Py.Comparable marker interfaces for classes with override Equals/CompareTo

        // Check if class implements IEnumerator_1 (which already inherits from IDisposable)
        let hasIEnumerator =
            ent.AllInterfaces
            |> Seq.exists (fun int -> Helpers.removeNamespace (int.Entity.FullName) = "IEnumerator_1")

        // Check if class implements IEnumerable_1 (avoid duplicate EnumerableBase from Py.Iterable)
        let hasIEnumerable =
            ent.AllInterfaces
            |> Seq.exists (fun int -> Helpers.removeNamespace (int.Entity.FullName) = "IEnumerable_1")

        // Check if class implements IDisposable (avoid duplicate DisposableBase from Py.ContextManager)
        let hasIDisposable =
            ent.AllInterfaces
            |> Seq.exists (fun int -> Helpers.removeNamespace (int.Entity.FullName) = "IDisposable")

        ent.AllInterfaces
        |> List.ofSeq
        |> List.filter (fun int ->
            let name = Helpers.removeNamespace (int.Entity.FullName)
            // Filter out IDisposable if IEnumerator_1 is present to avoid diamond inheritance
            // Filter out Py.Iterable if IEnumerable_1 is present to avoid duplicate EnumerableBase
            // Filter out Py.ContextManager if IDisposable is present to avoid duplicate DisposableBase
            Bases.allowedInterfaces |> List.contains name
            && not (hasIEnumerator && name = "IDisposable")
            && not (hasIEnumerable && name = "Iterable")
            && not (hasIDisposable && name = "ContextManager")
        )
        |> List.collect (fun int ->
            let name = Helpers.removeNamespace int.Entity.FullName
            let fullName = int.Entity.FullName

            // Map interface names to ABC base class(es) using shared helper
            let abcClasses =
                match Bases.getAbcClassesForInterface name fullName with
                | Some classes -> classes
                | None -> [ name ] // Fallback: use the interface name itself

            // Filter out self-referential generic arguments to avoid forward reference errors
            let genericArgs =
                int.GenericArgs
                |> List.filter (fun genArg ->
                    match genArg with
                    | Fable.DeclaredType({ FullName = fullName }, _) ->
                        Naming.toPascalCase (Helpers.removeNamespace fullName) <> entName
                    | _ -> true
                )

            // Generate the ABC base class references
            abcClasses
            |> List.map (fun abcClassName ->
                let expr = Bases.makeAbcBaseExpr com ctx abcClassName genericArgs
                expr, []
            )
        )
        |> Helpers.unzipArgs

    // For abstract classes, add ABC as a base class
    let abcBase =
        if ent.IsAbstractClass then
            [ com.GetImportExpr(ctx, "abc", "ABC") ]
        else
            []

    let bases = (baseExpr |> Option.toList) @ abcBase
    let name = com.GetIdentifier(ctx, Naming.toPascalCase entName)

    // Check if the class has static properties using proper detection
    let hasStaticProperties =
        // Don't apply metaclass to classes that inherit from base types with existing metaclasses
        let hasConflictingBase =
            baseExpr
            |> Option.exists (fun expr ->
                match expr with
                | Expression.Attribute { Attr = Identifier name } when
                    name = "Union" || name = "Record" || name = "FSharpException"
                    ->
                    true
                | Expression.Name { Id = Identifier name } when
                    name = "Union" || name = "Record" || name = "FSharpException"
                    ->
                    true
                | _ -> false
            )
            || ent.IsFSharpUnion
            || ent.IsFSharpRecord
            || ent.IsFSharpExceptionDeclaration

        if hasConflictingBase then
            false
        else
            // Get the original member declarations from the entity
            let members = ent.MembersFunctionsAndValues

            members
            |> Seq.exists (fun info -> not info.IsInstance && (info.IsGetter || info.IsSetter))

    let keywords =
        // Add metaclass if the class has static properties but only if the class is
        // decorated with [<AttachMembers>]
        if hasStaticProperties && hasAttribute Atts.attachMembers ent.Attributes then
            let staticPropertyMetaExpr = libValue com ctx "util" "StaticPropertyMeta"
            [ Keyword.keyword (Identifier "metaclass", staticPropertyMetaExpr) ]
        else
            []

    // Generate custom decorators from [<Decorate>] attributes
    let customDecorators =
        let decoratorInfos = Util.getDecoratorInfo com ent.Attributes
        Util.generateDecorators com ctx decoratorInfos

    stmts
    @ [
        Statement.classDef (
            name,
            body = classBody,
            bases = bases @ interfaces,
            typeParams = typeParams,
            keywords = keywords,
            decoratorList = customDecorators
        )
    ]

let createSlotsForRecordType (com: IPythonCompiler) ctx (classEnt: Fable.Entity) =
    let strFromIdent (ident: Identifier) = ident.Name

    if classEnt.IsValueType then
        let elements =
            getEntityFieldsAsProps com ctx classEnt
            |> Array.map (nameFromKey com ctx >> strFromIdent >> Expression.stringConstant)
            |> Array.toList

        let slots = Expression.list (elements, Load)

        [ Statement.assign ([ Expression.name ("__slots__", Store) ], slots) ]
    else
        []

let declareType
    (com: IPythonCompiler)
    (ctx: Context)
    (ent: Fable.Entity)
    (entName: string)
    (consArgs: Arguments)
    (isOptional: bool)
    (consBody: Statement list)
    (baseExpr: Expression option)
    (classMembers: Statement list)
    (pythonClassParams: ClassAttributes option)
    (attachedMembers: Fable.MemberDecl list)
    (extractedInitialValues: (string * Fable.MemberDecl * Expression) list)
    : Statement list
    =
    let slotMembers = createSlotsForRecordType com ctx ent

    let typeDeclaration =
        match ent.IsFSharpRecord with
        | true ->
            declareDataClassType com ctx ent entName consArgs isOptional consBody baseExpr classMembers slotMembers
        | false ->
            declareClassType
                com
                ctx
                ent
                entName
                consArgs
                isOptional
                consBody
                baseExpr
                classMembers
                slotMembers
                pythonClassParams
                attachedMembers
                extractedInitialValues

    let reflectionDeclaration, stmts =
        let ta = fableModuleAnnotation com ctx "Reflection" "TypeInfo" []

        let genArgs =
            Array.init ent.GenericParameters.Length (fun i -> "gen" + string<int> i |> makeIdent)

        let args =
            genArgs
            |> Array.mapToList (fun id -> Arg.arg (ident com ctx id, annotation = ta))

        let args = Arguments.arguments args
        let generics = genArgs |> Array.mapToList (identAsExpr com ctx)

        let body, stmts = transformReflectionInfo com ctx None ent generics
        let expr, stmts' = makeFunctionExpression com ctx None (args, body, [], ta)

        let name = com.GetIdentifier(ctx, entName + Naming.reflectionSuffix)

        expr |> declareModuleMember com ctx ent.IsPublic name None, stmts @ stmts'

    stmts @ typeDeclaration @ reflectionDeclaration

let tryParseEmitMethodMacro (macro: string) =
    // Parse EmitMethod macros like "$0.methodName($1...)" to extract method name
    let pattern = @"\$0\.(\w+)\(\$1\.\.\.\)"
    let regex = Regex pattern
    let m = macro |> regex.Match

    if m.Success then
        Some m.Groups[1].Value
    else
        None

let tryParseEmitConstructorMacro (macro: string) =
    // Parse EmitConstructor macros like "new $0($1...)" to extract constructor call
    let pattern = @"new \$0\(\$1\.\.\.\)"
    let regex = Regex pattern
    let m = macro |> regex.Match

    if m.Success then
        Some() // Return Some unit to indicate it's a constructor pattern
    else
        None

let calculateTypeParams
    (com: IPythonCompiler)
    ctx
    (info: Fable.MemberFunctionOrValue)
    (argTypes: Fable.Type list)
    (bodyType: Fable.Type)
    =
    // Calculate type parameters for Python 3.12 syntax
    // Use Fable AST types directly instead of Python AST heuristics
    let explicitGenerics = Annotation.getMemberGenParams info.GenericParameters

    let signatureGenerics =
        (getGenericTypeParams (argTypes @ [ bodyType ]), ctx.ScopedTypeParams)
        ||> Set.difference

    let repeatedGenerics =
        Set.empty
        |> Set.union explicitGenerics
        |> Set.union signatureGenerics
        // Filter out generics that are already defined at class level
        |> Set.difference
        <| ctx.ScopedTypeParams

    // Use constraint-aware version to preserve type bounds (e.g., 'T :> IDisposable)
    Annotation.makeFunctionTypeParamsWithConstraints com ctx info.GenericParameters repeatedGenerics

let transformModuleFunction
    (com: IPythonCompiler)
    ctx
    (info: Fable.MemberFunctionOrValue)
    (membName: string)
    (fableArgs: Fable.Ident list)
    (body: Fable.Expr)
    =
    let argTypes = fableArgs |> List.map _.Type

    // Compute which type params will be declared in this function's PEP 695 []
    // BEFORE transforming the body, so inner functions know these are already in scope
    // and won't re-declare them (which would cause "TypeVar already in use" errors).
    let explicitGenerics = Annotation.getMemberGenParams info.GenericParameters

    let signatureGenerics =
        (getGenericTypeParams (argTypes @ [ body.Type ]), ctx.ScopedTypeParams)
        ||> Set.difference

    let declaredTypeParams =
        Set.empty
        |> Set.union explicitGenerics
        |> Set.union signatureGenerics
        |> Set.difference
        <| ctx.ScopedTypeParams

    let ctxWithDeclaredParams =
        { ctx with ScopedTypeParams = Set.union ctx.ScopedTypeParams declaredTypeParams }

    let args, body', returnType =
        getMemberArgsAndBody com ctxWithDeclaredParams (NonAttached membName) info.HasSpread fableArgs body

    let typeParams =
        Annotation.makeFunctionTypeParamsWithConstraints com ctx info.GenericParameters declaredTypeParams

    let name = com.GetIdentifier(ctx, membName |> Naming.toPythonNaming)

    let isAsync = isTaskType body.Type

    let stmt =
        createFunctionWithTypeParams name args body' [] returnType info.XmlDoc typeParams isAsync

    let expr = Expression.name name

    info.Attributes
    |> hasAttribute Atts.entryPoint
    |> function
        | true -> [ stmt; declareEntryPoint com ctx expr ]
        | false ->
            if com.OutputType = OutputType.Library then
                com.AddExport membName |> ignore

            [ stmt ]

let transformAction (com: IPythonCompiler) ctx expr = transformAsStatements com ctx None expr

let nameFromKey (com: IPythonCompiler) (ctx: Context) key =
    match key with
    | Expression.Name { Id = ident } -> ident
    | Expression.Constant(value = StringLiteral name) -> com.GetIdentifier(ctx, name)
    | name -> failwith $"Not a valid name: %A{name}"

let generateStaticPropertySetter
    (com: IPythonCompiler)
    (ctx: Context)
    (className: string)
    (propertyName: string)
    (setterBody: Statement list)
    (args: Arguments)
    : Statement
    =
    let functionName = $"_%s{className}_%s{propertyName}_setter"
    let functionNameIdent = com.GetIdentifier(ctx, functionName)

    // Create setter function with just the value parameter (remove 'self' for static)
    let setterArgs =
        match args.Args with
        | [ _self; valueArg ] -> Arguments.arguments [ valueArg ]
        | [ valueArg ] -> Arguments.arguments [ valueArg ]
        | _ -> Arguments.arguments [ Arg.arg "value" ]

    Statement.functionDef (functionNameIdent, setterArgs, body = setterBody)

// Check if a class needs StaticProperty descriptor (has static properties)
let classHasStaticProperties (members: Fable.MemberDecl list) (com: IPythonCompiler) : bool =
    members
    |> List.exists (fun memb ->
        let info = com.GetMember(memb.MemberRef)
        not info.IsInstance && (info.IsGetter || info.IsSetter)
    )

let transformAttachedProperty
    (com: IPythonCompiler)
    ctx
    (ent: Fable.Entity)
    (info: Fable.MemberFunctionOrValue)
    (memb: Fable.MemberDecl)
    (pythonClassParams: ClassAttributes option)
    =
    let isStatic = not info.IsInstance
    let isGetter = info.IsGetter

    // For static properties, we'll handle them differently using descriptors
    if isStatic then
        // Static properties need special handling - return empty list for now
        // They will be processed at the class level
        []
    else
        // Check if we should use attributes style
        let useAttributesStyle =
            match pythonClassParams with
            | Some parms when parms.Style = ClassStyle.Attributes -> true
            | _ -> false

        if useAttributesStyle then
            // For attributes style, we don't generate property methods
            // The attributes will be handled at the class level
            []
        else
            // Instance properties use the traditional approach (properties style)
            // Get custom decorators from Py.Decorate attributes
            let customDecorators =
                let decoratorInfos = Util.getDecoratorInfo com info.Attributes
                Util.generateDecorators com ctx decoratorInfos

            let decorators =
                customDecorators
                @ [
                    if isGetter then
                        Expression.name "property"
                    else
                        Expression.name $"%s{memb.Name}.setter"
                ]

            let args, body, returnType =
                getMemberArgsAndBody com ctx (Attached isStatic) false memb.Args memb.Body

            // Apply the same naming convention as record fields for record types
            let propertyName =
                //if shouldUseRecordFieldNaming ent then
                //    memb.Name |> Naming.toFieldSnakeCase |> Helpers.clean
                //else
                memb.Name |> Naming.toPropertyNaming

            let key = com.GetIdentifier(ctx, propertyName)

            let self = Arg.arg "self"
            let arguments = { args with Args = self :: args.Args }

            let argTypes = memb.Args |> List.map _.Type
            let typeParams = calculateTypeParams com ctx info argTypes memb.Body.Type

            let isAsync = isTaskType memb.Body.Type

            createFunctionWithTypeParams key arguments body decorators returnType None typeParams isAsync
            |> List.singleton

let transformAttachedMethod (com: IPythonCompiler) ctx (info: Fable.MemberFunctionOrValue) (memb: Fable.MemberDecl) =
    let isStatic = not info.IsInstance

    // Check if this method has Py.ClassMethod attribute
    let hasClassMethodAttribute =
        info.Attributes
        |> Seq.exists (fun att -> att.Entity.FullName = Atts.pyClassMethod)

    // Get custom decorators from Py.Decorate attributes
    let customDecorators =
        let decoratorInfos = Util.getDecoratorInfo com info.Attributes
        Util.generateDecorators com ctx decoratorInfos

    let decorators =
        // Custom decorators come first (outermost), then static/classmethod decorator
        customDecorators
        @ if isStatic then
              if hasClassMethodAttribute then
                  [ Expression.name "classmethod" ]
              else
                  [ Expression.name "staticmethod" ]
          else
              []

    let argTypes = memb.Args |> List.map _.Type
    let typeParams = calculateTypeParams com ctx info argTypes memb.Body.Type

    let makeMethod name argCount args body decorators returnType =
        let key = memberFromName com ctx name (Some argCount) |> nameFromKey com ctx
        let isAsync = isTaskType memb.Body.Type

        createFunctionWithTypeParams key args body decorators returnType None typeParams isAsync

    let args, body, returnType =
        getMemberArgsAndBody com ctx (Attached isStatic) info.HasSpread memb.Args memb.Body

    let args =
        let declaredAsGenericSingleArg =
            List.isEmpty args.Defaults
            && List.length args.Args = 1
            && (
                match info.CurriedParameterGroups |> List.collect id with
                | [ p ] ->
                    match p.Type with
                    | Fable.GenericParam _ -> true
                    | _ -> false
                | _ -> false
            )

        if declaredAsGenericSingleArg then
            { args with Defaults = [ libValue com ctx "util" "UNIT" ] }
        else
            args

    let self = Arg.arg "self"

    let arguments =
        if isStatic then
            args
        else
            { args with Args = self :: args.Args }

    // Classes that need __iter__ should define it explicitly through interfaces like Py.MutableMapping
    [
        makeMethod memb.Name (List.length memb.Args) arguments body decorators returnType
    ]

let transformUnion (com: IPythonCompiler) ctx (ent: Fable.Entity) (entName: string) classMembers =
    // Get generic type parameters for the union
    let typeParams = makeEntityTypeParams com ctx ent

    // Get generic parameter names for parameterizing base class in case classes
    // Use uppercase and clean to match makeTypeParams behavior
    let genParamNames =
        ent.GenericParameters
        |> List.map (fun p -> p.Name.ToUpperInvariant() |> Helpers.clean)

    // Generate the cases() static method for the base class
    let casesMethod =
        let expr, stmts =
            ent.UnionCases
            |> Seq.map (getUnionCaseName >> makeStrConst)
            |> Seq.toList
            |> makeList com ctx

        let name = Identifier "cases"
        let body = stmts @ [ Statement.return' expr ]
        let decorators = [ Expression.name "staticmethod" ]

        let returnType =
            Expression.subscript (Expression.name "list", Expression.name "str")

        Statement.functionDef (
            name,
            Arguments.arguments (),
            body = body,
            returns = returnType,
            decoratorList = decorators
        )

    // Generate the base class (e.g., MyUnion[T](Union) or MyUnion(Union))
    let baseUnionExpr = libValue com ctx "union" "Union"
    // casesMethod is always present, so body is never empty
    let baseClassBody = casesMethod :: classMembers

    // Base class uses leading underscore (private), type alias gets clean name (public)
    let baseClassName = com.GetIdentifier(ctx, "_" + entName)

    let baseClassDef =
        Statement.classDef (baseClassName, bases = [ baseUnionExpr ], body = baseClassBody, typeParams = typeParams)

    // Generate case classes with @tagged_union decorator
    let caseClasses =
        ent.UnionCases
        |> List.indexed
        |> List.collect (fun (tag, uci) ->
            // Use full case class name (UnionName_CaseName) to avoid collisions
            // Pass the entity name to ensure consistent scoping with base class
            let caseClassName = getUnionCaseClassName com ent uci (Some entName)
            let caseClassIdent = com.GetIdentifier(ctx, caseClassName)

            // Export the case class for library builds
            if com.OutputType = OutputType.Library then
                com.AddExport caseClassName |> ignore

            // Get the tagged_union decorator with the tag number (simple int literal)
            let taggedUnionDecorator =
                let taggedUnion = libValue com ctx "union" "tagged_union"
                let tagLiteral = Expression.intConstant tag
                Expression.call (taggedUnion, [ tagLiteral ])

            // Generate field annotations for the case class (field: type syntax)
            // Use a context without EnclosingUnionBaseClass so field types use type alias
            let caseCtx = { ctx with EnclosingUnionBaseClass = None }

            let fieldAnnotations =
                uci.UnionCaseFields
                |> List.map (fun field ->
                    // toFieldSnakeCase appends '_' to camelCase names ("name" -> "name_") so a
                    // field can't collide with the inherited `Union.name` property, which @dataclass
                    // would treat as a default value ("non-default argument follows default"). See #4645.
                    let fieldName = field.Name |> Naming.toFieldSnakeCase |> Helpers.clean
                    // Uncurry lambda types for field annotations since union case fields
                    // store uncurried functions at runtime (same as record fields)
                    let fieldType =
                        match field.FieldType with
                        | Fable.LambdaType _ -> FableTransforms.uncurryType field.FieldType
                        | _ -> field.FieldType

                    let ta, _ = Annotation.typeAnnotation com caseCtx None fieldType
                    let target = Expression.name (fieldName, Store)
                    // Use annAssign to generate: field: type (not field = type)
                    Statement.annAssign (target, annotation = ta, simple = true)
                )

            // Declare the singleton as a ClassVar (assigned below, once the class exists) so
            // Pyright recognizes the attribute; ClassVar is excluded from dataclass fields.
            // The type is a quoted forward reference since the class isn't defined yet here.
            let singletonAnnotation =
                if List.isEmpty uci.UnionCaseFields then
                    let classVar = com.GetImportExpr(ctx, "typing", "ClassVar")
                    let selfType = Expression.stringConstant caseClassName
                    let classVarAnnotation = Expression.subscript (classVar, selfType)

                    [
                        Statement.annAssign (
                            Expression.name unionCaseSingletonAttrName,
                            annotation = classVarAnnotation
                        )
                    ]
                else
                    []

            let caseClassBody =
                match fieldAnnotations @ singletonAnnotation with
                | [] -> [ Statement.ellipsis ]
                | body -> body

            // The case class inherits from the parameterized base union class
            // e.g., class Either_Left[TL, TR](_Either_2[TL, TR]): ...
            let baseClassExpr =
                Expression.name ("_" + entName)
                |> Annotation.makeGenericParamSubscript genParamNames

            let caseClassDef =
                Statement.classDef (
                    caseClassIdent,
                    bases = [ baseClassExpr ],
                    body = caseClassBody,
                    decoratorList = [ taggedUnionDecorator ],
                    typeParams = typeParams
                )

            // fsc represents a union case with no fields as a single shared instance, so e.g.
            // `LanguagePrimitives.PhysicalEquality X.A X.A` is true. Mirror that by precomputing
            // one instance and reusing it (see the NewUnion case above) instead of constructing
            // a new one on every access.
            let singletonDecl =
                if List.isEmpty uci.UnionCaseFields then
                    let target =
                        Expression.attribute (Expression.name caseClassIdent, unionCaseSingletonAttr, Store)

                    [
                        Statement.assign ([ target ], Expression.call (Expression.name caseClassIdent, []))
                    ]
                else
                    []

            caseClassDef :: singletonDecl
        )

    // Generate type alias: type MyUnion[T] = MyUnion_CaseA[T] | MyUnion_CaseB[T] | ...
    // The type alias uses the clean name (public API), base class uses underscore prefix (private)
    let typeAlias =
        let aliasName = Expression.name entName

        // If generic, parameterize each case type
        let caseTypes =
            ent.UnionCases
            |> List.map (fun uci ->
                // Use the full case class name (UnionName_CaseName)
                let caseClassName = getUnionCaseClassName com ent uci (Some entName)

                Expression.name caseClassName
                |> Annotation.makeGenericParamSubscript genParamNames
            )

        let unionType =
            match caseTypes with
            | [] -> Expression.name "None"
            | [ single ] -> single
            | first :: rest -> List.fold (fun acc t -> Expression.binOp (acc, BitOr, t)) first rest

        Statement.typeAlias (aliasName, unionType, typeParams = typeParams)

    // Generate reflection declaration for the union type (same as for records/classes)
    let reflectionDeclaration, reflectionStmts =
        let ta = fableModuleAnnotation com ctx "reflection" "TypeInfo" []

        let genArgs =
            Array.init ent.GenericParameters.Length (fun i -> "gen" + string<int> i |> makeIdent)

        let args =
            genArgs
            |> Array.mapToList (fun id -> Arg.arg (ident com ctx id, annotation = ta))

        let args = Arguments.arguments args
        let generics = genArgs |> Array.mapToList (identAsExpr com ctx)

        let body, stmts = transformReflectionInfo com ctx None ent generics
        let expr, stmts' = makeFunctionExpression com ctx None (args, body, [], ta)

        let name = com.GetIdentifier(ctx, entName + Naming.reflectionSuffix)

        expr |> declareModuleMember com ctx ent.IsPublic name None, stmts @ stmts'

    // Return all statements: base class, case classes, type alias, reflection
    reflectionStmts
    @ [ baseClassDef ]
    @ caseClasses
    @ [ typeAlias ]
    @ reflectionDeclaration

let transformClassWithCompilerGeneratedConstructor
    (com: IPythonCompiler)
    ctx
    (ent: Fable.Entity)
    (entName: string)
    classMembers
    (classAttributes: ClassAttributes)
    =
    // printfn "transformClassWithCompilerGeneratedConstructor"
    let fieldIds = getEntityFieldsAsIdents com ent

    let args =
        fieldIds
        |> Array.map (fun id -> com.GetIdentifier(ctx, id.Name) |> Expression.name)

    let isOptional =
        Helpers.isOptional fieldIds || ent.IsFSharpRecord || ent.IsValueType

    let baseExpr =
        if ent.IsFSharpExceptionDeclaration then
            libValue com ctx "exceptions" "FSharpException" |> Some
        elif ent.IsFSharpRecord || ent.IsValueType then
            libValue com ctx "record" "Record" |> Some
        else
            None

    let body =
        [
            if Option.isSome baseExpr then
                yield callSuperAsStatement []

            // For attributes style, use direct attribute names and proper parameter handling
            if classAttributes.Style = ClassStyle.Attributes then
                yield!
                    ent.FSharpFields
                    |> List.filter (fun field -> not field.IsStatic)
                    |> List.collect (fun field ->
                        let fieldName = field.Name |> Naming.toPropertyNaming
                        let left = get com ctx None thisExpr fieldName false
                        // For attributes style, use the property name as the argument name
                        let argName = field.Name |> Naming.toPropertyNaming
                        let right = Expression.name argName |> wrapIntExpression field.FieldType

                        // Always assign the parameter value to the attribute
                        assign None left right |> exprAsStatement ctx
                    )
            else
                yield!
                    ent.FSharpFields
                    |> List.filter (fun field -> not field.IsStatic)
                    |> List.collecti (fun i field ->
                        let fieldName =
                            if shouldUseRecordFieldNaming ent then
                                field.Name |> Naming.toFieldSnakeCase |> Helpers.clean
                            else
                                match Util.getFieldNamingKind com field.FieldType field.Name with
                                | InstancePropertyBacking -> field.Name |> Naming.toPropertyBackingFieldNaming
                                | StaticProperty -> field.Name |> Naming.toPropertyNaming
                                | RegularField -> field.Name |> Naming.toPythonNaming

                        let left = get com ctx None thisExpr fieldName false
                        let right = args[i] |> wrapIntExpression field.FieldType

                        assign None left right |> exprAsStatement ctx
                    )
        ]

    let args =
        fieldIds
        |> Array.mapToList (fun id ->
            let ta, _ = Annotation.typeAnnotation com ctx None id.Type
            Arg.arg (ident com ctx id, annotation = ta)
        )
        |> (fun args -> Arguments.arguments (args = args))

    declareType com ctx ent entName args isOptional body baseExpr classMembers (Some classAttributes) [] []

let transformClassWithPrimaryConstructor
    (com: IPythonCompiler)
    ctx
    (classDecl: Fable.ClassDecl)
    (classMembers: Statement list)
    (cons: Fable.MemberDecl)
    (classAttributes: ClassAttributes)
    =
    // printfn "transformClassWithPrimaryConstructor: %A" classDecl.Name
    // printfn "PythonClass params: style=%A, init=%b" classAttributes.Style classAttributes.Init
    let classEnt = com.GetEntity(classDecl.Entity)
    let classIdent = Expression.name (com.GetIdentifier(ctx, classDecl.Name))

    // Extract initial values from constructor body for both init=true and init=false cases
    let getterMembers =
        if classAttributes.Style = ClassStyle.Attributes then
            classDecl.AttachedMembers
            |> List.filter (fun memb ->
                let info = com.GetMember(memb.MemberRef)
                info.IsGetter
            )
        else
            []

    let extractedInitialValues, stmts =
        if classAttributes.Style = ClassStyle.Attributes then
            getterMembers
            |> List.map (fun getterMemb ->
                // printfn "Extracting default value for property %s" (getterMemb.Name |> Naming.toPropertyNaming)
                let propertyName = getterMemb.Name |> Naming.toPropertyNaming

                let extracted =
                    Util.tryExtractInitializationValueFromConstructor com ctx cons.Body propertyName

                let result, stmts =
                    extracted
                    |> Option.defaultWith (fun () ->
                        // printfn "Using type default for property %s" propertyName
                        Util.getDefaultValueForType com ctx getterMemb.Body.Type, []
                    )
                // printfn "Final default value for %s: %A" propertyName result
                (propertyName, getterMemb, result), stmts
            )
            |> List.unzip
            // Flatten the list of statements generated from the property extractions
            |> fun (extractedInitialValues, stmts) -> extractedInitialValues, List.concat stmts
        else
            [], []

    let consArgs, consBody, _returnType =
        if classAttributes.Style = ClassStyle.Attributes then
            if classAttributes.Init then
                // For attributes style with init=true, generate new constructor with property names
                // Place required params (no safe default) before optional params (with safe default),
                // so Python's trailing-default rule is respected.
                let requiredProps, optionalProps =
                    extractedInitialValues
                    |> List.partition (fun (propertyName, _getterMemb, defaultValue) ->
                        match defaultValue with
                        // Treat as required only when default is a bare name equal to the parameter itself
                        // e.g., Age: int = Age. Keep None and other expressions as optional defaults.
                        | Name name when name.Id.Name = propertyName -> true
                        | _ -> false
                    )

                let propertyArgs =
                    let toArg (propertyName: string, getterMemb: Fable.MemberDecl, _defaultValue: Expression) =
                        let ta, _ = Annotation.typeAnnotation com ctx None getterMemb.Body.Type
                        Arg.arg (propertyName, annotation = ta)

                    let argsRequired = requiredProps |> List.map toArg
                    let argsOptional = optionalProps |> List.map toArg

                    let defaults = optionalProps |> List.map (fun (_pn, _gm, dv) -> dv)

                    Arguments.arguments (args = (argsRequired @ argsOptional), defaults = defaults)

                let propertyBody =
                    extractedInitialValues
                    |> List.collect (fun (propertyName, _getterMemb, _defaultValue) ->
                        let left = get com ctx None thisExpr propertyName false
                        let right = Expression.name propertyName
                        assign None left right |> exprAsStatement ctx
                    )

                propertyArgs, propertyBody, Expression.none
            else
                // For attributes style with init=false, no constructor arguments or body
                Arguments.empty, [], Expression.none
        else
            let info = com.GetMember(cons.MemberRef)
            getMemberArgsAndBody com ctx ClassConstructor info.HasSpread cons.Args cons.Body

    let isOptional = Helpers.isOptional (cons.Args |> Array.ofList)

    // Change exposed constructor's return type from None to entity type.
    // Use None for repeatedGenerics to include all class type parameters in the return type,
    // not just those that appear in constructor arguments. The exposed constructor wrapper
    // declares all class type params as function type params, so they're all in scope.
    let returnType =
        let genParams = getEntityGenParams classEnt

        makeGenericTypeAnnotation' com ctx classDecl.Name (genParams |> List.ofSeq) None

    let exposedCons =
        if classAttributes.Style = ClassStyle.Attributes && not classAttributes.Init then
            // For attributes style with init=false, don't generate an exposed constructor
            // since there's no __init__ method to call
            []
        elif classEnt.IsAbstractClass then
            // Don't generate exposed constructor for abstract classes since they can't be instantiated
            []
        else
            let argExprs = consArgs.Args |> List.map (fun p -> Expression.identifier p.Arg)
            let exposedConsBody = Expression.call (classIdent, argExprs)
            let name = com.GetIdentifier(ctx, cons.Name)

            // Calculate type parameters for the exposed constructor wrapper
            // The exposed constructor is a module-level function, so it needs to declare
            // all type params including the class's type params (which are in ctx.ScopedTypeParams)
            let argTypes = cons.Args |> List.map _.Type

            let returnFableType =
                let genTypes =
                    classEnt.GenericParameters
                    |> List.map (fun gp -> Fable.Type.GenericParam(gp.Name, gp.IsMeasure, gp.Constraints))

                Fable.DeclaredType(classDecl.Entity, genTypes)

            // Use empty ScopedTypeParams since this is a module-level function
            let ctxForExposedCons = { ctx with ScopedTypeParams = Set.empty }
            let info = com.GetMember(cons.MemberRef)

            let typeParams =
                calculateTypeParams com ctxForExposedCons info argTypes returnFableType

            let body = wrapExprInBlockWithReturn (exposedConsBody, [])

            [
                createFunctionWithTypeParams name consArgs body [] returnType None typeParams false
            ]

    let baseExpr, consBody =
        classDecl.BaseCall
        |> extractBaseExprFromBaseCall com ctx classEnt.BaseType
        |> Option.orElseWith (fun () ->
            if classEnt.IsValueType then
                Some(libValue com ctx "record" "Record", ([], [], []))
            else
                None
        )
        |> Option.map (fun (baseExpr, (baseArgs, _kw, stmts)) ->
            let consBody = stmts @ [ callSuperAsStatement baseArgs ] @ consBody

            Some baseExpr, consBody
        )
        |> Option.defaultValue (None, consBody)

    [
        yield! stmts
        yield!
            declareType
                com
                ctx
                classEnt
                classDecl.Name
                consArgs
                isOptional
                consBody
                baseExpr
                classMembers
                (Some classAttributes)
                classDecl.AttachedMembers
                extractedInitialValues
        yield! exposedCons
    ]

let transformInterface (com: IPythonCompiler) ctx (classEnt: Fable.Entity) (_classDecl: Fable.ClassDecl) =
    // printfn "transformInterface"
    let classIdent = com.GetIdentifier(ctx, Helpers.removeNamespace classEnt.FullName)

    // Check if interface has [<Mangle>] attribute
    let isMangled = hasAttribute Atts.mangle classEnt.Attributes

    let members =
        classEnt.MembersFunctionsAndValues
        |> Seq.filter (fun memb ->
            not memb.IsProperty
            // Filter out methods with emit attributes (like EmitMethod, EmitConstructor, etc.)
            // These should be handled as emit expressions, not as interface methods
            && not (hasAnyEmitAttribute memb.Attributes)
        )
        |> List.ofSeq
        |> List.groupBy (fun memb -> memb.DisplayName)
        // Remove duplicate method when we have getters and setters
        |> List.collect (fun (_, gr) ->
            gr
            |> List.filter (fun memb -> gr.Length = 1 || (memb.IsGetter || memb.IsSetter))
        )

    // [<CLIEvent>] properties are represented in FCS as both an event property getter (e.g.
    // "Event" with CompiledName "get_Event") and add_/remove_ accessor methods. Object
    // expressions only implement the add_/remove_ methods, so we must exclude the event
    // property getter from the Protocol to avoid an unimplementable abstract member.
    let eventPropertyNames =
        members
        |> List.choose (fun m ->
            if m.CompiledName.StartsWith("add_", System.StringComparison.Ordinal) then
                Some(m.CompiledName.Substring(4))
            else
                None
        )
        |> Set.ofList

    let members =
        members
        |> List.filter (fun m -> not (eventPropertyNames.Contains(m.DisplayName)))

    let classMembers =
        [
            for memb in members do
                // Use mangled name if interface has [<Mangle>] attribute
                let name =
                    if isMangled then
                        Bases.InterfaceNaming.getMangledMemberName classEnt memb
                    elif memb.IsGetter || memb.IsSetter then
                        memb.CompiledName
                        |> Naming.removeGetSetPrefix
                        |> Naming.toPythonNaming
                        |> Helpers.clean
                    else
                        memb.DisplayName |> Naming.toPythonNaming |> Helpers.clean

                let abstractMethod = com.GetImportExpr(ctx, "abc", "abstractmethod")

                // For mangled interfaces, don't use @property decorators - members are plain methods
                let decorators =
                    [
                        if not isMangled && (memb.IsValue || memb.IsGetter) then
                            Expression.name "property"
                        if not isMangled && memb.IsSetter then
                            Expression.name $"%s{name}.setter"

                        abstractMethod
                    ] // Must be after @property

                let name = com.GetIdentifier(ctx, name)

                let args =
                    // Make protocol method parameters positional-only (using /) to avoid
                    // parameter name mismatch errors when subclasses use different names
                    // (e.g., value_1 instead of value due to closure captures)
                    let allParams =
                        memb.CurriedParameterGroups
                        |> Seq.indexed
                        |> Seq.collect (fun (n, parameterGroup) ->
                            parameterGroup |> Seq.indexed |> Seq.map (fun (m, pg) -> (n + m, pg))
                        )
                        |> Seq.toList

                    // Split regular params from vararg param using shared helper
                    let regularParams, varArgParam = splitVarArg memb.HasSpread allParams

                    let posOnlyArgs =
                        [
                            if memb.IsInstance then
                                Arg.arg "self"

                            for idx, pg in regularParams do
                                // Uncurry function types to match class implementations
                                // F# interface uses curried types (LambdaType) but class methods
                                // use uncurried types (DelegateType) at runtime
                                let paramType = FableTransforms.uncurryType pg.Type
                                let ta, _ = Annotation.typeAnnotation com ctx None paramType

                                Arg.arg (pg.Name |> Option.defaultValue $"__arg%d{idx}", annotation = ta)
                        ]

                    // For vararg parameter, extract element type from array type for annotation
                    let vararg =
                        varArgParam
                        |> Option.map (fun (_idx, pg) ->
                            let elementType = getVarArgElementType pg.Type
                            let ta, _ = Annotation.typeAnnotation com ctx None elementType
                            Arg.arg (pg.Name |> Option.defaultValue "rest", annotation = ta)
                        )

                    Arguments.arguments (posonlyargs = posOnlyArgs, ?vararg = vararg)

                // Also uncurry return type for consistency with class implementations
                let uncurriedReturnType = FableTransforms.uncurryType memb.ReturnParameter.Type
                let returnType, _ = Annotation.typeAnnotation com ctx None uncurriedReturnType

                let body = [ Statement.ellipsis ]

                // Calculate type parameters for generic abstract methods
                let typeParams = Annotation.makeMemberTypeParams com ctx memb.GenericParameters

                Statement.functionDef (
                    name,
                    args,
                    body,
                    returns = returnType,
                    decoratorList = decorators,
                    typeParams = typeParams
                )

            if members.IsEmpty then
                Statement.Pass
        ]

    let bases =
        [
            let interfaces =
                classEnt.AllInterfaces
                |> List.ofSeq
                |> List.choose (fun int ->
                    if int.Entity.FullName <> classEnt.FullName then
                        Some int.Entity
                    else
                        None
                )

            for ref in interfaces do
                let entity = com.TryGetEntity(ref)

                match entity with
                | Some entity ->
                    let expr, _stmts = Annotation.makeEntityTypeAnnotation com ctx entity.Ref [] None

                    expr
                | None -> ()

            // Always add Protocol as explicit base class for interfaces.
            // Per PEP 544: subclassing a protocol doesn't make the subclass a protocol
            // unless it also has typing.Protocol as an explicit base class.
            com.GetImportExpr(ctx, "typing", "Protocol")

        // Python 3.12: Generic type parameters are handled in class definition, not as base classes
        ]

    // Generate type parameters for Python 3.12
    let typeParams = makeEntityTypeParams com ctx classEnt

    [
        Statement.classDef (classIdent, body = classMembers, bases = bases, typeParams = typeParams)
    ]

// Helper function to extract initial value from getter body
// Returns (value, isFactory, externalFields, stmts) where isFactory indicates if the value is a lambda function,
// externalFields contains field names that need to be added as class attributes
// and stmts contains statements (e.g., local function declarations) from closures that need lifted out of the
// to the nearest enclosing scope.
let getInitialValue
    com
    ctx
    (className: string)
    (getterMemb: Fable.MemberDecl)
    (wrapInLambda: bool)
    (isUnion: bool)
    (fallback: Expression)
    : (Expression * bool * string list * Statement list)
    =
    match getterMemb.Body with
    | Fable.Value(kind, r) ->
        // Use transformValue for literal values - never wrapped
        let value, stmts = transformValue com ctx r kind

        if isUnion && wrapInLambda then
            // A union is emitted as a base class (`_Demo`) holding the static property
            // followed by the case classes (`Demo_A`, ...). Constructing a case eagerly in
            // the class body raises `NameError` because the case class doesn't exist yet.
            // Defer with a lambda (StaticLazyProperty); this also matches F# getter
            // semantics where the body is re-evaluated on each access.
            Expression.lambda (Arguments.arguments [], value), true, [], stmts
        else
            value, false, [], stmts
    | Fable.Get(Fable.IdentExpr _, Fable.FieldGet fieldInfo, _, _) when
        fieldInfo.Name.EndsWith("@", System.StringComparison.Ordinal)
        ->
        // For @ fields (backing fields), use fallback value directly instead of lambda reference
        // The static constructor will set the actual value
        fallback, false, [], []
    | Fable.Get(Fable.IdentExpr identExpr, Fable.FieldGet fieldInfo, _, _) when identExpr.Name = className ->
        // For external field references (like backing_field), create lambda and note the field
        let classNameExpr = Expression.name identExpr.Name
        let originalFieldName = fieldInfo.Name
        // Apply Python naming convention transformation to match setter/static constructor
        let transformedFieldName = originalFieldName |> Naming.toPythonNaming

        let fieldAccess =
            Expression.attribute (classNameExpr, Identifier transformedFieldName)

        if wrapInLambda then
            Expression.lambda (Arguments.arguments [], fieldAccess), true, [ transformedFieldName ], []
        else
            fieldAccess, false, [ transformedFieldName ], []
    | _ ->
        // For other expressions, try to transform
        try
            let expr, stmts = com.TransformAsExpr(ctx, getterMemb.Body)

            if wrapInLambda then
                Expression.lambda (Arguments.arguments [], expr), true, [], stmts
            else
                expr, false, [], stmts
        with _ ->
            fallback, false, [], []


// Process a single static property and return (property assignment, extra statements, external field declarations)
let transformStaticProperty
    (com: IPythonCompiler)
    (ctx: Context)
    (name: string)
    (ent: Fable.Entity)
    (propName: string)
    (members: Fable.MemberDecl list)
    =
    let getter =
        members |> List.tryFind (fun m -> (com.GetMember(m.MemberRef)).IsGetter)

    let setter =
        members |> List.tryFind (fun m -> (com.GetMember(m.MemberRef)).IsSetter)

    // printfn "transformStaticProperty: %A" propName
    let propertyName =
        if shouldUseRecordFieldNaming ent then
            propName |> Naming.toFieldSnakeCase |> Helpers.clean
        else
            propName |> Naming.toPropertyNaming

    // Create generic StaticProperty with type parameter for better type inference
    let makeStaticProperty (propType: Fable.Type) args isFactory =
        let className =
            if isFactory then
                "StaticLazyProperty"
            else
                "StaticProperty"

        let staticPropertyClass = libValue com ctx "util" className

        // `StaticProperty[T]` is a value expression evaluated in the class body, so a type
        // referencing the enclosing entity (not yet bound there) raises `NameError`. Quoting just
        // the name is not enough — an operator like the `|` in `Example | None` still runs eagerly
        // and fails on a string operand. So emit the whole annotation as one string forward
        // reference: it never evaluates at runtime, yet the type checker resolves it at module scope.
        let referencesEnclosingEntity (propType: Fable.Type) =
            // Walk the type structurally via `Type.Generics`, which enumerates the generic args of
            // every case (Array, Option, List, Tuple, Lambda/Delegate, Nullable, anonymous records,
            // nested declared types), so no shape is missed as new cases are added.
            let rec check (t: Fable.Type) =
                (match t with
                 | Fable.DeclaredType(entRef, _) -> (com.GetEntity entRef).FullName = ent.FullName
                 | _ -> false)
                || List.exists check t.Generics

            check propType

        let typeAnnotation =
            if referencesEnclosingEntity propType then
                // Render the enclosing union with its base-class name (`_Example`, not the alias
                // `Example`): both resolve at module scope inside the forward-reference string, but
                // the generated *value* is typed against the base class (e.g. a `unit -> Example`
                // factory produces `() -> _Example`), so the base name keeps the annotation and the
                // value consistent for the type checker. `typeAnnotation` still registers the
                // imports the string references (e.g. `Array`) as a side effect.
                let ctx = { ctx with EnclosingUnionBaseClass = Some ent.DisplayName }

                let ta, _ = Annotation.typeAnnotation com ctx None propType
                Expression.stringConstant (Annotation.annotationToString ta)
            else
                let ta, _ = Annotation.typeAnnotation com ctx None propType
                ta

        let genericStaticProperty =
            Expression.subscript (staticPropertyClass, typeAnnotation)

        Expression.call (genericStaticProperty, args)

    // StaticProperty descriptors handle their own storage - no separate backing fields needed

    // Helper function to generate external field declarations
    let generateExternalFieldDeclarations (externalFields: string list) =
        externalFields
        |> List.map (fun fieldName ->
            let fieldType = Expression.name "str" // Default to str type for external fields
            let defaultValue = Expression.stringConstant ""
            Statement.assign (Expression.name fieldName, fieldType, defaultValue)
        )

    match getter, setter with
    | Some getterMemb, None ->
        // Read-only property
        let fallback = Util.getDefaultValueForType com ctx getterMemb.Body.Type

        let initialValue, isFactory, externalFields, initialValueStmts =
            getInitialValue com ctx name getterMemb true ent.IsFSharpUnion fallback

        let propExpr = makeStaticProperty getterMemb.Body.Type [ initialValue ] isFactory

        // Generate class attribute declarations for external fields
        let externalFieldDeclarations = generateExternalFieldDeclarations externalFields

        Some(propertyName, propExpr), initialValueStmts @ externalFieldDeclarations

    | Some getterMemb, Some setterMemb ->
        // Property with both getter and setter
        let setterArgs, setterBody, _setterReturnType =
            getMemberArgsAndBody com ctx (Attached true) false setterMemb.Args setterMemb.Body

        let fallback = Util.getDefaultValueForType com ctx getterMemb.Body.Type

        let initialValue, isFactory, externalFields, initialValueStmts =
            getInitialValue com ctx name getterMemb true false fallback

        // Check if setter has custom logic beyond simple assignment to the property itself
        // For simple properties, we don't need setter functions since StaticProperty handles storage
        let hasCustomSetter =
            match setterBody with
            | [ Statement.Global { Names = [] }
                Statement.Assign {
                                     Targets = [ Expression.Attribute {
                                                                          Value = Expression.Name {
                                                                                                      Id = Identifier className_
                                                                                                  }
                                                                          Attr = Identifier propName_
                                                                      } ]
                                 } ] when className_ = name && propName_ = propertyName -> false // Simple assignment to the property itself - no custom setter needed
            | _ -> true // Has custom logic, multiple statements, or assigns to different fields

        if hasCustomSetter then
            // Generate setter function for complex setters
            let setterFunc =
                generateStaticPropertySetter com ctx name propertyName setterBody setterArgs

            let setterFuncName = $"_%s{name}_%s{propertyName}_setter"

            let propExpr =
                makeStaticProperty getterMemb.Body.Type [ initialValue; Expression.name setterFuncName ] isFactory

            // Generate class attribute declarations for external fields
            let externalFieldDeclarations = generateExternalFieldDeclarations externalFields

            Some(propertyName, propExpr), initialValueStmts @ [ setterFunc ] @ externalFieldDeclarations
        else
            // Simple setter, no custom function needed - just use the descriptor
            let propExpr = makeStaticProperty getterMemb.Body.Type [ initialValue ] isFactory

            // Generate class attribute declarations for external fields
            let externalFieldDeclarations = generateExternalFieldDeclarations externalFields

            Some(propertyName, propExpr), initialValueStmts @ externalFieldDeclarations

    | None, Some setterMemb ->
        // Setter-only property (unusual but possible)
        let setterArgs, setterBody, _setterReturnType =
            getMemberArgsAndBody com ctx (Attached true) false setterMemb.Args setterMemb.Body

        let setterFunc =
            generateStaticPropertySetter com ctx name propertyName setterBody setterArgs

        let setterFuncName = $"_%s{name}_%s{propertyName}_setter"

        // For setter-only properties, we need to get the type from somewhere
        // Use the setter's value parameter type
        let propertyType =
            match setterMemb.Args with
            | [ _; valueArg ] -> valueArg.Type
            | [ valueArg ] -> valueArg.Type
            | _ -> Fable.Any

        let propExpr =
            makeStaticProperty propertyType [ Expression.none; Expression.name setterFuncName ] false

        Some(propertyName, propExpr), [ setterFunc ]

    | None, None ->
        // Should not happen
        None, []

// Extract static properties handling into its own function
let transformStaticProperties (com: IPythonCompiler) (ctx: Context) (decl: Fable.ClassDecl) (ent: Fable.Entity) =

    let staticPropMembers =
        decl.AttachedMembers
        |> List.filter (fun memb ->
            let info = com.GetMember(memb.MemberRef)
            not info.IsInstance && (info.IsGetter || info.IsSetter) && not memb.IsMangled
        )

    if List.isEmpty staticPropMembers then
        [], [], []
    else
        // Group static properties by name
        let groupedProps =
            staticPropMembers |> List.groupBy (fun memb -> memb.Name) |> Map.ofList

        let propStatements = ResizeArray<Statement>()
        let propMap = ResizeArray<string * Expression>()

        // Process each static property
        for propName, members in Map.toList groupedProps do
            let propertyAssignment, extraStatements =
                transformStaticProperty com ctx decl.Name ent propName members

            match propertyAssignment with
            | Some(name, expr) -> propMap.Add((name, expr))
            | None -> ()

            extraStatements |> List.iter propStatements.Add

        let allStatements = List.ofSeq propStatements

        // Separate backing field declarations (for class body) from setter functions (for module level)
        let backingFieldDeclarations, setterFunctions =
            allStatements
            |> List.partition (fun stmt ->
                match stmt with
                | Statement.AnnAssign _ -> true // Backing field declarations go in class body
                | Statement.FunctionDef _ -> false // Setter functions go at module level
                | _ -> false
            )

        // Add static property declarations to class members
        let staticPropertyDeclarations =
            propMap
            |> Seq.toList
            |> List.map (fun (propName, propExpr) ->
                // Use the computed expression (factory function or value)
                Statement.assign ([ Expression.name propName ], propExpr)
            )

        // Return: (classMembers, setterFunctions, backingFieldDeclarations)
        staticPropertyDeclarations, setterFunctions, backingFieldDeclarations

let rec transformDeclaration (com: IPythonCompiler) ctx (decl: Fable.Declaration) =
    // printfn "transformDeclaration: %A" decl
    // printfn "ctx.UsedNames: %A" ctx.UsedNames

    let withCurrentScope (ctx: Context) (usedNames: Set<string>) f =
        let ctx =
            { ctx with UsedNames = { ctx.UsedNames with CurrentDeclarationScope = HashSet usedNames } }

        let result = f ctx

        ctx.UsedNames.DeclarationScopes.UnionWith(ctx.UsedNames.CurrentDeclarationScope)

        result

    match decl with
    | Fable.ModuleDeclaration decl -> decl.Members |> List.collect (transformDeclaration com ctx)

    | Fable.ActionDeclaration decl ->
        withCurrentScope ctx decl.UsedNames
        <| fun ctx -> transformAction com ctx decl.Body

    | Fable.MemberDeclaration decl ->
        withCurrentScope ctx decl.UsedNames
        <| fun ctx ->
            let info = com.GetMember(decl.MemberRef)

            let decls =
                if info.IsValue then
                    let value, stmts = transformAsExpr com ctx decl.Body
                    let name = com.GetIdentifier(ctx, Naming.toPythonNaming decl.Name)
                    let ta, _ = Annotation.typeAnnotation com ctx None decl.Body.Type
                    // Erase Option wrapper if needed (Call/CurriedApply returning Option[T] to T | None)
                    let value =
                        if needsOptionEraseForBinding decl.Body decl.Body.Type then
                            wrapInOptionErase com ctx value
                        else
                            value

                    stmts @ declareModuleMember com ctx info.IsPublic name (Some ta) value
                else
                    transformModuleFunction com ctx info decl.Name decl.Args decl.Body

            decls

    | Fable.ClassDeclaration decl ->
        // printfn "Class: %A" decl
        let ent = com.GetEntity(decl.Entity)

        // Check for erased unions and generate type aliases
        let hasEraseAttribute =
            ent.Attributes |> Seq.exists (fun att -> att.Entity.FullName = Atts.erase)

        if hasEraseAttribute && ent.IsFSharpUnion then
            // Generate type alias for erased union
            match ent.UnionCases with
            | [ singleCase ] when singleCase.UnionCaseFields.Length = 1 ->
                // Simple case: [<Erase>] type X = X of int becomes X = int
                let field = singleCase.UnionCaseFields.[0]
                let ta, _ = Annotation.typeAnnotation com ctx None field.FieldType
                let name = com.GetIdentifierAsExpr(ctx, decl.Name)
                [ Statement.assign ([ name ], ta) ]
            | _ ->
                // For now, just create an alias to Any for complex cases
                let name = com.GetIdentifierAsExpr(ctx, decl.Name)
                let anyType = com.GetImportExpr(ctx, "typing", "Any")
                [ Statement.assign ([ name ], anyType) ]
        elif hasEraseAttribute && ent.IsInterface then
            // Erased interfaces should not generate any code
            []
        elif hasEraseAttribute then
            // Erased classes (e.g., custom attribute types) should not generate any code
            []
        else
            // Check for PythonClass attribute and extract parameters
            let classAttributes =
                if hasPythonClassAttribute com ent.Attributes then
                    getPythonClassParameters com ent.Attributes
                else
                    ClassAttributes.Default

            // Raise error if classAttributes.Style is ClassStyle.Properties and classAttributes.Init is false
            if classAttributes.Style = ClassStyle.Properties && not classAttributes.Init then
                failwithf "ClassAttributes.Init must be true when ClassAttributes.Style is ClassStyle.Properties"

            // Add class generic parameters to scoped type params so methods don't redeclare them
            let classGenericParams =
                ent.GenericParameters
                |> List.map (fun p -> p.Name |> Helpers.clean)
                |> Set.ofList

            let ctx =
                { ctx with ScopedTypeParams = Set.union ctx.ScopedTypeParams classGenericParams }

            // For union types, set the enclosing base class context so type annotations
            // inside base class methods use the base class name instead of type alias
            let ctx =
                if ent.IsFSharpUnion then
                    { ctx with EnclosingUnionBaseClass = Some decl.Name }
                else
                    ctx

            decl.AttachedMembers
            |> List.choose (fun memb ->
                if memb.IsMangled then
                    None
                else
                    let info =
                        memb.ImplementedSignatureRef
                        |> Option.map com.GetMember
                        |> Option.defaultWith (fun () -> com.GetMember(memb.MemberRef))

                    Some
                        {|
                            name = memb.Name
                            isGetter = info.IsGetter
                            isSetter = info.IsSetter
                        |}
            )
            |> List.groupBy (fun m -> m.name)
            |> List.iter (fun (name, entries) ->
                let isValidGetterSetterPair =
                    entries.Length = 2
                    && entries |> List.exists _.isGetter
                    && entries |> List.exists _.isSetter

                if entries.Length > 1 && not isValidGetterSetterPair then
                    $"Overloads are not supported when using [<AttachMembers>]: '{name}' in {decl.Name} is defined more than once. Rename one of the members."
                    |> addWarning com [] None
            )

            let classMembers =
                decl.AttachedMembers
                |> List.collect (fun memb ->
                    withCurrentScope ctx memb.UsedNames
                    <| fun ctx ->
                        let info =
                            memb.ImplementedSignatureRef
                            |> Option.map com.GetMember
                            |> Option.defaultWith (fun () -> com.GetMember(memb.MemberRef))

                        if not memb.IsMangled && (info.IsGetter || info.IsSetter) then
                            transformAttachedProperty com ctx ent info memb (Some classAttributes)
                        else
                            transformAttachedMethod com ctx info memb
                )

            // Handle static properties separately using descriptors
            let staticPropertyDeclarations, setterFunctions, backingFieldDeclarations =
                transformStaticProperties com ctx decl ent

            // Generate abstract method stubs for abstract classes
            let abstractMethodStubs =
                Bases.generateAbstractMethodStubs com ctx ent decl.AttachedMembers

            // Generate Python protocol dunders for Py.Mapping and Py.Set interfaces
            let pythonProtocolDunders = Bases.generatePythonProtocolDunders com ctx ent

            let allClassMembers =
                classMembers
                @ backingFieldDeclarations
                @ staticPropertyDeclarations
                @ abstractMethodStubs
                @ pythonProtocolDunders

            let allStatements = setterFunctions

            match ent, decl.Constructor with
            | ent, _ when ent.IsInterface -> transformInterface com ctx ent decl
            | ent, _ when ent.IsFSharpUnion ->
                // Union types need static property statements too!
                let unionStmts = transformUnion com ctx ent decl.Name allClassMembers
                allStatements @ unionStmts
            | _, Some cons ->
                withCurrentScope ctx cons.UsedNames
                <| fun ctx ->
                    let classStmts =
                        transformClassWithPrimaryConstructor com ctx decl allClassMembers cons classAttributes

                    allStatements @ classStmts
            | _, None ->
                let classStmts =
                    transformClassWithCompilerGeneratedConstructor com ctx ent decl.Name allClassMembers classAttributes

                allStatements @ classStmts

let transformTypeVars (com: IPythonCompiler) ctx (typeVars: HashSet<string>) =
    // For Python 3.12, we don't need module-level TypeVar declarations
    // Type parameters are defined directly in function/class signatures
    []

let transformExports (_com: IPythonCompiler) _ctx (exports: HashSet<string>) =
    let exports = exports |> List.ofSeq |> List.sort

    match exports with
    | [] -> []
    | _ ->
        let all = Expression.name "__all__"
        let names = exports |> List.map Expression.stringConstant |> Expression.list

        [ Statement.assign ([ all ], names) ]

let transformImports (_com: IPythonCompiler) (imports: Import list) : Statement list =
    let imports =
        imports
        |> List.map (fun im ->
            let moduleName = im.Module

            match im.Name with
            | Some "*"
            | Some "default" ->
                let (Identifier local) = im.LocalIdent

                if moduleName <> local then
                    Some moduleName, Alias.alias im.LocalIdent
                else
                    None, Alias.alias im.LocalIdent
            | Some name ->
                let name = name |> Naming.toPythonNaming

                Some moduleName, Alias.alias (Identifier(Helpers.clean name), asname = im.LocalIdent)
            | None -> None, Alias.alias (Identifier moduleName, asname = im.LocalIdent)
        )
        |> List.groupBy fst
        |> List.map (fun (a, b) -> a, List.map snd b)
        |> List.sortBy (fun name ->
            let name =
                match name with
                | Some moduleName, _ -> moduleName.ToLower()
                | None, { Name = name } :: _ -> name.Name
                | _ -> ""

            match name with
            | name when name.StartsWith(".", StringComparison.Ordinal) -> "D" + name
            | name when name.StartsWith("__", StringComparison.Ordinal) -> "A" + name
            | name when name.StartsWith("fable", StringComparison.Ordinal) -> "C" + name
            | _ -> "B" + name
        )

    [
        for moduleName, aliases in imports do
            match moduleName with
            | Some name -> Statement.importFrom (Some(Identifier(name)), aliases)
            | None ->
                // Do not put multiple imports on a single line. flake8(E401)
                for alias in aliases do
                    Statement.import [ alias ]
    ]

let getIdentForImport (ctx: Context) (moduleName: string) (name: string option) =
    // printfn "getIdentForImport: %A" (moduleName, name)
    match name with
    | None ->
        // Handle Python-style relative imports like ".native_code", "..native_code", "...module" etc.
        // Path.GetFileNameWithoutExtension(".native_code") returns "" which is wrong
        let moduleName = moduleName.TrimStart('.')

        let lastPart =
            match moduleName.LastIndexOf('.') with
            | -1 -> moduleName
            | idx -> moduleName.Substring(idx + 1)

        if lastPart.Length > 0 then
            lastPart
        else
            Path.GetFileNameWithoutExtension(moduleName)
    | Some name -> name |> Naming.toPythonNaming
    |> getUniqueNameInRootScope ctx
    |> Identifier

let transformFile (com: IPythonCompiler) (file: Fable.File) =
    let declScopes =
        let hs = HashSet()

        for decl in file.Declarations do
            hs.UnionWith(decl.UsedNames)

        hs

    let ctx =
        {
            File = file
            UsedNames =
                {
                    RootScope = HashSet file.UsedNamesInRootScope
                    DeclarationScopes = declScopes
                    CurrentDeclarationScope = Unchecked.defaultof<_>
                }
            BoundVars =
                {
                    EnclosingScope = HashSet()
                    LocalScope = HashSet()
                    Inceptions = 0
                }
            DecisionTargets = []
            HoistVars = fun _ -> false
            TailCallOpportunity = None
            OptimizeTailCall = fun () -> ()
            ScopedTypeParams = Set.empty
            TypeParamsScope = 0
            NarrowedTypes = Map.empty
            EnclosingUnionBaseClass = None
            InEmitMacroArgument = false
        }

    // printfn "file: %A" file.Declarations
    let rootDecls = List.collect (transformDeclaration com ctx) file.Declarations

    let rootComment =
        com.GetRootModule(com.CurrentFile)
        |> snd
        |> Option.bind FSharp2Fable.TypeHelpers.tryGetXmlDoc

    let typeVars = com.GetAllTypeVars() |> transformTypeVars com ctx
    let importDecls = com.GetAllImports() |> transformImports com
    let exports = com.GetAllExports() |> transformExports com ctx
    let body = importDecls @ typeVars @ rootDecls @ exports
    Module.module' (body, ?comment = rootComment)