fix(streams): lower namespace ReadableStream.from

changelog.d/11026-readable-stream-from-namespace.md

@@ -0,0 +1,7 @@
+### Fixed
+
+- `ReadableStream.from()` now works through a `node:stream/web` namespace
+  import, including TypeScript-cast forms such as
+  `(streamWeb.ReadableStream as any).from(items)`. The returned stream and
+  reader retain their native types, so `read()` yields `{ done, value }`
+  objects and iterable drain loops terminate.

crates/perry-hir/src/destructuring/var_decl/native_new.rs

@@ -147,46 +147,24 @@ pub(crate) fn register_native_from_new_and_calls(
         }
     }
 
-    // #1645: `const rs = ReadableStream.from(iterable)` — the `.from`
+    // #1645/#10568: `const rs = ReadableStream.from(iterable)` — including
+    // the namespace-import spelling `(streamWeb.ReadableStream as any).from`.
     // Call result is typed Any, so register the binding as a
     // ReadableStream native instance (mirroring `new ReadableStream`'s
     // typing). Without this, `rs.getReader()` / `for await (const c of
     // rs)` fall to generic dispatch on the numeric stream handle and
     // fail. The Call itself is routed to `js_readable_stream_from_iterable`
     // in codegen (expr/calls.rs).
-    if let Some(init_expr) = &decl.init {
-        if let ast::Expr::Call(call) = init_expr.as_ref() {
-            if let ast::Callee::Expr(callee) = &call.callee {
-                if let ast::Expr::Member(m) = callee.as_ref() {
-                    if let ast::MemberProp::Ident(prop) = &m.prop {
-                        if prop.sym.as_ref() == "from" {
-                            let mut obj_inner: &ast::Expr = m.obj.as_ref();
-                            loop {
-                                obj_inner = match obj_inner {
-                                    ast::Expr::TsAs(x) => &x.expr,
-                                    ast::Expr::TsNonNull(x) => &x.expr,
-                                    ast::Expr::TsSatisfies(x) => &x.expr,
-                                    ast::Expr::TsTypeAssertion(x) => &x.expr,
-                                    ast::Expr::TsConstAssertion(x) => &x.expr,
-                                    ast::Expr::Paren(x) => &x.expr,
-                                    _ => break,
-                                };
-                            }
-                            if matches!(
-                                obj_inner,
-                                ast::Expr::Ident(i) if i.sym.as_ref() == "ReadableStream"
-                            ) {
-                                ctx.register_native_instance(
-                                    name.to_string(),
-                                    "readable_stream".to_string(),
-                                    "ReadableStream".to_string(),
-                                );
-                            }
-                        }
-                    }
-                }
-            }
-        }
+    if decl
+        .init
+        .as_deref()
+        .is_some_and(|init| crate::lower_types::is_web_readable_stream_from_call(ctx, init))
+    {
+        ctx.register_native_instance(
+            name.to_string(),
+            "readable_stream".to_string(),
+            "ReadableStream".to_string(),
+        );
     }
 
     // Check if this is an awaited native class instantiation (e.g., await new Redis())

crates/perry-hir/src/destructuring/var_decl/type_infer.rs

@@ -203,6 +203,9 @@ pub(crate) fn infer_decl_type(
     // dispatches via the native-instance registry, not this declared type.
     if matches!(ty, Type::Any) {
         if let Some(init_expr) = &decl.init {
+            if crate::lower_types::is_web_readable_stream_from_call(ctx, init_expr) {
+                ty = Type::Named("ReadableStream".to_string());
+            }
             if let ast::Expr::Call(call) = init_expr.as_ref() {
                 if let ast::Callee::Expr(callee) = &call.callee {
                     if let ast::Expr::Member(m) = callee.as_ref() {

crates/perry-hir/src/lower/expr_call/static_and_instance.rs

@@ -71,6 +71,30 @@ pub(super) fn try_static_method_and_instance(
     // handle it. Refs test262 language/arguments-object
     // cls-*-static-*-spread-operator.
     let static_call_has_spread = call.args.iter().any(|a| a.spread.is_some());
+
+    // `import * as web from "node:stream/web"; (web.ReadableStream as
+    // any).from(xs)` has a nested namespace receiver. Route it through the
+    // same native factory as the named-import form before the generic
+    // module.Class.staticMethod arm sees it as `stream/web.ReadableStream`.
+    if !static_call_has_spread {
+        if let ast::Expr::Member(member) = expr {
+            if matches!(&member.prop, ast::MemberProp::Ident(prop) if prop.sym.as_ref() == "from")
+                && crate::lower_types::is_web_readable_stream_constructor_ref(
+                    ctx,
+                    member.obj.as_ref(),
+                )
+            {
+                return Ok(Ok(Expr::NativeMethodCall {
+                    module: "readable_stream".to_string(),
+                    class_name: Some("ReadableStream".to_string()),
+                    object: None,
+                    method: "from".to_string(),
+                    args,
+                }));
+            }
+        }
+    }
+
     // Check for static method calls (e.g., Counter.increment())
     if let ast::Expr::Member(member) = expr {
         if let ast::Expr::Ident(obj_ident) = unwrap_ts_wrappers(member.obj.as_ref()) {

crates/perry-hir/src/lower_types.rs

@@ -1137,6 +1137,69 @@ pub(crate) fn is_node_readable_static_factory_call(
         && is_node_readable_constructor_ref(ctx, member.obj.as_ref())
 }
 
+fn is_web_readable_stream_module_alias(ctx: &LoweringContext, name: &str) -> bool {
+    matches!(
+        ctx.lookup_native_module(name),
+        Some(("stream/web" | "node:stream/web", None))
+    ) || matches!(
+        ctx.namespace_import_sources.get(name).map(String::as_str),
+        Some("stream/web" | "node:stream/web")
+    )
+}
+
+pub(crate) fn is_web_readable_stream_constructor_ref(
+    ctx: &LoweringContext,
+    expr: &ast::Expr,
+) -> bool {
+    match expr {
+        ast::Expr::Ident(ident) => {
+            let name = ident.sym.as_ref();
+            matches!(
+                ctx.lookup_native_module(name),
+                Some(("stream/web" | "node:stream/web", Some("ReadableStream")))
+            ) || (name == "ReadableStream" && !ctx.shadows_unqualified_global(name))
+        }
+        ast::Expr::Member(member) => {
+            let (ast::Expr::Ident(obj), ast::MemberProp::Ident(prop)) =
+                (member.obj.as_ref(), &member.prop)
+            else {
+                return false;
+            };
+            prop.sym.as_ref() == "ReadableStream"
+                && is_web_readable_stream_module_alias(ctx, obj.sym.as_ref())
+        }
+        ast::Expr::Paren(paren) => is_web_readable_stream_constructor_ref(ctx, &paren.expr),
+        ast::Expr::TsAs(ts_as) => is_web_readable_stream_constructor_ref(ctx, &ts_as.expr),
+        ast::Expr::TsTypeAssertion(ts_assert) => {
+            is_web_readable_stream_constructor_ref(ctx, &ts_assert.expr)
+        }
+        ast::Expr::TsNonNull(non_null) => {
+            is_web_readable_stream_constructor_ref(ctx, &non_null.expr)
+        }
+        ast::Expr::TsConstAssertion(const_assert) => {
+            is_web_readable_stream_constructor_ref(ctx, &const_assert.expr)
+        }
+        ast::Expr::TsSatisfies(satisfies) => {
+            is_web_readable_stream_constructor_ref(ctx, &satisfies.expr)
+        }
+        _ => false,
+    }
+}
+
+pub(crate) fn is_web_readable_stream_from_call(ctx: &LoweringContext, expr: &ast::Expr) -> bool {
+    let ast::Expr::Call(call) = expr else {
+        return false;
+    };
+    let ast::Callee::Expr(callee) = &call.callee else {
+        return false;
+    };
+    let ast::Expr::Member(member) = callee.as_ref() else {
+        return false;
+    };
+    matches!(&member.prop, ast::MemberProp::Ident(prop) if prop.sym.as_ref() == "from")
+        && is_web_readable_stream_constructor_ref(ctx, member.obj.as_ref())
+}
+
 fn expr_may_have_typed_receiver(expr: &ast::Expr, ctx: &LoweringContext) -> bool {
     match expr {
         ast::Expr::Lit(ast::Lit::Str(_)) => true,

crates/perry-hir/tests/readable_stream_from_lowering.rs

@@ -58,3 +58,72 @@ fn readable_stream_from_static_factory_lowers_to_native_factory() {
         other => panic!("expected ReadableStream.from NativeMethodCall, got: {other:#?}"),
     }
 }
+
+#[test]
+fn namespace_readable_stream_from_lowers_to_native_factory_and_reader() {
+    let module = lower(
+        r#"
+        import * as streamWeb from "node:stream/web";
+        const rs: any = (streamWeb.ReadableStream as any).from(["a"]);
+        const reader = rs.getReader();
+        const result = reader.read();
+    "#,
+    );
+
+    let lets: Vec<(&str, &Expr)> = module
+        .init
+        .iter()
+        .filter_map(|stmt| match stmt {
+            Stmt::Let {
+                name,
+                init: Some(expr),
+                ..
+            } => Some((name.as_str(), expr)),
+            _ => None,
+        })
+        .collect();
+
+    assert!(matches!(
+        lets.as_slice(),
+        [
+            (
+                "rs",
+                Expr::NativeMethodCall {
+                    module,
+                    class_name: Some(class_name),
+                    object: None,
+                    method,
+                    ..
+                }
+            ),
+            (
+                "reader",
+                Expr::NativeMethodCall {
+                    module: reader_module,
+                    class_name: Some(reader_class),
+                    object: Some(_),
+                    method: reader_method,
+                    ..
+                }
+            ),
+            (
+                "result",
+                Expr::NativeMethodCall {
+                    module: read_module,
+                    class_name: Some(read_class),
+                    object: Some(_),
+                    method: read_method,
+                    ..
+                }
+            )
+        ] if module == "readable_stream"
+            && class_name == "ReadableStream"
+            && method == "from"
+            && reader_module == "readable_stream"
+            && reader_class == "ReadableStream"
+            && reader_method == "getReader"
+            && read_module == "readable_stream_reader"
+            && read_class == "ReadableStreamDefaultReader"
+            && read_method == "read"
+    ));
+}

test-files/test_gap_10568_readable_stream_from.ts

@@ -0,0 +1,9 @@
+import * as streamWeb from "node:stream/web";
+
+const stream: any = (streamWeb.ReadableStream as any).from(["x", "y", "z"]);
+const reader = stream.getReader();
+
+for (let index = 0; index < 4; index++) {
+  const result: any = await reader.read();
+  console.log(index, result.done, result.value, JSON.stringify(Object.keys(result)));
+}