Don't panic on large shift counts

This also refactors the fold_expr function to avoid declaring any code
erroneous. Instead, we defer the decision to rustc itself, which also
has the side-effect of generating a nicer error.

Author: meithecatte

enumflags_derive/src/lib.rs

@@ -3,6 +3,7 @@ extern crate proc_macro;
 #[macro_use]
 extern crate quote;
 
+use std::convert::TryFrom;
 use syn::{Data, Ident, DeriveInput, DataEnum, spanned::Spanned};
 use proc_macro2::{TokenStream, Span};
 
@@ -46,42 +47,27 @@ pub fn bitflags_internal(
 }
 
 /// Try to evaluate the expression given.
-///
-/// Returns `Err` when the expression is erroneous, and `Ok(None)` when
-/// information outside of the syntax, such as a `const`.
-fn fold_expr(expr: &syn::Expr) -> Result<Option<u64>, syn::Error> {
-    /// Recurse, but bubble-up both kinds of errors.
-    /// (I miss my monad transformers)
-    macro_rules! fold_expr {
-        ($($x:tt)*) => {
-            match fold_expr($($x)*)? {
-                Some(x) => x,
-                None => return Ok(None),
-            }
-        }
-    }
-
+fn fold_expr(expr: &syn::Expr) -> Option<u64> {
     use syn::Expr;
     match expr {
         Expr::Lit(ref expr_lit) => {
             match expr_lit.lit {
-                syn::Lit::Int(ref lit_int) => {
-                    Ok(Some(lit_int.base10_parse()
-                        .map_err(|_| syn::Error::new_spanned(lit_int,
-                                "Integer literal out of range"))?))
-                }
-                _ => Ok(None),
+                syn::Lit::Int(ref lit_int) => lit_int.base10_parse().ok(),
+                _ => None,
             }
         },
         Expr::Binary(ref expr_binary) => {
-            let l = fold_expr!(&expr_binary.left);
-            let r = fold_expr!(&expr_binary.right);
+            let l = fold_expr(&expr_binary.left)?;
+            let r = fold_expr(&expr_binary.right)?;
             match &expr_binary.op {
-                syn::BinOp::Shl(_) => Ok(Some(l << r)),
-                _ => Ok(None),
+                syn::BinOp::Shl(_) => {
+                    u32::try_from(r).ok()
+                        .and_then(|r| l.checked_shl(r))
+                }
+                _ => None,
             }
         }
-        _ => Ok(None),
+        _ => None,
     }
 }
 
@@ -98,7 +84,7 @@ fn collect_flags<'a>(variants: impl Iterator<Item=&'a syn::Variant>)
             }
 
             let value = if let Some(ref expr) = variant.discriminant {
-                if let Some(n) = fold_expr(&expr.1)? {
+                if let Some(n) = fold_expr(&expr.1) {
                     FlagValue::Literal(n)
                 } else {
                     FlagValue::Deferred

test_suite/ui/literal_out_of_range.rs

@@ -1,4 +1,5 @@
-#[enumflags2::bitflags]
+//#[enumflags2::bitflags]
+#[repr(u64)]
 #[derive(Copy, Clone)]
 enum Foo {
     BigNumber = 0xdeadbeefcafebabe1337,

test_suite/ui/literal_out_of_range.stderr

@@ -1,5 +1,9 @@
-error: Integer literal out of range
- --> $DIR/literal_out_of_range.rs:4:17
+error: literal out of range for u64
+ --> $DIR/literal_out_of_range.rs:5:17
   |
-4 |     BigNumber = 0xdeadbeefcafebabe1337,
+5 |     BigNumber = 0xdeadbeefcafebabe1337,
   |                 ^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: `#[deny(overflowing_literals)]` on by default
+  = note: the literal `0xdeadbeefcafebabe1337` (decimal `1051570404360395033547575`) does not fit into the type `u64` and will become `13758438582043677495u64`
+  = help: consider using `u128` instead

test_suite/ui/shift_out_of_range.rs

@@ -0,0 +1,15 @@
+#[enumflags2::bitflags]
+#[repr(u64)]
+#[derive(Copy, Clone)]
+enum Foo {
+    BigNumber = 1 << 69,
+}
+
+#[enumflags2::bitflags]
+#[repr(u16)]
+#[derive(Copy, Clone)]
+enum Bar {
+    BigNumber = 1 << 20,
+}
+
+fn main() {}

test_suite/ui/shift_out_of_range.stderr

@@ -0,0 +1,11 @@
+error[E0080]: evaluation of constant value failed
+ --> $DIR/shift_out_of_range.rs:5:17
+  |
+5 |     BigNumber = 1 << 69,
+  |                 ^^^^^^^ attempt to shift left with overflow
+
+error[E0080]: evaluation of constant value failed
+  --> $DIR/shift_out_of_range.rs:12:17
+   |
+12 |     BigNumber = 1 << 20,
+   |                 ^^^^^^^ attempt to shift left with overflow