Remove existing AFIDT implementation

3 files changed, 3 insertions, 89 deletions

diff --git a/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs b/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
index 3fceada2510..78a45243983 100644
--- a/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
+++ b/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
@@ -9,7 +9,6 @@ use std::ops::ControlFlow;
 use rustc_errors::FatalError;
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
-use rustc_middle::bug;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::{
     self, EarlyBinder, GenericArgs, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable,
@@ -807,31 +806,8 @@ fn contains_illegal_impl_trait_in_trait<'tcx>(
     let ty = tcx.liberate_late_bound_regions(fn_def_id, ty);
 
     if tcx.asyncness(fn_def_id).is_async() {
-        // FIXME(async_fn_in_dyn_trait): Think of a better way to unify these code paths
-        // to issue an appropriate feature suggestion when users try to use AFIDT.
-        // Obviously we must only do this once AFIDT is finished enough to actually be usable.
-        if tcx.features().async_fn_in_dyn_trait() {
-            let ty::Alias(ty::Projection, proj) = *ty.kind() else {
-                bug!("expected async fn in trait to return an RPITIT");
-            };
-            assert!(tcx.is_impl_trait_in_trait(proj.def_id));
-
-            // FIXME(async_fn_in_dyn_trait): We should check that this bound is legal too,
-            // and stop relying on `async fn` in the definition.
-            for bound in tcx.item_bounds(proj.def_id).instantiate(tcx, proj.args) {
-                if let Some(violation) = bound
-                    .visit_with(&mut IllegalRpititVisitor { tcx, allowed: Some(proj) })
-                    .break_value()
-                {
-                    return Some(violation);
-                }
-            }
-
-            None
-        } else {
-            // Rendering the error as a separate `async-specific` message is better.
-            Some(MethodViolationCode::AsyncFn)
-        }
+        // Rendering the error as a separate `async-specific` message is better.
+        Some(MethodViolationCode::AsyncFn)
     } else {
         ty.visit_with(&mut IllegalRpititVisitor { tcx, allowed: None }).break_value()
     }
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
index 2c60be63bd5..6057b66c483 100644
--- a/compiler/rustc_trait_selection/src/traits/project.rs
+++ b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -7,8 +7,8 @@ use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::DefKind;
 use rustc_hir::lang_items::LangItem;
+use rustc_infer::infer::DefineOpaqueTypes;
 use rustc_infer::infer::resolve::OpportunisticRegionResolver;
-use rustc_infer::infer::{DefineOpaqueTypes, RegionVariableOrigin};
 use rustc_infer::traits::{ObligationCauseCode, PredicateObligations};
 use rustc_middle::traits::select::OverflowError;
 use rustc_middle::traits::{BuiltinImplSource, ImplSource, ImplSourceUserDefinedData};
@@ -18,8 +18,6 @@ use rustc_middle::ty::{
 };
 use rustc_middle::{bug, span_bug};
 use rustc_span::sym;
-use rustc_type_ir::elaborate;
-use thin_vec::thin_vec;
 use tracing::{debug, instrument};
 
 use super::{
@@ -63,9 +61,6 @@ enum ProjectionCandidate<'tcx> {
     /// Bounds specified on an object type
     Object(ty::PolyProjectionPredicate<'tcx>),
 
-    /// Built-in bound for a dyn async fn in trait
-    ObjectRpitit,
-
     /// From an "impl" (or a "pseudo-impl" returned by select)
     Select(Selection<'tcx>),
 }
@@ -832,16 +827,6 @@ fn assemble_candidates_from_object_ty<'cx, 'tcx>(
         env_predicates,
         false,
     );
-
-    // `dyn Trait` automagically project their AFITs to `dyn* Future`.
-    if tcx.is_impl_trait_in_trait(obligation.predicate.def_id)
-        && let Some(out_trait_def_id) = data.principal_def_id()
-        && let rpitit_trait_def_id = tcx.parent(obligation.predicate.def_id)
-        && elaborate::supertrait_def_ids(tcx, out_trait_def_id)
-            .any(|trait_def_id| trait_def_id == rpitit_trait_def_id)
-    {
-        candidate_set.push_candidate(ProjectionCandidate::ObjectRpitit);
-    }
 }
 
 #[instrument(
@@ -1273,8 +1258,6 @@ fn confirm_candidate<'cx, 'tcx>(
         ProjectionCandidate::Select(impl_source) => {
             confirm_select_candidate(selcx, obligation, impl_source)
         }
-
-        ProjectionCandidate::ObjectRpitit => confirm_object_rpitit_candidate(selcx, obligation),
     };
 
     // When checking for cycle during evaluation, we compare predicates with
@@ -2070,45 +2053,6 @@ fn confirm_impl_candidate<'cx, 'tcx>(
     }
 }
 
-fn confirm_object_rpitit_candidate<'cx, 'tcx>(
-    selcx: &mut SelectionContext<'cx, 'tcx>,
-    obligation: &ProjectionTermObligation<'tcx>,
-) -> Progress<'tcx> {
-    let tcx = selcx.tcx();
-    let mut obligations = thin_vec![];
-
-    // Compute an intersection lifetime for all the input components of this GAT.
-    let intersection =
-        selcx.infcx.next_region_var(RegionVariableOrigin::MiscVariable(obligation.cause.span));
-    for component in obligation.predicate.args {
-        match component.unpack() {
-            ty::GenericArgKind::Lifetime(lt) => {
-                obligations.push(obligation.with(tcx, ty::OutlivesPredicate(lt, intersection)));
-            }
-            ty::GenericArgKind::Type(ty) => {
-                obligations.push(obligation.with(tcx, ty::OutlivesPredicate(ty, intersection)));
-            }
-            ty::GenericArgKind::Const(_ct) => {
-                // Consts have no outlives...
-            }
-        }
-    }
-
-    Progress {
-        term: Ty::new_dynamic(
-            tcx,
-            tcx.item_bounds_to_existential_predicates(
-                obligation.predicate.def_id,
-                obligation.predicate.args,
-            ),
-            intersection,
-            ty::DynStar,
-        )
-        .into(),
-        obligations,
-    }
-}
-
 // Get obligations corresponding to the predicates from the where-clause of the
 // associated type itself.
 fn assoc_ty_own_obligations<'cx, 'tcx>(
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
index 4cd6781ab89..4404324d5cd 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -616,12 +616,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         for assoc_type in assoc_types {
             let defs: &ty::Generics = tcx.generics_of(assoc_type);
 
-            // When `async_fn_in_dyn_trait` is enabled, we don't need to check the
-            // RPITIT for compatibility, since it's not provided by the user.
-            if tcx.features().async_fn_in_dyn_trait() && tcx.is_impl_trait_in_trait(assoc_type) {
-                continue;
-            }
-
             if !defs.own_params.is_empty() {
                 tcx.dcx().span_delayed_bug(
                     obligation.cause.span,