[PERF] dont check impossible preds

Author: BoxyUwU

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -335,43 +335,43 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: ty::PseudoCanonicalInput<'tcx, GlobalId<'tcx>>,
 ) -> ::rustc_middle::mir::interpret::EvalToAllocationRawResult<'tcx> {
-    // Avoid evaluating instances with impossible bounds required to hold as
-    // this can result in executing code that should never be executed.
-    let instance_def = key.value.instance.def_id();
-    if tcx.def_kind(instance_def) == DefKind::AnonConst
-        && let ty::AnonConstKind::GCEConst = tcx.anon_const_kind(instance_def)
-    { // ... do nothing for GCE anon consts as it would cycle
-    } else if tcx.def_kind(instance_def) == DefKind::AnonConst
-        && let ty::AnonConstKind::RepeatExprCount = tcx.anon_const_kind(instance_def)
-    {
-        // Instead of erroring when encountering a repeat expr hack const with impossible
-        // preds we just FCW, as anon consts are unnameable and this code *might* wind up
-        // supported one day if the anon const is a path expr.
-        if tcx.instantiate_and_check_impossible_predicates((
-            instance_def,
-            tcx.erase_regions(key.value.instance.args),
-        )) {
-            if let Some(local_def) = instance_def.as_local() {
-                tcx.node_span_lint(
-                    rustc_session::lint::builtin::CONST_EVALUATABLE_UNCHECKED,
-                    tcx.local_def_id_to_hir_id(local_def),
-                    tcx.def_span(instance_def),
-                    |lint| {
-                        lint.primary_message(
-                            "cannot use constants which depend on trivially-false where clauses",
-                        );
-                    },
-                )
-            } else {
-                // If the repeat expr count is from some upstream crate then we don't care to
-                // lint on it as it should have been linted on when compiling the upstream crate.
-            }
-        };
-    } else if tcx
-        .instantiate_and_check_impossible_predicates((instance_def, key.value.instance.args))
-    {
-        return Err(ErrorHandled::TooGeneric(tcx.def_span(instance_def)));
-    }
+    // // Avoid evaluating instances with impossible bounds required to hold as
+    // // this can result in executing code that should never be executed.
+    // let instance_def = key.value.instance.def_id();
+    // if tcx.def_kind(instance_def) == DefKind::AnonConst
+    //     && let ty::AnonConstKind::GCEConst = tcx.anon_const_kind(instance_def)
+    // { // ... do nothing for GCE anon consts as it would cycle
+    // } else if tcx.def_kind(instance_def) == DefKind::AnonConst
+    //     && let ty::AnonConstKind::RepeatExprCount = tcx.anon_const_kind(instance_def)
+    // {
+    //     // Instead of erroring when encountering a repeat expr hack const with impossible
+    //     // preds we just FCW, as anon consts are unnameable and this code *might* wind up
+    //     // supported one day if the anon const is a path expr.
+    //     if tcx.instantiate_and_check_impossible_predicates((
+    //         instance_def,
+    //         tcx.erase_regions(key.value.instance.args),
+    //     )) {
+    //         if let Some(local_def) = instance_def.as_local() {
+    //             tcx.node_span_lint(
+    //                 rustc_session::lint::builtin::CONST_EVALUATABLE_UNCHECKED,
+    //                 tcx.local_def_id_to_hir_id(local_def),
+    //                 tcx.def_span(instance_def),
+    //                 |lint| {
+    //                     lint.primary_message(
+    //                         "cannot use constants which depend on trivially-false where clauses",
+    //                     );
+    //                 },
+    //             )
+    //         } else {
+    //             // If the repeat expr count is from some upstream crate then we don't care to
+    //             // lint on it as it should have been linted on when compiling the upstream crate.
+    //         }
+    //     };
+    // } else if tcx
+    //     .instantiate_and_check_impossible_predicates((instance_def, key.value.instance.args))
+    // {
+    //     return Err(ErrorHandled::TooGeneric(tcx.def_span(instance_def)));
+    // }
 
     // This shouldn't be used for statics, since statics are conceptually places,
     // not values -- so what we do here could break pointer identity.