rarw

Author: lcnr

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -1,17 +1,15 @@
 use std::iter;
 use std::rc::Rc;
 
-use rustc_data_structures::frozen::Frozen;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::DefId;
 use rustc_index::IndexVec;
+use rustc_infer::infer::outlives::env::RegionBoundPairs;
 use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin};
+use rustc_infer::traits::ObligationCause;
 use rustc_macros::extension;
 use rustc_middle::bug;
-use rustc_middle::mir::ConstraintCategory;
-use rustc_middle::ty::relate::{
-    Relate, RelateResult, TypeRelation, structurally_relate_consts, structurally_relate_tys,
-};
+use rustc_middle::mir::{Body, ConstraintCategory};
 use rustc_middle::ty::{
     self, DefiningScopeKind, GenericArgsRef, OpaqueHiddenType, OpaqueTypeKey, Region, RegionVid,
     Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable,
@@ -23,13 +21,16 @@ use rustc_trait_selection::error_reporting::infer::region::unexpected_hidden_reg
 use rustc_trait_selection::opaque_types::{
     InvalidOpaqueTypeArgs, check_opaque_type_parameter_valid,
 };
+use rustc_trait_selection::solve::NoSolution;
+use rustc_trait_selection::traits::query::type_op::custom::CustomTypeOp;
 use tracing::{debug, instrument};
 
 use super::reverse_sccs::ReverseSccGraph;
 use super::values::RegionValues;
 use super::{ConstraintSccs, RegionDefinition, RegionInferenceContext};
 use crate::constraints::ConstraintSccIndex;
 use crate::consumers::OutlivesConstraint;
+use crate::type_check::canonical::fully_perform_op_raw;
 use crate::type_check::free_region_relations::UniversalRegionRelations;
 use crate::type_check::{Locations, MirTypeckRegionConstraints};
 use crate::universal_regions::{RegionClassification, UniversalRegions};
@@ -52,8 +53,11 @@ impl<'tcx> BorrowCheckRootCtxt<'tcx> {
     pub(crate) fn handle_opaque_type_uses(&mut self, borrowck_state: &mut BorrowckState<'tcx>) {
         let BorrowckState {
             infcx,
-            constraints,
+            body_owned,
             universal_region_relations,
+            region_bound_pairs,
+            known_type_outlives_obligations,
+            constraints,
             location_map,
             deferred_opaque_type_errors,
             ..
@@ -62,10 +66,13 @@ impl<'tcx> BorrowCheckRootCtxt<'tcx> {
         handle_opaque_type_uses(
             self,
             infcx,
-            constraints,
-            deferred_opaque_type_errors,
+            body_owned,
             universal_region_relations,
+            region_bound_pairs,
+            known_type_outlives_obligations,
             location_map,
+            constraints,
+            deferred_opaque_type_errors,
         )
     }
 }
@@ -82,7 +89,7 @@ struct RegionCtxt<'a, 'tcx> {
 impl<'a, 'tcx> RegionCtxt<'a, 'tcx> {
     fn new(
         infcx: &'a BorrowckInferCtxt<'tcx>,
-        universal_region_relations: &'a Frozen<UniversalRegionRelations<'tcx>>,
+        universal_region_relations: &'a UniversalRegionRelations<'tcx>,
         location_map: Rc<DenseLocationMap>,
         constraints: &MirTypeckRegionConstraints<'tcx>,
     ) -> RegionCtxt<'a, 'tcx> {
@@ -160,10 +167,13 @@ impl<'a, 'tcx> RegionCtxt<'a, 'tcx> {
 pub(crate) fn handle_opaque_type_uses<'tcx>(
     root_cx: &mut BorrowCheckRootCtxt<'tcx>,
     infcx: &BorrowckInferCtxt<'tcx>,
+    body: &Body<'tcx>,
+    universal_region_relations: &UniversalRegionRelations<'tcx>,
+    region_bound_pairs: &RegionBoundPairs<'tcx>,
+    known_type_outlives_obligations: &[ty::PolyTypeOutlivesPredicate<'tcx>],
+    location_map: &Rc<DenseLocationMap>,
     constraints: &mut MirTypeckRegionConstraints<'tcx>,
     deferred_errors: &mut Vec<DeferredOpaqueTypeError<'tcx>>,
-    universal_region_relations: &Frozen<UniversalRegionRelations<'tcx>>,
-    location_map: &Rc<DenseLocationMap>,
 ) {
     let opaque_types = infcx.take_opaque_types();
     if opaque_types.is_empty() {
@@ -197,7 +207,16 @@ pub(crate) fn handle_opaque_type_uses<'tcx>(
         &mut opaque_types,
     );
 
-    apply_defining_uses(root_cx, infcx, constraints, universal_region_relations, &opaque_types);
+    apply_defining_uses(
+        root_cx,
+        infcx,
+        body,
+        &universal_region_relations.universal_regions,
+        region_bound_pairs,
+        known_type_outlives_obligations,
+        constraints,
+        &opaque_types,
+    );
 }
 
 #[derive(Debug)]
@@ -212,7 +231,7 @@ fn collect_defining_uses<'tcx>(
     infcx: &BorrowckInferCtxt<'tcx>,
     constraints: &mut MirTypeckRegionConstraints<'tcx>,
     deferred_errors: &mut Vec<DeferredOpaqueTypeError<'tcx>>,
-    universal_region_relations: &Frozen<UniversalRegionRelations<'tcx>>,
+    universal_region_relations: &UniversalRegionRelations<'tcx>,
     location_map: &Rc<DenseLocationMap>,
     opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
 ) {
@@ -546,8 +565,11 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for HiddenTypeMeh<'_, 'tcx> {
 fn apply_defining_uses<'tcx>(
     root_cx: &mut BorrowCheckRootCtxt<'tcx>,
     infcx: &BorrowckInferCtxt<'tcx>,
+    body: &Body<'tcx>,
+    universal_regions: &UniversalRegions<'tcx>,
+    region_bound_pairs: &RegionBoundPairs<'tcx>,
+    known_type_outlives_obligations: &[ty::PolyTypeOutlivesPredicate<'tcx>],
     constraints: &mut MirTypeckRegionConstraints<'tcx>,
-    universal_region_relations: &Frozen<UniversalRegionRelations<'tcx>>,
     opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
 ) {
     let tcx = infcx.tcx;
@@ -570,122 +592,30 @@ fn apply_defining_uses<'tcx>(
             }
         });
 
-        let universal_regions = &universal_region_relations.universal_regions;
-        let mut relation =
-            EquateRegions { infcx, span: hidden_type.span, universal_regions, constraints };
-        match TypeRelation::relate(&mut relation, hidden_type.ty, expected.ty) {
-            Ok(_) => {}
-            Err(_) => {
-                let _ = hidden_type.build_mismatch_error(&expected, tcx).map(|d| d.emit());
-            }
-        }
-
-        // normalize -> equate
-        //
-        // Do we need to normalize?
-        // Only to support non-universal type or const args. It feels likely that we need (and want) to do so
-        // This once again needs to be careful about cycles: normalizing and equating while defining/revealing
-        // opaque types may end up introducing new defining uses.
-
-        // How can we equate here?
-        // If we need to normalize the answer is just "it's TypeChecker time"
-        // without it we could manually walk over the types using a type relation and equate region vars
-        // that way.
-    }
-}
-
-fn to_region_vid<'tcx>(
-    constraints: &MirTypeckRegionConstraints<'tcx>,
-    universal_regions: &UniversalRegions<'tcx>,
-    r: Region<'tcx>,
-) -> RegionVid {
-    if let ty::RePlaceholder(placeholder) = r.kind() {
-        constraints.get_placeholder_region(placeholder).as_var()
-    } else {
-        universal_regions.to_region_vid(r)
-    }
-}
-
-// FUCKING SHIT NO!wegrdtfhergfsg
-struct EquateRegions<'a, 'tcx> {
-    infcx: &'a BorrowckInferCtxt<'tcx>,
-    span: Span,
-    universal_regions: &'a UniversalRegions<'tcx>,
-    constraints: &'a mut MirTypeckRegionConstraints<'tcx>,
-}
-
-impl<'tcx> TypeRelation<TyCtxt<'tcx>> for EquateRegions<'_, 'tcx> {
-    fn cx(&self) -> TyCtxt<'tcx> {
-        self.infcx.tcx
-    }
-
-    fn relate_with_variance<T: Relate<TyCtxt<'tcx>>>(
-        &mut self,
-        _variance: ty::Variance,
-        _info: ty::VarianceDiagInfo<TyCtxt<'tcx>>,
-        a: T,
-        b: T,
-    ) -> RelateResult<'tcx, T> {
-        self.relate(a, b)
-    }
-
-    fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
-        structurally_relate_tys(self, a, b)
-    }
-
-    fn regions(
-        &mut self,
-        a: ty::Region<'tcx>,
-        b: ty::Region<'tcx>,
-    ) -> RelateResult<'tcx, ty::Region<'tcx>> {
-        if matches!(a.kind(), ty::ReBound(..)) || matches!(b.kind(), ty::ReBound(..)) {
-            assert_eq!(a, b);
-            return Ok(a);
-        }
-
-        let a_vid = to_region_vid(self.constraints, self.universal_regions, a);
-        let b_vid = to_region_vid(self.constraints, self.universal_regions, b);
-        let locations = Locations::All(self.span);
-        self.constraints.outlives_constraints.push(OutlivesConstraint {
-            sup: a_vid,
-            sub: b_vid,
-            locations,
-            span: self.span,
-            category: ConstraintCategory::OpaqueType,
-            variance_info: ty::VarianceDiagInfo::None,
-            from_closure: false,
-        });
-        self.constraints.outlives_constraints.push(OutlivesConstraint {
-            sup: b_vid,
-            sub: a_vid,
+        let locations = Locations::All(hidden_type.span);
+        fully_perform_op_raw(
+            infcx,
+            body,
+            universal_regions,
+            region_bound_pairs,
+            known_type_outlives_obligations,
+            constraints,
             locations,
-            span: self.span,
-            category: ConstraintCategory::OpaqueType,
-            variance_info: ty::VarianceDiagInfo::None,
-            from_closure: false,
-        });
-
-        Ok(a)
-    }
-
-    fn consts(
-        &mut self,
-        a: ty::Const<'tcx>,
-        b: ty::Const<'tcx>,
-    ) -> RelateResult<'tcx, ty::Const<'tcx>> {
-        structurally_relate_consts(self, a, b)
-    }
-
-    fn binders<T>(
-        &mut self,
-        a: ty::Binder<'tcx, T>,
-        b: ty::Binder<'tcx, T>,
-    ) -> RelateResult<'tcx, ty::Binder<'tcx, T>>
-    where
-        T: Relate<TyCtxt<'tcx>>,
-    {
-        self.relate(a.skip_binder(), b.skip_binder())?;
-        Ok(a)
+            ConstraintCategory::OpaqueType,
+            CustomTypeOp::new(
+                |ocx| {
+                    let cause = ObligationCause::misc(
+                        hidden_type.span,
+                        body.source.def_id().expect_local(),
+                    );
+                    let expected = ocx.normalize(&cause, infcx.param_env, expected);
+                    ocx.eq(&cause, infcx.param_env, expected.ty, hidden_type.ty)
+                        .map_err(|_| NoSolution)
+                },
+                "equating opaque types",
+            ),
+        )
+        .expect("failed to relate opaque types");
     }
 }