Use the recorded types in MIR to determine generator auto-trait implementations

When we construct a generator type, we build a `ty::GeneratorWitness`
from a list of types that may live across a suspend point. These types are
used to determine the 'constitutent types' for a generator when
selecting an auto-trait predicate. Any types appearing in the
GeneratorWitness are required to implement the auto trait (e.g. `Send`
or `Sync`).

This analysis
is based on the HIR - as a result, it is unable to take liveness of
variables into account. This often results in unnecessary bounds being
computing (e.g requiring that a `Rc` be `Sync` even if it is dropped
before a suspend point), making generators and `async fn`s much less
ergonomic to write.

This commit uses the generator MIR to determine the actual 'constituent
types' of a generator. Specifically, a type in the generator witness is
considered to be a 'constituent type' of the witness if it appears in
the `field_tys` of the computed `GeneratorLayout`. Any type which is
stored across an suspend point must be a constituent type (since it could
be used again after a suspend), while any type that is not stored across
a suspend point cannot possible be a constituent type (since it is
impossible for it to be used again).

By re-using the existing generator layout computation logic, we get some
nice properties for free:
* Types which are dead before the suspend point are not considered
constituent types
* Types without Drop impls not considered constituent types if their
scope extends across an await point (assuming that they are never used
after an await point).

Note that this only affects `ty::GeneratorWitness`, *not*
`ty::Generator` itself. Upvars (captured types from the parent scope)
are considered to be constituent types of the base `ty::Generator`, not
the inner `ty::GeneratorWitness`. This means that upvars are always
considered constituent types - this is because by defintion, they always
live across the first implicit suspend point.

-------

Implementation:

The most significant part of this PR is the introduction of a new
'delayed generator witness mode' to `TraitEngine`. As @nikomatsakis
pointed out, attmepting to compute generator MIR during type-checking
results in the following cycle:

1. We attempt to type-check a generator's parent function
2. During type checking of the parent function, we record a
   predicate of the form `<generator>: AutoTrait`
3. We add this predicate to a `TraitEngine`, and attempt to fulfill it.
4. When we atempt to select the predicate, we attempt to compute the MIR
   for `<generator>`
5. The MIR query attempts to compute `type_of(generator_def_id)`, which
   results in us attempting to type-check the generator's parent function.

To break this cycle, we defer processing of all auto-trait predicates
involving `ty::GeneratorWitness`. These predicates are recorded in the
`TypeckTables` for the parent function. During MIR type-checking of the
parent function, we actually attempt to fulfill these predicates,
reporting any errors that occur.

The rest of the PR is mostly fallout from this change:

* `ty::GeneratorWitness` now stores the `DefId` of its generator. This
allows us to retrieve the MIR for the generator when `SelectionContext`
processes a predicate involving a `ty::GeneratorWitness`
* Since we now store `PredicateObligations` in `TypeckTables`, several
different types have now become `RustcEncodable`/`RustcDecodable`. These
are purely mechanical changes (adding new `#[derives]`), with one
exception - a new `SpecializedDecoder` impl for `List<Predicate>`.
This was essentially identical to other `SpecializedDecoder` imps, but it
would be good to have someone check it over.
* When we delay processing of a `Predicate`, we move it from one
`InferCtxt` to another. This requires us to prevent any inference
variables from leaking out from the first `InferCtxt` - if used in
another `InferCtxt`, they will either be non-existent or refer to the
the wrong variable. Fortunately, the predicate itself has no region
variables - the `ty::GeneratorWitness` has only late-bound regions,
while auto-traits have no generic parameters whatsoever.

However, we still need to deal with the `ObligationCause` stored by the
`PredicateObligation`. An `ObligationCause` (or a nested cause) may have
any number of region variables stored inside it (e.g. from stored
types). Luckily, `ObligationCause` is only used for error reporting, so
we can safely erase all regions variables from it, without affecting the
actual processing of the obligation.

To accomplish this, I took the somewhat unusual approach of implementing
`TypeFoldable` for `ObligationCause`, but did *not* change the `TypeFoldable`
implementation of `Obligation` to fold its contained
`ObligationCause. Other than this one odd case, all other callers of
`TypeFoldable` have no interest in folding an `ObligationCause`. As a
result, we explicitly fold the `ObligationCause` when computing our
deferred generator witness predicates. Since `ObligationCause` is only
used for displaying error messages, the worst that can happen is that a
slightly odd error message is displayed to a user.

With this change, several tests now have fewer errors than they did
previously, due to the improved generator analysis. Unfortunately, this
does not resolve issue rust-lang#64960. The MIR generator transformation stores
format temporaries in the generator, due to the fact that the `format!`
macro takes a reference to them. As a result, they are still considered
constituent types of the `GeneratorWitness`, and are still required to
implement `Send` and `Sync.

* I've changed the pretty-printing of `ty::GeneratorWitness` to print
out its generator DefId, as well as the word `witness`. This makes
debugging issues related to the computation of constituent types much
simpler.

As a final note, this PR contains one unrelated change - all generators
now implement `Freeze` unconditionally. I've opened a separate PR
containing this change - however, it's necessary to allow this branch to
compile without cycle errors. I've left it in this PR to make it easy to
test out this branch on actual code. Assuming that it is accepted, this
PR will be rebased against `master` when it is merged. Otherwise, I'll
need to figure out a different approach to generator
const-qualification.

Author: Aaron1011

src/librustc/hir/mod.rs

@@ -89,6 +89,10 @@ impl HirId {
     }
 }
 
+CloneTypeFoldableImpls! {
+    HirId,
+}
+
 impl rustc_serialize::UseSpecializedEncodable for HirId {
     fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         let HirId {

src/librustc/traits/chalk_fulfill.rs

@@ -9,23 +9,39 @@ use crate::traits::{
     SelectionError,
 };
 use crate::traits::query::NoSolution;
+use crate::traits::DelayedGenerators;
 use crate::infer::InferCtxt;
 use crate::infer::canonical::{Canonical, OriginalQueryValues};
-use crate::ty::{self, Ty};
+use crate::ty::{self, Ty, Predicate};
 use rustc_data_structures::fx::FxHashSet;
 
 pub type CanonicalGoal<'tcx> = Canonical<'tcx, InEnvironment<'tcx, ty::Predicate<'tcx>>>;
 
 pub struct FulfillmentContext<'tcx> {
     obligations: FxHashSet<InEnvironment<'tcx, PredicateObligation<'tcx>>>,
+    // See FulfillmentContext for more details about delayed generator
+    // witness obligations
+    delayed_generator_witnesses: DelayedGenerators<'tcx>,
+    has_delayed_generator_witnesses: bool
 }
 
 impl FulfillmentContext<'tcx> {
     crate fn new() -> Self {
         FulfillmentContext {
             obligations: FxHashSet::default(),
+            delayed_generator_witnesses: None,
+            has_delayed_generator_witnesses: false
         }
     }
+
+    crate fn with_delayed_generator_witness() -> Self {
+        FulfillmentContext {
+            obligations: FxHashSet::default(),
+            delayed_generator_witnesses: Some(Vec::new()),
+            has_delayed_generator_witnesses: true
+        }
+
+    }
 }
 
 fn in_environment(
@@ -108,6 +124,24 @@ impl TraitEngine<'tcx> for FulfillmentContext<'tcx> {
                     goal: obligation.goal.predicate,
                 }, &mut orig_values);
 
+                // See FulfillmentContext for more details about this
+                if self.has_delayed_generator_witnesses {
+
+                    if let Predicate::Trait(p) = obligation.goal.predicate {
+                        if let ty::GeneratorWitness(..) = p.skip_binder().self_ty().kind {
+                            if infcx.tcx.trait_is_auto(p.def_id()) {
+                                debug!("delaying generator witness predicate {:?}",
+                                       obligation.goal.predicate);
+
+                                self.delayed_generator_witnesses.as_mut()
+                                    .expect("Already consumed generator witnesses!")
+                                    .push(obligation.goal);
+                                continue;
+                            }
+                        }
+                    }
+                }
+
                 match infcx.tcx.evaluate_goal(canonical_goal) {
                     Ok(response) => {
                         if response.is_proven() {
@@ -165,4 +199,11 @@ impl TraitEngine<'tcx> for FulfillmentContext<'tcx> {
     fn pending_obligations(&self) -> Vec<PredicateObligation<'tcx>> {
         self.obligations.iter().map(|obligation| obligation.goal.clone()).collect()
     }
+
+    fn delayed_generator_obligations(&mut self) -> Option<Vec<PredicateObligation<'tcx>>> {
+        if !self.has_delayed_generator_witnesses {
+            panic!("Tried to retrieve delayed generators in wrong mode!")
+        }
+        self.delayed_generator_witnesses.take()
+    }
 }

src/librustc/traits/engine.rs

@@ -55,6 +55,22 @@ pub trait TraitEngine<'tcx>: 'tcx {
     ) -> Result<(), Vec<FulfillmentError<'tcx>>>;
 
     fn pending_obligations(&self) -> Vec<PredicateObligation<'tcx>>;
+
+    /// Retrieves the list of delayed generator witness predicates
+    /// stored by this `TraitEngine`. This `TraitEngine` must have been
+    /// created by `TraitEngine::with_delayed_generator_witness` - otherwise,
+    /// this method will panic.
+    ///
+    /// Calling this method consumes the underling `Vec` - subsequent calls
+    /// will return `None`.
+    ///
+    /// This method *MUST* be called on a `TraitEngine` created by
+    /// `with_delayed_generator_witness` - if the `TraitEngine` is dropped
+    /// without this method being called, a panic will occur. This ensures
+    /// that the caller explicitly acknowledges these stored predicates -
+    /// failure to do so will result in unsound code being accepted by
+    /// the compiler.
+    fn delayed_generator_obligations(&mut self) -> Option<Vec<PredicateObligation<'tcx>>>;
 }
 
 pub trait TraitEngineExt<'tcx> {
@@ -85,4 +101,28 @@ impl dyn TraitEngine<'tcx> {
             Box::new(FulfillmentContext::new())
         }
     }
+
+    /// Creates a `TraitEngine` in a special 'delay generator witness' mode.
+    /// This imposes additional requirements for the caller in order to avoid
+    /// accepting unsound code, and should only be used by `FnCtxt`. All other
+    /// users of `TraitEngine` should use `TraitEngine::new`
+    ///
+    /// A `TraitEngine` returned by this constructor will not attempt
+    /// to resolve any `GeneratorWitness` predicates involving auto traits,
+    /// Specifically, predicates of the form:
+    ///
+    /// `<GeneratorWitness>: MyTrait` where `MyTrait` is an auto-trait
+    /// will be stored for later retrieval by `delayed_generator_obligations`.
+    /// The caller of this code *MUST* register these predicates with a
+    /// regular `TraitEngine` (created with `TraitEngine::new`) at some point.
+    /// Otherwise, these predicates will never be evaluated, resulting in
+    /// unsound programs being accepted by the compiler.
+    pub fn with_delayed_generator_witness(tcx: TyCtxt<'tcx>) -> Box<Self> {
+        if tcx.sess.opts.debugging_opts.chalk {
+            Box::new(ChalkFulfillmentContext::with_delayed_generator_witness())
+        } else {
+            Box::new(FulfillmentContext::with_delayed_generator_witness())
+        }
+
+    }
 }

src/librustc/traits/error_reporting.rs

@@ -2181,7 +2181,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                         ty::Adt(ty::AdtDef { did, .. }, ..) if
                             self.tcx.is_diagnostic_item(sym::gen_future, *did) => {},
                         ty::Generator(did, ..) => generator = generator.or(Some(did)),
-                        ty::GeneratorWitness(_) | ty::Opaque(..) => {},
+                        ty::GeneratorWitness(..) | ty::Opaque(..) => {},
                         _ => return false,
                     }
 

src/librustc/traits/fulfill.rs

@@ -15,14 +15,15 @@ use super::{FulfillmentError, FulfillmentErrorCode};
 use super::{ObligationCause, PredicateObligation};
 use super::project;
 use super::select::SelectionContext;
-use super::{Unimplemented, ConstEvalFailure};
+use super::{Unimplemented, ConstEvalFailure, DelayedGenerators};
 
 impl<'tcx> ForestObligation for PendingPredicateObligation<'tcx> {
     type Predicate = ty::Predicate<'tcx>;
 
     fn as_predicate(&self) -> &Self::Predicate { &self.obligation.predicate }
 }
 
+
 /// The fulfillment context is used to drive trait resolution. It
 /// consists of a list of obligations that must be (eventually)
 /// satisfied. The job is to track which are satisfied, which yielded
@@ -59,7 +60,17 @@ pub struct FulfillmentContext<'tcx> {
     // other fulfillment contexts sometimes do live inside of
     // a snapshot (they don't *straddle* a snapshot, so there
     // is no trouble there).
-    usable_in_snapshot: bool
+    usable_in_snapshot: bool,
+
+    // Whether or not we show delay the selection of predicates
+    // involving `ty::GeneratorWitness`.
+    // This is used by `FnCtxt` to delay the checking of
+    // `GeneratorWitness` predicates, since generator MIR is
+    // not available when `FnCxtxt` is run.
+    has_delayed_generator_witness: bool,
+    // The delayed generator witness predicates. This is only
+    // used when `has_delayed_generator_witness:` is `true`
+    delayed_generator_witness: DelayedGenerators<'tcx>,
 }
 
 #[derive(Clone, Debug)]
@@ -79,6 +90,18 @@ impl<'a, 'tcx> FulfillmentContext<'tcx> {
             predicates: ObligationForest::new(),
             register_region_obligations: true,
             usable_in_snapshot: false,
+            delayed_generator_witness: None,
+            has_delayed_generator_witness: false
+        }
+    }
+
+    pub fn with_delayed_generator_witness() -> FulfillmentContext<'tcx> {
+        FulfillmentContext {
+            predicates: ObligationForest::new(),
+            register_region_obligations: true,
+            usable_in_snapshot: false,
+            delayed_generator_witness: Some(Vec::new()),
+            has_delayed_generator_witness: true
         }
     }
 
@@ -87,14 +110,18 @@ impl<'a, 'tcx> FulfillmentContext<'tcx> {
             predicates: ObligationForest::new(),
             register_region_obligations: true,
             usable_in_snapshot: true,
+            delayed_generator_witness: None,
+            has_delayed_generator_witness: false
         }
     }
 
     pub fn new_ignoring_regions() -> FulfillmentContext<'tcx> {
         FulfillmentContext {
             predicates: ObligationForest::new(),
             register_region_obligations: false,
-            usable_in_snapshot: false
+            usable_in_snapshot: false,
+            delayed_generator_witness: None,
+            has_delayed_generator_witness: false
         }
     }
 
@@ -112,6 +139,8 @@ impl<'a, 'tcx> FulfillmentContext<'tcx> {
 
             // Process pending obligations.
             let outcome = self.predicates.process_obligations(&mut FulfillProcessor {
+                has_delayed_generator_witness: self.has_delayed_generator_witness,
+                delayed_generator_witness: &mut self.delayed_generator_witness,
                 selcx,
                 register_region_obligations: self.register_region_obligations
             }, DoCompleted::No);
@@ -226,10 +255,19 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {
     fn pending_obligations(&self) -> Vec<PredicateObligation<'tcx>> {
         self.predicates.map_pending_obligations(|o| o.obligation.clone())
     }
+
+    fn delayed_generator_obligations(&mut self) -> Option<Vec<PredicateObligation<'tcx>>> {
+        if !self.has_delayed_generator_witness {
+            panic!("Tried to retrieve delayed generators in wrong mode!")
+        }
+        self.delayed_generator_witness.take()
+    }
 }
 
 struct FulfillProcessor<'a, 'b, 'tcx> {
     selcx: &'a mut SelectionContext<'b, 'tcx>,
+    has_delayed_generator_witness: bool,
+    delayed_generator_witness: &'a mut DelayedGenerators<'tcx>,
     register_region_obligations: bool,
 }
 
@@ -309,6 +347,21 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
             ty::Predicate::Trait(ref data) => {
                 let trait_obligation = obligation.with(data.clone());
 
+
+                if self.has_delayed_generator_witness &&
+                    self.selcx.tcx().trait_is_auto(data.def_id()) {
+                    // Ok to skip binder - bound regions do not affect whether self
+                    // type is a `GeneratorWitness
+                    if let ty::GeneratorWitness(..) = data.skip_binder().self_ty().kind {
+                        debug!("delaying generator witness predicate `{:?}` at depth {}",
+                               data, obligation.recursion_depth);
+                        self.delayed_generator_witness.as_mut()
+                            .expect("Delayed generator witnesses already consumed!")
+                            .push(obligation.clone());
+                        return ProcessResult::Changed(vec![])
+                    }
+                }
+
                 if data.is_global() {
                     // no type variables present, can use evaluation for better caching.
                     // FIXME: consider caching errors too.
@@ -319,6 +372,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
                     }
                 }
 
+
                 match self.selcx.select(&trait_obligation) {
                     Ok(Some(vtable)) => {
                         debug!("selecting trait `{:?}` at depth {} yielded Ok(Some)",