introduce infcx.at(..).dropck_outlives(..) operaton [VIC]

Backed by a canonicalized query. This computes all the types/regions that need
to be live when the destructor runs (i.e., that the dtor may access).

Author: nikomatsakis

src/librustc/ich/impls_ty.rs

@@ -818,12 +818,6 @@ impl_stable_hash_for!(struct ty::Destructor {
     did
 });
 
-impl_stable_hash_for!(struct ty::DtorckConstraint<'tcx> {
-    outlives,
-    dtorck_types
-});
-
-
 impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::CrateVariancesMap {
     fn hash_stable<W: StableHasherResult>(&self,
                                           hcx: &mut StableHashingContext<'gcx>,

src/librustc/traits/query/dropck_outlives.rs

@@ -0,0 +1,183 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use infer::at::At;
+use infer::canonical::{Canonical, Canonicalize, QueryResult};
+use infer::InferOk;
+use std::iter::FromIterator;
+use ty::{self, CanonicalIntern, Ty, TyCtxt};
+use ty::subst::Kind;
+use std::rc::Rc;
+
+pub type CanonicalTyGoal<'tcx> = Canonical<ty::ParamEnvAnd<'tcx, Ty<'tcx>>>;
+
+impl<'cx, 'gcx, 'tcx> At<'cx, 'gcx, 'tcx> {
+    /// Given a type `ty` of some value being dropped, computes a set
+    /// of "kinds" (types, regions) that must be outlive the execution
+    /// of the destructor. These basically correspond to data that the
+    /// destructor might access. This is used during regionck to
+    /// impose "outlives" constraints on any lifetimes referenced
+    /// within.
+    ///
+    /// The rules here are given by the "dropck" RFCs, notably [#1238]
+    /// and [#1327]. This is a fixed-point computation, where we
+    /// explore all the data that will be dropped (transitively) when
+    /// a value of type `ty` is dropped. For each type T that will be
+    /// dropped and which has a destructor, we must assume that all
+    /// the types/regions of T are live during the destructor, unless
+    /// they are marked with a special attribute (`#[may_dangle]`).
+    ///
+    /// [#1238]: https://github.com/rust-lang/rfcs/blob/master/text/1238-nonparametric-dropck.md
+    /// [#1327]: https://github.com/rust-lang/rfcs/blob/master/text/1327-dropck-param-eyepatch.md
+    pub fn dropck_outlives(&self, ty: Ty<'tcx>) -> InferOk<'tcx, Vec<Kind<'tcx>>> {
+        let tcx = self.infcx.tcx;
+        let gcx = tcx.global_tcx();
+        let (c_ty, orig_values) = self.infcx.canonicalize_query(&self.param_env.and(ty));
+        let span = self.cause.span;
+        match &gcx.dropck_outlives(c_ty) {
+            Ok(result) if result.is_proven() => {
+                match self.infcx.instantiate_query_result(
+                    self.cause,
+                    self.param_env,
+                    &orig_values,
+                    result,
+                ) {
+                    Ok(InferOk {
+                        value: DropckOutlivesResult { kinds, overflows },
+                        obligations,
+                    }) => {
+                        for overflow_ty in overflows.into_iter().take(1) {
+                            let mut err = struct_span_err!(
+                                tcx.sess,
+                                span,
+                                E0320,
+                                "overflow while adding drop-check rules for {}",
+                                self.infcx.resolve_type_vars_if_possible(&ty),
+                            );
+                            err.note(&format!("overflowed on {}", overflow_ty));
+                            err.emit();
+                        }
+
+                        return InferOk {
+                            value: kinds,
+                            obligations,
+                        };
+                    }
+
+                    Err(_) => { /* fallthrough to error-handling code below */ }
+                }
+            }
+
+            _ => { /* fallthrough to error-handling code below */ }
+        }
+
+        // Errors and ambiuity in dropck occur in two cases:
+        // - unresolved inference variables at the end of typeck
+        // - non well-formed types where projections cannot be resolved
+        // Either of these should hvae created an error before.
+        tcx.sess
+            .delay_span_bug(span, "dtorck encountered internal error");
+        return InferOk {
+            value: vec![],
+            obligations: vec![],
+        };
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct DropckOutlivesResult<'tcx> {
+    pub kinds: Vec<Kind<'tcx>>,
+    pub overflows: Vec<Ty<'tcx>>,
+}
+
+/// A set of constraints that need to be satisfied in order for
+/// a type to be valid for destruction.
+#[derive(Clone, Debug)]
+pub struct DtorckConstraint<'tcx> {
+    /// Types that are required to be alive in order for this
+    /// type to be valid for destruction.
+    pub outlives: Vec<ty::subst::Kind<'tcx>>,
+
+    /// Types that could not be resolved: projections and params.
+    pub dtorck_types: Vec<Ty<'tcx>>,
+
+    /// If, during the computation of the dtorck constraint, we
+    /// overflow, that gets recorded here. The caller is expected to
+    /// report an error.
+    pub overflows: Vec<Ty<'tcx>>,
+}
+
+impl<'tcx> DtorckConstraint<'tcx> {
+    pub fn empty() -> DtorckConstraint<'tcx> {
+        DtorckConstraint {
+            outlives: vec![],
+            dtorck_types: vec![],
+            overflows: vec![],
+        }
+    }
+}
+
+impl<'tcx> FromIterator<DtorckConstraint<'tcx>> for DtorckConstraint<'tcx> {
+    fn from_iter<I: IntoIterator<Item = DtorckConstraint<'tcx>>>(iter: I) -> Self {
+        let mut result = Self::empty();
+
+        for DtorckConstraint {
+            outlives,
+            dtorck_types,
+            overflows,
+        } in iter
+        {
+            result.outlives.extend(outlives);
+            result.dtorck_types.extend(dtorck_types);
+            result.overflows.extend(overflows);
+        }
+
+        result
+    }
+}
+impl<'gcx: 'tcx, 'tcx> Canonicalize<'gcx, 'tcx> for ty::ParamEnvAnd<'tcx, Ty<'tcx>> {
+    type Canonicalized = &'gcx CanonicalTyGoal<'gcx>;
+
+    fn intern(gcx: TyCtxt<'_, 'gcx, 'gcx>, value: Canonical<Self::Lifted>) -> Self::Canonicalized {
+        value.intern_into(gcx)
+    }
+}
+
+BraceStructTypeFoldableImpl! {
+    impl<'tcx> TypeFoldable<'tcx> for DropckOutlivesResult<'tcx> {
+        kinds, overflows
+    }
+}
+
+BraceStructLiftImpl! {
+    impl<'a, 'tcx> Lift<'tcx> for DropckOutlivesResult<'a> {
+        type Lifted = DropckOutlivesResult<'tcx>;
+        kinds, overflows
+    }
+}
+
+impl_stable_hash_for!(struct DropckOutlivesResult<'tcx> {
+    kinds, overflows
+});
+
+impl<'gcx: 'tcx, 'tcx> Canonicalize<'gcx, 'tcx> for QueryResult<'tcx, DropckOutlivesResult<'tcx>> {
+    // we ought to intern this, but I'm too lazy just now
+    type Canonicalized = Rc<Canonical<QueryResult<'gcx, DropckOutlivesResult<'gcx>>>>;
+
+    fn intern(_gcx: TyCtxt<'_, 'gcx, 'gcx>, value: Canonical<Self::Lifted>) -> Self::Canonicalized {
+        Rc::new(value)
+    }
+}
+
+impl_stable_hash_for!(struct DtorckConstraint<'tcx> {
+    outlives,
+    dtorck_types,
+    overflows
+});

src/librustc/traits/query/mod.rs

@@ -15,6 +15,7 @@
 //! The providers for the queries defined here can be found in
 //! `librustc_traits`.
 
+pub mod dropck_outlives;
 pub mod normalize;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]

src/librustc/ty/context.rs

@@ -35,6 +35,7 @@ use ty::subst::{Kind, Substs};
 use ty::ReprOptions;
 use ty::Instance;
 use traits;
+use traits::query::dropck_outlives::CanonicalTyGoal;
 use traits::query::normalize::CanonicalProjectionGoal;
 use ty::{self, Ty, TypeAndMut};
 use ty::{TyS, TypeVariants, Slice};
@@ -107,6 +108,7 @@ pub struct GlobalArenas<'tcx> {
     /// miri allocations
     const_allocs: TypedArena<interpret::Allocation>,
 
+    canonical_ty_goal_arena: TypedArena<CanonicalTyGoal<'tcx>>,
     canonical_projection_goal_arena: TypedArena<CanonicalProjectionGoal<'tcx>>,
 }
 
@@ -122,6 +124,7 @@ impl<'tcx> GlobalArenas<'tcx> {
             tables: TypedArena::new(),
             const_allocs: TypedArena::new(),
             canonical_projection_goal_arena: TypedArena::new(),
+            canonical_ty_goal_arena: TypedArena::new(),
         }
     }
 }
@@ -892,6 +895,11 @@ pub struct GlobalCtxt<'tcx> {
 
     output_filenames: Arc<OutputFilenames>,
 
+    /// HashSet used to canonicalize interned canonical types for the
+    /// `dropck_outlives` query. Each new unique instance is allocated
+    /// in an arena for use as a query key.
+    canonical_ty_goal_set: RefCell<FxHashSet<Interned<'tcx, CanonicalTyGoal<'tcx>>>>,
+
     /// HashSet used to canonicalize interned canonical projection
     /// goals. Each new unique instance is allocated in an arena for
     /// use as a query key.
@@ -1215,6 +1223,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             on_disk_query_result_cache,
             types: common_types,
             canonical_projection_goal_set: RefCell::new(FxHashSet()),
+            canonical_ty_goal_set: RefCell::new(FxHashSet()),
             trait_map,
             export_map: resolutions.export_map.into_iter().map(|(k, v)| {
                 (k, Rc::new(v))
@@ -1755,6 +1764,26 @@ impl<'tcx> Borrow<RegionKind> for Interned<'tcx, RegionKind> {
     }
 }
 
+impl<'tcx> Borrow<CanonicalTyGoal<'tcx>> for Interned<'tcx, CanonicalTyGoal<'tcx>> {
+    fn borrow<'a>(&'a self) -> &'a CanonicalTyGoal<'tcx> {
+        &self.0
+    }
+}
+
+impl<'tcx> PartialEq for Interned<'tcx, CanonicalTyGoal<'tcx>> {
+    fn eq(&self, other: &Self) -> bool {
+        self.0 == other.0
+    }
+}
+
+impl<'tcx> Eq for Interned<'tcx, CanonicalTyGoal<'tcx>> { }
+
+impl<'tcx> Hash for Interned<'tcx, CanonicalTyGoal<'tcx>> {
+    fn hash<H: Hasher>(&self, s: &mut H) {
+        self.0.hash(s)
+    }
+}
+
 impl<'tcx> Borrow<CanonicalProjectionGoal<'tcx>> for Interned<'tcx, CanonicalProjectionGoal<'tcx>> {
     fn borrow<'a>(&'a self) -> &'a CanonicalProjectionGoal<'tcx> {
         &self.0
@@ -2457,6 +2486,20 @@ where
     fn intern_into(self, gcx: TyCtxt<'_, 'gcx, '_>) -> &'gcx Self;
 }
 
+impl<'gcx> CanonicalIntern<'gcx> for CanonicalTyGoal<'gcx> {
+    fn arena(gcx: TyCtxt<'_, 'gcx, '_>) -> &'gcx TypedArena<Self> {
+        &gcx.global_arenas.canonical_ty_goal_arena
+    }
+
+    fn set<'cx>(gcx: TyCtxt<'cx, 'gcx, '_>) -> &'cx RefCell<FxHashSet<Interned<'gcx, Self>>> {
+        &gcx.canonical_ty_goal_set
+    }
+
+    fn intern_into(self, gcx: TyCtxt<'_, 'gcx, '_>) -> &'gcx Self {
+        intern_into_impl(self, gcx)
+    }
+}
+
 impl<'gcx> CanonicalIntern<'gcx> for CanonicalProjectionGoal<'gcx> {
     fn arena(gcx: TyCtxt<'_, 'gcx, '_>) -> &'gcx TypedArena<Self> {
         &gcx.global_arenas.canonical_projection_goal_arena

src/librustc/ty/maps/config.rs

@@ -60,6 +60,12 @@ impl<'tcx> QueryDescription<'tcx> for queries::normalize_projection_ty<'tcx> {
     }
 }
 
+impl<'tcx> QueryDescription<'tcx> for queries::dropck_outlives<'tcx> {
+    fn describe(_tcx: TyCtxt, goal: &'tcx Canonical<ParamEnvAnd<'tcx, Ty<'tcx>>>) -> String {
+        format!("computing dropck types for `{:?}`", goal)
+    }
+}
+
 impl<'tcx> QueryDescription<'tcx> for queries::is_copy_raw<'tcx> {
     fn describe(_tcx: TyCtxt, env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> String {
         format!("computing whether `{}` is `Copy`", env.value)

src/librustc/ty/maps/keys.rs

@@ -170,3 +170,13 @@ impl<'tcx> Key for &'tcx Canonical<ParamEnvAnd<'tcx, ty::ProjectionTy<'tcx>>> {
         DUMMY_SP
     }
 }
+
+impl<'tcx> Key for &'tcx Canonical<ParamEnvAnd<'tcx, Ty<'tcx>>> {
+    fn map_crate(&self) -> CrateNum {
+        LOCAL_CRATE
+    }
+
+    fn default_span(&self, _tcx: TyCtxt) -> Span {
+        DUMMY_SP
+    }
+}

src/librustc/ty/maps/mod.rs

@@ -34,6 +34,7 @@ use session::{CompileResult, CrateDisambiguator};
 use session::config::OutputFilenames;
 use traits::Vtable;
 use traits::query::NoSolution;
+use traits::query::dropck_outlives::{DtorckConstraint, DropckOutlivesResult};
 use traits::query::normalize::NormalizationResult;
 use traits::specialization_graph;
 use ty::{self, CrateInherentImpls, ParamEnvAnd, Ty, TyCtxt};
@@ -112,7 +113,9 @@ define_maps! { <'tcx>
     [] fn adt_def: AdtDefOfItem(DefId) -> &'tcx ty::AdtDef,
     [] fn adt_destructor: AdtDestructor(DefId) -> Option<ty::Destructor>,
     [] fn adt_sized_constraint: SizedConstraint(DefId) -> &'tcx [Ty<'tcx>],
-    [] fn adt_dtorck_constraint: DtorckConstraint(DefId) -> ty::DtorckConstraint<'tcx>,
+    [] fn adt_dtorck_constraint: DtorckConstraint(
+        DefId
+    ) -> Result<DtorckConstraint<'tcx>, NoSolution>,
 
     /// True if this is a const fn
     [] fn is_const_fn: IsConstFn(DefId) -> bool,
@@ -372,6 +375,11 @@ define_maps! { <'tcx>
         &'tcx Canonical<ParamEnvAnd<'tcx, ty::ProjectionTy<'tcx>>>
     ) -> Result<Rc<Canonical<QueryResult<'tcx, NormalizationResult<'tcx>>>>, NoSolution>,
 
+    /// Do not call this query directly: invoke `infcx.at().dropck_outlives()` instead.
+    [] fn dropck_outlives: normalize_ty_node(
+        &'tcx Canonical<ParamEnvAnd<'tcx, Ty<'tcx>>>
+    ) -> Result<Rc<Canonical<QueryResult<'tcx, DropckOutlivesResult<'tcx>>>>, NoSolution>,
+
     [] fn substitute_normalize_and_test_predicates:
         substitute_normalize_and_test_predicates_node((DefId, &'tcx Substs<'tcx>)) -> bool,
 
@@ -519,7 +527,7 @@ fn output_filenames_node<'tcx>(_: CrateNum) -> DepConstructor<'tcx> {
 fn vtable_methods_node<'tcx>(trait_ref: ty::PolyTraitRef<'tcx>) -> DepConstructor<'tcx> {
     DepConstructor::VtableMethods{ trait_ref }
 }
-fn normalize_ty_node<'tcx>(_: Ty<'tcx>) -> DepConstructor<'tcx> {
+fn normalize_ty_node<'tcx, T>(_: T) -> DepConstructor<'tcx> {
     DepConstructor::NormalizeTy
 }
 

src/librustc/ty/maps/values.rs

@@ -35,12 +35,6 @@ impl<'tcx> Value<'tcx> for Ty<'tcx> {
     }
 }
 
-impl<'tcx> Value<'tcx> for ty::DtorckConstraint<'tcx> {
-    fn from_cycle_error<'a>(_: TyCtxt<'a, 'tcx, 'tcx>) -> Self {
-        Self::empty()
-    }
-}
-
 impl<'tcx> Value<'tcx> for ty::SymbolName {
     fn from_cycle_error<'a>(_: TyCtxt<'a, 'tcx, 'tcx>) -> Self {
         ty::SymbolName { name: Symbol::intern("<error>").as_str() }