Use async iterable webidl type in ReadableStream.from

index.bs

@@ -488,7 +488,7 @@ The Web IDL definition for the {{ReadableStream}} class is given as follows:
 interface ReadableStream {
   constructor(optional object underlyingSource, optional QueuingStrategy strategy = {});
 
-  static ReadableStream from(any asyncIterable);
+  static ReadableStream from(async iterable<any> asyncIterable);
 
   readonly attribute boolean locked;
 
@@ -2123,43 +2123,25 @@ The following abstract operations operate on {{ReadableStream}} instances at a h
 </div>
 
 <div algorithm>
- <dfn abstract-op lt="ReadableStreamFromIterable" id="readable-stream-from-iterable">
+ <dfn abstract-op export lt="ReadableStreamFromIterable" id="readable-stream-from-iterable">
  ReadableStreamFromIterable(|asyncIterable|)</dfn> performs the following steps:
 
  1. Let |stream| be undefined.
- 1. Let |iteratorRecord| be ? [$GetIterator$](|asyncIterable|, async).
  1. Let |startAlgorithm| be an algorithm that returns undefined.
  1. Let |pullAlgorithm| be the following steps:
-  1. Let |nextResult| be [$IteratorNext$](|iteratorRecord|).
-  1. If |nextResult| is an abrupt completion, return [=a promise rejected with=]
-     |nextResult|.\[[Value]].
-  1. Let |nextPromise| be [=a promise resolved with=] |nextResult|.\[[Value]].
-  1. Return the result of [=reacting=] to |nextPromise| with the following fulfillment steps,
-     given |iterResult|:
-   1. If [$Type$](|iterResult|) is not Object, throw a {{TypeError}}.
-   1. Let |done| be ? [$IteratorComplete$](|iterResult|).
-   1. If |done| is true:
-    1. Perform ! [$ReadableStreamDefaultControllerClose$](|stream|.[=ReadableStream/[[controller]]=]).
-   1. Otherwise:
-    1. Let |value| be ? [$IteratorValue$](|iterResult|).
-    1. Perform ! [$ReadableStreamDefaultControllerEnqueue$](|stream|.[=ReadableStream/[[controller]]=],
-       |value|).
+  1. Let |nextPromise| be the result of [=getting the next value/get an async iterable next value=]
+     from |asyncIterable|.
+  1. Return the result of [=reacting=] to |nextPromise|:
+   - If |next| was fulfilled with value |v|:
+    1. If |v| is [=end of iteration=], perform ! [$ReadableStreamDefaultControllerClose$](|stream|.[=ReadableStream/[[controller]]=]).
        <!-- TODO (future): If we allow changing the queuing strategy, this Enqueue might throw.
-             We'll then need to catch the error and close the async iterator. -->
+          We'll then need to catch the error and close the async iterator. -->
+    1. Otherwise, perform ! [$ReadableStreamDefaultControllerEnqueue$](|stream|.[=ReadableStream/[[controller]]=], |v|).
+   - If |next| was rejected with reason |r|, perform ! [$ReadableStreamDefaultControllerError$](|stream|.[=ReadableStream/[[controller]]=], |r|).
  1. Let |cancelAlgorithm| be the following steps, given |reason|:
-  1. Let |iterator| be |iteratorRecord|.\[[Iterator]].
-  1. Let |returnMethod| be [$GetMethod$](|iterator|, "`return`").
-  1. If |returnMethod| is an abrupt completion, return [=a promise rejected with=]
-     |returnMethod|.\[[Value]].
-  1. If |returnMethod|.\[[Value]] is undefined, return [=a promise resolved with=] undefined.
-  1. Let |returnResult| be [$Call$](|returnMethod|.\[[Value]], |iterator|, « |reason| »).
-  1. If |returnResult| is an abrupt completion, return [=a promise rejected with=]
-     |returnResult|.\[[Value]].
-  1. Let |returnPromise| be [=a promise resolved with=] |returnResult|.\[[Value]].
-  1. Return the result of [=reacting=] to |returnPromise| with the following fulfillment steps,
-     given |iterResult|:
-   1. If [$Type$](|iterResult|) is not Object, throw a {{TypeError}}.
-   1. Return undefined.
+  1. Let |finishPromise| be the result of [=closing/close an async iterable=] |asyncIterable| with
+     reason |reason|.
+  1. Return |finishPromise|.
  1. Set |stream| to ! [$CreateReadableStream$](|startAlgorithm|, |pullAlgorithm|, |cancelAlgorithm|,
     0).
  1. Return |stream|.