Combine expression and pattern adjustments map in InferenceResult

Author: Veykril

crates/hir-ty/src/diagnostics/expr.rs

@@ -279,9 +279,9 @@ impl ExprValidator {
     fn is_known_valid_scrutinee(&self, scrutinee_expr: ExprId, db: &dyn HirDatabase) -> bool {
         if self
             .infer
-            .expr_adjustments
-            .get(&scrutinee_expr)
-            .is_some_and(|adjusts| adjusts.iter().any(|a| matches!(a.kind, Adjust::Deref(..))))
+            .expr_adjustments(scrutinee_expr)
+            .iter()
+            .any(|a| matches!(a.kind, Adjust::Deref(..)))
         {
             return false;
         }

crates/hir-ty/src/diagnostics/match_check.rs

@@ -113,13 +113,9 @@ impl<'a> PatCtxt<'a> {
         // Pattern adjustment is part of RFC 2005-match-ergonomics.
         // More info https://github.com/rust-lang/rust/issues/42640#issuecomment-313535089
         let unadjusted_pat = self.lower_pattern_unadjusted(pat);
-        self.infer.pat_adjustments.get(&pat).map(|it| &**it).unwrap_or_default().iter().rev().fold(
-            unadjusted_pat,
-            |subpattern, ref_ty| Pat {
-                ty: ref_ty.clone(),
-                kind: Box::new(PatKind::Deref { subpattern }),
-            },
-        )
+        self.infer.pat_adjustments(pat).iter().rev().fold(unadjusted_pat, |subpattern, ref_ty| {
+            Pat { ty: ref_ty.target.clone(), kind: Box::new(PatKind::Deref { subpattern }) }
+        })
     }
 
     fn lower_pattern_unadjusted(&mut self, pat: PatId) -> Pat {

crates/hir-ty/src/infer.rs

@@ -460,9 +460,6 @@ pub struct InferenceResult {
     // `TyKind::Error`.
     // Which will then mark this field.
     pub(crate) has_errors: bool,
-    /// Interned common types to return references to.
-    /// Stores the types which were implicitly dereferenced in pattern binding modes.
-    pub pat_adjustments: FxHashMap<PatId, Vec<Ty>>,
     /// Stores the binding mode (`ref` in `let ref x = 2`) of bindings.
     ///
     /// This one is tied to the `PatId` instead of `BindingId`, because in some rare cases, a binding in an
@@ -477,7 +474,8 @@ pub struct InferenceResult {
     /// ```
     /// the first `rest` has implicit `ref` binding mode, but the second `rest` binding mode is `move`.
     pub binding_modes: ArenaMap<PatId, BindingMode>,
-    pub expr_adjustments: FxHashMap<ExprId, Box<[Adjustment]>>,
+    /// For patterns, this stores the types which were implicitly dereferenced in pattern binding modes.
+    adjustments: FxHashMap<ExprOrPatId, Box<[Adjustment]>>,
     pub(crate) closure_info: FxHashMap<ClosureId, (Vec<CapturedItem>, FnTrait)>,
     // FIXME: remove this field
     pub mutated_bindings_in_closure: FxHashSet<BindingId>,
@@ -488,6 +486,12 @@ impl InferenceResult {
     pub fn method_resolution(&self, expr: ExprId) -> Option<(FunctionId, Substitution)> {
         self.method_resolutions.get(&expr).cloned()
     }
+    pub fn pat_adjustments(&self, pat: PatId) -> &[Adjustment] {
+        self.adjustments.get(&ExprOrPatId::PatId(pat)).map_or(&[], |v| v.as_ref())
+    }
+    pub fn expr_adjustments(&self, expr: ExprId) -> &[Adjustment] {
+        self.adjustments.get(&ExprOrPatId::ExprId(expr)).map_or(&[], |v| v.as_ref())
+    }
     pub fn field_resolution(&self, expr: ExprId) -> Option<Either<FieldId, TupleFieldId>> {
         self.field_resolutions.get(&expr).copied()
     }
@@ -751,9 +755,8 @@ impl<'db> InferenceContext<'db> {
             type_of_for_iterator,
             type_mismatches,
             has_errors,
-            pat_adjustments,
             binding_modes: _,
-            expr_adjustments,
+            adjustments,
             // Types in `closure_info` have already been `resolve_completely()`'d during
             // `InferenceContext::infer_closures()` (in `HirPlace::ty()` specifically), so no need
             // to resolve them here.
@@ -769,7 +772,7 @@ impl<'db> InferenceContext<'db> {
         // Even though coercion casts provide type hints, we check casts after fallback for
         // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
         let mut apply_adjustments = |expr, adj: Vec<_>| {
-            expr_adjustments.insert(expr, adj.into_boxed_slice());
+            adjustments.insert(ExprOrPatId::ExprId(expr), adj.into_boxed_slice());
         };
         let mut set_coercion_cast = |expr| {
             coercion_casts.insert(expr);
@@ -868,16 +871,11 @@ impl<'db> InferenceContext<'db> {
                 *has_errors || subst.type_parameters(Interner).any(|ty| ty.contains_unknown());
         }
         assoc_resolutions.shrink_to_fit();
-        for adjustment in expr_adjustments.values_mut().flatten() {
+        for adjustment in adjustments.values_mut().flatten() {
             adjustment.target = table.resolve_completely(adjustment.target.clone());
             *has_errors = *has_errors || adjustment.target.contains_unknown();
         }
-        expr_adjustments.shrink_to_fit();
-        for adjustment in pat_adjustments.values_mut().flatten() {
-            *adjustment = table.resolve_completely(adjustment.clone());
-            *has_errors = *has_errors || adjustment.contains_unknown();
-        }
-        pat_adjustments.shrink_to_fit();
+        adjustments.shrink_to_fit();
         result.tuple_field_access_types = tuple_field_accesses_rev
             .into_iter()
             .enumerate()
@@ -1260,7 +1258,7 @@ impl<'db> InferenceContext<'db> {
         if adjustments.is_empty() {
             return;
         }
-        match self.result.expr_adjustments.entry(expr) {
+        match self.result.adjustments.entry(expr.into()) {
             std::collections::hash_map::Entry::Occupied(mut entry) => {
                 match (&mut entry.get_mut()[..], &adjustments[..]) {
                     (

crates/hir-ty/src/infer/closure.rs

@@ -905,8 +905,7 @@ impl CapturedItemWithoutTy {
 impl InferenceContext<'_> {
     fn place_of_expr(&mut self, tgt_expr: ExprId) -> Option<HirPlace> {
         let r = self.place_of_expr_without_adjust(tgt_expr)?;
-        let adjustments =
-            self.result.expr_adjustments.get(&tgt_expr).map(|it| &**it).unwrap_or_default();
+        let adjustments = self.result.expr_adjustments(tgt_expr);
         apply_adjusts_to_place(&mut self.current_capture_span_stack, r, adjustments)
     }
 
@@ -1087,12 +1086,12 @@ impl InferenceContext<'_> {
     }
 
     fn walk_expr(&mut self, tgt_expr: ExprId) {
-        if let Some(it) = self.result.expr_adjustments.get_mut(&tgt_expr) {
+        if let Some(it) = self.result.adjustments.get_mut(&tgt_expr.into()) {
             // FIXME: this take is completely unneeded, and just is here to make borrow checker
             // happy. Remove it if you can.
             let x_taken = mem::take(it);
             self.walk_expr_with_adjust(tgt_expr, &x_taken);
-            *self.result.expr_adjustments.get_mut(&tgt_expr).unwrap() = x_taken;
+            *self.result.adjustments.get_mut(&tgt_expr.into()).unwrap() = x_taken;
         } else {
             self.walk_expr_without_adjust(tgt_expr);
         }
@@ -1389,7 +1388,7 @@ impl InferenceContext<'_> {
                 },
             },
         }
-        if self.result.pat_adjustments.get(&p).is_some_and(|it| !it.is_empty()) {
+        if !self.result.pat_adjustments(p).is_empty() {
             for_mut = BorrowKind::Mut { kind: MutBorrowKind::ClosureCapture };
         }
         self.body.walk_pats_shallow(p, |p| self.walk_pat_inner(p, update_result, for_mut));
@@ -1401,10 +1400,8 @@ impl InferenceContext<'_> {
 
     fn expr_ty_after_adjustments(&self, e: ExprId) -> Ty {
         let mut ty = None;
-        if let Some(it) = self.result.expr_adjustments.get(&e) {
-            if let Some(it) = it.last() {
-                ty = Some(it.target.clone());
-            }
+        if let Some(it) = self.result.expr_adjustments(e).last() {
+            ty = Some(it.target.clone());
         }
         ty.unwrap_or_else(|| self.expr_ty(e))
     }
@@ -1515,8 +1512,7 @@ impl InferenceContext<'_> {
     }
 
     fn consume_with_pat(&mut self, mut place: HirPlace, tgt_pat: PatId) {
-        let adjustments_count =
-            self.result.pat_adjustments.get(&tgt_pat).map(|it| it.len()).unwrap_or_default();
+        let adjustments_count = self.result.pat_adjustments(tgt_pat).len();
         place.projections.extend((0..adjustments_count).map(|_| ProjectionElem::Deref));
         self.current_capture_span_stack
             .extend((0..adjustments_count).map(|_| MirSpan::PatId(tgt_pat)));
@@ -1736,8 +1732,12 @@ impl InferenceContext<'_> {
 
             for (derefed_callee, callee_ty, params, expr) in exprs {
                 if let &Expr::Call { callee, .. } = &self.body[expr] {
-                    let mut adjustments =
-                        self.result.expr_adjustments.remove(&callee).unwrap_or_default().into_vec();
+                    let mut adjustments = self
+                        .result
+                        .adjustments
+                        .remove(&callee.into())
+                        .unwrap_or_default()
+                        .into_vec();
                     self.write_fn_trait_method_resolution(
                         kind,
                         &derefed_callee,
@@ -1746,7 +1746,7 @@ impl InferenceContext<'_> {
                         &params,
                         expr,
                     );
-                    self.result.expr_adjustments.insert(callee, adjustments.into_boxed_slice());
+                    self.result.adjustments.insert(callee.into(), adjustments.into_boxed_slice());
                 }
             }
         }

crates/hir-ty/src/infer/coerce.rs

@@ -160,7 +160,7 @@ impl CoerceMany {
         // - [Comment from rustc](https://github.com/rust-lang/rust/blob/5ff18d0eaefd1bd9ab8ec33dab2404a44e7631ed/compiler/rustc_hir_typeck/src/coercion.rs#L1334-L1335)
         // First try to coerce the new expression to the type of the previous ones,
         // but only if the new expression has no coercion already applied to it.
-        if expr.is_none_or(|expr| !ctx.result.expr_adjustments.contains_key(&expr)) {
+        if expr.is_none_or(|expr| !ctx.result.adjustments.contains_key(&expr.into())) {
             if let Ok(res) = ctx.coerce(expr, &expr_ty, &self.merged_ty(), CoerceNever::Yes) {
                 self.final_ty = Some(res);
                 if let Some(expr) = expr {

crates/hir-ty/src/infer/expr.rs

@@ -250,12 +250,10 @@ impl InferenceContext<'_> {
         // While we don't allow *arbitrary* coercions here, we *do* allow
         // coercions from `!` to `expected`.
         if ty.is_never() {
-            if let Some(adjustments) = self.result.expr_adjustments.get(&expr) {
-                return if let [Adjustment { kind: Adjust::NeverToAny, target }] = &**adjustments {
-                    target.clone()
-                } else {
-                    self.err_ty()
-                };
+            match self.result.expr_adjustments(expr) {
+                [Adjustment { kind: Adjust::NeverToAny, target }] => return target.clone(),
+                [_, ..] => return self.err_ty(),
+                [] => (),
             }
 
             if let Some(target) = expected.only_has_type(&mut self.table) {

crates/hir-ty/src/infer/mutability.rs

@@ -24,7 +24,7 @@ impl InferenceContext<'_> {
     }
 
     fn infer_mut_expr(&mut self, tgt_expr: ExprId, mut mutability: Mutability) {
-        if let Some(adjustments) = self.result.expr_adjustments.get_mut(&tgt_expr) {
+        if let Some(adjustments) = self.result.adjustments.get_mut(&tgt_expr.into()) {
             for adj in adjustments.iter_mut().rev() {
                 match &mut adj.kind {
                     Adjust::NeverToAny | Adjust::Deref(None) | Adjust::Pointer(_) => (),
@@ -138,8 +138,8 @@ impl InferenceContext<'_> {
                                 let mut base_ty = None;
                                 let base_adjustments = self
                                     .result
-                                    .expr_adjustments
-                                    .get_mut(&base)
+                                    .adjustments
+                                    .get_mut(&base.into())
                                     .and_then(|it| it.last_mut());
                                 if let Some(Adjustment {
                                     kind: Adjust::Borrow(AutoBorrow::Ref(_, mutability)),

crates/hir-ty/src/infer/pat.rs

@@ -11,8 +11,8 @@ use hir_expand::name::Name;
 use stdx::TupleExt;
 
 use crate::{
-    DeclContext, DeclOrigin, InferenceDiagnostic, Interner, Mutability, Scalar, Substitution, Ty,
-    TyBuilder, TyExt, TyKind,
+    Adjust, Adjustment, DeclContext, DeclOrigin, InferenceDiagnostic, Interner, Mutability, Scalar,
+    Substitution, Ty, TyBuilder, TyExt, TyKind,
     consteval::{self, try_const_usize, usize_const},
     infer::{
         BindingMode, ERROR_TY, Expectation, InferenceContext, TypeMismatch, coerce::CoerceNever,
@@ -250,7 +250,8 @@ impl InferenceContext<'_> {
         } else if self.is_non_ref_pat(self.body, pat) {
             let mut pat_adjustments = Vec::new();
             while let Some((inner, _lifetime, mutability)) = expected.as_reference() {
-                pat_adjustments.push(expected.clone());
+                pat_adjustments
+                    .push(Adjustment { kind: Adjust::Deref(None), target: expected.clone() });
                 expected = self.resolve_ty_shallow(inner);
                 default_bm = match default_bm {
                     BindingMode::Move => BindingMode::Ref(mutability),
@@ -260,8 +261,7 @@ impl InferenceContext<'_> {
             }
 
             if !pat_adjustments.is_empty() {
-                pat_adjustments.shrink_to_fit();
-                self.result.pat_adjustments.insert(pat, pat_adjustments);
+                self.result.adjustments.insert(pat.into(), pat_adjustments.into_boxed_slice());
             }
         }
 
@@ -306,12 +306,13 @@ impl InferenceContext<'_> {
                 match self.table.coerce(&expected, &ty_inserted_vars, CoerceNever::Yes) {
                     Ok((adjustments, coerced_ty)) => {
                         if !adjustments.is_empty() {
-                            self.result
-                                .pat_adjustments
-                                .entry(pat)
-                                .or_default()
-                                .extend(adjustments.into_iter().map(|adjust| adjust.target));
+                            let adjustments = match self.result.adjustments.remove(&pat.into()) {
+                                Some(prev) => prev.into_iter().chain(adjustments).collect(),
+                                None => adjustments.into_boxed_slice(),
+                            };
+                            self.result.adjustments.insert(pat.into(), adjustments);
                         }
+
                         self.write_pat_ty(pat, coerced_ty);
                         return self.pat_ty_after_adjustment(pat);
                     }
@@ -419,10 +420,10 @@ impl InferenceContext<'_> {
 
     fn pat_ty_after_adjustment(&self, pat: PatId) -> Ty {
         self.result
-            .pat_adjustments
-            .get(&pat)
+            .adjustments
+            .get(&pat.into())
             .and_then(|it| it.first())
-            .unwrap_or(&self.result.type_of_pat[pat])
+            .map_or_else(|| &self.result.type_of_pat[pat], |adj| &adj.target)
             .clone()
     }
 

crates/hir-ty/src/mir/lower.rs

@@ -399,7 +399,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
         place: Place,
         prev_block: BasicBlockId,
     ) -> Result<Option<BasicBlockId>> {
-        if let Some(adjustments) = self.infer.expr_adjustments.get(&expr_id) {
+        if let adjustments @ [_, ..] = self.infer.expr_adjustments(expr_id) {
             return self.lower_expr_to_place_with_adjust(expr_id, place, prev_block, adjustments);
         }
         self.lower_expr_to_place_without_adjust(expr_id, place, prev_block)
@@ -1054,13 +1054,10 @@ impl<'ctx> MirLowerCtx<'ctx> {
                 }
                 if let hir_def::hir::BinaryOp::Assignment { op: Some(op) } = op {
                     // last adjustment is `&mut` which we don't want it.
-                    let adjusts = self
-                        .infer
-                        .expr_adjustments
-                        .get(lhs)
-                        .and_then(|it| it.split_last())
-                        .map(|it| it.1)
-                        .ok_or(MirLowerError::TypeError("adjustment of binary op was missing"))?;
+                    let adjusts =
+                        self.infer.expr_adjustments(*lhs).split_last().map(|it| it.1).ok_or(
+                            MirLowerError::TypeError("adjustment of binary op was missing"),
+                        )?;
                     let Some((lhs_place, current)) =
                         self.lower_expr_as_place_with_adjust(current, *lhs, false, adjusts)?
                     else {
@@ -1597,10 +1594,8 @@ impl<'ctx> MirLowerCtx<'ctx> {
 
     fn expr_ty_after_adjustments(&self, e: ExprId) -> Ty {
         let mut ty = None;
-        if let Some(it) = self.infer.expr_adjustments.get(&e) {
-            if let Some(it) = it.last() {
-                ty = Some(it.target.clone());
-            }
+        if let Some(it) = self.infer.expr_adjustments(e).last() {
+            ty = Some(it.target.clone());
         }
         ty.unwrap_or_else(|| self.expr_ty_without_adjust(e))
     }
@@ -1674,7 +1669,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
     }
 
     fn has_adjustments(&self, expr_id: ExprId) -> bool {
-        !self.infer.expr_adjustments.get(&expr_id).map(|it| it.is_empty()).unwrap_or(true)
+        !self.infer.expr_adjustments(expr_id).is_empty()
     }
 
     fn merge_blocks(

crates/hir-ty/src/mir/lower/as_place.rs

@@ -115,9 +115,11 @@ impl MirLowerCtx<'_> {
         expr_id: ExprId,
         upgrade_rvalue: bool,
     ) -> Result<Option<(Place, BasicBlockId)>> {
-        match self.infer.expr_adjustments.get(&expr_id) {
-            Some(a) => self.lower_expr_as_place_with_adjust(current, expr_id, upgrade_rvalue, a),
-            None => self.lower_expr_as_place_without_adjust(current, expr_id, upgrade_rvalue),
+        match self.infer.expr_adjustments(expr_id) {
+            a @ [_, ..] => {
+                self.lower_expr_as_place_with_adjust(current, expr_id, upgrade_rvalue, a)
+            }
+            [] => self.lower_expr_as_place_without_adjust(current, expr_id, upgrade_rvalue),
         }
     }
 
@@ -254,13 +256,8 @@ impl MirLowerCtx<'_> {
                         index_fn,
                     );
                 }
-                let adjusts = self
-                    .infer
-                    .expr_adjustments
-                    .get(base)
-                    .and_then(|it| it.split_last())
-                    .map(|it| it.1)
-                    .unwrap_or(&[]);
+                let adjusts =
+                    self.infer.expr_adjustments(*base).split_last().map(|it| it.1).unwrap_or(&[]);
                 let Some((mut p_base, current)) =
                     self.lower_expr_as_place_with_adjust(current, *base, true, adjusts)?
                 else {

crates/hir-ty/src/mir/lower/pattern_matching.rs

@@ -119,7 +119,7 @@ impl MirLowerCtx<'_> {
         pattern: PatId,
         mode: MatchingMode,
     ) -> Result<(BasicBlockId, Option<BasicBlockId>)> {
-        let cnt = self.infer.pat_adjustments.get(&pattern).map(|x| x.len()).unwrap_or_default();
+        let cnt = self.infer.pat_adjustments(pattern).len();
         cond_place.projection = self.result.projection_store.intern(
             cond_place
                 .projection