From 5896998e7659bf22ffb804956a3680c028ede45f Mon Sep 17 00:00:00 2001
From: Aaron Hill <aa1ronham@gmail.com>
Date: Sun, 5 Jan 2020 22:32:53 -0500
Subject: [PATCH] Don't run const propagation on items with inconsistent bounds

Using `#![feature(trivial_bounds)]`, it's possible to write functions
with unsatisfiable 'where' clauses, making them uncallable. However, the
user can act as if these 'where' clauses are true inside the body of the
function, leading to code that would normally be impossible to write.

Since const propgation can run even without any user-written calls to a
function, we need to explcitly check for these uncallable functions.
---
 src/librustc_mir/transform/const_prop.rs      | 25 +++++++++++++++++++
 ...ounds-inconsistent-associated-functions.rs |  4 +++
 ...s-inconsistent-associated-functions.stderr |  2 ++
 3 files changed, 31 insertions(+)
 create mode 100644 src/test/ui/trivial-bounds/trivial-bounds-inconsistent-associated-functions.stderr

diff --git a/src/librustc_mir/transform/const_prop.rs b/src/librustc_mir/transform/const_prop.rs
index 1d5a643484a..48ab24a14c7 100644
--- a/src/librustc_mir/transform/const_prop.rs
+++ b/src/librustc_mir/transform/const_prop.rs
@@ -74,6 +74,31 @@ impl<'tcx> MirPass<'tcx> for ConstProp {
             return;
         }
 
+        // Check if it's even possible to satisy the 'where' clauses
+        // for this item.
+        // This branch will never be taken for any normal function.
+        // However, it's possible to `#!feature(trivial_bounds)]` to write
+        // a function with impossible to satisfy clauses, e.g.:
+        // `fn foo() where String: Copy {}`
+        //
+        // We don't usually need to worry about this kind of case,
+        // since we would get a compilation error if the user tried
+        // to call it. However, since we can do const propagation
+        // even without any calls to the function, we need to make
+        // sure that it even makes sense to try to evaluate the body.
+        // If there are unsatisfiable where clauses, then all bets are
+        // off, and we just give up.
+        if !tcx.substitute_normalize_and_test_predicates((
+            source.def_id(),
+            InternalSubsts::identity_for_item(tcx, source.def_id()),
+        )) {
+            trace!(
+                "ConstProp skipped for item with unsatisfiable predicates: {:?}",
+                source.def_id()
+            );
+            return;
+        }
+
         trace!("ConstProp starting for {:?}", source.def_id());
 
         let dummy_body = &Body::new(
diff --git a/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-associated-functions.rs b/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-associated-functions.rs
index 6450ddd1b67..818be105547 100644
--- a/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-associated-functions.rs
+++ b/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-associated-functions.rs
@@ -1,4 +1,8 @@
 // run-pass
+// Force mir to be emitted, to ensure that const
+// propagation doesn't ICE on a function
+// with an 'impossible' body. See issue #67696
+// compile-flags: --emit=mir,link
 // Inconsistent bounds with trait implementations
 
 #![feature(trivial_bounds)]
diff --git a/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-associated-functions.stderr b/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-associated-functions.stderr
new file mode 100644
index 00000000000..0ee1e2e0ba5
--- /dev/null
+++ b/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-associated-functions.stderr
@@ -0,0 +1,2 @@
+warning: due to multiple output types requested, the explicitly specified output file name will be adapted for each output type
+