Basic support for generators as iterators

[JsonFreeman]

This covers part of the proposal in #2873. Namely, it handles checking types in a generator function, and inferring the return type of a generator function.

Specifically, here is what is implemented (copied from the proposal, with strikethroughs marking the differences):

Type annotation on a generator

A generator function can have a return type annotation, just like a function. The annotation represents the type of the generator returned by the function. Here is an example:

function *g(): Iterable<string> {
    for (var i = 0; i < 100; i++) {
        yield ""; // string is assignable to string
    }
    yield * otherStringGenerator(); // otherStringGenerator must be iterable and element type assignable to string
}

Here are the rules:

• IterableIterator<any> must be assignable to the type annotation.
  • An element type T is structurally retrieved from the type denoted by the type annotation, considering the type annotation as an IterableIterator. It is an error if IterableIterator<T> for this T is not assignable to the type denoted by the type annotation.
• The operand of every yield expression (if present) must be assignable to the element type of the generator (string in this case)
• The operand of every yield * expression must be assignable to Iterable<any>
• The element type of the operand of every yield * expression must be assignable to the element type of the generator. (string is assignable to string)
• The operand of a yield (if present) expression is contextually typed by the element type of the generator (string)
• The operand of a yield * expression is contextually typed by the type of the generator (Iterable<string>)
• A yield expression has type any.
• A yield * expression has type any.
• The generator cannot have return expressions.
  • The generator is allowed to have return expressions as well, but they are ignored for the purposes of type checking the generator type.

Inferring the type of a generator

A generator function with no type annotation can have the type annotation inferred. So in the following case, the type will be inferred from the yield statements:

function *g() {
    for (var i = 0; i < 100; i++) {
        yield ""; // infer string
    }
    yield * otherStringGenerator(); // infer element type of otherStringGenerator
}

• Rather than inferring Iterable, we will infer IterableIterator, with some element type. The reason is that someone can call next directly on the generator without first getting its iterator. A generator is in fact an iterator as well as an iterable.
• The element type is the common supertype of all the yield operands and the element types of all the yield * operands.
• It is an error if there is no common supertype.
• As before, the operand of every yield * expression must be assignable to Iterable<any>
• yield and yield * expressions again have type any
• If the generator is contextually typed, the operands of yield expressions are contextually typed by the element type of the contextual type
• If the generator is contextually typed, the operands of yield * expressions are contextually typed by the contextual type.
• Again, return expressions are allowed, but not used for inferring the element type.~~ Return expressions are not allowed. Consider relaxing this later, particularly if there is no type annotation.~~
• If there are no yield operands and no yield* expressions, the element type is an implicit any, which errors in noImplicitAny mode.

[DanielRosenwasser]

I think it's kind of weird that getTypeFromTypeNode returns unknownType when failing whereas getElementTypeFromIterableIterator returns undefined.

[JsonFreeman]

getElementTypeFromIterableIterator is used for computing a contextual type, and everything that is used for getting a contextual type has to return undefined if it has nothing to contribute.

[DanielRosenwasser]

We'll need to do work on quick info and highlighting spans later on

[JsonFreeman]

What is there to do for quick info? Highlighting spans will require work yes.

[DanielRosenwasser]

Just to confirm what quick info looks like for a function type.

By the way, can you default-export a generator?

[JsonFreeman]

Yes, you can default-export a generator.