Avoid follow-up errors if the number of generic parameters already doesn't match

Author: oli-obk

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -231,6 +231,13 @@ pub struct GenericArgCountResult {
     pub correct: Result<(), GenericArgCountMismatch>,
 }
 
+impl GenericArgCountResult {
+    fn error_reported(&self) -> Option<ErrorGuaranteed> {
+        let err = self.correct.as_ref().err()?;
+        err.reported
+    }
+}
+
 /// A context which can lower HIR's [`GenericArg`] to `rustc_middle`'s [`ty::GenericArg`].
 ///
 /// Its only consumer is [`generics::lower_generic_args`].
@@ -403,9 +410,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             self_ty.is_some(),
         );
 
-        if let Err(err) = &arg_count.correct
-            && let Some(reported) = err.reported
-        {
+        if let Some(reported) = arg_count.error_reported() {
             self.set_tainted_by_errors(reported);
         }
 
@@ -601,6 +606,21 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             &mut args_ctx,
         );
 
+        if let Some(guar) = arg_count.error_reported() {
+            return (
+                tcx.mk_args_from_iter(args.iter().map(|arg| match arg.unpack() {
+                    GenericArgKind::Lifetime(_) => {
+                        ty::GenericArg::from(ty::Region::new_error(tcx, guar))
+                    }
+                    GenericArgKind::Type(_) => Ty::new_error(tcx, guar).into(),
+                    GenericArgKind::Const(_) => {
+                        ty::Const::new_error(tcx, guar, Ty::new_error(tcx, guar)).into()
+                    }
+                })),
+                arg_count,
+            );
+        }
+
         (args, arg_count)
     }
 

compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs

@@ -8,7 +8,9 @@ use rustc_hir::def_id::DefId;
 use rustc_lint_defs::builtin::UNUSED_ASSOCIATED_TYPE_BOUNDS;
 use rustc_middle::span_bug;
 use rustc_middle::ty::fold::BottomUpFolder;
-use rustc_middle::ty::{self, ExistentialPredicateStableCmpExt as _, Ty, TyCtxt, TypeFoldable};
+use rustc_middle::ty::{
+    self, ExistentialPredicateStableCmpExt as _, Ty, TyCtxt, TypeFoldable, TypeVisitableExt,
+};
 use rustc_middle::ty::{DynKind, Upcast};
 use rustc_span::{ErrorGuaranteed, Span};
 use rustc_trait_selection::traits::error_reporting::report_object_safety_error;
@@ -214,7 +216,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         // Erase the `dummy_self` (`trait_object_dummy_self`) used above.
         let existential_trait_refs = regular_traits.iter().map(|i| {
             i.trait_ref().map_bound(|trait_ref: ty::TraitRef<'tcx>| {
-                assert_eq!(trait_ref.self_ty(), dummy_self);
+                if !trait_ref.self_ty().references_error() {
+                    assert_eq!(trait_ref.self_ty(), dummy_self);
+                }
 
                 // Verify that `dummy_self` did not leak inside default type parameters. This
                 // could not be done at path creation, since we need to see through trait aliases.
@@ -281,7 +285,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         let existential_projections = projection_bounds.iter().map(|(bound, _)| {
             bound.map_bound(|mut b| {
-                assert_eq!(b.projection_term.self_ty(), dummy_self);
+                if !b.projection_term.self_ty().references_error() {
+                    assert_eq!(b.projection_term.self_ty(), dummy_self);
+                }
 
                 // Like for trait refs, verify that `dummy_self` did not leak inside default type
                 // parameters.

tests/ui/const-generics/adt_const_params/transmutable-ice-110969.rs

@@ -24,7 +24,6 @@ fn via_associated_const() {
     trait Trait {
         const FALSE: bool = assert::is_transmutable::<Src, Dst, Context, {}>();
         //~^ ERROR mismatched types
-        //~| ERROR `Src` cannot be safely transmuted into `Dst`
         //~| ERROR mismatched types
     }
 }

tests/ui/const-generics/adt_const_params/transmutable-ice-110969.stderr

@@ -12,28 +12,13 @@ error[E0308]: mismatched types
 LL |         const FALSE: bool = assert::is_transmutable::<Src, Dst, Context, {}>();
    |                                                                          ^^ expected `Assume`, found `()`
 
-error[E0277]: `Src` cannot be safely transmuted into `Dst`
-  --> $DIR/transmutable-ice-110969.rs:25:60
-   |
-LL |         const FALSE: bool = assert::is_transmutable::<Src, Dst, Context, {}>();
-   |                                                            ^^^ `Dst` may carry safety invariants
-   |
-note: required by a bound in `is_transmutable`
-  --> $DIR/transmutable-ice-110969.rs:11:14
-   |
-LL |     pub fn is_transmutable<Src, Dst, Context, const ASSUME: std::mem::Assume>()
-   |            --------------- required by a bound in this function
-LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src, Context, ASSUME>,
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
-
 error[E0308]: mismatched types
   --> $DIR/transmutable-ice-110969.rs:25:29
    |
 LL |         const FALSE: bool = assert::is_transmutable::<Src, Dst, Context, {}>();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `bool`, found `()`
 
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
-Some errors have detailed explanations: E0107, E0277, E0308.
+Some errors have detailed explanations: E0107, E0308.
 For more information about an error, try `rustc --explain E0107`.

tests/ui/consts/fn_trait_refs.stderr

@@ -18,6 +18,12 @@ LL |     T: ~const Fn<()> + ~const Destruct,
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
+error[E0220]: associated type `Output` not found for `T`
+  --> $DIR/fn_trait_refs.rs:13:35
+   |
+LL | const fn tester_fn<T>(f: T) -> T::Output
+   |                                   ^^^^^^ associated type `Output` not found
+
 error: `~const` can only be applied to `#[const_trait]` traits
   --> $DIR/fn_trait_refs.rs:22:15
    |
@@ -32,6 +38,12 @@ LL |     T: ~const FnMut<()> + ~const Destruct,
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
+error[E0220]: associated type `Output` not found for `T`
+  --> $DIR/fn_trait_refs.rs:20:43
+   |
+LL | const fn tester_fn_mut<T>(mut f: T) -> T::Output
+   |                                           ^^^^^^ associated type `Output` not found
+
 error: `~const` can only be applied to `#[const_trait]` traits
   --> $DIR/fn_trait_refs.rs:29:15
    |
@@ -46,6 +58,12 @@ LL |     T: ~const FnOnce<()>,
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
+error[E0220]: associated type `Output` not found for `T`
+  --> $DIR/fn_trait_refs.rs:27:40
+   |
+LL | const fn tester_fn_once<T>(f: T) -> T::Output
+   |                                        ^^^^^^ associated type `Output` not found
+
 error: `~const` can only be applied to `#[const_trait]` traits
   --> $DIR/fn_trait_refs.rs:36:15
    |
@@ -60,6 +78,24 @@ LL |     T: ~const Fn<()> + ~const Destruct,
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
+error[E0220]: associated type `Output` not found for `T`
+  --> $DIR/fn_trait_refs.rs:34:38
+   |
+LL | const fn test_fn<T>(mut f: T) -> (T::Output, T::Output, T::Output)
+   |                                      ^^^^^^ associated type `Output` not found
+
+error[E0220]: associated type `Output` not found for `T`
+  --> $DIR/fn_trait_refs.rs:34:49
+   |
+LL | const fn test_fn<T>(mut f: T) -> (T::Output, T::Output, T::Output)
+   |                                                 ^^^^^^ associated type `Output` not found
+
+error[E0220]: associated type `Output` not found for `T`
+  --> $DIR/fn_trait_refs.rs:34:60
+   |
+LL | const fn test_fn<T>(mut f: T) -> (T::Output, T::Output, T::Output)
+   |                                                            ^^^^^^ associated type `Output` not found
+
 error: `~const` can only be applied to `#[const_trait]` traits
   --> $DIR/fn_trait_refs.rs:50:15
    |
@@ -74,115 +110,52 @@ LL |     T: ~const FnMut<()> + ~const Destruct,
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error[E0015]: cannot call non-const operator in constants
-  --> $DIR/fn_trait_refs.rs:72:17
-   |
-LL |         assert!(test_one == (1, 1, 1));
-   |                 ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: calls in constants are limited to constant functions, tuple structs and tuple variants
-help: add `#![feature(effects)]` to the crate attributes to enable
-   |
-LL + #![feature(effects)]
+error[E0220]: associated type `Output` not found for `T`
+  --> $DIR/fn_trait_refs.rs:48:42
    |
+LL | const fn test_fn_mut<T>(mut f: T) -> (T::Output, T::Output)
+   |                                          ^^^^^^ associated type `Output` not found
 
-error[E0015]: cannot call non-const operator in constants
-  --> $DIR/fn_trait_refs.rs:75:17
-   |
-LL |         assert!(test_two == (2, 2));
-   |                 ^^^^^^^^^^^^^^^^^^
-   |
-   = note: calls in constants are limited to constant functions, tuple structs and tuple variants
-help: add `#![feature(effects)]` to the crate attributes to enable
-   |
-LL + #![feature(effects)]
+error[E0220]: associated type `Output` not found for `T`
+  --> $DIR/fn_trait_refs.rs:48:53
    |
+LL | const fn test_fn_mut<T>(mut f: T) -> (T::Output, T::Output)
+   |                                                     ^^^^^^ associated type `Output` not found
 
-error[E0015]: cannot call non-const closure in constant functions
+error[E0618]: expected function, found `T`
   --> $DIR/fn_trait_refs.rs:17:5
    |
-LL |     f()
-   |     ^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
-   |
-LL |     T: ~const Fn<()> + ~const Destruct + ~const std::ops::Fn<()>,
-   |                                        +++++++++++++++++++++++++
-help: add `#![feature(effects)]` to the crate attributes to enable
-   |
-LL + #![feature(effects)]
-   |
-
-error[E0493]: destructor of `T` cannot be evaluated at compile-time
-  --> $DIR/fn_trait_refs.rs:13:23
-   |
 LL | const fn tester_fn<T>(f: T) -> T::Output
-   |                       ^ the destructor for this type cannot be evaluated in constant functions
+   |                       - `f` has type `T`
 ...
-LL | }
-   | - value is dropped here
-
-error[E0015]: cannot call non-const closure in constant functions
-  --> $DIR/fn_trait_refs.rs:24:5
-   |
 LL |     f()
-   |     ^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
-   |
-LL |     T: ~const FnMut<()> + ~const Destruct + ~const std::ops::FnMut<()>,
-   |                                           ++++++++++++++++++++++++++++
-help: add `#![feature(effects)]` to the crate attributes to enable
-   |
-LL + #![feature(effects)]
-   |
+   |     ^--
+   |     |
+   |     call expression requires function
 
-error[E0493]: destructor of `T` cannot be evaluated at compile-time
-  --> $DIR/fn_trait_refs.rs:20:27
+error[E0618]: expected function, found `T`
+  --> $DIR/fn_trait_refs.rs:24:5
    |
 LL | const fn tester_fn_mut<T>(mut f: T) -> T::Output
-   |                           ^^^^^ the destructor for this type cannot be evaluated in constant functions
+   |                           ----- `f` has type `T`
 ...
-LL | }
-   | - value is dropped here
-
-error[E0015]: cannot call non-const closure in constant functions
-  --> $DIR/fn_trait_refs.rs:31:5
-   |
 LL |     f()
-   |     ^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
-   |
-LL |     T: ~const FnOnce<()> + ~const std::ops::FnOnce<()>,
-   |                          +++++++++++++++++++++++++++++
-help: add `#![feature(effects)]` to the crate attributes to enable
-   |
-LL + #![feature(effects)]
-   |
+   |     ^--
+   |     |
+   |     call expression requires function
 
-error[E0493]: destructor of `T` cannot be evaluated at compile-time
-  --> $DIR/fn_trait_refs.rs:34:21
-   |
-LL | const fn test_fn<T>(mut f: T) -> (T::Output, T::Output, T::Output)
-   |                     ^^^^^ the destructor for this type cannot be evaluated in constant functions
-...
-LL | }
-   | - value is dropped here
-
-error[E0493]: destructor of `T` cannot be evaluated at compile-time
-  --> $DIR/fn_trait_refs.rs:48:25
+error[E0618]: expected function, found `T`
+  --> $DIR/fn_trait_refs.rs:31:5
    |
-LL | const fn test_fn_mut<T>(mut f: T) -> (T::Output, T::Output)
-   |                         ^^^^^ the destructor for this type cannot be evaluated in constant functions
+LL | const fn tester_fn_once<T>(f: T) -> T::Output
+   |                            - `f` has type `T`
 ...
-LL | }
-   | - value is dropped here
+LL |     f()
+   |     ^--
+   |     |
+   |     call expression requires function
 
-error: aborting due to 20 previous errors
+error: aborting due to 22 previous errors
 
-Some errors have detailed explanations: E0015, E0493, E0635.
-For more information about an error, try `rustc --explain E0015`.
+Some errors have detailed explanations: E0220, E0618, E0635.
+For more information about an error, try `rustc --explain E0220`.

tests/ui/consts/unstable-const-fn-in-libcore.stderr

@@ -4,41 +4,17 @@ error: `~const` can only be applied to `#[const_trait]` traits
 LL |     const fn unwrap_or_else<F: ~const FnOnce() -> T>(self, f: F) -> T {
    |                                       ^^^^^^^^^^^^^
 
-error[E0015]: cannot call non-const closure in constant functions
+error[E0618]: expected function, found `F`
   --> $DIR/unstable-const-fn-in-libcore.rs:24:26
    |
-LL |             Opt::None => f(),
-   |                          ^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
-   |
-LL |     const fn unwrap_or_else<F: ~const FnOnce() -> T + ~const std::ops::FnOnce<()>>(self, f: F) -> T {
-   |                                                     +++++++++++++++++++++++++++++
-help: add `#![feature(effects)]` to the crate attributes to enable
-   |
-LL + #![feature(effects)]
-   |
-
-error[E0493]: destructor of `F` cannot be evaluated at compile-time
-  --> $DIR/unstable-const-fn-in-libcore.rs:19:60
-   |
-LL |     const fn unwrap_or_else<F: ~const FnOnce() -> T>(self, f: F) -> T {
-   |                                                            ^ the destructor for this type cannot be evaluated in constant functions
-...
-LL |     }
-   |     - value is dropped here
-
-error[E0493]: destructor of `Opt<T>` cannot be evaluated at compile-time
-  --> $DIR/unstable-const-fn-in-libcore.rs:19:54
-   |
 LL |     const fn unwrap_or_else<F: ~const FnOnce() -> T>(self, f: F) -> T {
-   |                                                      ^^^^ the destructor for this type cannot be evaluated in constant functions
+   |                                                            - `f` has type `F`
 ...
-LL |     }
-   |     - value is dropped here
+LL |             Opt::None => f(),
+   |                          ^--
+   |                          |
+   |                          call expression requires function
 
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0015, E0493.
-For more information about an error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0618`.

tests/ui/generic-associated-types/gat-trait-path-missing-lifetime.rs

@@ -9,7 +9,6 @@ impl<T> X for T { //~ ERROR: not all trait items implemented
     //~^ ERROR missing generics for associated type
     //~^^ ERROR missing generics for associated type
     //~| ERROR method `foo` has 1 type parameter but its trait declaration has 0 type parameters
-    //~| ERROR may not live long enough
     t
   }
 }