Merge pull request #22168 from ChayimFriedman2/type-must-be-known-v2

feat: Feature a "type annotations needed" diagnostic when an infer var cannot be resolved at the end of inference

Author: ChayimFriedman2

crates/hir-def/src/expr_store.rs

@@ -561,6 +561,7 @@ impl ExpressionStore {
             | Pat::ConstBlock(..)
             | Pat::Wild
             | Pat::Missing
+            | Pat::Rest
             | Pat::Expr(_) => {}
             &Pat::Bind { subpat, .. } => {
                 if let Some(subpat) = subpat {

crates/hir-def/src/expr_store/lower.rs

@@ -2622,15 +2622,7 @@ impl<'db> ExprCollector<'db> {
                 let expr_id = self.alloc_expr(expr, expr_ptr);
                 Pat::Lit(expr_id)
             }
-            ast::Pat::RestPat(_) => {
-                // `RestPat` requires special handling and should not be mapped
-                // to a Pat. Here we are using `Pat::Missing` as a fallback for
-                // when `RestPat` is mapped to `Pat`, which can easily happen
-                // when the source code being analyzed has a malformed pattern
-                // which includes `..` in a place where it isn't valid.
-
-                Pat::Missing
-            }
+            ast::Pat::RestPat(_) => Pat::Rest,
             ast::Pat::BoxPat(boxpat) => {
                 let inner = self.collect_pat_opt(boxpat.pat(), binding_list);
                 Pat::Box { inner }

crates/hir-def/src/expr_store/pretty.rs

@@ -895,6 +895,7 @@ impl Printer<'_> {
 
         match pat {
             Pat::Missing => w!(self, "�"),
+            Pat::Rest => w!(self, ".."),
             Pat::Wild => w!(self, "_"),
             Pat::Tuple { args, ellipsis } => {
                 w!(self, "(");

crates/hir-def/src/hir.rs

@@ -666,6 +666,8 @@ pub struct RecordFieldPat {
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Pat {
     Missing,
+    /// A rest pattern. Not valid outside special context.
+    Rest,
     Wild,
     Tuple {
         args: Box<[PatId]>,
@@ -721,6 +723,7 @@ impl Pat {
             | Pat::ConstBlock(..)
             | Pat::Wild
             | Pat::Missing
+            | Pat::Rest
             | Pat::Expr(_) => {}
             Pat::Bind { subpat, .. } => {
                 subpat.iter().copied().for_each(f);

crates/hir-ty/src/autoderef.rs

@@ -10,7 +10,7 @@ use rustc_type_ir::inherent::{IntoKind, Ty as _};
 use tracing::debug;
 
 use crate::{
-    ParamEnvAndCrate,
+    ParamEnvAndCrate, Span,
     db::HirDatabase,
     infer::InferenceContext,
     next_solver::{
@@ -39,7 +39,7 @@ pub fn autoderef<'db>(
 ) -> impl Iterator<Item = Ty<'db>> + use<'db> {
     let interner = DbInterner::new_with(db, env.krate);
     let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
-    let (ty, _) = infcx.instantiate_canonical(&ty);
+    let (ty, _) = infcx.instantiate_canonical(Span::Dummy, &ty);
     let autoderef = Autoderef::new(&infcx, env.param_env, ty);
     let mut v = Vec::new();
     for (ty, _steps) in autoderef {

crates/hir-ty/src/db.rs

@@ -147,7 +147,7 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     #[salsa::invoke(crate::lower::const_param_ty_query)]
     #[salsa::transparent]
-    fn const_param_ty_ns<'db>(&'db self, def: ConstParamId) -> Ty<'db>;
+    fn const_param_ty<'db>(&'db self, def: ConstParamId) -> Ty<'db>;
 
     #[salsa::invoke(crate::lower::impl_trait_with_diagnostics)]
     #[salsa::transparent]

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

@@ -258,7 +258,7 @@ impl<'db> UnsafeVisitor<'db> {
                     self.on_unsafe_op(current.into(), UnsafetyReason::UnionField)
                 }
                 // `Or` only wraps other patterns, and `Missing`/`Wild` do not constitute a read.
-                Pat::Missing | Pat::Wild | Pat::Or(_) => {}
+                Pat::Missing | Pat::Rest | Pat::Wild | Pat::Or(_) => {}
             }
         }