fix: Fix invalid signature bitflags

11 files changed, 100 insertions, 103 deletions

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
index 93305f0faa1..01476deb623 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
@@ -157,7 +157,7 @@ pub(crate) fn print_struct(
             wln!(p, "#[repr(pack({}))]", pack.bytes());
         }
     }
-    if flags.contains(StructFlags::IS_FUNDAMENTAL) {
+    if flags.contains(StructFlags::FUNDAMENTAL) {
         wln!(p, "#[fundamental]");
     }
     w!(p, "struct ");
@@ -202,16 +202,16 @@ pub(crate) fn print_function(
         line_format: LineFormat::Newline,
         edition,
     };
-    if flags.contains(FnFlags::HAS_CONST_KW) {
+    if flags.contains(FnFlags::CONST) {
         w!(p, "const ");
     }
-    if flags.contains(FnFlags::HAS_ASYNC_KW) {
+    if flags.contains(FnFlags::ASYNC) {
         w!(p, "async ");
     }
-    if flags.contains(FnFlags::HAS_UNSAFE_KW) {
+    if flags.contains(FnFlags::UNSAFE) {
         w!(p, "unsafe ");
     }
-    if flags.contains(FnFlags::HAS_SAFE_KW) {
+    if flags.contains(FnFlags::EXPLICIT_SAFE) {
         w!(p, "safe ");
     }
     if let Some(abi) = abi {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
index 86d6445e292..4800a1c9f3b 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
@@ -50,18 +50,18 @@ pub struct StructSignature {
 bitflags! {
     #[derive(Debug, Copy, Clone, PartialEq, Eq)]
     pub struct StructFlags: u8 {
-        /// Indicates whether the struct is `PhantomData`.
-        const IS_PHANTOM_DATA  = 1 << 2;
-        /// Indicates whether the struct has a `#[fundamental]` attribute.
-        const IS_FUNDAMENTAL   = 1 << 3;
         /// Indicates whether the struct has a `#[rustc_has_incoherent_inherent_impls]` attribute.
-        const IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPLS      = 1 << 4;
+        const RUSTC_HAS_INCOHERENT_INHERENT_IMPLS = 1 << 1;
+        /// Indicates whether the struct has a `#[fundamental]` attribute.
+        const FUNDAMENTAL      = 1 << 2;
+        /// Indicates whether the struct is `PhantomData`.
+        const IS_PHANTOM_DATA  = 1 << 3;
         /// Indicates whether this struct is `Box`.
-        const IS_BOX           = 1 << 5;
+        const IS_BOX           = 1 << 4;
         /// Indicates whether this struct is `ManuallyDrop`.
-        const IS_MANUALLY_DROP = 1 << 6;
+        const IS_MANUALLY_DROP = 1 << 5;
         /// Indicates whether this struct is `UnsafeCell`.
-        const IS_UNSAFE_CELL   = 1 << 7;
+        const IS_UNSAFE_CELL   = 1 << 6;
     }
 }
 
@@ -73,10 +73,10 @@ impl StructSignature {
 
         let mut flags = StructFlags::empty();
         if attrs.by_key(&sym::rustc_has_incoherent_inherent_impls).exists() {
-            flags |= StructFlags::IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPLS;
+            flags |= StructFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS;
         }
         if attrs.by_key(&sym::fundamental).exists() {
-            flags |= StructFlags::IS_FUNDAMENTAL;
+            flags |= StructFlags::FUNDAMENTAL;
         }
         if let Some(lang) = attrs.lang_item() {
             match lang {
@@ -129,10 +129,10 @@ impl UnionSignature {
         let attrs = item_tree.attrs(db, krate, ModItem::from(loc.id.value).into());
         let mut flags = StructFlags::empty();
         if attrs.by_key(&sym::rustc_has_incoherent_inherent_impls).exists() {
-            flags |= StructFlags::IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPLS;
+            flags |= StructFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS;
         }
         if attrs.by_key(&sym::fundamental).exists() {
-            flags |= StructFlags::IS_FUNDAMENTAL;
+            flags |= StructFlags::FUNDAMENTAL;
         }
 
         let repr = attrs.repr();
@@ -162,7 +162,7 @@ impl UnionSignature {
 bitflags! {
     #[derive(Debug, Copy, Clone, PartialEq, Eq)]
     pub struct EnumFlags: u8 {
-        const IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPLS  = 1 << 4;
+        const RUSTC_HAS_INCOHERENT_INHERENT_IMPLS  = 1 << 1;
     }
 }
 
@@ -182,7 +182,7 @@ impl EnumSignature {
         let attrs = item_tree.attrs(db, loc.container.krate, ModItem::from(loc.id.value).into());
         let mut flags = EnumFlags::empty();
         if attrs.by_key(&sym::rustc_has_incoherent_inherent_impls).exists() {
-            flags |= EnumFlags::IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPLS;
+            flags |= EnumFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS;
         }
 
         let repr = attrs.repr();
@@ -219,8 +219,8 @@ impl EnumSignature {
 bitflags::bitflags! {
     #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
     pub struct ConstFlags: u8 {
-        const HAS_BODY = 1 << 0;
-        const RUSTC_ALLOW_INCOHERENT_IMPL = 1 << 1;
+        const HAS_BODY = 1 << 1;
+        const RUSTC_ALLOW_INCOHERENT_IMPL = 1 << 7;
     }
 }
 
@@ -271,12 +271,12 @@ impl ConstSignature {
 bitflags::bitflags! {
     #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
     pub struct StaticFlags: u8 {
-        const HAS_BODY = 1 << 0;
-        const RUSTC_ALLOW_INCOHERENT_IMPL = 1 << 1;
-        const MUTABLE = 1 << 2;
-        const HAS_UNSAFE = 1 << 3;
-        const HAS_SAFE = 1 << 4;
-        const IS_EXTERN = 1 << 5;
+        const HAS_BODY = 1 << 1;
+        const MUTABLE    = 1 << 3;
+        const UNSAFE     = 1 << 4;
+        const EXPLICIT_SAFE = 1 << 5;
+        const EXTERN     = 1 << 6;
+        const RUSTC_ALLOW_INCOHERENT_IMPL = 1 << 7;
     }
 }
 
@@ -302,7 +302,7 @@ impl StaticSignature {
         }
 
         if matches!(loc.container, ItemContainerId::ExternBlockId(_)) {
-            flags.insert(StaticFlags::IS_EXTERN);
+            flags.insert(StaticFlags::EXTERN);
         }
 
         let source = loc.source(db);
@@ -313,10 +313,10 @@ impl StaticSignature {
             flags.insert(StaticFlags::MUTABLE);
         }
         if source.value.unsafe_token().is_some() {
-            flags.insert(StaticFlags::HAS_UNSAFE);
+            flags.insert(StaticFlags::UNSAFE);
         }
         if source.value.safe_token().is_some() {
-            flags.insert(StaticFlags::HAS_SAFE);
+            flags.insert(StaticFlags::EXPLICIT_SAFE);
         }
 
         let (store, source_map, type_ref) =
@@ -337,8 +337,8 @@ impl StaticSignature {
 bitflags::bitflags! {
     #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
     pub struct ImplFlags: u8 {
-        const IS_NEGATIVE = 1 << 0;
-        const IS_UNSAFE = 1 << 1;
+        const NEGATIVE = 1 << 1;
+        const UNSAFE = 1 << 3;
     }
 }
 
@@ -358,10 +358,10 @@ impl ImplSignature {
         let mut flags = ImplFlags::empty();
         let src = loc.source(db);
         if src.value.unsafe_token().is_some() {
-            flags.insert(ImplFlags::IS_UNSAFE);
+            flags.insert(ImplFlags::UNSAFE);
         }
         if src.value.excl_token().is_some() {
-            flags.insert(ImplFlags::IS_NEGATIVE);
+            flags.insert(ImplFlags::NEGATIVE);
         }
 
         let (store, source_map, self_ty, target_trait, generic_params) =
@@ -383,13 +383,13 @@ impl ImplSignature {
 bitflags::bitflags! {
     #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
     pub struct TraitFlags: u8 {
-        const IS_AUTO = 1 << 0;
-        const IS_UNSAFE = 1 << 1;
-        const IS_FUNDAMENTAL = 1 << 2;
-        const RUSTC_HAS_INCOHERENT_INHERENT_IMPLS = 1 << 3;
-        const SKIP_ARRAY_DURING_METHOD_DISPATCH = 1 << 4;
-        const SKIP_BOXED_SLICE_DURING_METHOD_DISPATCH = 1 << 5;
-        const RUSTC_PAREN_SUGAR = 1 << 6;
+        const RUSTC_HAS_INCOHERENT_INHERENT_IMPLS = 1 << 1;
+        const FUNDAMENTAL = 1 << 2;
+        const UNSAFE = 1 << 3;
+        const AUTO = 1 << 4;
+        const SKIP_ARRAY_DURING_METHOD_DISPATCH = 1 << 5;
+        const SKIP_BOXED_SLICE_DURING_METHOD_DISPATCH = 1 << 6;
+        const RUSTC_PAREN_SUGAR = 1 << 7;
     }
 }
 
@@ -410,13 +410,13 @@ impl TraitSignature {
         let attrs = item_tree.attrs(db, loc.container.krate, ModItem::from(loc.id.value).into());
         let source = loc.source(db);
         if source.value.auto_token().is_some() {
-            flags.insert(TraitFlags::IS_AUTO);
+            flags.insert(TraitFlags::AUTO);
         }
         if source.value.unsafe_token().is_some() {
-            flags.insert(TraitFlags::IS_UNSAFE);
+            flags.insert(TraitFlags::UNSAFE);
         }
         if attrs.by_key(&sym::fundamental).exists() {
-            flags |= TraitFlags::IS_FUNDAMENTAL;
+            flags |= TraitFlags::FUNDAMENTAL;
         }
         if attrs.by_key(&sym::rustc_has_incoherent_inherent_impls).exists() {
             flags |= TraitFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS;
@@ -489,21 +489,21 @@ impl TraitAliasSignature {
 bitflags! {
     #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
     pub struct FnFlags: u16 {
-        const HAS_SELF_PARAM = 1 << 0;
         const HAS_BODY = 1 << 1;
-        const HAS_DEFAULT_KW = 1 << 2;
-        const HAS_CONST_KW = 1 << 3;
-        const HAS_ASYNC_KW = 1 << 4;
-        const HAS_UNSAFE_KW = 1 << 5;
-        const IS_VARARGS = 1 << 6;
-        const HAS_SAFE_KW = 1 << 7;
+        const DEFAULT = 1 << 2;
+        const CONST = 1 << 3;
+        const ASYNC = 1 << 4;
+        const UNSAFE = 1 << 5;
+        const HAS_VARARGS = 1 << 6;
+        const RUSTC_ALLOW_INCOHERENT_IMPL = 1 << 7;
+        const HAS_SELF_PARAM = 1 << 8;
         /// The `#[target_feature]` attribute is necessary to check safety (with RFC 2396),
         /// but keeping it for all functions will consume a lot of memory when there are
         /// only very few functions with it. So we only encode its existence here, and lookup
         /// it if needed.
-        const HAS_TARGET_FEATURE = 1 << 8;
-        const DEPRECATED_SAFE_2024 = 1 << 9;
-        const RUSTC_ALLOW_INCOHERENT_IMPLS = 1 << 10;
+        const HAS_TARGET_FEATURE = 1 << 9;
+        const DEPRECATED_SAFE_2024 = 1 << 10;
+        const EXPLICIT_SAFE = 1 << 11;
     }
 }
 
@@ -532,7 +532,7 @@ impl FunctionSignature {
         let mut flags = FnFlags::empty();
         let attrs = item_tree.attrs(db, module.krate, ModItem::from(loc.id.value).into());
         if attrs.by_key(&sym::rustc_allow_incoherent_impl).exists() {
-            flags.insert(FnFlags::RUSTC_ALLOW_INCOHERENT_IMPLS);
+            flags.insert(FnFlags::RUSTC_ALLOW_INCOHERENT_IMPL);
         }
 
         if attrs.by_key(&sym::target_feature).exists() {
@@ -546,20 +546,20 @@ impl FunctionSignature {
             if attrs.by_key(&sym::rustc_deprecated_safe_2024).exists() {
                 flags.insert(FnFlags::DEPRECATED_SAFE_2024);
             } else {
-                flags.insert(FnFlags::HAS_UNSAFE_KW);
+                flags.insert(FnFlags::UNSAFE);
             }
         }
         if source.value.async_token().is_some() {
-            flags.insert(FnFlags::HAS_ASYNC_KW);
+            flags.insert(FnFlags::ASYNC);
         }
         if source.value.const_token().is_some() {
-            flags.insert(FnFlags::HAS_CONST_KW);
+            flags.insert(FnFlags::CONST);
         }
         if source.value.default_token().is_some() {
-            flags.insert(FnFlags::HAS_DEFAULT_KW);
+            flags.insert(FnFlags::DEFAULT);
         }
         if source.value.safe_token().is_some() {
-            flags.insert(FnFlags::HAS_SAFE_KW);
+            flags.insert(FnFlags::EXPLICIT_SAFE);
         }
         if source.value.body().is_some() {
             flags.insert(FnFlags::HAS_BODY);
@@ -575,7 +575,7 @@ impl FunctionSignature {
             flags.insert(FnFlags::HAS_SELF_PARAM);
         }
         if variadic {
-            flags.insert(FnFlags::IS_VARARGS);
+            flags.insert(FnFlags::HAS_VARARGS);
         }
         (
             Arc::new(FunctionSignature {
@@ -603,19 +603,19 @@ impl FunctionSignature {
     }
 
     pub fn is_default(&self) -> bool {
-        self.flags.contains(FnFlags::HAS_DEFAULT_KW)
+        self.flags.contains(FnFlags::DEFAULT)
     }
 
     pub fn is_const(&self) -> bool {
-        self.flags.contains(FnFlags::HAS_CONST_KW)
+        self.flags.contains(FnFlags::CONST)
     }
 
     pub fn is_async(&self) -> bool {
-        self.flags.contains(FnFlags::HAS_ASYNC_KW)
+        self.flags.contains(FnFlags::ASYNC)
     }
 
     pub fn is_unsafe(&self) -> bool {
-        self.flags.contains(FnFlags::HAS_UNSAFE_KW)
+        self.flags.contains(FnFlags::UNSAFE)
     }
 
     pub fn is_deprecated_safe_2024(&self) -> bool {
@@ -623,11 +623,11 @@ impl FunctionSignature {
     }
 
     pub fn is_safe(&self) -> bool {
-        self.flags.contains(FnFlags::HAS_SAFE_KW)
+        self.flags.contains(FnFlags::EXPLICIT_SAFE)
     }
 
     pub fn is_varargs(&self) -> bool {
-        self.flags.contains(FnFlags::IS_VARARGS)
+        self.flags.contains(FnFlags::HAS_VARARGS)
     }
 
     pub fn has_target_feature(&self) -> bool {
@@ -637,10 +637,10 @@ impl FunctionSignature {
 
 bitflags! {
     #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
-    pub struct TypeAliasFlags: u16 {
-        const IS_EXTERN = 1 << 7;
-        const RUSTC_ALLOW_INCOHERENT_IMPLS = 1 << 8;
-        const RUSTC_HAS_INCOHERENT_INHERENT_IMPLS = 1 << 9;
+    pub struct TypeAliasFlags: u8 {
+        const RUSTC_HAS_INCOHERENT_INHERENT_IMPL = 1 << 1;
+        const IS_EXTERN = 1 << 6;
+        const RUSTC_ALLOW_INCOHERENT_IMPL = 1 << 7;
     }
 }
 
@@ -669,10 +669,10 @@ impl TypeAliasSignature {
             ModItem::from(loc.id.value).into(),
         );
         if attrs.by_key(&sym::rustc_has_incoherent_inherent_impls).exists() {
-            flags.insert(TypeAliasFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS);
+            flags.insert(TypeAliasFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPL);
         }
         if attrs.by_key(&sym::rustc_allow_incoherent_impl).exists() {
-            flags.insert(TypeAliasFlags::RUSTC_ALLOW_INCOHERENT_IMPLS);
+            flags.insert(TypeAliasFlags::RUSTC_ALLOW_INCOHERENT_IMPL);
         }
         if matches!(loc.container, ItemContainerId::ExternBlockId(_)) {
             flags.insert(TypeAliasFlags::IS_EXTERN);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
index e4b36d5baf4..24deb00b385 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
@@ -674,13 +674,13 @@ pub(crate) fn trait_datum_query(
     let generic_params = generics(db, trait_.into());
     let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
     let flags = rust_ir::TraitFlags {
-        auto: trait_data.flags.contains(TraitFlags::IS_AUTO),
+        auto: trait_data.flags.contains(TraitFlags::AUTO),
         upstream: trait_.lookup(db).container.krate() != krate,
         non_enumerable: true,
         coinductive: false, // only relevant for Chalk testing
         // FIXME: set these flags correctly
         marker: false,
-        fundamental: trait_data.flags.contains(TraitFlags::IS_FUNDAMENTAL),
+        fundamental: trait_data.flags.contains(TraitFlags::FUNDAMENTAL),
     };
     let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars);
     let associated_ty_ids =
@@ -761,10 +761,7 @@ pub(crate) fn adt_datum_query(
     let (fundamental, phantom_data) = match adt_id {
         hir_def::AdtId::StructId(s) => {
             let flags = db.struct_signature(s).flags;
-            (
-                flags.contains(StructFlags::IS_FUNDAMENTAL),
-                flags.contains(StructFlags::IS_PHANTOM_DATA),
-            )
+            (flags.contains(StructFlags::FUNDAMENTAL), flags.contains(StructFlags::IS_PHANTOM_DATA))
         }
         // FIXME set fundamental flags correctly
         hir_def::AdtId::UnionId(_) => (false, false),
@@ -851,7 +848,7 @@ fn impl_def_datum(db: &dyn HirDatabase, krate: Crate, impl_id: hir_def::ImplId)
         rust_ir::ImplType::External
     };
     let where_clauses = convert_where_clauses(db, impl_id.into(), &bound_vars);
-    let negative = impl_data.flags.contains(ImplFlags::IS_NEGATIVE);
+    let negative = impl_data.flags.contains(ImplFlags::NEGATIVE);
     let polarity = if negative { rust_ir::Polarity::Negative } else { rust_ir::Polarity::Positive };
 
     let impl_datum_bound = rust_ir::ImplDatumBound { trait_ref, where_clauses };
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
index c39b6115c55..3cba71c6077 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
@@ -560,7 +560,7 @@ impl<'a> DeclValidator<'a> {
 
     fn validate_static(&mut self, static_id: StaticId) {
         let data = self.db.static_signature(static_id);
-        if data.flags.contains(StaticFlags::IS_EXTERN) {
+        if data.flags.contains(StaticFlags::EXTERN) {
             cov_mark::hit!(extern_static_incorrect_case_ignored);
             return;
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
index 376b734e31d..ca0f33fa693 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
@@ -361,8 +361,8 @@ impl<'a> UnsafeVisitor<'a> {
             let static_data = self.db.static_signature(id);
             if static_data.flags.contains(StaticFlags::MUTABLE) {
                 self.on_unsafe_op(node, UnsafetyReason::MutableStatic);
-            } else if static_data.flags.contains(StaticFlags::IS_EXTERN)
-                && !static_data.flags.contains(StaticFlags::HAS_SAFE)
+            } else if static_data.flags.contains(StaticFlags::EXTERN)
+                && !static_data.flags.contains(StaticFlags::EXPLICIT_SAFE)
             {
                 self.on_unsafe_op(node, UnsafetyReason::ExternStatic);
             }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index 81e224c4d6d..a3376d93014 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -429,7 +429,7 @@ where
         // Allow `impl AutoTrait` predicates
         if let WhereClause::Implemented(TraitRef { trait_id, substitution }) = pred {
             let trait_data = db.trait_signature(from_chalk_trait_id(*trait_id));
-            if trait_data.flags.contains(TraitFlags::IS_AUTO)
+            if trait_data.flags.contains(TraitFlags::AUTO)
                 && substitution
                     .as_slice(Interner)
                     .first()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 25b449ab853..3ef15e5a2c9 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -586,13 +586,13 @@ impl<'a> TyLoweringContext<'a> {
                             .db
                             .trait_signature(from_chalk_trait_id(lhs_id))
                             .flags
-                            .contains(TraitFlags::IS_AUTO);
+                            .contains(TraitFlags::AUTO);
                         let rhs_id = rhs.trait_id;
                         let rhs_is_auto = ctx
                             .db
                             .trait_signature(from_chalk_trait_id(rhs_id))
                             .flags
-                            .contains(TraitFlags::IS_AUTO);
+                            .contains(TraitFlags::AUTO);
 
                         if !lhs_is_auto && !rhs_is_auto {
                             multiple_regular_traits = true;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index 25b32ea6ae8..d591ea8fe87 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -386,15 +386,15 @@ pub fn def_crates(db: &dyn HirDatabase, ty: &Ty, cur_crate: Crate) -> Option<Sma
                 hir_def::AdtId::StructId(id) => db
                     .struct_signature(id)
                     .flags
-                    .contains(StructFlags::IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
+                    .contains(StructFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
                 hir_def::AdtId::UnionId(id) => db
                     .union_signature(id)
                     .flags
-                    .contains(StructFlags::IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
+                    .contains(StructFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
                 hir_def::AdtId::EnumId(id) => db
                     .enum_signature(id)
                     .flags
-                    .contains(EnumFlags::IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
+                    .contains(EnumFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
             };
             Some(if rustc_has_incoherent_inherent_impls {
                 db.incoherent_inherent_impl_crates(cur_crate, TyFingerprint::Adt(def_id))
@@ -408,7 +408,7 @@ pub fn def_crates(db: &dyn HirDatabase, ty: &Ty, cur_crate: Crate) -> Option<Sma
                 if db
                     .type_alias_signature(alias)
                     .flags
-                    .contains(TypeAliasFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS)
+                    .contains(TypeAliasFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPL)
                 {
                     db.incoherent_inherent_impl_crates(cur_crate, TyFingerprint::ForeignType(id))
                 } else {
@@ -831,15 +831,15 @@ fn is_inherent_impl_coherent(
                 hir_def::AdtId::StructId(id) => db
                     .struct_signature(id)
                     .flags
-                    .contains(StructFlags::IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
+                    .contains(StructFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
                 hir_def::AdtId::UnionId(id) => db
                     .union_signature(id)
                     .flags
-                    .contains(StructFlags::IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
+                    .contains(StructFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
                 hir_def::AdtId::EnumId(it) => db
                     .enum_signature(it)
                     .flags
-                    .contains(EnumFlags::IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
+                    .contains(EnumFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
             },
             TyKind::Dyn(it) => it.principal_id().is_some_and(|trait_id| {
                 db.trait_signature(from_chalk_trait_id(trait_id))
@@ -854,7 +854,7 @@ fn is_inherent_impl_coherent(
             && !items.items.is_empty()
             && items.items.iter().all(|&(_, assoc)| match assoc {
                 AssocItemId::FunctionId(it) => {
-                    db.function_signature(it).flags.contains(FnFlags::RUSTC_ALLOW_INCOHERENT_IMPLS)
+                    db.function_signature(it).flags.contains(FnFlags::RUSTC_ALLOW_INCOHERENT_IMPL)
                 }
                 AssocItemId::ConstId(it) => {
                     db.const_signature(it).flags.contains(ConstFlags::RUSTC_ALLOW_INCOHERENT_IMPL)
@@ -862,7 +862,7 @@ fn is_inherent_impl_coherent(
                 AssocItemId::TypeAliasId(it) => db
                     .type_alias_signature(it)
                     .flags
-                    .contains(TypeAliasFlags::RUSTC_ALLOW_INCOHERENT_IMPLS),
+                    .contains(TypeAliasFlags::RUSTC_ALLOW_INCOHERENT_IMPL),
             })
     }
 }
@@ -898,7 +898,7 @@ pub fn check_orphan_rules(db: &dyn HirDatabase, impl_: ImplId) -> bool {
                 TyKind::Ref(_, _, referenced) => ty = referenced.clone(),
                 &TyKind::Adt(AdtId(hir_def::AdtId::StructId(s)), ref subs) => {
                     let struct_signature = db.struct_signature(s);
-                    if struct_signature.flags.contains(StructFlags::IS_FUNDAMENTAL) {
+                    if struct_signature.flags.contains(StructFlags::FUNDAMENTAL) {
                         let next = subs.type_parameters(Interner).next();
                         match next {
                             Some(it) => ty = it,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index 7f5fc824d4c..29b468fef77 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -2754,7 +2754,7 @@ impl Evaluator<'_> {
             return Ok(*o);
         };
         let static_data = self.db.static_signature(st);
-        let result = if !static_data.flags.contains(StaticFlags::IS_EXTERN) {
+        let result = if !static_data.flags.contains(StaticFlags::EXTERN) {
             let konst = self.db.const_eval_static(st).map_err(|e| {
                 MirEvalError::ConstEvalError(static_data.name.as_str().to_owned(), Box::new(e))
             })?;
diff --git a/src/tools/rust-analyzer/crates/hir/src/display.rs b/src/tools/rust-analyzer/crates/hir/src/display.rs
index 8885f328dbd..5bb2c24a5f0 100644
--- a/src/tools/rust-analyzer/crates/hir/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/display.rs
@@ -794,10 +794,10 @@ impl HirDisplay for Trait {
 fn write_trait_header(trait_: &Trait, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
     write_visibility(trait_.module(f.db).id, trait_.visibility(f.db), f)?;
     let data = f.db.trait_signature(trait_.id);
-    if data.flags.contains(TraitFlags::IS_UNSAFE) {
+    if data.flags.contains(TraitFlags::UNSAFE) {
         f.write_str("unsafe ")?;
     }
-    if data.flags.contains(TraitFlags::IS_AUTO) {
+    if data.flags.contains(TraitFlags::AUTO) {
         f.write_str("auto ")?;
     }
     write!(f, "trait {}", data.name.display(f.db, f.edition()))?;
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 0f3667eaf47..f560157deb8 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -2898,11 +2898,11 @@ impl Trait {
     }
 
     pub fn is_auto(self, db: &dyn HirDatabase) -> bool {
-        db.trait_signature(self.id).flags.contains(TraitFlags::IS_AUTO)
+        db.trait_signature(self.id).flags.contains(TraitFlags::AUTO)
     }
 
     pub fn is_unsafe(&self, db: &dyn HirDatabase) -> bool {
-        db.trait_signature(self.id).flags.contains(TraitFlags::IS_UNSAFE)
+        db.trait_signature(self.id).flags.contains(TraitFlags::UNSAFE)
     }
 
     pub fn type_or_const_param_count(
@@ -4454,11 +4454,11 @@ impl Impl {
     }
 
     pub fn is_negative(self, db: &dyn HirDatabase) -> bool {
-        db.impl_signature(self.id).flags.contains(ImplFlags::IS_NEGATIVE)
+        db.impl_signature(self.id).flags.contains(ImplFlags::NEGATIVE)
     }
 
     pub fn is_unsafe(self, db: &dyn HirDatabase) -> bool {
-        db.impl_signature(self.id).flags.contains(ImplFlags::IS_UNSAFE)
+        db.impl_signature(self.id).flags.contains(ImplFlags::UNSAFE)
     }
 
     pub fn module(self, db: &dyn HirDatabase) -> Module {