[REFACTOR] use OpaqueTypeMap type alias

Author: aliemjay

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -3,6 +3,7 @@ use rustc_data_structures::vec_map::VecMap;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::OpaqueTyOrigin;
 use rustc_infer::infer::error_reporting::unexpected_hidden_region_diagnostic;
+use rustc_infer::infer::opaque_types::OpaqueTypeMap;
 use rustc_infer::infer::TyCtxtInferExt as _;
 use rustc_infer::infer::{DefiningAnchor, InferCtxt};
 use rustc_infer::traits::{Obligation, ObligationCause, TraitEngine};
@@ -62,12 +63,12 @@ impl<'tcx> RegionInferenceContext<'tcx> {
     pub(crate) fn infer_opaque_types(
         &self,
         infcx: &InferCtxt<'_, 'tcx>,
-        opaque_ty_decls: VecMap<OpaqueTypeKey<'tcx>, (OpaqueHiddenType<'tcx>, OpaqueTyOrigin)>,
+        opaque_ty_decls: OpaqueTypeMap<'tcx>,
     ) -> VecMap<LocalDefId, OpaqueHiddenType<'tcx>> {
         let mut result: VecMap<LocalDefId, OpaqueHiddenType<'tcx>> = VecMap::new();
-        for (opaque_type_key, (concrete_type, origin)) in opaque_ty_decls {
+        for (opaque_type_key, decl) in opaque_ty_decls {
             let substs = opaque_type_key.substs;
-            debug!(?concrete_type, ?substs);
+            debug!(?decl.hidden_type, ?substs);
 
             let mut subst_regions = vec![self.universal_regions.fr_static];
             let universal_substs = infcx.tcx.fold_regions(substs, |region, _| {
@@ -90,7 +91,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                     None => {
                         subst_regions.push(vid);
                         infcx.tcx.sess.delay_span_bug(
-                            concrete_type.span,
+                            decl.hidden_type.span,
                             "opaque type with non-universal region substs",
                         );
                         infcx.tcx.lifetimes.re_static
@@ -102,7 +103,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             subst_regions.dedup();
 
             let universal_concrete_type =
-                infcx.tcx.fold_regions(concrete_type, |region, _| match *region {
+                infcx.tcx.fold_regions(decl.hidden_type, |region, _| match *region {
                     ty::ReVar(vid) => subst_regions
                         .iter()
                         .find(|ur_vid| self.eval_equal(vid, **ur_vid))
@@ -118,7 +119,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             let ty = infcx.infer_opaque_definition_from_instantiation(
                 opaque_type_key,
                 universal_concrete_type,
-                origin,
+                decl.origin,
             );
             // Sometimes two opaque types are the same only after we remap the generic parameters
             // back to the opaque type definition. E.g. we may have `OpaqueType<X, Y>` mapped to `(X, Y)`
@@ -128,19 +129,19 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                 if prev.ty != ty {
                     if !ty.references_error() {
                         prev.report_mismatch(
-                            &OpaqueHiddenType { ty, span: concrete_type.span },
+                            &OpaqueHiddenType { ty, span: decl.hidden_type.span },
                             infcx.tcx,
                         );
                     }
                     prev.ty = infcx.tcx.ty_error();
                 }
                 // Pick a better span if there is one.
                 // FIXME(oli-obk): collect multiple spans for better diagnostics down the road.
-                prev.span = prev.span.substitute_dummy(concrete_type.span);
+                prev.span = prev.span.substitute_dummy(decl.hidden_type.span);
             } else {
                 result.insert(
                     opaque_type_key.def_id,
-                    OpaqueHiddenType { ty, span: concrete_type.span },
+                    OpaqueHiddenType { ty, span: decl.hidden_type.span },
                 );
             }
         }

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -5,16 +5,15 @@ use std::{fmt, iter, mem};
 
 use either::Either;
 
-use hir::OpaqueTyOrigin;
 use rustc_data_structures::frozen::Frozen;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_data_structures::vec_map::VecMap;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::lang_items::LangItem;
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_infer::infer::canonical::QueryRegionConstraints;
+use rustc_infer::infer::opaque_types::{OpaqueTypeDecl, OpaqueTypeMap};
 use rustc_infer::infer::outlives::env::RegionBoundPairs;
 use rustc_infer::infer::region_constraints::RegionConstraintData;
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
@@ -30,8 +29,8 @@ use rustc_middle::ty::cast::CastTy;
 use rustc_middle::ty::subst::{GenericArgKind, SubstsRef, UserSubsts};
 use rustc_middle::ty::visit::TypeVisitable;
 use rustc_middle::ty::{
-    self, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, OpaqueHiddenType,
-    OpaqueTypeKey, RegionVid, ToPredicate, Ty, TyCtxt, UserType, UserTypeAnnotationIndex,
+    self, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, RegionVid, ToPredicate, Ty,
+    TyCtxt, UserType, UserTypeAnnotationIndex,
 };
 use rustc_span::def_id::CRATE_DEF_ID;
 use rustc_span::{Span, DUMMY_SP};
@@ -870,8 +869,7 @@ struct BorrowCheckContext<'a, 'tcx> {
 pub(crate) struct MirTypeckResults<'tcx> {
     pub(crate) constraints: MirTypeckRegionConstraints<'tcx>,
     pub(crate) universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,
-    pub(crate) opaque_type_values:
-        VecMap<OpaqueTypeKey<'tcx>, (OpaqueHiddenType<'tcx>, OpaqueTyOrigin)>,
+    pub(crate) opaque_type_values: OpaqueTypeMap<'tcx>,
 }
 
 /// A collection of region constraints that must be satisfied for the
@@ -2645,9 +2643,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
     /// Generates member constraints for the opaque types found so far.
     /// Returns a map to their hidden types.
-    fn finalize_opaque_types(
-        &mut self,
-    ) -> VecMap<OpaqueTypeKey<'tcx>, (OpaqueHiddenType<'tcx>, OpaqueTyOrigin)> {
+    fn finalize_opaque_types(&mut self) -> OpaqueTypeMap<'tcx> {
         let opaque_type_values =
             self.infcx.inner.borrow_mut().opaque_type_storage.take_opaque_types();
 
@@ -2686,7 +2682,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                     hidden_type.ty = self.infcx.tcx.ty_error();
                 }
 
-                (opaque_type_key, (hidden_type, decl.origin))
+                (opaque_type_key, OpaqueTypeDecl { hidden_type, ..decl })
             })
             .collect()
     }