Merge pull request rust-lang#19675 from Veykril/push-uuluymsosttr

fix: Fix type argument mismatch incorrectly triggering on inferred trait args

Author: Veykril

src/tools/rust-analyzer/crates/hir-ty/src/infer.rs

@@ -1675,7 +1675,7 @@ impl<'a> InferenceContext<'a> {
                     // `lower_partly_resolved_path()` returns `None` as type namespace unless
                     // `remaining_segments` is empty, which is never the case here. We don't know
                     // which namespace the new `ty` is in until normalized anyway.
-                    (ty, _) = path_ctx.lower_partly_resolved_path(resolution, false);
+                    (ty, _) = path_ctx.lower_partly_resolved_path(resolution, true);
                     tried_resolving_once = true;
 
                     ty = self.table.insert_type_vars(ty);

src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs

@@ -177,7 +177,7 @@ impl InferenceContext<'_> {
             let ty = self.table.normalize_associated_types_in(ty);
 
             path_ctx.ignore_last_segment();
-            let (ty, _) = path_ctx.lower_ty_relative_path(ty, orig_ns);
+            let (ty, _) = path_ctx.lower_ty_relative_path(ty, orig_ns, true);
             drop_ctx(ctx, no_diagnostics);
             let ty = self.table.insert_type_vars(ty);
             let ty = self.table.normalize_associated_types_in(ty);
@@ -207,7 +207,7 @@ impl InferenceContext<'_> {
                         (TypeNs::TraitId(trait_), true) => {
                             let self_ty = self.table.new_type_var();
                             let trait_ref =
-                                path_ctx.lower_trait_ref_from_resolved_path(trait_, self_ty);
+                                path_ctx.lower_trait_ref_from_resolved_path(trait_, self_ty, true);
                             drop_ctx(ctx, no_diagnostics);
                             self.resolve_trait_assoc_item(trait_ref, last_segment, id)
                         }

src/tools/rust-analyzer/crates/hir-ty/src/lower.rs

@@ -506,7 +506,7 @@ impl<'a> TyLoweringContext<'a> {
         if let Some(type_ref) = path.type_anchor() {
             let (ty, res) = self.lower_ty_ext(type_ref);
             let mut ctx = self.at_path(path_id);
-            return ctx.lower_ty_relative_path(ty, res);
+            return ctx.lower_ty_relative_path(ty, res, false);
         }
 
         let mut ctx = self.at_path(path_id);
@@ -536,7 +536,7 @@ impl<'a> TyLoweringContext<'a> {
             TypeNs::TraitId(tr) => tr,
             _ => return None,
         };
-        Some((ctx.lower_trait_ref_from_resolved_path(resolved, explicit_self_ty), ctx))
+        Some((ctx.lower_trait_ref_from_resolved_path(resolved, explicit_self_ty, false), ctx))
     }
 
     fn lower_trait_ref(

src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs

@@ -137,12 +137,13 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
         ty: Ty,
         // We need the original resolution to lower `Self::AssocTy` correctly
         res: Option<TypeNs>,
+        infer_args: bool,
     ) -> (Ty, Option<TypeNs>) {
         match self.segments.len() - self.current_segment_idx {
             0 => (ty, res),
             1 => {
                 // resolve unselected assoc types
-                (self.select_associated_type(res), None)
+                (self.select_associated_type(res, infer_args), None)
             }
             _ => {
                 // FIXME report error (ambiguous associated type)
@@ -166,6 +167,7 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
                         let trait_ref = self.lower_trait_ref_from_resolved_path(
                             trait_,
                             TyKind::Error.intern(Interner),
+                            infer_args,
                         );
 
                         self.skip_resolved_segment();
@@ -181,7 +183,7 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
                                 // this point (`trait_ref.substitution`).
                                 let substitution = self.substs_from_path_segment(
                                     associated_ty.into(),
-                                    false,
+                                    infer_args,
                                     None,
                                     true,
                                 );
@@ -276,7 +278,7 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
         };
 
         self.skip_resolved_segment();
-        self.lower_ty_relative_path(ty, Some(resolution))
+        self.lower_ty_relative_path(ty, Some(resolution), infer_args)
     }
 
     fn handle_type_ns_resolution(&mut self, resolution: &TypeNs) {
@@ -472,7 +474,7 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
         Some(res)
     }
 
-    fn select_associated_type(&mut self, res: Option<TypeNs>) -> Ty {
+    fn select_associated_type(&mut self, res: Option<TypeNs>, infer_args: bool) -> Ty {
         let Some(res) = res else {
             return TyKind::Error.intern(Interner);
         };
@@ -506,7 +508,8 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
                 // generic params. It's inefficient to splice the `Substitution`s, so we may want
                 // that method to optionally take parent `Substitution` as we already know them at
                 // this point (`t.substitution`).
-                let substs = self.substs_from_path_segment(associated_ty.into(), false, None, true);
+                let substs =
+                    self.substs_from_path_segment(associated_ty.into(), infer_args, None, true);
 
                 let substs = Substitution::from_iter(
                     Interner,
@@ -830,17 +833,19 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
         &mut self,
         resolved: TraitId,
         explicit_self_ty: Ty,
+        infer_args: bool,
     ) -> TraitRef {
-        let substs = self.trait_ref_substs_from_path(resolved, explicit_self_ty);
+        let substs = self.trait_ref_substs_from_path(resolved, explicit_self_ty, infer_args);
         TraitRef { trait_id: to_chalk_trait_id(resolved), substitution: substs }
     }
 
     fn trait_ref_substs_from_path(
         &mut self,
         resolved: TraitId,
         explicit_self_ty: Ty,
+        infer_args: bool,
     ) -> Substitution {
-        self.substs_from_path_segment(resolved.into(), false, Some(explicit_self_ty), false)
+        self.substs_from_path_segment(resolved.into(), infer_args, Some(explicit_self_ty), false)
     }
 
     pub(super) fn assoc_type_bindings_from_type_bound<'c>(

src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/incorrect_generics_len.rs

@@ -172,4 +172,16 @@ fn foo<T: Trait<Assoc<i32> = bool>>() {}
         "#,
         );
     }
+
+    #[test]
+    fn regression_19669() {
+        check_diagnostics(
+            r#"
+//- minicore: from
+fn main() {
+    let _: i32 = Into::into(0);
+}
+"#,
+        );
+    }
 }