Repository: TypeScript
Issue: Allow generic yield* types
Labels: Suggestion,Help Wanted,Effort: Moderate,Rescheduled

## Search Terms

generic yield asterisk type preserve

## Suggestion

Currently, the `yield*` construct doesn't work properly with generic types. I would like to see these kinds of situations get proper types:

```ts
function* foo<T extends Iterable<any>>(x: T) {
    yield* x;
}
// Inferred return type: `Generator<any, void, undefined>`
```

I would like to see some kind of `Iteratorify` types added:
```ts
type YieldTypeOfIterableType<R> = R extends Iterable<infer Y> | Iterator<infer Y> | IterableIterator<infer Y> | Generator<infer Y> ? Y : never;

type Awaited<T> =
  T extends null | undefined ? T : // for non-strictNullChecks
  T extends PromiseLike<infer U> ? Awaited<U> :
  T;

/** Extracts the `Symbol.asyncIterator` return type, falling back to the `Symbol.iterator` return type if necessary. */
type AsyncIteratorify<T> = [T] extends [{ [Symbol.asyncIterator]: () => void } | { [Symbol.iterator]: () => void }]
    // Tests whether a given type has a valid AsyncIterator / Iterator in every unioned type before actually computing the type
    // This is so AsyncIteratorify<Set<string> | {}> will resolve to `never`
    ? T extends infer U
        ? U extends { [Symbol.asyncIterator]: () => infer R }
            ? YieldTypeOfIterableType<R>
            : U extends { [Symbol.iterator]: () => infer R }
                ? Awaited<YieldTypeOfIterableType<R>>
                : never
        : never
    : never;

/** Extracts the `Symbol.iterator` return type. */
type Iteratorify<T> = [T] extends [{ [Symbol.iterator]: () => void }]
    // Tests whether a given type has a valid Iterator in every unioned type before actually computing the type
    // This is so Iteratorify<Set<string> | {}> will resolve to `never`
    ? T extends infer U
        ? U extends { [Symbol.iterator]: () => infer R }
            ? YieldTypeOfIterableType<R>
            : never
        : never
	: never;

function foo<T extends Iterable<any>>(arr: T): Generator<Iteratorify<T>>;
function* foo<T extends Iterable<any>>(x: T) {
    yield* x;
}

for (const x of foo([1, 2])) console.log(x); // x is a number :D
```

However, this still won't work for generic `this` parameters in `Symbol.iterator` calls:
```ts
for (const x of foo({
    a: 1,
    *[Symbol.iterator]<T>(this: T) {
        for (const x in this) yield x;
    }
})) console.log(x);
```
For this, we would need https://github.com/microsoft/TypeScript/issues/37181 (and we would need a way to allow for passing in implicit `this` parameters in that proposal)

## Checklist

My suggestion meets these guidelines:

* [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [x] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).