Check if bitflags deps pulls its weight

Bitflags is generally a good dependency -- it's lightweight, well
maintained and embraced by the ecosystem.

I wonder, however, do we really need it? Doesn't feel like it adds much
to be honest.

1 files changed, 9 insertions, 9 deletions

diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 39e8403b0..ab7ad8310 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -411,24 +411,24 @@ impl Ctx {
 
         let ast_id = self.source_ast_id_map.ast_id(func);
 
-        let mut flags = FnFlags::empty();
+        let mut flags = FnFlags::default();
         if func.body().is_some() {
-            flags |= FnFlags::HAS_BODY;
+            flags.bits |= FnFlags::HAS_BODY;
         }
         if has_self_param {
-            flags |= FnFlags::HAS_SELF_PARAM;
+            flags.bits |= FnFlags::HAS_SELF_PARAM;
         }
         if func.default_token().is_some() {
-            flags |= FnFlags::IS_DEFAULT;
+            flags.bits |= FnFlags::IS_DEFAULT;
         }
         if func.const_token().is_some() {
-            flags |= FnFlags::IS_CONST;
+            flags.bits |= FnFlags::IS_CONST;
         }
         if func.async_token().is_some() {
-            flags |= FnFlags::IS_ASYNC;
+            flags.bits |= FnFlags::IS_ASYNC;
         }
         if func.unsafe_token().is_some() {
-            flags |= FnFlags::IS_UNSAFE;
+            flags.bits |= FnFlags::IS_UNSAFE;
         }
 
         let mut res = Function {
@@ -653,9 +653,9 @@ impl Ctx {
                             let func_id = self.lower_function(&ast)?;
                             let func = &mut self.data().functions[func_id.index];
                             if is_intrinsic_fn_unsafe(&func.name) {
-                                func.flags |= FnFlags::IS_UNSAFE;
+                                func.flags.bits |= FnFlags::IS_UNSAFE;
                             }
-                            func.flags |= FnFlags::IS_IN_EXTERN_BLOCK;
+                            func.flags.bits |= FnFlags::IS_IN_EXTERN_BLOCK;
                             func_id.into()
                         }
                         ast::ExternItem::Static(ast) => {