Description of changes:

This implements the generator feature for Rust. We translate a generator type similarly to an enum with a variant for each suspend point.

Consider the following generator:

|| {
    let a = true;
    let b = &a;
    yield;
    assert_eq!(b as *const _, &a as *const _);
    yield;
};

Rustc compiles this to something similar to the following enum (but there are differences, see below!):

enum GeneratorEnum {
    Unresumed,                        // initial state of the generator
    Returned,                         // generator has returned
    Panicked,                         // generator has panicked
    Suspend0 { b: &bool, a: bool },   // state after suspending (`yield`ing) for the first time
    Suspend1,                         // state after suspending (`yield`ing) for the second time
}

However, its layout may differ from normal Rust enums in the following ways:

• Contrary to enums, the discriminant may not be at offset 0.
• Contrary to enums, there may be other fields than the discriminant "at the top level" (outside the variants).

This means that we CANNOT use the enum translation, which would be roughly as follows:

struct GeneratorEnum {
    int case; // discriminant
    union GeneratorEnum-union cases; // variant
}

union GeneratorEnum-union {
    struct Unresumed variant0;
    struct Returned variant1;
    // ...
}

Instead, we use the following translation:

union GeneratorEnum {
    struct DirectFields direct_fields;
    struct Unresumed generator_variant_Unresumed;
    struct Returned generator_variant_Returned;
    // ...
}

struct DirectFields {
    // padding (for bool *b in Suspend0 below)
    char case;
    // padding (for bool a in Suspend0 below)
}

struct Unresumed {
    // padding (this variant has no fields)
}

// ...

struct Suspend0 {
    bool *generator_field_0; // variable b in the generator code above
    // padding (for char case in DirectFields)
    bool generator_field_1; // variable a in the generator code above
}

Of course, if the generator has any other top-level/direct fields, they'd be included in the DirectFields struct as well.

Resolved issues:

Resolves #416

Call-outs:

• The function ignore_var_ty became redundant, so I removed it.
• There is some code duplication with codegen_enum. I'm not sure how to remove it because codegen_enum relies on an AdtDef, which is not available for generators (because the relevant enum is generated in MIR).
• I added a couple of assertions in codegen_enum that document assumptions that we currently make about enum layouts. (I don't know if they're guaranteed for enums, but they don't hold for generators, so I thought it would be good to be explicit about it.)
• One of the new tests (discriminant.rs, taken from rustc) takes a bit over a minute on my laptop. Is that too much?
  • Discussed with @danielsn, decision: leave it in, but move slow tests to a separate test suite in a follow-up PR

Testing:

• How is this change tested? 3 existing regression tests (that now work) + 16 test cases from rustc (src/test/ui/generator/)

• Is this a refactor change? No

Checklist

• Each commit message has a non-empty body, explaining why the change was made
• Methods or procedures are documented
• Regression or unit tests are included, or existing tests cover the modified code
• My PR is restricted to a single feature or bugfix

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 and MIT licenses.