Remove unused field

Author: oli-obk

compiler/rustc_infer/src/infer/canonical/query_response.rs

@@ -91,7 +91,6 @@ impl<'tcx> InferCtxt<'tcx> {
             var_values: inference_vars,
             region_constraints: QueryRegionConstraints::default(),
             certainty: Certainty::Proven, // Ambiguities are OK!
-            opaque_types: vec![],
             value: answer,
         })
     }
@@ -140,28 +139,14 @@ impl<'tcx> InferCtxt<'tcx> {
         let certainty =
             if ambig_errors.is_empty() { Certainty::Proven } else { Certainty::Ambiguous };
 
-        let opaque_types = self.take_opaque_types_for_query_response();
-
         Ok(QueryResponse {
             var_values: inference_vars,
             region_constraints,
             certainty,
             value: answer,
-            opaque_types,
         })
     }
 
-    /// FIXME: This method should only be used for canonical queries and therefore be private.
-    ///
-    /// As the new solver does canonicalization slightly differently, this is also used there
-    /// for now. This should hopefully change fairly soon.
-    pub fn take_opaque_types_for_query_response(&self) -> Vec<(Ty<'tcx>, Ty<'tcx>)> {
-        std::mem::take(&mut self.inner.borrow_mut().opaque_type_storage.opaque_types)
-            .into_iter()
-            .map(|(k, v)| (self.tcx.mk_opaque(k.def_id.to_def_id(), k.substs), v.hidden_type.ty))
-            .collect()
-    }
-
     /// Given the (canonicalized) result to a canonical query,
     /// instantiates the result so it can be used, plugging in the
     /// values from the canonical query. (Note that the result may
@@ -244,8 +229,8 @@ impl<'tcx> InferCtxt<'tcx> {
     where
         R: Debug + TypeFoldable<'tcx>,
     {
-        let InferOk { value: result_subst, mut obligations } = self
-            .query_response_substitution_guess(cause, param_env, original_values, query_response)?;
+        let InferOk { value: result_subst, mut obligations } =
+            self.query_response_substitution_guess(cause, original_values, query_response)?;
 
         // Compute `QueryOutlivesConstraint` values that unify each of
         // the original values `v_o` that was canonicalized into a
@@ -363,12 +348,8 @@ impl<'tcx> InferCtxt<'tcx> {
             original_values, query_response,
         );
 
-        let mut value = self.query_response_substitution_guess(
-            cause,
-            param_env,
-            original_values,
-            query_response,
-        )?;
+        let mut value =
+            self.query_response_substitution_guess(cause, original_values, query_response)?;
 
         value.obligations.extend(
             self.unify_query_response_substitution_guess(
@@ -396,7 +377,6 @@ impl<'tcx> InferCtxt<'tcx> {
     fn query_response_substitution_guess<R>(
         &self,
         cause: &ObligationCause<'tcx>,
-        param_env: ty::ParamEnv<'tcx>,
         original_values: &OriginalQueryValues<'tcx>,
         query_response: &Canonical<'tcx, QueryResponse<'tcx, R>>,
     ) -> InferResult<'tcx, CanonicalVarValues<'tcx>>
@@ -496,16 +476,7 @@ impl<'tcx> InferCtxt<'tcx> {
             )),
         };
 
-        let mut obligations = vec![];
-
-        // Carry all newly resolved opaque types to the caller's scope
-        for &(a, b) in &query_response.value.opaque_types {
-            let a = substitute_value(self.tcx, &result_subst, a);
-            let b = substitute_value(self.tcx, &result_subst, b);
-            obligations.extend(self.at(cause, param_env).eq(a, b)?.obligations);
-        }
-
-        Ok(InferOk { value: result_subst, obligations })
+        Ok(InferOk { value: result_subst, obligations: vec![] })
     }
 
     /// Given a "guess" at the values for the canonical variables in

compiler/rustc_middle/src/infer/canonical.rs

@@ -204,12 +204,6 @@ pub struct QueryResponse<'tcx, R> {
     pub var_values: CanonicalVarValues<'tcx>,
     pub region_constraints: QueryRegionConstraints<'tcx>,
     pub certainty: Certainty,
-    /// List of opaque types which we tried to compare to another type.
-    /// Inside the query we don't know yet whether the opaque type actually
-    /// should get its hidden type inferred. So we bubble the opaque type
-    /// and the type it was compared against upwards and let the query caller
-    /// handle it.
-    pub opaque_types: Vec<(Ty<'tcx>, Ty<'tcx>)>,
     pub value: R,
 }
 

compiler/rustc_middle/src/traits/solve.rs

@@ -4,7 +4,7 @@ use rustc_data_structures::intern::Interned;
 
 use crate::ty::{
     ir::{self, TypeFoldable, TypeVisitable},
-    FallibleTypeFolder, Ty, TyCtxt, TypeFolder, TypeVisitor,
+    FallibleTypeFolder, TyCtxt, TypeFolder, TypeVisitor,
 };
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
@@ -19,32 +19,27 @@ impl<'tcx> std::ops::Deref for ExternalConstraints<'tcx> {
 }
 
 /// Additional constraints returned on success.
-#[derive(Debug, PartialEq, Eq, Clone, Hash, Default)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub struct ExternalConstraintsData<'tcx> {
     // FIXME: implement this.
-    pub regions: (),
-    pub opaque_types: Vec<(Ty<'tcx>, Ty<'tcx>)>,
+    pub regions: &'tcx (),
+}
+
+impl<'tcx> Default for ExternalConstraintsData<'tcx> {
+    fn default() -> Self {
+        Self { regions: &() }
+    }
 }
 
 impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for ExternalConstraints<'tcx> {
     fn try_fold_with<F: FallibleTypeFolder<'tcx>>(self, folder: &mut F) -> Result<Self, F::Error> {
-        Ok(ir::FallibleTypeFolder::interner(folder).intern_external_constraints(
-            ExternalConstraintsData {
-                regions: (),
-                opaque_types: self
-                    .opaque_types
-                    .iter()
-                    .map(|opaque| opaque.try_fold_with(folder))
-                    .collect::<Result<_, F::Error>>()?,
-            },
-        ))
+        Ok(ir::FallibleTypeFolder::interner(folder)
+            .intern_external_constraints(ExternalConstraintsData { regions: &() }))
     }
 
     fn fold_with<F: TypeFolder<'tcx>>(self, folder: &mut F) -> Self {
-        ir::TypeFolder::interner(folder).intern_external_constraints(ExternalConstraintsData {
-            regions: (),
-            opaque_types: self.opaque_types.iter().map(|opaque| opaque.fold_with(folder)).collect(),
-        })
+        ir::TypeFolder::interner(folder)
+            .intern_external_constraints(ExternalConstraintsData { regions: &() })
     }
 }
 
@@ -54,7 +49,6 @@ impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for ExternalConstraints<'tcx> {
         visitor: &mut V,
     ) -> std::ops::ControlFlow<V::BreakTy> {
         self.regions.visit_with(visitor)?;
-        self.opaque_types.visit_with(visitor)?;
         ControlFlow::Continue(())
     }
 }

compiler/rustc_trait_selection/src/solve/mod.rs

@@ -92,10 +92,9 @@ impl<'tcx> CanonicalResponseExt for Canonical<'tcx, Response<'tcx>> {
     fn has_no_inference_or_external_constraints(&self) -> bool {
         // so that we get a compile error when regions are supported
         // so this code can be checked for being correct
-        let _: () = self.value.external_constraints.regions;
+        let _: &() = self.value.external_constraints.regions;
 
         self.value.var_values.is_identity()
-            && self.value.external_constraints.opaque_types.is_empty()
     }
 }
 
@@ -582,14 +581,11 @@ fn compute_external_query_constraints<'tcx>(
     infcx: &InferCtxt<'tcx>,
 ) -> Result<ExternalConstraints<'tcx>, NoSolution> {
     let region_obligations = infcx.take_registered_region_obligations();
-    let opaque_types = infcx.take_opaque_types_for_query_response();
-    Ok(infcx.tcx.intern_external_constraints(ExternalConstraintsData {
-        // FIXME: Now that's definitely wrong :)
-        //
-        // Should also do the leak check here I think
-        regions: drop(region_obligations),
-        opaque_types,
-    }))
+    // FIXME: Now that's definitely wrong :)
+    //
+    // Should also do the leak check here I think
+    drop(region_obligations);
+    Ok(infcx.tcx.intern_external_constraints(ExternalConstraintsData { regions: &() }))
 }
 
 fn instantiate_canonical_query_response<'tcx>(
@@ -609,10 +605,6 @@ fn instantiate_canonical_query_response<'tcx>(
                     Certainty::Yes => OldCertainty::Proven,
                     Certainty::Maybe(_) => OldCertainty::Ambiguous,
                 },
-                // FIXME: This to_owned makes me sad, but we should eventually impl
-                // `instantiate_query_response_and_region_obligations` separately
-                // instead of piggybacking off of the old implementation.
-                opaque_types: resp.external_constraints.opaque_types.to_owned(),
                 value: resp.certainty,
             }),
         ) else { bug!(); };

compiler/rustc_traits/src/chalk/mod.rs

@@ -131,7 +131,6 @@ pub(crate) fn evaluate_goal<'tcx>(
                 var_values: CanonicalVarValues { var_values },
                 region_constraints: QueryRegionConstraints::default(),
                 certainty: Certainty::Proven,
-                opaque_types: vec![],
                 value: (),
             },
         };
@@ -159,7 +158,6 @@ pub(crate) fn evaluate_goal<'tcx>(
                                 var_values: CanonicalVarValues::dummy(),
                                 region_constraints: QueryRegionConstraints::default(),
                                 certainty: Certainty::Ambiguous,
-                                opaque_types: vec![],
                                 value: (),
                             },
                         };