language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-11-03 21:25:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

fix: Fix invalid signature bitflags

Browse source
This commit is contained in:
Lukas Wirth 2025-04-10 15:38:50 +02:00
parent f880acd18c
commit 4fdc2507c6
11 changed files with 100 additions and 103 deletions
Download patch file Download diff file Expand all files Collapse all files

11
crates/hir-ty/src/chalk_db.rs
View file

@ -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 };

2
crates/hir-ty/src/diagnostics/decl_check.rs
View file

@ -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;
}

4
crates/hir-ty/src/diagnostics/unsafe_check.rs
View file

@ -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);
}

2
crates/hir-ty/src/dyn_compatibility.rs
View file

@ -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()

4
crates/hir-ty/src/lower.rs
View file

@ -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;

20
crates/hir-ty/src/method_resolution.rs
View file

@ -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,

2
crates/hir-ty/src/mir/eval.rs
View file

@ -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))
})?;