Remove diagnostic_only_typeck and fix placeholder suggestion for const/static

Author: compiler-errors

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -412,7 +412,7 @@ fn infer_placeholder_type<'tcx>(
     kind: &'static str,
 ) -> Ty<'tcx> {
     let tcx = cx.tcx();
-    let ty = tcx.diagnostic_only_typeck(def_id).node_type(body_id.hir_id);
+    let ty = tcx.typeck(def_id).node_type(body_id.hir_id);
 
     // If this came from a free `const` or `static mut?` item,
     // then the user may have written e.g. `const A = 42;`.

compiler/rustc_hir_typeck/src/lib.rs

@@ -87,21 +87,7 @@ fn used_trait_imports(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &UnordSet<LocalDef
 }
 
 fn typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &'tcx ty::TypeckResults<'tcx> {
-    let fallback = move || tcx.type_of(def_id.to_def_id()).instantiate_identity();
-    typeck_with_fallback(tcx, def_id, fallback, None)
-}
-
-/// Used only to get `TypeckResults` for type inference during error recovery.
-/// Currently only used for type inference of `static`s and `const`s to avoid type cycle errors.
-fn diagnostic_only_typeck<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    def_id: LocalDefId,
-) -> &'tcx ty::TypeckResults<'tcx> {
-    let fallback = move || {
-        let span = tcx.hir().span(tcx.local_def_id_to_hir_id(def_id));
-        Ty::new_error_with_message(tcx, span, "diagnostic only typeck table used")
-    };
-    typeck_with_fallback(tcx, def_id, fallback, None)
+    typeck_with_fallback(tcx, def_id, None)
 }
 
 /// Same as `typeck` but `inspect` is invoked on evaluation of each root obligation.
@@ -113,15 +99,13 @@ pub fn inspect_typeck<'tcx>(
     def_id: LocalDefId,
     inspect: ObligationInspector<'tcx>,
 ) -> &'tcx ty::TypeckResults<'tcx> {
-    let fallback = move || tcx.type_of(def_id.to_def_id()).instantiate_identity();
-    typeck_with_fallback(tcx, def_id, fallback, Some(inspect))
+    typeck_with_fallback(tcx, def_id, Some(inspect))
 }
 
-#[instrument(level = "debug", skip(tcx, fallback, inspector), ret)]
+#[instrument(level = "debug", skip(tcx, inspector), ret)]
 fn typeck_with_fallback<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: LocalDefId,
-    fallback: impl Fn() -> Ty<'tcx> + 'tcx,
     inspector: Option<ObligationInspector<'tcx>>,
 ) -> &'tcx ty::TypeckResults<'tcx> {
     // Closures' typeck results come from their outermost function,
@@ -151,6 +135,10 @@ fn typeck_with_fallback<'tcx>(
 
     if let Some(hir::FnSig { header, decl, .. }) = node.fn_sig() {
         let fn_sig = if decl.output.is_suggestable_infer_ty().is_some() {
+            // In the case that we're recovering `fn() -> W<_>` or some other return
+            // type that has an infer in it, lower the type directly so that it'll
+            // be correctly filled with infer. We'll use this inference to provide
+            // a suggestion later on.
             fcx.lowerer().lower_fn_ty(id, header.safety, header.abi, decl, None, None)
         } else {
             tcx.fn_sig(def_id).instantiate_identity()
@@ -164,8 +152,19 @@ fn typeck_with_fallback<'tcx>(
 
         check_fn(&mut fcx, fn_sig, None, decl, def_id, body, tcx.features().unsized_fn_params());
     } else {
-        let expected_type = infer_type_if_missing(&fcx, node);
-        let expected_type = expected_type.unwrap_or_else(fallback);
+        let expected_type = if let Some(infer_ty) = infer_type_if_missing(&fcx, node) {
+            infer_ty
+        } else if let Some(ty) = node.ty()
+            && ty.is_suggestable_infer_ty()
+        {
+            // In the case that we're recovering `const X: [T; _]` or some other
+            // type that has an infer in it, lower the type directly so that it'll
+            // be correctly filled with infer. We'll use this inference to provide
+            // a suggestion later on.
+            fcx.lowerer().lower_ty(ty)
+        } else {
+            tcx.type_of(def_id).instantiate_identity()
+        };
 
         let expected_type = fcx.normalize(body.value.span, expected_type);
 
@@ -506,5 +505,5 @@ fn fatally_break_rust(tcx: TyCtxt<'_>, span: Span) -> ! {
 
 pub fn provide(providers: &mut Providers) {
     method::provide(providers);
-    *providers = Providers { typeck, diagnostic_only_typeck, used_trait_imports, ..*providers };
+    *providers = Providers { typeck, used_trait_imports, ..*providers };
 }

compiler/rustc_middle/src/query/mod.rs

@@ -1100,9 +1100,6 @@ rustc_queries! {
         desc { |tcx| "type-checking `{}`", tcx.def_path_str(key) }
         cache_on_disk_if(tcx) { !tcx.is_typeck_child(key.to_def_id()) }
     }
-    query diagnostic_only_typeck(key: LocalDefId) -> &'tcx ty::TypeckResults<'tcx> {
-        desc { |tcx| "type-checking `{}`", tcx.def_path_str(key) }
-    }
 
     query used_trait_imports(key: LocalDefId) -> &'tcx UnordSet<LocalDefId> {
         desc { |tcx| "finding used_trait_imports `{}`", tcx.def_path_str(key) }

tests/ui/const-generics/generic_arg_infer/in-signature.stderr

@@ -30,13 +30,19 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/in-signature.rs:22:15
    |
 LL | const ARR_CT: [u8; _] = [0; 3];
-   |               ^^^^^^^ not allowed in type signatures
+   |               ^^^^^^^
+   |               |
+   |               not allowed in type signatures
+   |               help: replace with the correct type: `[u8; 3]`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/in-signature.rs:24:20
    |
 LL | static ARR_STATIC: [u8; _] = [0; 3];
-   |                    ^^^^^^^ not allowed in type signatures
+   |                    ^^^^^^^
+   |                    |
+   |                    not allowed in type signatures
+   |                    help: replace with the correct type: `[u8; 3]`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/in-signature.rs:26:14

tests/ui/consts/issue-104768.rs

@@ -1,4 +1,5 @@
 const A: &_ = 0_u32;
 //~^ ERROR: the placeholder `_` is not allowed within types on item signatures for constants
+//~| ERROR: mismatched types
 
 fn main() {}

tests/ui/consts/issue-104768.stderr

@@ -1,3 +1,16 @@
+error[E0308]: mismatched types
+  --> $DIR/issue-104768.rs:1:15
+   |
+LL | const A: &_ = 0_u32;
+   |               ^^^^^ expected `&_`, found `u32`
+   |
+   = note: expected reference `&'static _`
+                   found type `u32`
+help: consider borrowing here
+   |
+LL | const A: &_ = &0_u32;
+   |               +
+
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/issue-104768.rs:1:10
    |
@@ -7,6 +20,7 @@ LL | const A: &_ = 0_u32;
    |          not allowed in type signatures
    |          help: replace with the correct type: `u32`
 
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0121`.
+Some errors have detailed explanations: E0121, E0308.
+For more information about an error, try `rustc --explain E0121`.

tests/ui/generic-const-items/assoc-const-missing-type.rs

@@ -12,7 +12,6 @@ impl Trait for () {
     const K<T> = ();
     //~^ ERROR missing type for `const` item
     //~| ERROR mismatched types
-    //~| ERROR mismatched types
     const Q = "";
     //~^ ERROR missing type for `const` item
     //~| ERROR lifetime parameters or bounds on const `Q` do not match the trait declaration

tests/ui/generic-const-items/assoc-const-missing-type.stderr

@@ -16,7 +16,7 @@ LL |     const K<T> = ();
    |               ^ help: provide a type for the associated constant: `()`
 
 error[E0195]: lifetime parameters or bounds on const `Q` do not match the trait declaration
-  --> $DIR/assoc-const-missing-type.rs:16:12
+  --> $DIR/assoc-const-missing-type.rs:15:12
    |
 LL |     const Q<'a>: &'a str;
    |            ---- lifetimes in impl do not match this const in trait
@@ -25,24 +25,12 @@ LL |     const Q = "";
    |            ^ lifetimes do not match const in trait
 
 error: missing type for `const` item
-  --> $DIR/assoc-const-missing-type.rs:16:12
+  --> $DIR/assoc-const-missing-type.rs:15:12
    |
 LL |     const Q = "";
    |            ^ help: provide a type for the associated constant: `: &str`
 
-error[E0308]: mismatched types
-  --> $DIR/assoc-const-missing-type.rs:12:18
-   |
-LL |     const K<T> = ();
-   |             -    ^^ expected type parameter `T`, found `()`
-   |             |
-   |             expected this type parameter
-   |
-   = note: expected type parameter `T`
-                   found unit type `()`
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
 Some errors have detailed explanations: E0195, E0308.
 For more information about an error, try `rustc --explain E0195`.

tests/ui/parser/issues/issue-89574.rs

@@ -2,5 +2,4 @@ fn main() {
     const EMPTY_ARRAY = [];
     //~^ missing type for `const` item
     //~| ERROR type annotations needed
-    //~| ERROR type annotations needed
 }

tests/ui/parser/issues/issue-89574.stderr

@@ -15,14 +15,6 @@ help: provide a type for the item
 LL |     const EMPTY_ARRAY: <type> = [];
    |                      ++++++++
 
-error[E0282]: type annotations needed
-  --> $DIR/issue-89574.rs:2:25
-   |
-LL |     const EMPTY_ARRAY = [];
-   |                         ^^ cannot infer type
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0282`.