Rust flagset
Python `IntFlag` becomes a `flags` from https://crates.io/crates/flagset , however simple bit operations do not work

```py
class Permissions(IntFlag):
    R = 1
    W = 2
    X = 16


def show():
    b = Permissions.R | Permissions.W
    if b & Permissions.R:
        print("R")
    else:
        print("Not R")
    if b & Permissions.W:
        print("W")
    else:
        print("Not W")
    if b & Permissions.X:
        print("X")
    else:
        print("Not X")
```
(should print `R\nW\nnot X\n')

becomes 

```rust
flags! {
    enum Permissions: c_int {
        R = 1,
        W = 2,
        X = 16,
    }
}

fn show() {
    let b: _ = (Permissions::R | Permissions::W);
    if (b & Permissions::R) {
        println!("{}", "R");
    } else {
        println!("{}", "Not R");
    }
    if (b & Permissions::W) {
        println!("{}", "W");
    } else {
        println!("{}", "Not W");
    }
    if (b & Permissions::X) {
        println!("{}", "X");
    } else {
        println!("{}", "Not X");
    }
}
```
which has all sorts of compile errors.

minimal changes needed are
```diff
@@ -35,18 +41,18 @@ fn show() {
     } else {
         println!("{}", "Not green");
     }
-    let b: _ = (Permissions::R | Permissions::W);
-    if (b & Permissions::R) {
+    let b: _ = Permissions::R | Permissions::W;
+    if (b & Permissions::R).bits() != 0b0 {
         println!("{}", "R");
     } else {
         println!("{}", "Not R");
     }
-    if (b & Permissions::W) {
+    if (b & Permissions::W).bits() != 0b0 {
         println!("{}", "W");
     } else {
         println!("{}", "Not W");
     }
-    if (b & Permissions::X) {
+    if (b & Permissions::X).bits() != 0b0 {
         println!("{}", "X");
     } else {
         println!("{}", "Not X");
```
`b: _` can also be detected to be `b: FlagSet<Permissions>`.

but ideally, a container is also generated so that the `b: _` can be replaced with a type
```rust
struct PermissionsContainer(FlagSet<Permissions>);
impl PermissionsContainer {
    fn new(flags: impl Into<FlagSet<Permissions>>) -> PermissionsContainer {
        PermissionsContainer(flags.into())
    }
}
```
then the changes are
```diff
-    let b: _ = (Permissions::R | Permissions::W);
-    if (b & Permissions::R) {
+    let b: PermissionsContainer = PermissionsContainer::new(Permissions::R | Permissions::W);
+    if (b.0 & Permissions::R).bits() != 0b0 {
```
We could also extend the generated PermissionsContainer so that the existing `if (b & Permissions::X) {` doesnt need to be modified.

It might be worth splitting int_enum to create a new "bitflags" test case, as bit operations are expected for flags but not for int enums.
