Diagnose trait errors

I.e. type does not implement trait.

There are a lot of other solver errors to be emitted, and the error is pretty simple currently, but this is a huge step!

Author: ChayimFriedman2

crates/hir-def/src/attrs.rs

@@ -263,6 +263,12 @@ fn match_attr_flags(attr_flags: &mut AttrFlags, attr: ast::Meta) -> ControlFlow<
                         }
                         _ => {}
                     },
+                    "diagnostic" => match &*second_segment {
+                        "do_not_recommend" => {
+                            attr_flags.insert(AttrFlags::DIAGNOSTIC_DO_NOT_RECOMMEND)
+                        }
+                        _ => {}
+                    },
                     _ => {}
                 },
             }
@@ -335,6 +341,8 @@ bitflags::bitflags! {
         const MACRO_STYLE_PARENTHESES = 1 << 48;
 
         const PREFER_UNDERSCORE_IMPORT = 1 << 49;
+
+        const DIAGNOSTIC_DO_NOT_RECOMMEND = 1 << 50;
     }
 }
 

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

@@ -30,12 +30,14 @@ impl<'db> ExprCollector<'db> {
     ) -> ExprId {
         let mut args = FormatArgumentsCollector::default();
         f.args().for_each(|arg| {
+            let expr = arg.expr();
             args.add(FormatArgument {
                 kind: match arg.arg_name() {
                     Some(name) => FormatArgumentKind::Named(Name::new_root(name.name().text())),
                     None => FormatArgumentKind::Normal,
                 },
-                expr: self.collect_expr_opt(arg.expr()),
+                syntax: expr.as_ref().map(AstPtr::new),
+                expr: self.collect_expr_opt(expr),
             });
         });
         let template = f.template();
@@ -53,8 +55,10 @@ impl<'db> ExprCollector<'db> {
             Some(((s, is_direct_literal), template)) => {
                 let call_ctx = SyntaxContext::root(self.def_map.edition());
                 let hygiene = self.hygiene_id_for(s.syntax().text_range());
+                let template_ptr = AstPtr::new(&template);
                 let fmt = format_args::parse(
                     &s,
+                    template_ptr,
                     fmt_snippet,
                     args,
                     is_direct_literal,
@@ -65,10 +69,7 @@ impl<'db> ExprCollector<'db> {
                                 .template_map
                                 .get_or_insert_with(Default::default)
                                 .implicit_capture_to_source
-                                .insert(
-                                    expr_id,
-                                    self.expander.in_file((AstPtr::new(&template), range)),
-                                );
+                                .insert(expr_id, self.expander.in_file((template_ptr, range)));
                         }
                         if !hygiene.is_root() {
                             self.store.ident_hygiene.insert(expr_id.into(), hygiene);
@@ -340,7 +341,8 @@ impl<'db> ExprCollector<'db> {
                         expr: args_ident_expr,
                         name: Name::new_tuple_field(arg_index),
                     });
-                    self.make_argument(arg, ty)
+                    let arg_ptr = arguments.get(arg_index).and_then(|it| it.syntax);
+                    self.make_argument(arg_ptr, arg, ty)
                 })
                 .collect();
             let args =
@@ -557,7 +559,8 @@ impl<'db> ExprCollector<'db> {
                         rawness: Rawness::Ref,
                         mutability: Mutability::Shared,
                     });
-                    self.make_argument(arg, ty)
+                    let arg_ptr = arguments.get(arg_index).and_then(|it| it.syntax);
+                    self.make_argument(arg_ptr, arg, ty)
                 })
                 .collect();
             let array =
@@ -649,7 +652,8 @@ impl<'db> ExprCollector<'db> {
                         rawness: Rawness::Ref,
                         mutability: Mutability::Shared,
                     });
-                    self.make_argument(ref_arg, ty)
+                    let arg_ptr = arguments.get(arg_index).and_then(|it| it.syntax);
+                    self.make_argument(arg_ptr, ref_arg, ty)
                 })
                 .collect();
             let args =
@@ -716,7 +720,8 @@ impl<'db> ExprCollector<'db> {
                         expr: args_ident_expr,
                         name: Name::new_tuple_field(arg_index),
                     });
-                    self.make_argument(arg, ty)
+                    let arg_ptr = arguments.get(arg_index).and_then(|it| it.syntax);
+                    self.make_argument(arg_ptr, arg, ty)
                 })
                 .collect();
             let array =
@@ -976,11 +981,16 @@ impl<'db> ExprCollector<'db> {
     /// ```text
     ///     <core::fmt::Argument>::new_…(arg)
     /// ```
-    fn make_argument(&mut self, arg: ExprId, ty: ArgumentType) -> ExprId {
+    fn make_argument(
+        &mut self,
+        arg_ptr: Option<AstPtr<ast::Expr>>,
+        arg: ExprId,
+        ty: ArgumentType,
+    ) -> ExprId {
         use ArgumentType::*;
         use FormatTrait::*;
 
-        let new_fn = self.ty_rel_lang_path_desugared_expr(
+        let new_fn = self.ty_rel_lang_path(
             self.lang_items().FormatArgument,
             match ty {
                 Format(Display) => sym::new_display,
@@ -995,6 +1005,22 @@ impl<'db> ExprCollector<'db> {
                 Usize => sym::from_usize,
             },
         );
+        let new_fn = match new_fn {
+            Some(new_fn) => {
+                let new_fn = self.store.exprs.alloc(Expr::Path(new_fn));
+                if let Some(arg_ptr) = arg_ptr {
+                    // Trait errors (the argument does not implement the expected fmt trait) will show
+                    // on this path, so to not end up with synthetic syntax we insert this mapping. We
+                    // don't want to insert the other way's mapping in order to not override the source
+                    // for the argument.
+                    self.store
+                        .expr_map_back
+                        .insert(new_fn, self.expander.in_file(arg_ptr.wrap_left()));
+                }
+                new_fn
+            }
+            None => self.missing_expr(),
+        };
         self.alloc_expr_desugared(Expr::Call { callee: new_fn, args: Box::new([arg]) })
     }
 

crates/hir-def/src/hir/format_args.rs

@@ -7,7 +7,7 @@ use rustc_parse_format as parse;
 use span::SyntaxContext;
 use stdx::TupleExt;
 use syntax::{
-    TextRange,
+    AstPtr, TextRange,
     ast::{self, IsString},
 };
 
@@ -146,6 +146,7 @@ pub enum FormatCount {
 pub struct FormatArgument {
     pub kind: FormatArgumentKind,
     pub expr: ExprId,
+    pub syntax: Option<AstPtr<ast::Expr>>,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -171,6 +172,7 @@ use PositionUsedAs::*;
 #[allow(clippy::unnecessary_lazy_evaluations)]
 pub(crate) fn parse(
     s: &ast::String,
+    string_ptr: AstPtr<ast::Expr>,
     fmt_snippet: Option<String>,
     mut args: FormatArgumentsCollector,
     is_direct_literal: bool,
@@ -273,6 +275,11 @@ pub(crate) fn parse(
                             // FIXME: This is problematic, we might want to synthesize a dummy
                             // expression proper and/or desugar these.
                             expr: synth(name, span),
+                            // FIXME: This will lead us to show failed trait bounds (e.g. `T: Display`)
+                            // on the whole template string for implicit arguments instead of just their name.
+                            // Fixing this is hard since we don't have an `AstPtr` for the arg, and it's
+                            // only part of an expression.
+                            syntax: Some(string_ptr),
                         }))
                     }
                 }

crates/hir-expand/src/files.rs

@@ -128,6 +128,16 @@ impl ErasedAstId {
     }
 }
 
+impl<FileKind, N: AstNode> InFileWrapper<FileKind, AstPtr<N>> {
+    #[inline]
+    pub fn upcast<M: AstNode>(self) -> InFileWrapper<FileKind, AstPtr<M>>
+    where
+        N: Into<M>,
+    {
+        self.map(|it| it.upcast())
+    }
+}
+
 impl<FileKind, T> InFileWrapper<FileKind, T> {
     pub fn new(file_id: FileKind, value: T) -> Self {
         Self { file_id, value }

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

@@ -177,7 +177,7 @@ impl<'db> ExprValidator<'db> {
         }
         // Check that the number of arguments matches the number of parameters.
 
-        if self.infer.expr_type_mismatches().next().is_some() {
+        if self.infer.exprs_have_type_mismatches() {
             // FIXME: Due to shortcomings in the current type system implementation, only emit
             // this diagnostic if there are no type mismatches in the containing function.
         } else if let Expr::MethodCall { receiver, .. } = expr {
@@ -331,7 +331,7 @@ impl<'db> ExprValidator<'db> {
             let &Statement::Let { pat, initializer, else_branch: None, .. } = stmt else {
                 continue;
             };
-            if self.infer.type_mismatch_for_pat(pat).is_some() {
+            if self.infer.pat_has_type_mismatch(pat) {
                 continue;
             }
             let Some(initializer) = initializer else { continue };
@@ -628,13 +628,13 @@ pub fn record_pattern_missing_fields(
 
 fn types_of_subpatterns_do_match(pat: PatId, body: &Body, infer: &InferenceResult) -> bool {
     fn walk(pat: PatId, body: &Body, infer: &InferenceResult, has_type_mismatches: &mut bool) {
-        match infer.type_mismatch_for_pat(pat) {
-            Some(_) => *has_type_mismatches = true,
-            None if *has_type_mismatches => (),
-            None => {
+        match infer.pat_has_type_mismatch(pat) {
+            true => *has_type_mismatches = true,
+            false if *has_type_mismatches => (),
+            false => {
                 let pat = &body[pat];
                 if let Pat::ConstBlock(expr) | Pat::Lit(expr) = *pat {
-                    *has_type_mismatches |= infer.type_mismatch_for_expr(expr).is_some();
+                    *has_type_mismatches |= infer.expr_has_type_mismatch(expr);
                     if *has_type_mismatches {
                         return;
                     }

crates/hir-ty/src/display.rs

@@ -59,8 +59,8 @@ use crate::{
     next_solver::{
         AliasTy, Allocation, Clause, ClauseKind, Const, ConstKind, DbInterner,
         ExistentialPredicate, FnSig, GenericArg, GenericArgKind, GenericArgs, ParamEnv, PolyFnSig,
-        Region, SolverDefId, StoredEarlyBinder, StoredTy, Term, TermKind, TraitRef, Ty, TyKind,
-        TypingMode, ValTree,
+        Region, SolverDefId, StoredEarlyBinder, StoredTy, Term, TermKind, TraitPredicate, TraitRef,
+        Ty, TyKind, TypingMode, ValTree,
         abi::Safety,
         infer::{DbInternerInferExt, traits::ObligationCause},
     },
@@ -2291,6 +2291,23 @@ impl<'db> HirDisplay<'db> for TraitRef<'db> {
     }
 }
 
+impl<'db> HirDisplay<'db> for TraitPredicate<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
+        self.self_ty().hir_fmt(f)?;
+        f.write_str(": ")?;
+        match self.polarity {
+            rustc_type_ir::PredicatePolarity::Positive => {}
+            rustc_type_ir::PredicatePolarity::Negative => f.write_char('!')?,
+        }
+        let trait_ = self.def_id().0;
+        f.start_location_link(trait_.into());
+        write!(f, "{}", TraitSignature::of(f.db, trait_).name.display(f.db, f.edition()))?;
+        f.end_location_link();
+        let substs = &self.trait_ref.args[1..];
+        hir_fmt_generic_args(f, substs, None, None)
+    }
+}
+
 impl<'db> HirDisplay<'db> for Region<'db> {
     fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
         match self.kind() {