clean up GVN TypeId test

tests/mir-opt/gvn_const_eval_polymorphic.no_optimize.GVN.diff

@@ -0,0 +1,12 @@
+- // MIR for `no_optimize` before GVN
++ // MIR for `no_optimize` after GVN
+
+  fn no_optimize() -> bool {
+      let mut _0: bool;
+
+      bb0: {
+          _0 = Eq(const no_optimize::<T>::{constant#0}, const no_optimize::<T>::{constant#1});
+          return;
+      }
+  }
+

tests/mir-opt/gvn_const_eval_polymorphic.optimize_false.GVN.diff

@@ -0,0 +1,13 @@
+- // MIR for `optimize_false` before GVN
++ // MIR for `optimize_false` after GVN
+
+  fn optimize_false() -> bool {
+      let mut _0: bool;
+
+      bb0: {
+-         _0 = Eq(const optimize_false::<T>::{constant#0}, const optimize_false::<T>::{constant#1});
++         _0 = const false;
+          return;
+      }
+  }
+

tests/mir-opt/gvn_const_eval_polymorphic.optimize_true.GVN.diff

@@ -0,0 +1,13 @@
+- // MIR for `optimize_true` before GVN
++ // MIR for `optimize_true` after GVN
+
+  fn optimize_true() -> bool {
+      let mut _0: bool;
+
+      bb0: {
+-         _0 = Eq(const optimize_true::<T>::{constant#0}, const optimize_true::<T>::{constant#1});
++         _0 = const true;
+          return;
+      }
+  }
+

tests/mir-opt/gvn_const_eval_polymorphic.rs

@@ -0,0 +1,57 @@
+//@ test-mir-pass: GVN
+//@ compile-flags: --crate-type lib
+
+//! Regressions test for a mis-optimization where some functions
+//! (`type_id` / `type_name` / `needs_drop`) could be evaluated in
+//! a generic context, even though their value depends on some type
+//! parameter `T`.
+//!
+//! In particular, `type_name_of_val(&generic::<T>)` was incorrectly
+//! evaluated to the string "crate_name::generic::<T>", and
+//! `no_optimize` was incorrectly optimized to `false`.
+
+#![feature(const_type_name)]
+
+fn generic<T>() {}
+
+const fn type_name_contains_i32<T>(_: &T) -> bool {
+    let pattern = b"i32";
+    let name = std::any::type_name::<T>().as_bytes();
+    let mut i = 0;
+    'outer: while i < name.len() - pattern.len() + 1 {
+        let mut j = 0;
+        while j < pattern.len() {
+            if name[i + j] != pattern[j] {
+                i += 1;
+                continue 'outer;
+            }
+            j += 1;
+        }
+        return true;
+    }
+    false
+}
+
+// EMIT_MIR gvn_const_eval_polymorphic.optimize_true.GVN.diff
+fn optimize_true<T>() -> bool {
+    // CHECK-LABEL: fn optimize_true(
+    // CHECK: _0 = const true;
+    // CHECK-NEXT: return;
+    (const { type_name_contains_i32(&generic::<i32>) }) == const { true }
+}
+
+// EMIT_MIR gvn_const_eval_polymorphic.optimize_false.GVN.diff
+fn optimize_false<T>() -> bool {
+    // CHECK-LABEL: fn optimize_false(
+    // CHECK: _0 = const false;
+    // CHECK-NEXT: return;
+    (const { type_name_contains_i32(&generic::<i64>) }) == const { true }
+}
+
+// EMIT_MIR gvn_const_eval_polymorphic.no_optimize.GVN.diff
+fn no_optimize<T>() -> bool {
+    // CHECK-LABEL: fn no_optimize(
+    // CHECK: _0 = Eq(const no_optimize::<T>::{constant#0}, const no_optimize::<T>::{constant#1});
+    // CHECK-NEXT: return;
+    (const { type_name_contains_i32(&generic::<T>) }) == const { true }
+}