Add needs_substs check to check_binary_op.

src/librustc_mir/transform/const_prop.rs

@@ -521,31 +521,37 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
         None
     }
 
+    /// Check for overflow for a unary op. Like check_binary_op, safe to call even if the operand
+    /// needs substs. In that case, no work is done.
     fn check_unary_op(
         &mut self,
         op: UnOp,
         arg: &Operand<'tcx>,
         source_info: SourceInfo,
     ) -> Option<()> {
-        if self.use_ecx(|this| {
-            let val = this.ecx.read_immediate(this.ecx.eval_operand(arg, None)?)?;
-            let (_res, overflow, _ty) = this.ecx.overflowing_unary_op(op, val)?;
-            Ok(overflow)
-        })? {
-            // `AssertKind` only has an `OverflowNeg` variant, so make sure that is
-            // appropriate to use.
-            assert_eq!(op, UnOp::Neg, "Neg is the only UnOp that can overflow");
-            self.report_assert_as_lint(
-                lint::builtin::ARITHMETIC_OVERFLOW,
-                source_info,
-                "this arithmetic operation will overflow",
-                AssertKind::OverflowNeg,
-            )?;
+        if !arg.needs_subst() {
+            if self.use_ecx(|this| {
+                let val = this.ecx.read_immediate(this.ecx.eval_operand(arg, None)?)?;
+                let (_res, overflow, _ty) = this.ecx.overflowing_unary_op(op, val)?;
+                Ok(overflow)
+            })? {
+                // `AssertKind` only has an `OverflowNeg` variant, so make sure that is
+                // appropriate to use.
+                assert_eq!(op, UnOp::Neg, "Neg is the only UnOp that can overflow");
+                self.report_assert_as_lint(
+                    lint::builtin::ARITHMETIC_OVERFLOW,
+                    source_info,
+                    "this arithmetic operation will overflow",
+                    AssertKind::OverflowNeg,
+                )?;
+            }
         }
 
         Some(())
     }
 
+    /// Check a binary operand for overflow. Safe to call with values that need substs -- those
+    /// values just won't be checked.
     fn check_binary_op(
         &mut self,
         op: BinOp,
@@ -576,18 +582,20 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
                 }
             }
 
-            // The remaining operators are handled through `overflowing_binary_op`.
-            if self.use_ecx(|this| {
-                let l = this.ecx.read_immediate(this.ecx.eval_operand(left, None)?)?;
-                let (_res, overflow, _ty) = this.ecx.overflowing_binary_op(op, l, r)?;
-                Ok(overflow)
-            })? {
-                self.report_assert_as_lint(
-                    lint::builtin::ARITHMETIC_OVERFLOW,
-                    source_info,
-                    "this arithmetic operation will overflow",
-                    AssertKind::Overflow(op),
-                )?;
+            if !left.needs_subst() {
+                // The remaining operators are handled through `overflowing_binary_op`.
+                if self.use_ecx(|this| {
+                    let l = this.ecx.read_immediate(this.ecx.eval_operand(left, None)?)?;
+                    let (_res, overflow, _ty) = this.ecx.overflowing_binary_op(op, l, r)?;
+                    Ok(overflow)
+                })? {
+                    self.report_assert_as_lint(
+                        lint::builtin::ARITHMETIC_OVERFLOW,
+                        source_info,
+                        "this arithmetic operation will overflow",
+                        AssertKind::Overflow(op),
+                    )?;
+                }
             }
         }