Exclude final methods from dyn-compat check and vtable

Author: mu001999

compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs

@@ -314,6 +314,11 @@ pub fn dyn_compatibility_violations_for_assoc_item(
     trait_def_id: DefId,
     item: ty::AssocItem,
 ) -> Vec<DynCompatibilityViolation> {
+    // `final` assoc functions don't prevent a trait from being dyn-compatible
+    if tcx.defaultness(item.def_id).is_final() {
+        return Vec::new();
+    }
+
     // Any item that has a `Self: Sized` requisite is otherwise exempt from the regulations.
     if tcx.generics_require_sized_self(item.def_id) {
         return Vec::new();

compiler/rustc_trait_selection/src/traits/vtable.rs

@@ -210,6 +210,11 @@ fn own_existential_vtable_entries_iter(
         debug!("own_existential_vtable_entry: trait_method={:?}", trait_method);
         let def_id = trait_method.def_id;
 
+        // Final methods should not be included in the vtable.
+        if trait_method.defaultness(tcx).is_final() {
+            return None;
+        }
+
         // Some methods cannot be called on an object; skip those.
         if !is_vtable_safe_method(tcx, trait_def_id, trait_method) {
             debug!("own_existential_vtable_entry: not vtable safe");

compiler/rustc_ty_utils/src/instance.rs

@@ -237,6 +237,12 @@ fn resolve_associated_item<'tcx>(
         }
         traits::ImplSource::Builtin(BuiltinImplSource::Object(_), _) => {
             let trait_ref = ty::TraitRef::from_assoc(tcx, trait_id, rcvr_args);
+
+            // `final` methods should be called directly.
+            if tcx.defaultness(trait_item_id).is_final() {
+                return Ok(Some(ty::Instance::new_raw(trait_item_id, rcvr_args)));
+            }
+
             if trait_ref.has_non_region_infer() || trait_ref.has_non_region_param() {
                 // We only resolve totally substituted vtable entries.
                 None

tests/ui/traits/final/dyn-compat.rs

@@ -0,0 +1,40 @@
+//@ run-pass
+
+#![feature(final_associated_functions)]
+
+trait FinalNoReceiver {
+    final fn no_receiver() {}
+}
+
+trait FinalGeneric {
+    final fn generic<T>(&self, _value: T) {}
+}
+
+trait FinalSelfParam {
+    final fn self_param(&self, _other: &Self) {}
+}
+
+trait FinalSelfReturn {
+    final fn self_return(&self) -> &Self {
+        self
+    }
+}
+
+struct S;
+
+impl FinalNoReceiver for S {}
+impl FinalGeneric for S {}
+impl FinalSelfParam for S {}
+impl FinalSelfReturn for S {}
+
+fn main() {
+    let s = S;
+    <S as FinalNoReceiver>::no_receiver();
+    let obj_generic: &dyn FinalGeneric = &s;
+    let obj_param: &dyn FinalSelfParam = &s;
+    let obj_return: &dyn FinalSelfReturn = &s;
+    obj_generic.generic(1u8);
+    obj_param.self_param(obj_param);
+    let _ = obj_return.self_return();
+    let _: &dyn FinalNoReceiver = &s;
+}