avoid creating an Instance only to immediately disassemble it again

Author: RalfJung

compiler/rustc_mir_build/messages.ftl

@@ -4,8 +4,6 @@ mir_build_already_borrowed = cannot borrow value as mutable because it is also b
 
 mir_build_already_mut_borrowed = cannot borrow value as immutable because it is also borrowed as mutable
 
-mir_build_assoc_const_in_pattern = associated consts cannot be referenced in patterns
-
 mir_build_bindings_with_variant_name =
     pattern binding `{$name}` is named the same as one of the variants of the type `{$ty_path}`
     .suggestion = to match on the variant, qualify the path

compiler/rustc_mir_build/src/errors.rs

@@ -566,13 +566,6 @@ pub(crate) struct StaticInPattern {
     pub(crate) span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(mir_build_assoc_const_in_pattern, code = E0158)]
-pub(crate) struct AssocConstInPattern {
-    #[primary_span]
-    pub(crate) span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(mir_build_const_param_in_pattern, code = E0158)]
 pub(crate) struct ConstParamInPattern {

compiler/rustc_mir_build/src/thir/pattern/mod.rs

@@ -548,37 +548,8 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
             _ => return pat_from_kind(self.lower_variant_or_leaf(res, id, span, ty, vec![])),
         };
 
-        // Use `Reveal::All` here because patterns are always monomorphic even if their function
-        // isn't.
-        let param_env_reveal_all = self.param_env.with_reveal_all_normalized(self.tcx);
-        // N.B. There is no guarantee that args collected in typeck results are fully normalized,
-        // so they need to be normalized in order to pass to `Instance::resolve`, which will ICE
-        // if given unnormalized types.
-        let args = self
-            .tcx
-            .normalize_erasing_regions(param_env_reveal_all, self.typeck_results.node_args(id));
-        let instance = match ty::Instance::try_resolve(self.tcx, param_env_reveal_all, def_id, args)
-        {
-            Ok(Some(i)) => i,
-            Ok(None) => {
-                // It should be assoc consts if there's no error but we cannot resolve it.
-                debug_assert!(is_associated_const);
-
-                let e = self.tcx.dcx().emit_err(AssocConstInPattern { span });
-                return pat_from_kind(PatKind::Error(e));
-            }
-
-            Err(_) => {
-                let e = self.tcx.dcx().emit_err(CouldNotEvalConstPattern { span });
-                return pat_from_kind(PatKind::Error(e));
-            }
-        };
-
-        let c = ty::Const::new_unevaluated(
-            self.tcx,
-            ty::UnevaluatedConst { def: instance.def_id(), args: instance.args },
-        );
-
+        let args = self.typeck_results.node_args(id);
+        let c = ty::Const::new_unevaluated(self.tcx, ty::UnevaluatedConst { def: def_id, args });
         let pattern = self.const_to_pat(c, ty, id, span);
 
         if !is_associated_const {

tests/ui/pattern/issue-68393-let-pat-assoc-constant.rs

@@ -18,9 +18,9 @@ impl Foo for Def {
 }
 
 pub fn test<A: Foo, B: Foo>(arg: EFoo, A::X: EFoo) {
-    //~^ ERROR associated consts cannot be referenced in patterns
+    //~^ ERROR constant pattern depends on a generic parameter
     let A::X = arg;
-    //~^ ERROR associated consts cannot be referenced in patterns
+    //~^ ERROR constant pattern depends on a generic parameter
 }
 
 fn main() {}

tests/ui/pattern/issue-68393-let-pat-assoc-constant.stderr

@@ -1,15 +1,14 @@
-error[E0158]: associated consts cannot be referenced in patterns
+error: constant pattern depends on a generic parameter
   --> $DIR/issue-68393-let-pat-assoc-constant.rs:22:9
    |
 LL |     let A::X = arg;
    |         ^^^^
 
-error[E0158]: associated consts cannot be referenced in patterns
+error: constant pattern depends on a generic parameter
   --> $DIR/issue-68393-let-pat-assoc-constant.rs:20:40
    |
 LL | pub fn test<A: Foo, B: Foo>(arg: EFoo, A::X: EFoo) {
    |                                        ^^^^
 
 error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0158`.