Merge branch 'main' into dbrattli/fable-python-more-tests

Author: dbrattli

pyrightconfig.ci.json

@@ -4,7 +4,6 @@
     "**/.venv/**",
     "**/node_modules/**",
     "temp/tests/Python/test_applicative.py",
-    "temp/tests/Python/test_misc.py",
     "temp/tests/Python/fable_modules/thoth_json_python/encode.py"
   ]
 }

src/Fable.Cli/CHANGELOG.md

@@ -10,6 +10,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 
 * [Python] Fix HashSet operations (Count, Contains, Remove, UnionWith, IntersectWith, ExceptWith) to work with both native Python sets and custom MutableSet (by @dbrattli)
+* [Python] Fix `Array.length`, `.Length`, `Array.isEmpty`, and `ResizeArray.Count` to use `len()` instead of `.length` property for plain Python list interop (by @dbrattli)
+* [Python] Fix `Task<T>` pass-through returns not being awaited in if/else and try/with branches (by @dbrattli)
+* [Python] Fix `:? T as x` type test pattern in closures causing `UnboundLocalError` due to `cast()` shadowing outer variable (by @dbrattli)
 
 ## 5.0.0-alpha.23 - 2026-02-03
 

src/Fable.Compiler/CHANGELOG.md

@@ -10,6 +10,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 
 * [Python] Fix HashSet operations (Count, Contains, Remove, UnionWith, IntersectWith, ExceptWith) to work with both native Python sets and custom MutableSet (by @dbrattli)
+* [Python] Fix `Array.length`, `.Length`, `Array.isEmpty`, and `ResizeArray.Count` to use `len()` instead of `.length` property for plain Python list interop (by @dbrattli)
+* [Python] Fix `Task<T>` pass-through returns not being awaited in if/else and try/with branches (by @dbrattli)
+* [Python] Fix `:? T as x` type test pattern in closures causing `UnboundLocalError` due to `cast()` shadowing outer variable (by @dbrattli)
 
 ## 5.0.0-alpha.22 - 2026-02-03
 

src/Fable.Transforms/Python/Fable2Python.Bases.fs

@@ -149,6 +149,9 @@ let generatePythonProtocolDunders (com: IPythonCompiler) ctx (classEnt: Fable.En
 
     // Generate IMapping dunders: __getitem__, __contains__, __len__, __iter__
     // Note: Method names use Python naming convention (lowercase with underscores)
+    // __iter__ always yields keys following Python's Mapping convention.
+    // F# iteration (for KeyValue(k,v) in map) compiles to GetEnumerator()/MoveNext()/Current
+    // and never uses __iter__, so this is purely for Python interop.
     let mappingDunders =
         if hasIMapping || hasIMutableMapping then
             [
@@ -170,9 +173,7 @@ let generatePythonProtocolDunders (com: IPythonCompiler) ctx (classEnt: Fable.En
                     Arguments.arguments [ Arg.arg "self" ],
                     body = [ Statement.return' (Expression.attribute (self, Identifier "Count", Load)) ]
                 )
-                // def __iter__(self):
-                //     for kv in to_iterator(self.GetEnumerator()):
-                //         yield kv[0]  # kv is a tuple (key, value)
+                // def __iter__(self): yields keys only (Python Mapping convention)
                 let toIterator = com.GetImportExpr(ctx, "fable_library.util", "to_iterator")
                 let kvVar = Expression.name "kv"
 
@@ -184,7 +185,7 @@ let generatePythonProtocolDunders (com: IPythonCompiler) ctx (classEnt: Fable.En
                             Statement.for' (
                                 kvVar,
                                 Expression.call (toIterator, [ selfCall "GetEnumerator" [] ]),
-                                // Access kv[0] since the enumerator yields tuples (key, value)
+                                // Yield kv[0] (key) since GetEnumerator yields (key, value) tuples
                                 [
                                     Statement.expr (
                                         Yield(Some(Expression.subscript (kvVar, Expression.intConstant 0, Load)))

src/Fable.Transforms/Python/Fable2Python.Transforms.fs

@@ -1305,35 +1305,12 @@ let transformTryCatch com (ctx: Context) r returnStrategy (body, catch: option<F
         )
     ]
 
-/// Helper function to generate a cast statement for type narrowing
-let makeCastStatement (com: IPythonCompiler) ctx (ident: Fable.Ident) (typ: Fable.Type) =
-    // Only add cast for generic types where type checker needs help
-    let hasGenerics =
-        match typ with
-        | Fable.DeclaredType(_, genArgs) when not (List.isEmpty genArgs) -> true
-        | Fable.Array _ -> true
-        | Fable.List _ -> true
-        | _ -> false
-
-    // Check if the original type already has the same generic arguments
-    // If so, Pyright can infer the narrowed type and the cast is unnecessary
-    let originalGenArgs = Annotation.getGenericArgs ident.Type
-    let targetGenArgs = Annotation.getGenericArgs typ
-
-    let sameGenericArgs =
-        not (List.isEmpty originalGenArgs)
-        && not (List.isEmpty targetGenArgs)
-        && originalGenArgs = targetGenArgs
-
-    if hasGenerics && not sameGenericArgs then
-        let cast = com.GetImportExpr(ctx, "typing", "cast")
-        let varExpr = identAsExpr com ctx ident
-        let typeAnnotation, importStmts = Annotation.typeAnnotation com ctx None typ
-        let castExpr = Expression.call (cast, [ typeAnnotation; varExpr ])
-        let castStmt = Statement.assign ([ varExpr ], castExpr)
-        importStmts @ [ castStmt ]
-    else
-        []
+/// 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

src/Fable.Transforms/Python/Fable2Python.Util.fs

@@ -1125,12 +1125,73 @@ module Helpers =
         let callInfo = Fable.CallInfo.Create(args = [ e ])
         makeIdentExpr "str" |> makeCall None Fable.String callInfo
 
-    /// Transform return statements to wrap their values with await
-    let wrapReturnWithAwait (body: Statement list) : Statement list =
+    /// Transform return statements to wrap their values with await.
+    /// Recursively traverses nested control flow (if/else, match, try, for, while, with)
+    /// to ensure ALL return statements in async functions get awaited.
+    let rec wrapReturnWithAwait (body: Statement list) : Statement list =
         body
         |> List.map (fun stmt ->
             match stmt with
+            | Statement.Return { Value = Some(Await _) } -> stmt // Already awaited
             | Statement.Return { Value = Some value } -> Statement.return' (Await value)
+            | Statement.If ifStmt ->
+                Statement.if' (
+                    ifStmt.Test,
+                    wrapReturnWithAwait ifStmt.Body,
+                    wrapReturnWithAwait ifStmt.Else,
+                    ?loc = ifStmt.Loc
+                )
+            | Statement.Match matchStmt ->
+                let cases =
+                    matchStmt.Cases
+                    |> List.map (fun case ->
+                        MatchCase.matchCase (case.Pattern, wrapReturnWithAwait case.Body, ?guard = case.Guard)
+                    )
+
+                Statement.match' (matchStmt.Subject, cases, ?loc = matchStmt.Loc)
+            | Statement.Try tryStmt ->
+                let handlers =
+                    tryStmt.Handlers
+                    |> List.map (fun h -> { h with Body = wrapReturnWithAwait h.Body })
+
+                Statement.try' (
+                    wrapReturnWithAwait tryStmt.Body,
+                    handlers = handlers,
+                    orElse = wrapReturnWithAwait tryStmt.OrElse,
+                    finalBody = wrapReturnWithAwait tryStmt.FinalBody,
+                    ?loc = tryStmt.Loc
+                )
+            | Statement.For forStmt ->
+                Statement.for' (
+                    forStmt.Target,
+                    forStmt.Iterator,
+                    body = wrapReturnWithAwait forStmt.Body,
+                    orelse = wrapReturnWithAwait forStmt.Else,
+                    ?typeComment = forStmt.TypeComment
+                )
+            | Statement.AsyncFor asyncForStmt ->
+                AsyncFor(
+                    AsyncFor.asyncFor (
+                        asyncForStmt.Target,
+                        asyncForStmt.Iterator,
+                        wrapReturnWithAwait asyncForStmt.Body,
+                        orelse = wrapReturnWithAwait asyncForStmt.Else,
+                        ?typeComment = asyncForStmt.TypeComment
+                    )
+                )
+            | Statement.While whileStmt ->
+                Statement.while' (
+                    whileStmt.Test,
+                    wrapReturnWithAwait whileStmt.Body,
+                    orelse = wrapReturnWithAwait whileStmt.Else,
+                    ?loc = whileStmt.Loc
+                )
+            | Statement.With withStmt ->
+                Statement.with' (
+                    withStmt.Items,
+                    body = wrapReturnWithAwait withStmt.Body,
+                    ?typeComment = withStmt.TypeComment
+                )
             | other -> other
         )
 

src/Fable.Transforms/Python/Replacements.fs

@@ -1760,12 +1760,9 @@ let resizeArrays (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (this
     | "GetEnumerator", Some ar, _ -> getEnumerator com r t ar |> Some
     | "get_Count", Some(MaybeCasted(ar)), _ ->
         match ar.Type with
-        // ResizeArray is Python list - use len() wrapped in int32()
-        | Array(_, ResizeArray) ->
+        | Array _ ->
             let lenExpr = Helper.GlobalCall("len", Int32.Number, [ ar ], ?loc = r)
             Helper.LibCall(com, "core", "int32", t, [ lenExpr ], ?loc = r) |> Some
-        // MutableArray/ImmutableArray are FSharpArray (Rust) with .length property returning Int32
-        | Array _ -> getFieldWith r t ar "length" |> Some
         | _ -> Helper.LibCall(com, "util", "count", t, [ ar ], ?loc = r) |> Some
     | "Clear", Some ar, _ -> Helper.LibCall(com, "Util", "clear", t, [ ar ], ?loc = r) |> Some
     | "Find", Some ar, [ arg ] ->
@@ -1894,8 +1891,8 @@ let arrays (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (thisArg: E
     // printfn "arrays: %A" i.CompiledName
     match i.CompiledName, thisArg, args with
     | "get_Length", Some arg, _ ->
-        // All arrays in Python are FSharpArray (Rust) which has .length property returning Int32
-        getFieldWith r t arg "length" |> Some
+        let lenExpr = Helper.GlobalCall("len", Int32.Number, [ arg ], ?loc = r)
+        Helper.LibCall(com, "core", "int32", t, [ lenExpr ], ?loc = r) |> Some
     | "get_Item", Some arg, [ idx ] -> getExpr r t arg idx |> Some
     | "set_Item", Some arg, [ idx; value ] -> setExpr r arg idx value |> Some
     | "Copy", None, [ _source; _sourceIndex; _target; _targetIndex; _count ] -> copyToArray com r t i args
@@ -1946,13 +1943,8 @@ let arrayModule (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (_: Ex
         Helper.LibCall(com, "list", "of_array", t, args, i.SignatureArgTypes, ?loc = r)
         |> Some
     | ("Length" | "Count"), [ arg ] ->
-        match arg.Type with
-        // ResizeArray is Python list - use len() wrapped in int32()
-        | Array(_, ResizeArray) ->
-            let lenExpr = Helper.GlobalCall("len", Int32.Number, [ arg ], ?loc = r)
-            Helper.LibCall(com, "core", "int32", t, [ lenExpr ], ?loc = r) |> Some
-        // MutableArray/ImmutableArray are FSharpArray (Rust) with .length property returning Int32
-        | _ -> getFieldWith r t arg "length" |> Some
+        let lenExpr = Helper.GlobalCall("len", Int32.Number, [ arg ], ?loc = r)
+        Helper.LibCall(com, "core", "int32", t, [ lenExpr ], ?loc = r) |> Some
     | "Item", [ idx; ar ] -> getExpr r t ar idx |> Some
     | "Get", [ ar; idx ] -> getExpr r t ar idx |> Some
     | "Set", [ ar; idx; value ] -> setExpr r ar idx value |> Some
@@ -1969,8 +1961,8 @@ let arrayModule (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (_: Ex
         // Use library function to create empty FSharpArray (Rust) instead of raw Python list
         Helper.LibCall(com, "array", "empty", t, [], ?loc = r) |> Some
     | "IsEmpty", [ ar ] ->
-        // Use .length property (Int32) instead of len() which returns Python int
-        eq (getFieldWith r Int32.Number ar "length") (makeIntConst 0) |> Some
+        eq (Helper.GlobalCall("len", Int32.Number, [ ar ], ?loc = r)) (makeIntConst 0)
+        |> Some
     | "Concat", [ ar1; ar2 ] -> makeBinOp r t ar1 ar2 BinaryPlus |> Some
     | Patterns.DicContains nativeArrayFunctions meth, _ ->
         let args, thisArg = List.splitLast args

tests/Python/TestMap.fs

@@ -333,3 +333,21 @@ let ``test Map works with keys with custom comparison`` () =
     |> Map.add { Bar = "a"; Foo = 10 } 2
     |> Map.count
     |> equal 1
+
+// Note: This compiles to GetEnumerator()/MoveNext()/Current, not __iter__
+[<Fact>]
+let ``test Map iteration with KeyValue yields key-value pairs`` () =
+    let myMap = Map [ "foo", 1; "bar", 2; "baz", 3 ]
+    let mutable keys = []
+    let mutable values = []
+    for KeyValue(key, value) in myMap do
+        keys <- key :: keys
+        values <- value :: values
+    keys |> List.sort |> equal ["bar"; "baz"; "foo"]
+    values |> List.sort |> equal [1; 2; 3]
+
+[<Fact>]
+let ``test Map keys and values work correctly`` () =
+    let myMap = Map [ "a", 10; "b", 20 ] :> IDictionary<_,_>
+    myMap.Keys |> Seq.toList |> equal ["a"; "b"]
+    myMap.Values |> Seq.toList |> equal [10; 20]

tests/Python/TestNonRegression.fs

@@ -284,3 +284,19 @@ let ``test named arguments are converted to snake_case`` () =
     let runner2 = NamedArgsSnakeCase.TestRunner(testCase = "test2", configArgs = [| "arg3" |])
     equal "test2" runner2.TestCase
     equal [| "arg3" |] runner2.ConfigArgs
+
+// Regression: type test pattern (:? T as x) inside closure should not cause
+// UnboundLocalError by reassigning the tested variable
+[<Fact>]
+let ``test type test pattern in closure does not shadow outer variable`` () =
+    let mutable result = ""
+    let processValue (value: obj) =
+        let inner () =
+            match value with
+            | :? string as s -> result <- s
+            | _ -> result <- "not a string"
+        inner ()
+    processValue (box "hello")
+    equal "hello" result
+    processValue (box 42)
+    equal "not a string" result

tests/Python/TestPyInterop.fs

@@ -902,4 +902,24 @@ let ``test Pydantic model_dump_json with float array`` () =
     json.Contains("1.5") |> equal true
     json.Contains("2.5") |> equal true
 
+// Regression tests: Array.length/.Length/Array.isEmpty must use len() so they
+// work on plain Python lists (e.g. from Emit, unbox, native APIs), not just FSharpArray.
+
+[<Fact>]
+let ``test Array.length works on plain Python list`` () =
+    let xs: int[] = emitPyExpr () "[1, 2, 3]"
+    Array.length xs |> equal 3
+
+[<Fact>]
+let ``test .Length works on plain Python list`` () =
+    let xs: int[] = emitPyExpr () "[10, 20]"
+    xs.Length |> equal 2
+
+[<Fact>]
+let ``test Array.isEmpty works on plain Python list`` () =
+    let xs: int[] = emitPyExpr () "[1]"
+    Array.isEmpty xs |> equal false
+    let ys: int[] = emitPyExpr () "[]"
+    Array.isEmpty ys |> equal true
+
 #endif