| use rustc_data_structures::fx::{FxHashMap, FxHashSet}; |
| use rustc_data_structures::stack::ensure_sufficient_stack; |
| use rustc_hir as hir; |
| use rustc_hir::def::DefKind; |
| use rustc_middle::query::Providers; |
| use rustc_middle::ty::layout::LayoutError; |
| use rustc_middle::ty::{self, Instance, Ty, TyCtxt}; |
| use rustc_session::lint::{lint_array, LintArray}; |
| use rustc_span::{sym, Span, Symbol}; |
| use rustc_target::abi::FIRST_VARIANT; |
| |
| use crate::lints::{BuiltinClashingExtern, BuiltinClashingExternSub}; |
| use crate::types; |
| |
| pub(crate) fn provide(providers: &mut Providers) { |
| *providers = Providers { clashing_extern_declarations, ..*providers }; |
| } |
| |
| pub(crate) fn get_lints() -> LintArray { |
| lint_array!(CLASHING_EXTERN_DECLARATIONS) |
| } |
| |
| fn clashing_extern_declarations(tcx: TyCtxt<'_>, (): ()) { |
| let mut lint = ClashingExternDeclarations::new(); |
| for id in tcx.hir_crate_items(()).foreign_items() { |
| lint.check_foreign_item(tcx, id); |
| } |
| } |
| |
| declare_lint! { |
| /// The `clashing_extern_declarations` lint detects when an `extern fn` |
| /// has been declared with the same name but different types. |
| /// |
| /// ### Example |
| /// |
| /// ```rust |
| /// mod m { |
| /// extern "C" { |
| /// fn foo(); |
| /// } |
| /// } |
| /// |
| /// extern "C" { |
| /// fn foo(_: u32); |
| /// } |
| /// ``` |
| /// |
| /// {{produces}} |
| /// |
| /// ### Explanation |
| /// |
| /// Because two symbols of the same name cannot be resolved to two |
| /// different functions at link time, and one function cannot possibly |
| /// have two types, a clashing extern declaration is almost certainly a |
| /// mistake. Check to make sure that the `extern` definitions are correct |
| /// and equivalent, and possibly consider unifying them in one location. |
| /// |
| /// This lint does not run between crates because a project may have |
| /// dependencies which both rely on the same extern function, but declare |
| /// it in a different (but valid) way. For example, they may both declare |
| /// an opaque type for one or more of the arguments (which would end up |
| /// distinct types), or use types that are valid conversions in the |
| /// language the `extern fn` is defined in. In these cases, the compiler |
| /// can't say that the clashing declaration is incorrect. |
| pub CLASHING_EXTERN_DECLARATIONS, |
| Warn, |
| "detects when an extern fn has been declared with the same name but different types" |
| } |
| |
| struct ClashingExternDeclarations { |
| /// Map of function symbol name to the first-seen hir id for that symbol name.. If seen_decls |
| /// contains an entry for key K, it means a symbol with name K has been seen by this lint and |
| /// the symbol should be reported as a clashing declaration. |
| // FIXME: Technically, we could just store a &'tcx str here without issue; however, the |
| // `impl_lint_pass` macro doesn't currently support lints parametric over a lifetime. |
| seen_decls: FxHashMap<Symbol, hir::OwnerId>, |
| } |
| |
| /// Differentiate between whether the name for an extern decl came from the link_name attribute or |
| /// just from declaration itself. This is important because we don't want to report clashes on |
| /// symbol name if they don't actually clash because one or the other links against a symbol with a |
| /// different name. |
| enum SymbolName { |
| /// The name of the symbol + the span of the annotation which introduced the link name. |
| Link(Symbol, Span), |
| /// No link name, so just the name of the symbol. |
| Normal(Symbol), |
| } |
| |
| impl SymbolName { |
| fn get_name(&self) -> Symbol { |
| match self { |
| SymbolName::Link(s, _) | SymbolName::Normal(s) => *s, |
| } |
| } |
| } |
| |
| impl ClashingExternDeclarations { |
| pub(crate) fn new() -> Self { |
| ClashingExternDeclarations { seen_decls: FxHashMap::default() } |
| } |
| |
| /// Insert a new foreign item into the seen set. If a symbol with the same name already exists |
| /// for the item, return its HirId without updating the set. |
| fn insert(&mut self, tcx: TyCtxt<'_>, fi: hir::ForeignItemId) -> Option<hir::OwnerId> { |
| let did = fi.owner_id.to_def_id(); |
| let instance = Instance::new(did, ty::List::identity_for_item(tcx, did)); |
| let name = Symbol::intern(tcx.symbol_name(instance).name); |
| if let Some(&existing_id) = self.seen_decls.get(&name) { |
| // Avoid updating the map with the new entry when we do find a collision. We want to |
| // make sure we're always pointing to the first definition as the previous declaration. |
| // This lets us avoid emitting "knock-on" diagnostics. |
| Some(existing_id) |
| } else { |
| self.seen_decls.insert(name, fi.owner_id) |
| } |
| } |
| |
| #[instrument(level = "trace", skip(self, tcx))] |
| fn check_foreign_item<'tcx>(&mut self, tcx: TyCtxt<'tcx>, this_fi: hir::ForeignItemId) { |
| let DefKind::Fn = tcx.def_kind(this_fi.owner_id) else { return }; |
| let Some(existing_did) = self.insert(tcx, this_fi) else { return }; |
| |
| let existing_decl_ty = tcx.type_of(existing_did).skip_binder(); |
| let this_decl_ty = tcx.type_of(this_fi.owner_id).instantiate_identity(); |
| debug!( |
| "ClashingExternDeclarations: Comparing existing {:?}: {:?} to this {:?}: {:?}", |
| existing_did, existing_decl_ty, this_fi.owner_id, this_decl_ty |
| ); |
| |
| // Check that the declarations match. |
| if !structurally_same_type( |
| tcx, |
| tcx.param_env(this_fi.owner_id), |
| existing_decl_ty, |
| this_decl_ty, |
| types::CItemKind::Declaration, |
| ) { |
| let orig = name_of_extern_decl(tcx, existing_did); |
| |
| // Finally, emit the diagnostic. |
| let this = tcx.item_name(this_fi.owner_id.to_def_id()); |
| let orig = orig.get_name(); |
| let previous_decl_label = get_relevant_span(tcx, existing_did); |
| let mismatch_label = get_relevant_span(tcx, this_fi.owner_id); |
| let sub = |
| BuiltinClashingExternSub { tcx, expected: existing_decl_ty, found: this_decl_ty }; |
| let decorator = if orig == this { |
| BuiltinClashingExtern::SameName { |
| this, |
| orig, |
| previous_decl_label, |
| mismatch_label, |
| sub, |
| } |
| } else { |
| BuiltinClashingExtern::DiffName { |
| this, |
| orig, |
| previous_decl_label, |
| mismatch_label, |
| sub, |
| } |
| }; |
| tcx.emit_spanned_lint( |
| CLASHING_EXTERN_DECLARATIONS, |
| this_fi.hir_id(), |
| mismatch_label, |
| decorator, |
| ); |
| } |
| } |
| } |
| |
| /// Get the name of the symbol that's linked against for a given extern declaration. That is, |
| /// the name specified in a #[link_name = ...] attribute if one was specified, else, just the |
| /// symbol's name. |
| fn name_of_extern_decl(tcx: TyCtxt<'_>, fi: hir::OwnerId) -> SymbolName { |
| if let Some((overridden_link_name, overridden_link_name_span)) = |
| tcx.codegen_fn_attrs(fi).link_name.map(|overridden_link_name| { |
| // FIXME: Instead of searching through the attributes again to get span |
| // information, we could have codegen_fn_attrs also give span information back for |
| // where the attribute was defined. However, until this is found to be a |
| // bottleneck, this does just fine. |
| (overridden_link_name, tcx.get_attr(fi, sym::link_name).unwrap().span) |
| }) |
| { |
| SymbolName::Link(overridden_link_name, overridden_link_name_span) |
| } else { |
| SymbolName::Normal(tcx.item_name(fi.to_def_id())) |
| } |
| } |
| |
| /// We want to ensure that we use spans for both decls that include where the |
| /// name was defined, whether that was from the link_name attribute or not. |
| fn get_relevant_span(tcx: TyCtxt<'_>, fi: hir::OwnerId) -> Span { |
| match name_of_extern_decl(tcx, fi) { |
| SymbolName::Normal(_) => tcx.def_span(fi), |
| SymbolName::Link(_, annot_span) => annot_span, |
| } |
| } |
| |
| /// Checks whether two types are structurally the same enough that the declarations shouldn't |
| /// clash. We need this so we don't emit a lint when two modules both declare an extern struct, |
| /// with the same members (as the declarations shouldn't clash). |
| fn structurally_same_type<'tcx>( |
| tcx: TyCtxt<'tcx>, |
| param_env: ty::ParamEnv<'tcx>, |
| a: Ty<'tcx>, |
| b: Ty<'tcx>, |
| ckind: types::CItemKind, |
| ) -> bool { |
| let mut seen_types = FxHashSet::default(); |
| structurally_same_type_impl(&mut seen_types, tcx, param_env, a, b, ckind) |
| } |
| |
| fn structurally_same_type_impl<'tcx>( |
| seen_types: &mut FxHashSet<(Ty<'tcx>, Ty<'tcx>)>, |
| tcx: TyCtxt<'tcx>, |
| param_env: ty::ParamEnv<'tcx>, |
| a: Ty<'tcx>, |
| b: Ty<'tcx>, |
| ckind: types::CItemKind, |
| ) -> bool { |
| debug!("structurally_same_type_impl(tcx, a = {:?}, b = {:?})", a, b); |
| |
| // Given a transparent newtype, reach through and grab the inner |
| // type unless the newtype makes the type non-null. |
| let non_transparent_ty = |mut ty: Ty<'tcx>| -> Ty<'tcx> { |
| loop { |
| if let ty::Adt(def, args) = *ty.kind() { |
| let is_transparent = def.repr().transparent(); |
| let is_non_null = types::nonnull_optimization_guaranteed(tcx, def); |
| debug!( |
| "non_transparent_ty({:?}) -- type is transparent? {}, type is non-null? {}", |
| ty, is_transparent, is_non_null |
| ); |
| if is_transparent && !is_non_null { |
| debug_assert_eq!(def.variants().len(), 1); |
| let v = &def.variant(FIRST_VARIANT); |
| // continue with `ty`'s non-ZST field, |
| // otherwise `ty` is a ZST and we can return |
| if let Some(field) = types::transparent_newtype_field(tcx, v) { |
| ty = field.ty(tcx, args); |
| continue; |
| } |
| } |
| } |
| debug!("non_transparent_ty -> {:?}", ty); |
| return ty; |
| } |
| }; |
| |
| let a = non_transparent_ty(a); |
| let b = non_transparent_ty(b); |
| |
| if !seen_types.insert((a, b)) { |
| // We've encountered a cycle. There's no point going any further -- the types are |
| // structurally the same. |
| true |
| } else if a == b { |
| // All nominally-same types are structurally same, too. |
| true |
| } else { |
| // Do a full, depth-first comparison between the two. |
| use rustc_type_ir::sty::TyKind::*; |
| let a_kind = a.kind(); |
| let b_kind = b.kind(); |
| |
| let compare_layouts = |a, b| -> Result<bool, &'tcx LayoutError<'tcx>> { |
| debug!("compare_layouts({:?}, {:?})", a, b); |
| let a_layout = &tcx.layout_of(param_env.and(a))?.layout.abi(); |
| let b_layout = &tcx.layout_of(param_env.and(b))?.layout.abi(); |
| debug!( |
| "comparing layouts: {:?} == {:?} = {}", |
| a_layout, |
| b_layout, |
| a_layout == b_layout |
| ); |
| Ok(a_layout == b_layout) |
| }; |
| |
| #[allow(rustc::usage_of_ty_tykind)] |
| let is_primitive_or_pointer = |
| |kind: &ty::TyKind<'_>| kind.is_primitive() || matches!(kind, RawPtr(..) | Ref(..)); |
| |
| ensure_sufficient_stack(|| { |
| match (a_kind, b_kind) { |
| (Adt(a_def, _), Adt(b_def, _)) => { |
| // We can immediately rule out these types as structurally same if |
| // their layouts differ. |
| match compare_layouts(a, b) { |
| Ok(false) => return false, |
| _ => (), // otherwise, continue onto the full, fields comparison |
| } |
| |
| // Grab a flattened representation of all fields. |
| let a_fields = a_def.variants().iter().flat_map(|v| v.fields.iter()); |
| let b_fields = b_def.variants().iter().flat_map(|v| v.fields.iter()); |
| |
| // Perform a structural comparison for each field. |
| a_fields.eq_by( |
| b_fields, |
| |&ty::FieldDef { did: a_did, .. }, &ty::FieldDef { did: b_did, .. }| { |
| structurally_same_type_impl( |
| seen_types, |
| tcx, |
| param_env, |
| tcx.type_of(a_did).instantiate_identity(), |
| tcx.type_of(b_did).instantiate_identity(), |
| ckind, |
| ) |
| }, |
| ) |
| } |
| (Array(a_ty, a_const), Array(b_ty, b_const)) => { |
| // For arrays, we also check the constness of the type. |
| a_const.kind() == b_const.kind() |
| && structurally_same_type_impl( |
| seen_types, tcx, param_env, *a_ty, *b_ty, ckind, |
| ) |
| } |
| (Slice(a_ty), Slice(b_ty)) => { |
| structurally_same_type_impl(seen_types, tcx, param_env, *a_ty, *b_ty, ckind) |
| } |
| (RawPtr(a_tymut), RawPtr(b_tymut)) => { |
| a_tymut.mutbl == b_tymut.mutbl |
| && structurally_same_type_impl( |
| seen_types, tcx, param_env, a_tymut.ty, b_tymut.ty, ckind, |
| ) |
| } |
| (Ref(_a_region, a_ty, a_mut), Ref(_b_region, b_ty, b_mut)) => { |
| // For structural sameness, we don't need the region to be same. |
| a_mut == b_mut |
| && structurally_same_type_impl( |
| seen_types, tcx, param_env, *a_ty, *b_ty, ckind, |
| ) |
| } |
| (FnDef(..), FnDef(..)) => { |
| let a_poly_sig = a.fn_sig(tcx); |
| let b_poly_sig = b.fn_sig(tcx); |
| |
| // We don't compare regions, but leaving bound regions around ICEs, so |
| // we erase them. |
| let a_sig = tcx.erase_late_bound_regions(a_poly_sig); |
| let b_sig = tcx.erase_late_bound_regions(b_poly_sig); |
| |
| (a_sig.abi, a_sig.unsafety, a_sig.c_variadic) |
| == (b_sig.abi, b_sig.unsafety, b_sig.c_variadic) |
| && a_sig.inputs().iter().eq_by(b_sig.inputs().iter(), |a, b| { |
| structurally_same_type_impl(seen_types, tcx, param_env, *a, *b, ckind) |
| }) |
| && structurally_same_type_impl( |
| seen_types, |
| tcx, |
| param_env, |
| a_sig.output(), |
| b_sig.output(), |
| ckind, |
| ) |
| } |
| (Tuple(a_args), Tuple(b_args)) => { |
| a_args.iter().eq_by(b_args.iter(), |a_ty, b_ty| { |
| structurally_same_type_impl(seen_types, tcx, param_env, a_ty, b_ty, ckind) |
| }) |
| } |
| // For these, it's not quite as easy to define structural-sameness quite so easily. |
| // For the purposes of this lint, take the conservative approach and mark them as |
| // not structurally same. |
| (Dynamic(..), Dynamic(..)) |
| | (Error(..), Error(..)) |
| | (Closure(..), Closure(..)) |
| | (Generator(..), Generator(..)) |
| | (GeneratorWitness(..), GeneratorWitness(..)) |
| | (Alias(ty::Projection, ..), Alias(ty::Projection, ..)) |
| | (Alias(ty::Inherent, ..), Alias(ty::Inherent, ..)) |
| | (Alias(ty::Opaque, ..), Alias(ty::Opaque, ..)) => false, |
| |
| // These definitely should have been caught above. |
| (Bool, Bool) | (Char, Char) | (Never, Never) | (Str, Str) => unreachable!(), |
| |
| // An Adt and a primitive or pointer type. This can be FFI-safe if non-null |
| // enum layout optimisation is being applied. |
| (Adt(..), other_kind) | (other_kind, Adt(..)) |
| if is_primitive_or_pointer(other_kind) => |
| { |
| let (primitive, adt) = |
| if is_primitive_or_pointer(a.kind()) { (a, b) } else { (b, a) }; |
| if let Some(ty) = types::repr_nullable_ptr(tcx, param_env, adt, ckind) { |
| ty == primitive |
| } else { |
| compare_layouts(a, b).unwrap_or(false) |
| } |
| } |
| // Otherwise, just compare the layouts. This may fail to lint for some |
| // incompatible types, but at the very least, will stop reads into |
| // uninitialised memory. |
| _ => compare_layouts(a, b).unwrap_or(false), |
| } |
| }) |
| } |
| } |