Use MIR body to compare "equivalences"

Author: estebank

compiler/rustc_lint/src/default_could_be_derived.rs

@@ -3,7 +3,8 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, DefKind, Res};
-use rustc_middle::ty::Ty;
+use rustc_middle::mir;
+use rustc_middle::ty::{self, Instance, Ty};
 use rustc_session::{declare_lint, declare_lint_pass};
 use rustc_span::Span;
 use rustc_span::symbol::{kw, sym};
@@ -391,42 +392,73 @@ impl<'tcx> LateLintPass<'tcx> for DefaultCouldBeDerived {
     }
 }
 
+/// For the `Default` impl for this type, we see if it has a `Default::default()` body composed
+/// only of a path, ctor or function call with no arguments. If so, we compare that `DefId`
+/// against the `DefId` of this field's value if it is also a call/path/ctor.
+/// If there's a match, it means that the contents of that type's `Default` impl are the
+/// same to what the user wrote on *their* `Default` impl for this field.
 fn check_path<'tcx>(
     cx: &LateContext<'tcx>,
     path: &hir::QPath<'_>,
     hir_id: hir::HirId,
     ty: Ty<'tcx>,
 ) -> bool {
-    let Some(default_def_id) = cx.tcx.get_diagnostic_item(sym::Default) else {
-        return false;
-    };
     let res = cx.qpath_res(&path, hir_id);
     let Some(def_id) = res.opt_def_id() else { return false };
-    if cx.tcx.is_diagnostic_item(sym::default_fn, def_id) {
+    let Some(default_fn_def_id) = cx.tcx.get_diagnostic_item(sym::default_fn) else {
+        return false;
+    };
+    if default_fn_def_id == def_id {
         // We have `field: Default::default(),`. This is what the derive would do already.
         return true;
     }
-    // For every `Default` impl for this type (there should be a single one), we see if it
-    // has a "canonical" `DefId` for a fn call with no arguments, or a path. If it does, we
-    // check that `DefId` with the `DefId` of this field's value if it is also a call/path.
-    // If there's a match, it means that the contents of that type's `Default` impl are the
-    // same to what the user wrote on *their* `Default` impl for this field.
-    let mut equivalents = vec![];
-    cx.tcx.for_each_relevant_impl(default_def_id, ty, |impl_def_id| {
-        let equivalent = match impl_def_id.as_local() {
-            None => cx.tcx.get_default_impl_equivalent(impl_def_id),
-            Some(local) => {
-                let def_kind = cx.tcx.def_kind(impl_def_id);
-                cx.tcx.get_default_equivalent(def_kind, local)
-            }
-        };
-        if let Some(did) = equivalent {
-            equivalents.push(did);
+
+    let args = ty::GenericArgs::for_item(cx.tcx, default_fn_def_id, |param, _| {
+        if let ty::GenericParamDefKind::Lifetime = param.kind {
+            cx.tcx.lifetimes.re_erased.into()
+        } else if param.index == 0 && param.name == kw::SelfUpper {
+            ty.into()
+        } else {
+            param.to_error(cx.tcx)
         }
     });
-    for did in equivalents {
-        if did == def_id {
+    let instance = Instance::try_resolve(cx.tcx, cx.typing_env(), default_fn_def_id, args);
+
+    let Ok(Some(instance)) = instance else { return false };
+    // Get the MIR Body for the `<Ty as Default>::default()` function.
+    // If it is a value or call (either fn or ctor), we compare its DefId against the one for the
+    // resolution of the expression we had in the path.
+    let body = cx.tcx.instance_mir(instance.def);
+    for block_data in body.basic_blocks.iter() {
+        if block_data.statements.len() == 1
+            && let mir::StatementKind::Assign(assign) = &block_data.statements[0].kind
+            && let mir::Rvalue::Aggregate(kind, _places) = &assign.1
+            && let mir::AggregateKind::Adt(did, variant_index, _, _, _) = &**kind
+            && let def = cx.tcx.adt_def(did)
+            && let variant = &def.variant(*variant_index)
+            && variant.fields.is_empty()
+            && let Some((_, did)) = variant.ctor
+            && did == def_id
+        {
             return true;
+        } else if block_data.statements.len() == 0
+            && let Some(term) = &block_data.terminator
+        {
+            match &term.kind {
+                mir::TerminatorKind::Call { func: mir::Operand::Constant(c), .. }
+                    if let ty::FnDef(did, _args) = c.ty().kind()
+                        && *did == def_id =>
+                {
+                    return true;
+                }
+                mir::TerminatorKind::TailCall { func: mir::Operand::Constant(c), .. }
+                    if let ty::FnDef(did, _args) = c.ty().kind()
+                        && *did == def_id =>
+                {
+                    return true;
+                }
+                _ => {}
+            }
         }
     }
     false

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1174,12 +1174,6 @@ impl<'a> CrateMetadataRef<'a> {
         self.root.tables.default_fields.get(self, id).map(|d| d.decode(self))
     }
 
-    /// For a given `impl Default for Ty`, return the "equivalence" for it, namely the `DefId` of
-    /// a path or function with no arguments that get's called from `<Ty as Default>::default()`.
-    fn get_default_impl_equivalent(self, id: DefIndex) -> Option<DefId> {
-        self.root.tables.default_impl_equivalent.get(self, id).map(|d| d.decode(self))
-    }
-
     fn get_trait_item_def_id(self, id: DefIndex) -> Option<DefId> {
         self.root.tables.trait_item_def_id.get(self, id).map(|d| d.decode_from_cdata(self))
     }

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -423,8 +423,6 @@ provide! { tcx, def_id, other, cdata,
         syms
     }
 
-    get_default_impl_equivalent => { cdata.get_default_impl_equivalent(def_id.index) }
-
     crate_extern_paths => { cdata.source().paths().cloned().collect() }
     expn_that_defined => { cdata.get_expn_that_defined(def_id.index, tcx.sess) }
     is_doc_hidden => { cdata.get_attr_flags(def_id.index).contains(AttrFlags::IS_DOC_HIDDEN) }

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1568,10 +1568,6 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 let table = tcx.associated_types_for_impl_traits_in_associated_fn(def_id);
                 record_defaulted_array!(self.tables.associated_types_for_impl_traits_in_associated_fn[def_id] <- table);
             }
-
-            if let Some(path_def_id) = tcx.get_default_equivalent(def_kind, local_id) {
-                record!(self.tables.default_impl_equivalent[def_id] <- path_def_id);
-            }
         }
 
         for (def_id, impls) in &tcx.crate_inherent_impls(()).0.inherent_impls {

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -451,7 +451,6 @@ define_tables! {
     trait_item_def_id: Table<DefIndex, RawDefId>,
     expn_that_defined: Table<DefIndex, LazyValue<ExpnId>>,
     default_fields: Table<DefIndex, LazyValue<DefId>>,
-    default_impl_equivalent: Table<DefIndex, LazyValue<DefId>>,
     params_in_repr: Table<DefIndex, LazyValue<BitSet<u32>>>,
     repr_options: Table<DefIndex, LazyValue<ReprOptions>>,
     // `def_keys` and `def_path_hashes` represent a lazy version of a

compiler/rustc_middle/src/query/mod.rs

@@ -1807,11 +1807,6 @@ rustc_queries! {
         separate_provide_extern
     }
 
-    query get_default_impl_equivalent(def_id: DefId) -> Option<DefId> {
-        desc { |tcx| "looking up the unit variant or fn call with no arguments equivalence for the `Default::default()` of `{}`", tcx.def_path_str(def_id) }
-        separate_provide_extern
-    }
-
     query late_bound_vars_map(owner_id: hir::OwnerId)
         -> &'tcx SortedMap<ItemLocalId, Vec<ty::BoundVariableKind>> {
         desc { |tcx| "looking up late bound vars inside `{}`", tcx.def_path_str(owner_id) }

compiler/rustc_middle/src/ty/context.rs

@@ -29,7 +29,7 @@ use rustc_data_structures::unord::UnordSet;
 use rustc_errors::{
     Applicability, Diag, DiagCtxtHandle, ErrorGuaranteed, LintDiagnostic, MultiSpan,
 };
-use rustc_hir::def::{CtorKind, DefKind, Res};
+use rustc_hir::def::{CtorKind, DefKind};
 use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::definitions::Definitions;
 use rustc_hir::intravisit::Visitor;
@@ -3205,58 +3205,6 @@ impl<'tcx> TyCtxt<'tcx> {
         }
     }
 
-    fn get_expr_equivalent(self, expr: &hir::Expr<'_>) -> Option<DefId> {
-        match &expr.kind {
-            hir::ExprKind::Path(qpath) => {
-                if self.has_typeck_results(expr.hir_id.owner.def_id) {
-                    let res = self.typeck(expr.hir_id.owner.def_id).qpath_res(&qpath, expr.hir_id);
-                    return res.opt_def_id();
-                }
-            }
-            hir::ExprKind::Call(hir::Expr { kind: hir::ExprKind::Path(qpath), hir_id, .. }, []) => {
-                if self.has_typeck_results(expr.hir_id.owner.def_id) {
-                    let res = self.typeck(expr.hir_id.owner.def_id).qpath_res(&qpath, *hir_id);
-                    return res.opt_def_id();
-                }
-            }
-            _ => {}
-        }
-        None
-    }
-
-    /// Given an `impl Default for Ty` item, return the `DefId` of the single path or fn call within
-    /// the `<Ty as Default::default()` function. This is used to compare between a type's
-    /// `Default::defaut()` implementation and what a user has used in their manual `Default` impl
-    /// for a type they control that has a field of type `Ty`.
-    pub fn get_default_equivalent(self, def_kind: DefKind, local_id: LocalDefId) -> Option<DefId> {
-        if (DefKind::Impl { of_trait: true }) == def_kind
-            && let hir::Node::Item(item) = self.hir_node_by_def_id(local_id)
-            && let hir::ItemKind::Impl(data) = item.kind
-            && let Some(trait_ref) = data.of_trait
-            && let Res::Def(DefKind::Trait, trait_def_id) = trait_ref.path.res
-            && let Some(default_def_id) = self.get_diagnostic_item(sym::Default)
-            && Some(trait_def_id) == Some(default_def_id)
-        {
-            let hir = self.hir();
-            for assoc in data.items {
-                let hir::AssocItemKind::Fn { has_self: false } = assoc.kind else { continue };
-                if assoc.ident.name != kw::Default {
-                    continue;
-                }
-                let assoc = hir.impl_item(assoc.id);
-                let hir::ImplItemKind::Fn(_ty, body) = assoc.kind else { continue };
-                let body = hir.body(body);
-                let hir::ExprKind::Block(hir::Block { stmts: [], expr: Some(expr), .. }, None) =
-                    body.value.kind
-                else {
-                    continue;
-                };
-                return self.get_expr_equivalent(&expr);
-            }
-        }
-        None
-    }
-
     /// Whether this is a trait implementation that has `#[diagnostic::do_not_recommend]`
     pub fn do_not_recommend_impl(self, def_id: DefId) -> bool {
         self.get_diagnostic_attr(def_id, sym::do_not_recommend).is_some()