fix: Generic constructor type inference from iterable arguments (jaseci-labs#5182)

## Summary
- `set(list[Item])` now correctly infers `set[Item]`
- `enumerate(list[Item])` now correctly infers `enumerate[Item]`
- Propagates TypeVar bindings through `base_classes` in MRO walk

Previously, generic constructors like `set()` and `enumerate()` returned
unparameterized types because TypeVar bindings weren't propagated
through the inheritance chain.

Author: kugesan1105

docs/docs/community/release_notes/jaclang.md

@@ -11,6 +11,7 @@ This document provides a summary of new features, improvements, and bug fixes in
 - **Type Checker: `type[T]` Member Access**: Accessing class-level members (e.g., `ClassVar`) on `type[T]` parameters now works correctly. `cls: type[MyClass]` → `cls.my_class_var` resolves to `MyClass`'s members.
 - **Type Checker: Property Support**: `@property` and `@cached_property` now correctly type-check. Accessing `obj.my_property` returns the property's return type instead of `FunctionType`.
 - **Fix: Static Methods on Class-Based Enums**: Static methods on `IntEnum`/`StrEnum` classes now correctly return their declared type instead of `<Unknown>`.
+- **Fix: Generic Constructor Type Inference**: `set(my_list)`, `enumerate(items)`, and similar generic constructors now correctly infer type parameters from iterable arguments (e.g., `set(list[Item])` → `set[Item]`). Previously returned unparameterized types.
 - **Type Checker: Generic Inheritance & Bidirectional Inference**: Added MRO-aware type argument resolution (`resolve_type_args_for_base`, `build_type_var_solution`) so multi-level generic inheritance chains are properly tracked. `_assign_class` now validates type args through the MRO with covariant/contravariant/invariant variance. `type[X]` annotations are now covariant (`type[SubClass]` assignable to `type[BaseClass]`). `FunctionType.specialize` and `specialize_member_type` use transitive TypeVar resolution. `infer_type_args` walks inherited constructors. Container literals (`list`, `dict`, `set`, `tuple`) now support bidirectional type inference via `expected_type` propagation from return statements, assignments, and function arguments, with element-level validation before adopting the expected type.
 - **Type Checker: Parameterized Types in Error Messages**: `ClassType.__str__` now displays type arguments for parameterized types (e.g., `list[int]`, `dict[str, bool]`) instead of bare class names. Error messages like `Cannot return <class list>, expected <class list>` now read `Cannot return list[Dog | Cat], expected list[int]`, making type mismatches immediately actionable.
 - **Client-Side Error Reporting**: Unhandled JavaScript errors and promise rejections in Jac client apps are now automatically captured and forwarded to the server via `POST /cl/__error__`, where they are logged through both the `jaclang.client_errors` logger and the dev console. Global error handlers (`window.onerror`, `unhandledrejection`) are installed at app initialization, and the `ErrorBoundary` fallback component also reports caught errors. Works with both the stdlib HTTP server and jac-scale (FastAPI).

jac/jaclang/compiler/type_system/impl/type_utils.impl.jac

@@ -534,8 +534,7 @@ impl resolve_type_args_for_base(
         return [];
     }
 
-    # Build cumulative TypeVar solution by walking the MRO.
-    # Start with src's own type_params -> type_args mapping.
+    # Build TypeVar solution starting with src's type_params -> type_args.
     solution: dict[str, types.TypeBase] = {};
     if src.shared.type_params and src.private and src.private.type_args {
         for (idx, tp) in enumerate(src.shared.type_params) {
@@ -545,33 +544,45 @@ impl resolve_type_args_for_base(
         }
     }
 
-    # Walk the MRO (which includes src itself as first entry).
-    # For each class in the MRO, if it has type_params and type_args,
-    # resolve the type_args using the current solution and add new bindings.
+    # Walk MRO and propagate TypeVar bindings through base_classes.
     for mro_cls in src.shared.mro {
         if mro_cls.shared.type_params
         and mro_cls.private
         and mro_cls.private.type_args {
             for (idx, tp) in enumerate(mro_cls.shared.type_params) {
                 if tp.name and idx < len(mro_cls.private.type_args) {
                     arg = mro_cls.private.type_args[idx];
-                    # Resolve any TypeVars in this arg using accumulated solution
-                    resolved = apply_solved_type_vars(arg, solution);
-                    solution[tp.name] = resolved;
+                    solution[tp.name] = apply_solved_type_vars(arg, solution);
+                }
+            }
+        }
+
+        # Propagate through base_classes (where type_args are stored).
+        if mro_cls.shared.base_classes {
+            for base_cls in mro_cls.shared.base_classes {
+                if isinstance(base_cls, types.ClassType)
+                and base_cls.shared.type_params
+                and base_cls.private
+                and base_cls.private.type_args {
+                    for (idx, base_tp) in enumerate(base_cls.shared.type_params) {
+                        if base_tp.name and idx < len(base_cls.private.type_args) {
+                            arg = base_cls.private.type_args[idx];
+                            solution[base_tp.name] = apply_solved_type_vars(
+                                arg, solution
+                            );
+                        }
+                    }
                 }
             }
         }
 
-        # When we reach the target base, extract its type_args with full substitution
         if mro_cls.shared == target_base.shared {
             if mro_cls.private and mro_cls.private.type_args {
                 return [
                     apply_solved_type_vars(arg, solution)
                     for arg in mro_cls.private.type_args
                 ];
             }
-            # MRO entry has no type_args — try to resolve target's type_params
-            # from accumulated solution (handles cases like class Foo(Bar[T]))
             if target_base.shared.type_params {
                 result: list[types.TypeBase] = [];
                 for tp in target_base.shared.type_params {
@@ -581,7 +592,6 @@ impl resolve_type_args_for_base(
                         result.append(types.UnknownType());
                     }
                 }
-                # Only return if we resolved at least one param
                 if any(not isinstance(r, types.UnknownType) for r in result) {
                     return result;
                 }

jac/jaclang/compiler/type_system/operations.jac

@@ -323,8 +323,8 @@ def get_type_of_binary_operation(
             );
         }
         # Check whether a type is a valid node operand for connections.
-        # Accepts: node instances, UnionType where all members are node instances,
-        # AnyType, and UnknownType (not enough info to diagnose).
+        # Accepts: node instances, list of node instances, UnionType where all
+        # members are valid, AnyType, and UnknownType (not enough info to diagnose).
         def is_valid_node_operand(t: jtypes.TypeBase) -> bool {
             if t.is_any_type() or isinstance(t, jtypes.UnknownType) {
                 return True;
@@ -335,6 +335,16 @@ def get_type_of_binary_operation(
             if isinstance(t, jtypes.UnionType) {
                 return all(is_valid_node_operand(m) for m in t.types);
             }
+            # Also accept list of node instances (runtime accepts list[NodeArchetype])
+            if isinstance(t, jtypes.ClassType)
+            and t.is_builtin()
+            and t.shared.class_name == "list" {
+                if t.private.type_args and len(t.private.type_args) > 0 {
+                    return is_valid_node_operand(t.private.type_args[0]);
+                }
+                return True;  # Unparameterized list - allow
+
+            }
             return False;
         }
         # TODO: In strict mode, UnknownType, AnyType, TypeVarType, and object should be errors
@@ -419,9 +429,21 @@ def get_type_of_binary_operation(
                     }
                 }
             }
+            # Connect operator returns list of nodes (right operand)
+            if evaluator.prefetch and evaluator.prefetch.list_class {
+                list_type = evaluator.prefetch.list_class.clone_as_instance();
+                if isinstance(list_type, jtypes.ClassType) {
+                    list_type.private.type_args = [right_type];
+                    return list_type;
+                }
+            }
             return right_type;
         }
     }
+    # Spawn operator: node spawn Walker() returns the walker instance
+    if isinstance(expr.op, uni.Token) and expr.op.name == Tok.KW_SPAWN {
+        return right_type;
+    }
     #  walrus assignment
     if isinstance(expr.op, uni.Token) and expr.op.name == Tok.WALRUS_EQ {
         # Walrus operator: (x := expr) assigns right to left and returns right's type

jac/jaclang/compiler/type_system/type_evaluator.impl/type_evaluator.impl.jac

@@ -1542,6 +1542,18 @@ impl TypeEvaluator._get_type_of_expression_core(
             }
             return types.UnknownType();
 
+        case uni.EdgeRefTrailer():
+            # Edge traversal: [node-->], [node<--], [node->:Edge:->], etc.
+            # Returns list[NodeArchetype] (default) or list[EdgeArchetype] (edges_only)
+            # TODO: Infer more specific types from filters like [?:Profile]
+            if self.prefetch and self.prefetch.list_class {
+                list_type = self.prefetch.list_class.clone_as_instance();
+                # Return list[Any] so indexing returns Any (allows attribute access)
+                list_type.private.type_args = [types.AnyType()];
+                return list_type;
+            }
+            return types.UnknownType();
+
     }
     # TODO: More expressions.
     return types.UnknownType();

jac/tests/compiler/passes/main/fixtures/checker/checker_gap_enumerate_type.jac

@@ -1,18 +1,4 @@
-"""Gap: enumerate() does not infer element types correctly.
-
-When using `for (idx, item) in enumerate(items)` where items is a typed list,
-the type checker should infer:
-- idx: int
-- item: the element type of the list
-
-Currently, both idx and item are Unknown because:
-1. enumerate(items) returns enumerate with empty type_args (should be enumerate[Item])
-2. __iter__ returns Self which is not resolved
-3. __next__ returns tuple[int, _T] but _T is not specialized
-
-Expected: Type errors for invalid assignments to idx and item.
-Actual: No type errors because types are Unknown.
-"""
+"""Test enumerate() type inference from iterable argument."""
 
 node Item {
     has id: int;
@@ -22,13 +8,8 @@ with entry {
     items: list[Item] = [Item(id=1), Item(id=2), Item(id=3)];
 
     for (idx, item) in enumerate(items) {
-        # When fixed: idx is int, so assigning to str should error
-        wrong_idx: str = idx;   # <-- Should Error: Cannot assign int to str
-
-        # When fixed: item is Item, so assigning to int should error
-        wrong_item: int = item;  # <-- Should Error: Cannot assign Item to int
-
-        # When fixed: item.id should work since item is Item
-        print(item.id);  # <-- Should work, currently errors with Unknown
+        wrong_idx: str = idx;    # Error: int -> str
+        wrong_item: int = item;  # Error: Item -> int
+        print(item.id);
     }
 }

jac/tests/compiler/passes/main/fixtures/checker/checker_gap_generic_call_inference.jac

@@ -1,24 +1,9 @@
-"""Gap: Generic type parameter inference from function/constructor arguments.
-
-When calling a generic function or constructor, the type parameter should be
-inferred from the argument types.
-
-For example:
-- enumerate(items: list[Item]) should return enumerate[Item]
-- zip(list[int], list[str]) should return zip[tuple[int, str]]
-
-Currently, generic calls return the generic type without type_args populated,
-so the type parameter remains unresolved.
-
-This is the root cause of the enumerate issue - without proper inference,
-enumerate(items) returns enumerate (no type_args) instead of enumerate[Item].
-"""
+"""Test generic type parameter inference from constructor arguments."""
 
 node Item {
     has value: int;
 }
 
-# Test: Generic class constructor should infer type parameter
 obj MyGeneric[T] {
     has data: T;
 
@@ -28,22 +13,17 @@ obj MyGeneric[T] {
 }
 
 with entry {
-    # Test 1: enumerate should infer T from iterable
     items: list[Item] = [Item(value=1), Item(value=2)];
 
-    # enumerate(items) should be enumerate[Item]
-    # __next__ should return tuple[int, Item]
+    # enumerate(items) infers enumerate[Item]
     for (i, x) in enumerate(items) {
-        # When fixed: x is Item, assigning to str should error
-        wrong_x: str = x;  # <-- Should Error: Cannot assign Item to str
-        print(x.value);    # <-- Should work, currently fails
+        wrong_x: str = x;  # Error: Item -> str
+        print(x.value);
     }
 
-    # Test 2: Custom generic class should infer type parameter
+    # MyGeneric(data=Item()) infers MyGeneric[Item]
     wrapper = MyGeneric(data=Item(value=42));
-    # wrapper should be MyGeneric[Item]
     result = wrapper.get_data();
-    # When fixed: result is Item, assigning to int should error
-    wrong_result: int = result;  # <-- Should Error: Cannot assign Item to int
-    print(result.value);         # <-- Should work if inference works
+    wrong_result: int = result;  # Error: Item -> int
+    print(result.value);
 }

jac/tests/compiler/passes/main/test_checker_pass.jac

@@ -2087,38 +2087,30 @@ test "final_union_type_no_crash" {
 # =============================================================================
 # Generic Type Inference Tests (Pyright-style)
 # =============================================================================
-"""Test enumerate() correctly infers element types from the iterable."""
 test "enumerate_type_inference" {
     program = JacProgram();
     path = os.path.join(CHECKER_FIXTURES, "checker_gap_enumerate_type.jac");
     mod = program.compile(path, options=NO_TC);
     TypeCheckPass(ir_in=mod, prog=program);
-    # idx inference works (int), but item type from enumerate's __next__ -> tuple[int, _T]
-    # is not yet fully resolved through stdlib stub overloads.
-    # Fully resolved: 2 errors (int->str, Item->int). Current: 3 (idx works, item still Unknown).
-    assert len(program.errors_had) == 3 , f"Expected 3 type errors, got {len(
+    assert len(program.errors_had) == 2 , f"Expected 2 type errors, got {len(
         program.errors_had
     )}";
-
     errors_str = "\n".join(e.pretty_print() for e in program.errors_had);
-    assert "Cannot assign int to str" in errors_str , "Expected error for idx: int assigned to str";
+    assert "Cannot assign int to str" in errors_str;
+    assert "Cannot assign Item to int" in errors_str;
 }
 
-"""Test generic class constructor infers type parameters from arguments."""
 test "generic_call_inference" {
     program = JacProgram();
     path = os.path.join(CHECKER_FIXTURES, "checker_gap_generic_call_inference.jac");
     mod = program.compile(path, options=NO_TC);
     TypeCheckPass(ir_in=mod, prog=program);
-    # Custom generic inference works (MyGeneric[Item] correctly inferred from constructor args).
-    # enumerate inference still partial — item type from stdlib stub overloads not fully resolved.
-    # Fully resolved: 2 errors (Item->str, Item->int). Current: 3 (MyGeneric works, enumerate partial).
-    assert len(program.errors_had) == 3 , f"Expected 3 type errors, got {len(
+    assert len(program.errors_had) == 2 , f"Expected 2 type errors, got {len(
         program.errors_had
     )}";
-
     errors_str = "\n".join(e.pretty_print() for e in program.errors_had);
-    assert "Cannot assign Item to int" in errors_str , "Expected error for result: Item assigned to int";
+    assert "Cannot assign Item to str" in errors_str;
+    assert "Cannot assign Item to int" in errors_str;
 }
 
 """Test bidirectional type inference for container literals and type[X] covariance."""

jac/tests/runtimelib/fixtures/serve_api.jac

@@ -62,7 +62,7 @@ walker ListCompletedTasks {
 
 walker GetTask {
     can fetch with Task entry {
-        return here;
+        report here;
     }
 }
 
@@ -94,7 +94,7 @@ def greet(name: str = "World") -> str {
 
 cl glob WELCOME_TITLE: str = "Runtime Test";
 
-cl def:pub client_page() {
+cl def:pub client_page() -> JsxElement {
     return <section class="welcome">
         <h1>
             {WELCOME_TITLE}