diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index f541840237742..286bbfb5ae849 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -2585,8 +2585,7 @@ pub enum TyPatKind {
 pub enum TraitObjectSyntax {
     // SAFETY: When adding new variants make sure to update the `Tag` impl.
     Dyn = 0,
-    DynStar = 1,
-    None = 2,
+    None = 1,
 }
 
 /// SAFETY: `TraitObjectSyntax` only has 3 data-less variants which means
@@ -2602,8 +2601,7 @@ unsafe impl Tag for TraitObjectSyntax {
     unsafe fn from_usize(tag: usize) -> Self {
         match tag {
             0 => TraitObjectSyntax::Dyn,
-            1 => TraitObjectSyntax::DynStar,
-            2 => TraitObjectSyntax::None,
+            1 => TraitObjectSyntax::None,
             _ => unreachable!(),
         }
     }
diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index 1ec56868f378f..c7f41fc3cb122 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -505,7 +505,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
     );
     gate_all!(associated_const_equality, "associated const equality is incomplete");
     gate_all!(yeet_expr, "`do yeet` expression is experimental");
-    gate_all!(dyn_star, "`dyn*` trait objects are experimental");
     gate_all!(const_closures, "const closures are experimental");
     gate_all!(builtin_syntax, "`builtin #` syntax is unstable");
     gate_all!(ergonomic_clones, "ergonomic clones are experimental");
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index 3d738fa31f2b3..9802ac90c9a65 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -1303,7 +1303,6 @@ impl<'a> State<'a> {
             ast::TyKind::TraitObject(bounds, syntax) => {
                 match syntax {
                     ast::TraitObjectSyntax::Dyn => self.word_nbsp("dyn"),
-                    ast::TraitObjectSyntax::DynStar => self.word_nbsp("dyn*"),
                     ast::TraitObjectSyntax::None => {}
                 }
                 self.print_type_bounds(bounds);
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index e37b5a33af82c..05bcd9f862efe 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -25,9 +25,9 @@ use rustc_middle::traits::query::NoSolution;
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::cast::CastTy;
 use rustc_middle::ty::{
-    self, Binder, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, CoroutineArgsExt,
-    Dynamic, GenericArgsRef, OpaqueHiddenType, OpaqueTypeKey, RegionVid, Ty, TyCtxt,
-    TypeVisitableExt, UserArgs, UserTypeAnnotationIndex, fold_regions,
+    self, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, CoroutineArgsExt,
+    GenericArgsRef, OpaqueHiddenType, OpaqueTypeKey, RegionVid, Ty, TyCtxt, TypeVisitableExt,
+    UserArgs, UserTypeAnnotationIndex, fold_regions,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_mir_dataflow::move_paths::MoveData;
@@ -1233,38 +1233,6 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                         );
                     }
 
-                    CastKind::PointerCoercion(PointerCoercion::DynStar, coercion_source) => {
-                        // get the constraints from the target type (`dyn* Clone`)
-                        //
-                        // apply them to prove that the source type `Foo` implements `Clone` etc
-                        let (existential_predicates, region) = match ty.kind() {
-                            Dynamic(predicates, region, ty::DynStar) => (predicates, region),
-                            _ => panic!("Invalid dyn* cast_ty"),
-                        };
-
-                        let self_ty = op.ty(self.body, tcx);
-
-                        let is_implicit_coercion = coercion_source == CoercionSource::Implicit;
-                        self.prove_predicates(
-                            existential_predicates
-                                .iter()
-                                .map(|predicate| predicate.with_self_ty(tcx, self_ty)),
-                            location.to_locations(),
-                            ConstraintCategory::Cast { is_implicit_coercion, unsize_to: None },
-                        );
-
-                        let outlives_predicate = tcx.mk_predicate(Binder::dummy(
-                            ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives(
-                                ty::OutlivesPredicate(self_ty, *region),
-                            )),
-                        ));
-                        self.prove_predicate(
-                            outlives_predicate,
-                            location.to_locations(),
-                            ConstraintCategory::Cast { is_implicit_coercion, unsize_to: None },
-                        );
-                    }
-
                     CastKind::PointerCoercion(
                         PointerCoercion::MutToConstPointer,
                         coercion_source,
diff --git a/compiler/rustc_codegen_cranelift/src/abi/mod.rs b/compiler/rustc_codegen_cranelift/src/abi/mod.rs
index 4c6fd90781543..8965e4a944d48 100644
--- a/compiler/rustc_codegen_cranelift/src/abi/mod.rs
+++ b/compiler/rustc_codegen_cranelift/src/abi/mod.rs
@@ -753,51 +753,6 @@ pub(crate) fn codegen_drop<'tcx>(
                 fx.bcx.ins().call_indirect(sig, drop_fn, &[ptr]);
                 fx.bcx.ins().jump(ret_block, &[]);
             }
-            ty::Dynamic(_, _, ty::DynStar) => {
-                // IN THIS ARM, WE HAVE:
-                // ty = *mut (dyn* Trait)
-                // which is: *mut exists<T: sizeof(T) == sizeof(usize)> (T, Vtable<T: Trait>)
-                //
-                // args = [ * ]
-                //          |
-                //          v
-                //      ( Data, Vtable )
-                //                |
-                //                v
-                //              /-------\
-                //              | ...   |
-                //              \-------/
-                //
-                //
-                // WE CAN CONVERT THIS INTO THE ABOVE LOGIC BY DOING
-                //
-                // data = &(*args[0]).0    // gives a pointer to Data above (really the same pointer)
-                // vtable = (*args[0]).1   // loads the vtable out
-                // (data, vtable)          // an equivalent Rust `*mut dyn Trait`
-                //
-                // SO THEN WE CAN USE THE ABOVE CODE.
-                let (data, vtable) = drop_place.to_cvalue(fx).dyn_star_force_data_on_stack(fx);
-                let drop_fn = crate::vtable::drop_fn_of_obj(fx, vtable);
-
-                let is_null = fx.bcx.ins().icmp_imm(IntCC::Equal, drop_fn, 0);
-                let target_block = fx.get_block(target);
-                let continued = fx.bcx.create_block();
-                fx.bcx.ins().brif(is_null, target_block, &[], continued, &[]);
-                fx.bcx.switch_to_block(continued);
-
-                let virtual_drop = Instance {
-                    def: ty::InstanceKind::Virtual(drop_instance.def_id(), 0),
-                    args: drop_instance.args,
-                };
-                let fn_abi = FullyMonomorphizedLayoutCx(fx.tcx)
-                    .fn_abi_of_instance(virtual_drop, ty::List::empty());
-
-                let sig = clif_sig_from_fn_abi(fx.tcx, fx.target_config.default_call_conv, &fn_abi);
-                let sig = fx.bcx.import_signature(sig);
-                fx.bcx.ins().call_indirect(sig, drop_fn, &[data]);
-                // FIXME implement cleanup on exceptions
-                fx.bcx.ins().jump(ret_block, &[]);
-            }
             _ => {
                 assert!(!matches!(drop_instance.def, InstanceKind::Virtual(_, _)));
 
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
index 1b68c6535da5f..bc0a0f034b236 100644
--- a/compiler/rustc_codegen_cranelift/src/base.rs
+++ b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -790,14 +790,6 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
                     let operand = codegen_operand(fx, operand);
                     crate::unsize::coerce_unsized_into(fx, operand, lval);
                 }
-                Rvalue::Cast(
-                    CastKind::PointerCoercion(PointerCoercion::DynStar, _),
-                    ref operand,
-                    _,
-                ) => {
-                    let operand = codegen_operand(fx, operand);
-                    crate::unsize::coerce_dyn_star(fx, operand, lval);
-                }
                 Rvalue::Cast(CastKind::Transmute, ref operand, _to_ty) => {
                     let operand = codegen_operand(fx, operand);
                     lval.write_cvalue_transmute(fx, operand);
diff --git a/compiler/rustc_codegen_cranelift/src/unsize.rs b/compiler/rustc_codegen_cranelift/src/unsize.rs
index df60b05c4636c..2aee0b2e97424 100644
--- a/compiler/rustc_codegen_cranelift/src/unsize.rs
+++ b/compiler/rustc_codegen_cranelift/src/unsize.rs
@@ -112,21 +112,6 @@ fn unsize_ptr<'tcx>(
     }
 }
 
-/// Coerces `src` to `dst_ty` which is guaranteed to be a `dyn*` type.
-pub(crate) fn cast_to_dyn_star<'tcx>(
-    fx: &mut FunctionCx<'_, '_, 'tcx>,
-    src: Value,
-    src_ty_and_layout: TyAndLayout<'tcx>,
-    dst_ty: Ty<'tcx>,
-    old_info: Option<Value>,
-) -> (Value, Value) {
-    assert!(
-        matches!(dst_ty.kind(), ty::Dynamic(_, _, ty::DynStar)),
-        "destination type must be a dyn*"
-    );
-    (src, unsized_info(fx, src_ty_and_layout.ty, dst_ty, old_info))
-}
-
 /// Coerce `src`, which is a reference to a value of type `src_ty`,
 /// to a value of type `dst_ty` and store the result in `dst`
 pub(crate) fn coerce_unsized_into<'tcx>(
@@ -174,24 +159,6 @@ pub(crate) fn coerce_unsized_into<'tcx>(
     }
 }
 
-pub(crate) fn coerce_dyn_star<'tcx>(
-    fx: &mut FunctionCx<'_, '_, 'tcx>,
-    src: CValue<'tcx>,
-    dst: CPlace<'tcx>,
-) {
-    let (data, extra) = if let ty::Dynamic(_, _, ty::DynStar) = src.layout().ty.kind() {
-        let (data, vtable) = src.load_scalar_pair(fx);
-        (data, Some(vtable))
-    } else {
-        let data = src.load_scalar(fx);
-        (data, None)
-    };
-
-    let (data, vtable) = cast_to_dyn_star(fx, data, src.layout(), dst.layout().ty, extra);
-
-    dst.write_cvalue(fx, CValue::by_val_pair(data, vtable, dst.layout()));
-}
-
 // Adapted from https://github.com/rust-lang/rust/blob/2a663555ddf36f6b041445894a8c175cd1bc718c/src/librustc_codegen_ssa/glue.rs
 
 pub(crate) fn size_and_align_of<'tcx>(
diff --git a/compiler/rustc_codegen_cranelift/src/value_and_place.rs b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
index cbfb215a892a4..9d73f200afe2b 100644
--- a/compiler/rustc_codegen_cranelift/src/value_and_place.rs
+++ b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
@@ -121,43 +121,6 @@ impl<'tcx> CValue<'tcx> {
         }
     }
 
-    // FIXME remove
-    /// Forces the data value of a dyn* value to the stack and returns a pointer to it as well as the
-    /// vtable pointer.
-    pub(crate) fn dyn_star_force_data_on_stack(
-        self,
-        fx: &mut FunctionCx<'_, '_, 'tcx>,
-    ) -> (Value, Value) {
-        assert!(self.1.ty.is_dyn_star());
-
-        match self.0 {
-            CValueInner::ByRef(ptr, None) => {
-                let (a_scalar, b_scalar) = match self.1.backend_repr {
-                    BackendRepr::ScalarPair(a, b) => (a, b),
-                    _ => unreachable!("dyn_star_force_data_on_stack({:?})", self),
-                };
-                let b_offset = scalar_pair_calculate_b_offset(fx.tcx, a_scalar, b_scalar);
-                let clif_ty2 = scalar_to_clif_type(fx.tcx, b_scalar);
-                let mut flags = MemFlags::new();
-                flags.set_notrap();
-                let vtable = ptr.offset(fx, b_offset).load(fx, clif_ty2, flags);
-                (ptr.get_addr(fx), vtable)
-            }
-            CValueInner::ByValPair(data, vtable) => {
-                let data_ptr = fx.create_stack_slot(
-                    u32::try_from(fx.target_config.pointer_type().bytes()).unwrap(),
-                    u32::try_from(fx.target_config.pointer_type().bytes()).unwrap(),
-                );
-                data_ptr.store(fx, data, MemFlags::trusted());
-
-                (data_ptr.get_addr(fx), vtable)
-            }
-            CValueInner::ByRef(_, Some(_)) | CValueInner::ByVal(_) => {
-                unreachable!("dyn_star_force_data_on_stack({:?})", self)
-            }
-        }
-    }
-
     pub(crate) fn try_to_ptr(self) -> Option<(Pointer, Option<Value>)> {
         match self.0 {
             CValueInner::ByRef(ptr, meta) => Some((ptr, meta)),
diff --git a/compiler/rustc_codegen_cranelift/src/vtable.rs b/compiler/rustc_codegen_cranelift/src/vtable.rs
index 1fae56949bc05..423cc8d225be1 100644
--- a/compiler/rustc_codegen_cranelift/src/vtable.rs
+++ b/compiler/rustc_codegen_cranelift/src/vtable.rs
@@ -46,34 +46,22 @@ pub(crate) fn get_ptr_and_method_ref<'tcx>(
     mut arg: CValue<'tcx>,
     idx: usize,
 ) -> (Pointer, Value) {
-    let (ptr, vtable) = 'block: {
-        if let BackendRepr::Scalar(_) = arg.layout().backend_repr {
-            while !arg.layout().ty.is_raw_ptr() && !arg.layout().ty.is_ref() {
-                let (idx, _) = arg
-                    .layout()
-                    .non_1zst_field(fx)
-                    .expect("not exactly one non-1-ZST field in a `DispatchFromDyn` type");
-                arg = arg.value_field(fx, idx);
-            }
-        }
-
-        if let ty::Ref(_, ty, _) = arg.layout().ty.kind() {
-            if ty.is_dyn_star() {
-                let inner_layout = fx.layout_of(arg.layout().ty.builtin_deref(true).unwrap());
-                let dyn_star = CPlace::for_ptr(Pointer::new(arg.load_scalar(fx)), inner_layout);
-                let ptr = dyn_star.place_field(fx, FieldIdx::ZERO).to_ptr();
-                let vtable = dyn_star.place_field(fx, FieldIdx::ONE).to_cvalue(fx).load_scalar(fx);
-                break 'block (ptr, vtable);
-            }
+    if let BackendRepr::Scalar(_) = arg.layout().backend_repr {
+        while !arg.layout().ty.is_raw_ptr() && !arg.layout().ty.is_ref() {
+            let (idx, _) = arg
+                .layout()
+                .non_1zst_field(fx)
+                .expect("not exactly one non-1-ZST field in a `DispatchFromDyn` type");
+            arg = arg.value_field(fx, idx);
         }
+    }
 
-        if let BackendRepr::ScalarPair(_, _) = arg.layout().backend_repr {
-            let (ptr, vtable) = arg.load_scalar_pair(fx);
-            (Pointer::new(ptr), vtable)
-        } else {
-            let (ptr, vtable) = arg.try_to_ptr().unwrap();
-            (ptr, vtable.unwrap())
-        }
+    let (ptr, vtable) = if let BackendRepr::ScalarPair(_, _) = arg.layout().backend_repr {
+        let (ptr, vtable) = arg.load_scalar_pair(fx);
+        (Pointer::new(ptr), vtable)
+    } else {
+        let (ptr, vtable) = arg.try_to_ptr().unwrap();
+        (ptr, vtable.unwrap())
     };
 
     let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes();
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index b06cfd1e4730e..102d4ea2fa6cf 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -262,28 +262,6 @@ pub(crate) fn unsize_ptr<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     }
 }
 
-/// Coerces `src` to `dst_ty` which is guaranteed to be a `dyn*` type.
-pub(crate) fn cast_to_dyn_star<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
-    bx: &mut Bx,
-    src: Bx::Value,
-    src_ty_and_layout: TyAndLayout<'tcx>,
-    dst_ty: Ty<'tcx>,
-    old_info: Option<Bx::Value>,
-) -> (Bx::Value, Bx::Value) {
-    debug!("cast_to_dyn_star: {:?} => {:?}", src_ty_and_layout.ty, dst_ty);
-    assert!(
-        matches!(dst_ty.kind(), ty::Dynamic(_, _, ty::DynStar)),
-        "destination type must be a dyn*"
-    );
-    let src = match bx.cx().type_kind(bx.cx().backend_type(src_ty_and_layout)) {
-        TypeKind::Pointer => src,
-        TypeKind::Integer => bx.inttoptr(src, bx.type_ptr()),
-        // FIXME(dyn-star): We probably have to do a bitcast first, then inttoptr.
-        kind => bug!("unexpected TypeKind for left-hand side of `dyn*` cast: {kind:?}"),
-    };
-    (src, unsized_info(bx, src_ty_and_layout.ty, dst_ty, old_info))
-}
-
 /// Coerces `src`, which is a reference to a value of type `src_ty`,
 /// to a value of type `dst_ty`, and stores the result in `dst`.
 pub(crate) fn coerce_unsized_into<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index 1d5fbfc0896d2..bde63fd501aa2 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -628,50 +628,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     virtual_drop,
                 )
             }
-            ty::Dynamic(_, _, ty::DynStar) => {
-                // IN THIS ARM, WE HAVE:
-                // ty = *mut (dyn* Trait)
-                // which is: *mut exists<T: sizeof(T) == sizeof(usize)> (T, Vtable<T: Trait>)
-                //
-                // args = [ * ]
-                //          |
-                //          v
-                //      ( Data, Vtable )
-                //                |
-                //                v
-                //              /-------\
-                //              | ...   |
-                //              \-------/
-                //
-                //
-                // WE CAN CONVERT THIS INTO THE ABOVE LOGIC BY DOING
-                //
-                // data = &(*args[0]).0    // gives a pointer to Data above (really the same pointer)
-                // vtable = (*args[0]).1   // loads the vtable out
-                // (data, vtable)          // an equivalent Rust `*mut dyn Trait`
-                //
-                // SO THEN WE CAN USE THE ABOVE CODE.
-                let virtual_drop = Instance {
-                    def: ty::InstanceKind::Virtual(drop_fn.def_id(), 0), // idx 0: the drop function
-                    args: drop_fn.args,
-                };
-                debug!("ty = {:?}", ty);
-                debug!("drop_fn = {:?}", drop_fn);
-                debug!("args = {:?}", args);
-                let fn_abi = bx.fn_abi_of_instance(virtual_drop, ty::List::empty());
-                let meta_ptr = place.project_field(bx, 1);
-                let meta = bx.load_operand(meta_ptr);
-                // Truncate vtable off of args list
-                args = &args[..1];
-                debug!("args' = {:?}", args);
-                (
-                    true,
-                    meth::VirtualIndex::from_index(ty::COMMON_VTABLE_ENTRIES_DROPINPLACE)
-                        .get_optional_fn(bx, meta.immediate(), ty, fn_abi),
-                    fn_abi,
-                    virtual_drop,
-                )
-            }
             _ => (
                 false,
                 bx.get_fn_addr(drop_fn),
@@ -1108,33 +1064,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         llargs.push(data_ptr);
                         continue;
                     }
-                    Immediate(_) => {
-                        // See comment above explaining why we peel these newtypes
-                        while !op.layout.ty.is_raw_ptr() && !op.layout.ty.is_ref() {
-                            let (idx, _) = op.layout.non_1zst_field(bx).expect(
-                                "not exactly one non-1-ZST field in a `DispatchFromDyn` type",
-                            );
-                            op = op.extract_field(self, bx, idx.as_usize());
-                        }
-
-                        // Make sure that we've actually unwrapped the rcvr down
-                        // to a pointer or ref to `dyn* Trait`.
-                        if !op.layout.ty.builtin_deref(true).unwrap().is_dyn_star() {
-                            span_bug!(fn_span, "can't codegen a virtual call on {:#?}", op);
-                        }
-                        let place = op.deref(bx.cx());
-                        let data_place = place.project_field(bx, 0);
-                        let meta_place = place.project_field(bx, 1);
-                        let meta = bx.load_operand(meta_place);
-                        llfn = Some(meth::VirtualIndex::from_index(idx).get_fn(
-                            bx,
-                            meta.immediate(),
-                            op.layout.ty,
-                            fn_abi,
-                        ));
-                        llargs.push(data_place.val.llval);
-                        continue;
-                    }
                     _ => {
                         span_bug!(fn_span, "can't codegen a virtual call on {:#?}", op);
                     }
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index db5ac6a514fb4..7ef04213d3207 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -468,12 +468,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                             bug!("unexpected non-pair operand");
                         }
                     }
-                    mir::CastKind::PointerCoercion(PointerCoercion::DynStar, _) => {
-                        let (lldata, llextra) = operand.val.pointer_parts();
-                        let (lldata, llextra) =
-                            base::cast_to_dyn_star(bx, lldata, operand.layout, cast.ty, llextra);
-                        OperandValue::Pair(lldata, llextra)
-                    }
                     | mir::CastKind::IntToInt
                     | mir::CastKind::FloatToInt
                     | mir::CastKind::FloatToFloat
diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
index c1d91f98957ef..0eb6f28bdb373 100644
--- a/compiler/rustc_const_eval/src/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -638,14 +638,6 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                 // These are all okay; they only change the type, not the data.
             }
 
-            Rvalue::Cast(
-                CastKind::PointerCoercion(PointerCoercion::Unsize | PointerCoercion::DynStar, _),
-                _,
-                _,
-            ) => {
-                // Unsizing and `dyn*` coercions are implemented for CTFE.
-            }
-
             Rvalue::Cast(CastKind::PointerExposeProvenance, _, _) => {
                 self.check_op(ops::RawPtrToIntCast);
             }
diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs
index 79c14b204e367..ebaa5a97a4aed 100644
--- a/compiler/rustc_const_eval/src/interpret/call.rs
+++ b/compiler/rustc_const_eval/src/interpret/call.rs
@@ -643,13 +643,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                             break self.ref_to_mplace(&val)?;
                         }
                         ty::Dynamic(.., ty::Dyn) => break receiver.assert_mem_place(), // no immediate unsized values
-                        ty::Dynamic(.., ty::DynStar) => {
-                            // Not clear how to handle this, so far we assume the receiver is always a pointer.
-                            span_bug!(
-                                self.cur_span(),
-                                "by-value calls on a `dyn*`... are those a thing?"
-                            );
-                        }
                         _ => {
                             // Not there yet, search for the only non-ZST field.
                             // (The rules for `DispatchFromDyn` ensure there's exactly one such field.)
@@ -662,39 +655,23 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 };
 
                 // Obtain the underlying trait we are working on, and the adjusted receiver argument.
-                let (trait_, dyn_ty, adjusted_recv) = if let ty::Dynamic(data, _, ty::DynStar) =
-                    receiver_place.layout.ty.kind()
-                {
-                    let recv = self.unpack_dyn_star(&receiver_place, data)?;
-
-                    (data.principal(), recv.layout.ty, recv.ptr())
-                } else {
-                    // Doesn't have to be a `dyn Trait`, but the unsized tail must be `dyn Trait`.
-                    // (For that reason we also cannot use `unpack_dyn_trait`.)
-                    let receiver_tail =
-                        self.tcx.struct_tail_for_codegen(receiver_place.layout.ty, self.typing_env);
-                    let ty::Dynamic(receiver_trait, _, ty::Dyn) = receiver_tail.kind() else {
-                        span_bug!(
-                            self.cur_span(),
-                            "dynamic call on non-`dyn` type {}",
-                            receiver_tail
-                        )
-                    };
-                    assert!(receiver_place.layout.is_unsized());
-
-                    // Get the required information from the vtable.
-                    let vptr = receiver_place.meta().unwrap_meta().to_pointer(self)?;
-                    let dyn_ty = self.get_ptr_vtable_ty(vptr, Some(receiver_trait))?;
-
-                    // It might be surprising that we use a pointer as the receiver even if this
-                    // is a by-val case; this works because by-val passing of an unsized `dyn
-                    // Trait` to a function is actually desugared to a pointer.
-                    (receiver_trait.principal(), dyn_ty, receiver_place.ptr())
+                // Doesn't have to be a `dyn Trait`, but the unsized tail must be `dyn Trait`.
+                // (For that reason we also cannot use `unpack_dyn_trait`.)
+                let receiver_tail =
+                    self.tcx.struct_tail_for_codegen(receiver_place.layout.ty, self.typing_env);
+                let ty::Dynamic(receiver_trait, _, ty::Dyn) = receiver_tail.kind() else {
+                    span_bug!(self.cur_span(), "dynamic call on non-`dyn` type {}", receiver_tail)
                 };
+                assert!(receiver_place.layout.is_unsized());
+
+                // Get the required information from the vtable.
+                let vptr = receiver_place.meta().unwrap_meta().to_pointer(self)?;
+                let dyn_ty = self.get_ptr_vtable_ty(vptr, Some(receiver_trait))?;
+                let adjusted_recv = receiver_place.ptr();
 
                 // Now determine the actual method to call. Usually we use the easy way of just
                 // looking up the method at index `idx`.
-                let vtable_entries = self.vtable_entries(trait_, dyn_ty);
+                let vtable_entries = self.vtable_entries(receiver_trait.principal(), dyn_ty);
                 let Some(ty::VtblEntry::Method(fn_inst)) = vtable_entries.get(idx).copied() else {
                     // FIXME(fee1-dead) these could be variants of the UB info enum instead of this
                     throw_ub_custom!(fluent::const_eval_dyn_call_not_a_method);
@@ -830,10 +807,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 // Dropping a trait object. Need to find actual drop fn.
                 self.unpack_dyn_trait(&place, data)?
             }
-            ty::Dynamic(data, _, ty::DynStar) => {
-                // Dropping a `dyn*`. Need to find actual drop fn.
-                self.unpack_dyn_star(&place, data)?
-            }
             _ => {
                 debug_assert_eq!(
                     instance,
diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs
index 1036935bb106a..7a73d70fc85dc 100644
--- a/compiler/rustc_const_eval/src/interpret/cast.rs
+++ b/compiler/rustc_const_eval/src/interpret/cast.rs
@@ -126,20 +126,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 }
             }
 
-            CastKind::PointerCoercion(PointerCoercion::DynStar, _) => {
-                if let ty::Dynamic(data, _, ty::DynStar) = cast_ty.kind() {
-                    // Initial cast from sized to dyn trait
-                    let vtable = self.get_vtable_ptr(src.layout.ty, data)?;
-                    let vtable = Scalar::from_maybe_pointer(vtable, self);
-                    let data = self.read_immediate(src)?.to_scalar();
-                    let _assert_pointer_like = data.to_pointer(self)?;
-                    let val = Immediate::ScalarPair(data, vtable);
-                    self.write_immediate(val, dest)?;
-                } else {
-                    bug!()
-                }
-            }
-
             CastKind::Transmute => {
                 assert!(src.layout.is_sized());
                 assert!(dest.layout.is_sized());
diff --git a/compiler/rustc_const_eval/src/interpret/stack.rs b/compiler/rustc_const_eval/src/interpret/stack.rs
index 3361a586b8eef..543d68d7f4519 100644
--- a/compiler/rustc_const_eval/src/interpret/stack.rs
+++ b/compiler/rustc_const_eval/src/interpret/stack.rs
@@ -499,8 +499,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 | ty::Closure(..)
                 | ty::CoroutineClosure(..)
                 | ty::Never
-                | ty::Error(_)
-                | ty::Dynamic(_, _, ty::DynStar) => true,
+                | ty::Error(_) => true,
 
                 ty::Str | ty::Slice(_) | ty::Dynamic(_, _, ty::Dyn) | ty::Foreign(..) => false,
 
diff --git a/compiler/rustc_const_eval/src/interpret/traits.rs b/compiler/rustc_const_eval/src/interpret/traits.rs
index 8b634955bb796..e4b5c82853a28 100644
--- a/compiler/rustc_const_eval/src/interpret/traits.rs
+++ b/compiler/rustc_const_eval/src/interpret/traits.rs
@@ -1,4 +1,4 @@
-use rustc_abi::{Align, FieldIdx, Size};
+use rustc_abi::{Align, Size};
 use rustc_middle::mir::interpret::{InterpResult, Pointer};
 use rustc_middle::ty::{self, ExistentialPredicateStableCmpExt, Ty, TyCtxt, VtblEntry};
 use tracing::trace;
@@ -125,24 +125,4 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         )?;
         interp_ok(mplace)
     }
-
-    /// Turn a `dyn* Trait` type into an value with the actual dynamic type.
-    pub(super) fn unpack_dyn_star<P: Projectable<'tcx, M::Provenance>>(
-        &self,
-        val: &P,
-        expected_trait: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
-    ) -> InterpResult<'tcx, P> {
-        assert!(
-            matches!(val.layout().ty.kind(), ty::Dynamic(_, _, ty::DynStar)),
-            "`unpack_dyn_star` only makes sense on `dyn*` types"
-        );
-        let data = self.project_field(val, FieldIdx::ZERO)?;
-        let vtable = self.project_field(val, FieldIdx::ONE)?;
-        let vtable = self.read_pointer(&vtable.to_op(self)?)?;
-        let ty = self.get_ptr_vtable_ty(vtable, Some(expected_trait))?;
-        // `data` is already the right thing but has the wrong type. So we transmute it.
-        let layout = self.layout_of(ty)?;
-        let data = data.transmute(layout, self)?;
-        interp_ok(data)
-    }
 }
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 7268001938021..e26cf0a4900f1 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -358,9 +358,6 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
             // arrays/slices
             ty::Array(..) | ty::Slice(..) => PathElem::ArrayElem(field),
 
-            // dyn* vtables
-            ty::Dynamic(_, _, ty::DynKind::DynStar) if field == 1 => PathElem::Vtable,
-
             // dyn traits
             ty::Dynamic(..) => {
                 assert_eq!(field, 0);
diff --git a/compiler/rustc_const_eval/src/interpret/visitor.rs b/compiler/rustc_const_eval/src/interpret/visitor.rs
index d5970b69baf79..a27b664613159 100644
--- a/compiler/rustc_const_eval/src/interpret/visitor.rs
+++ b/compiler/rustc_const_eval/src/interpret/visitor.rs
@@ -101,26 +101,6 @@ pub trait ValueVisitor<'tcx, M: Machine<'tcx>>: Sized {
                 // recurse with the inner type
                 return self.visit_field(v, 0, &inner_mplace.into());
             }
-            ty::Dynamic(data, _, ty::DynStar) => {
-                // DynStar types. Very different from a dyn type (but strangely part of the
-                // same variant in `TyKind`): These are pairs where the 2nd component is the
-                // vtable, and the first component is the data (which must be ptr-sized).
-
-                // First make sure the vtable can be read at its type.
-                // The type of this vtable is fake, it claims to be a reference to some actual memory but that isn't true.
-                // So we transmute it to a raw pointer.
-                let raw_ptr_ty = Ty::new_mut_ptr(*self.ecx().tcx, self.ecx().tcx.types.unit);
-                let raw_ptr_ty = self.ecx().layout_of(raw_ptr_ty)?;
-                let vtable_field = self
-                    .ecx()
-                    .project_field(v, FieldIdx::ONE)?
-                    .transmute(raw_ptr_ty, self.ecx())?;
-                self.visit_field(v, 1, &vtable_field)?;
-
-                // Then unpack the first field, and continue.
-                let data = self.ecx().unpack_dyn_star(v, data)?;
-                return self.visit_field(v, 0, &data);
-            }
             // Slices do not need special handling here: they have `Array` field
             // placement with length 0, so we enter the `Array` case below which
             // indirectly uses the metadata to determine the actual length.
diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs
index a855e4c1b0ef2..10fcf744fbcf3 100644
--- a/compiler/rustc_feature/src/removed.rs
+++ b/compiler/rustc_feature/src/removed.rs
@@ -123,6 +123,9 @@ declare_features! (
     /// [^1]: Formerly known as "object safe".
     (removed, dyn_compatible_for_dispatch, "1.87.0", Some(43561),
      Some("removed, not used heavily and represented additional complexity in dyn compatibility"), 136522),
+    /// Allows `dyn* Trait` objects.
+    (removed, dyn_star, "1.65.0", Some(102425),
+     Some("removed as it was no longer necessary for AFIDT (async fn in dyn trait) support")),
     /// Uses generic effect parameters for [const] bounds
     (removed, effects, "1.84.0", Some(102090),
      Some("removed, redundant with `#![feature(const_trait_impl)]`"), 132479),
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 719ba597da190..ea6c38a65c169 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -481,8 +481,6 @@ declare_features! (
     (unstable, doc_cfg_hide, "1.57.0", Some(43781)),
     /// Allows `#[doc(masked)]`.
     (unstable, doc_masked, "1.21.0", Some(44027)),
-    /// Allows `dyn* Trait` objects.
-    (incomplete, dyn_star, "1.65.0", Some(102425)),
     /// Allows the .use postfix syntax `x.use` and use closures `use |x| { ... }`
     (incomplete, ergonomic_clones, "1.87.0", Some(132290)),
     /// Allows exhaustive pattern matching on types that contain uninhabited types.
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 1fdee975e07a3..3fb62d3bdf4a4 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -956,7 +956,7 @@ impl<'hir> Generics<'hir> {
                     && let Some(ret_ty) = segment.args().paren_sugar_output()
                     && let ret_ty = ret_ty.peel_refs()
                     && let TyKind::TraitObject(_, tagged_ptr) = ret_ty.kind
-                    && let TraitObjectSyntax::Dyn | TraitObjectSyntax::DynStar = tagged_ptr.tag()
+                    && let TraitObjectSyntax::Dyn = tagged_ptr.tag()
                     && ret_ty.span.can_be_used_for_suggestions()
                 {
                     Some(ret_ty.span)
diff --git a/compiler/rustc_hir/src/hir/tests.rs b/compiler/rustc_hir/src/hir/tests.rs
index 1fd793bc1616f..4f9609fd360d7 100644
--- a/compiler/rustc_hir/src/hir/tests.rs
+++ b/compiler/rustc_hir/src/hir/tests.rs
@@ -45,7 +45,6 @@ define_tests! {
 #[test]
 fn trait_object_roundtrips() {
     trait_object_roundtrips_impl(TraitObjectSyntax::Dyn);
-    trait_object_roundtrips_impl(TraitObjectSyntax::DynStar);
     trait_object_roundtrips_impl(TraitObjectSyntax::None);
 }
 
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 55bf2ab6b50e1..6b2854d96af61 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2433,7 +2433,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 } else {
                     let repr = match repr {
                         TraitObjectSyntax::Dyn | TraitObjectSyntax::None => ty::Dyn,
-                        TraitObjectSyntax::DynStar => ty::DynStar,
                     };
                     self.lower_trait_object_ty(hir_ty.span, hir_ty.hir_id, bounds, lifetime, repr)
                 }
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index e00c22c47aa7d..c523a03e012e4 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -420,7 +420,6 @@ impl<'a> State<'a> {
                 let syntax = lifetime.tag();
                 match syntax {
                     ast::TraitObjectSyntax::Dyn => self.word_nbsp("dyn"),
-                    ast::TraitObjectSyntax::DynStar => self.word_nbsp("dyn*"),
                     ast::TraitObjectSyntax::None => {}
                 }
                 let mut first = true;
diff --git a/compiler/rustc_hir_typeck/src/cast.rs b/compiler/rustc_hir_typeck/src/cast.rs
index 6f8abc1e67d29..3eeb0eac023a9 100644
--- a/compiler/rustc_hir_typeck/src/cast.rs
+++ b/compiler/rustc_hir_typeck/src/cast.rs
@@ -143,7 +143,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             | ty::Coroutine(..)
             | ty::Adt(..)
             | ty::Never
-            | ty::Dynamic(_, _, ty::DynStar)
             | ty::Error(_) => {
                 let guar = self
                     .dcx()
@@ -734,14 +733,6 @@ impl<'a, 'tcx> CastCheck<'tcx> {
         use rustc_middle::ty::cast::CastTy::*;
         use rustc_middle::ty::cast::IntTy::*;
 
-        if self.cast_ty.is_dyn_star() {
-            // This coercion will fail if the feature is not enabled, OR
-            // if the coercion is (currently) illegal (e.g. `dyn* Foo + Send`
-            // to `dyn* Foo`). Report "casting is invalid" rather than
-            // "non-primitive cast".
-            return Err(CastError::IllegalCast);
-        }
-
         let (t_from, t_cast) = match (CastTy::from_ty(self.expr_ty), CastTy::from_ty(self.cast_ty))
         {
             (Some(t_from), Some(t_cast)) => (t_from, t_cast),
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index 57d3c5da87344..3ca04ba330bd7 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -231,9 +231,6 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             ty::Ref(r_b, _, mutbl_b) => {
                 return self.coerce_borrowed_pointer(a, b, r_b, mutbl_b);
             }
-            ty::Dynamic(predicates, region, ty::DynStar) if self.tcx.features().dyn_star() => {
-                return self.coerce_dyn_star(a, b, predicates, region);
-            }
             ty::Adt(pin, _)
                 if self.tcx.features().pin_ergonomics()
                     && self.tcx.is_lang_item(pin.did(), hir::LangItem::Pin) =>
@@ -773,71 +770,6 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         Ok(coercion)
     }
 
-    fn coerce_dyn_star(
-        &self,
-        a: Ty<'tcx>,
-        b: Ty<'tcx>,
-        predicates: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
-        b_region: ty::Region<'tcx>,
-    ) -> CoerceResult<'tcx> {
-        if !self.tcx.features().dyn_star() {
-            return Err(TypeError::Mismatch);
-        }
-
-        // FIXME(dyn_star): We should probably allow things like casting from
-        // `dyn* Foo + Send` to `dyn* Foo`.
-        if let ty::Dynamic(a_data, _, ty::DynStar) = a.kind()
-            && let ty::Dynamic(b_data, _, ty::DynStar) = b.kind()
-            && a_data.principal_def_id() == b_data.principal_def_id()
-        {
-            return self.unify(a, b);
-        }
-
-        // Check the obligations of the cast -- for example, when casting
-        // `usize` to `dyn* Clone + 'static`:
-        let obligations = predicates
-            .iter()
-            .map(|predicate| {
-                // For each existential predicate (e.g., `?Self: Clone`) instantiate
-                // the type of the expression (e.g., `usize` in our example above)
-                // and then require that the resulting predicate (e.g., `usize: Clone`)
-                // holds (it does).
-                let predicate = predicate.with_self_ty(self.tcx, a);
-                Obligation::new(self.tcx, self.cause.clone(), self.param_env, predicate)
-            })
-            .chain([
-                // Enforce the region bound (e.g., `usize: 'static`, in our example).
-                Obligation::new(
-                    self.tcx,
-                    self.cause.clone(),
-                    self.param_env,
-                    ty::Binder::dummy(ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives(
-                        ty::OutlivesPredicate(a, b_region),
-                    ))),
-                ),
-                // Enforce that the type is `usize`/pointer-sized.
-                Obligation::new(
-                    self.tcx,
-                    self.cause.clone(),
-                    self.param_env,
-                    ty::TraitRef::new(
-                        self.tcx,
-                        self.tcx.require_lang_item(hir::LangItem::PointerLike, self.cause.span),
-                        [a],
-                    ),
-                ),
-            ])
-            .collect();
-
-        Ok(InferOk {
-            value: (
-                vec![Adjustment { kind: Adjust::Pointer(PointerCoercion::DynStar), target: b }],
-                b,
-            ),
-            obligations,
-        })
-    }
-
     /// Applies reborrowing for `Pin`
     ///
     /// We currently only support reborrowing `Pin<&mut T>` as `Pin<&mut T>`. This is accomplished
diff --git a/compiler/rustc_middle/src/ty/adjustment.rs b/compiler/rustc_middle/src/ty/adjustment.rs
index 3bacdfe5ac880..74573455f531a 100644
--- a/compiler/rustc_middle/src/ty/adjustment.rs
+++ b/compiler/rustc_middle/src/ty/adjustment.rs
@@ -36,9 +36,6 @@ pub enum PointerCoercion {
     /// type. Codegen backends and miri figure out what has to be done
     /// based on the precise source/target type at hand.
     Unsize,
-
-    /// Go from a pointer-like type to a `dyn*` object.
-    DynStar,
 }
 
 /// Represents coercing a value to a different type of value.
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index 90b832df281f0..09379d9d8059f 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -946,21 +946,6 @@ where
                     }
                 }
 
-                ty::Dynamic(_, _, ty::DynStar) => {
-                    if i == 0 {
-                        TyMaybeWithLayout::Ty(Ty::new_mut_ptr(tcx, tcx.types.unit))
-                    } else if i == 1 {
-                        // FIXME(dyn-star) same FIXME as above applies here too
-                        TyMaybeWithLayout::Ty(Ty::new_imm_ref(
-                            tcx,
-                            tcx.lifetimes.re_static,
-                            Ty::new_array(tcx, tcx.types.usize, 3),
-                        ))
-                    } else {
-                        bug!("no field {i} on dyn*")
-                    }
-                }
-
                 ty::Alias(..)
                 | ty::Bound(..)
                 | ty::Placeholder(..)
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index bee490b3648b9..b4c4f48a0a6c2 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -810,7 +810,6 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                 }
                 match repr {
                     ty::Dyn => p!("dyn "),
-                    ty::DynStar => p!("dyn* "),
                 }
                 p!(print(data));
                 if print_r {
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index 3971ac13bbe05..399a6d6ebc525 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -1321,11 +1321,6 @@ impl<'tcx> Ty<'tcx> {
         matches!(self.kind(), Dynamic(_, _, ty::Dyn))
     }
 
-    #[inline]
-    pub fn is_dyn_star(self) -> bool {
-        matches!(self.kind(), Dynamic(_, _, ty::DynStar))
-    }
-
     #[inline]
     pub fn is_enum(self) -> bool {
         matches!(self.kind(), Adt(adt_def, _) if adt_def.is_enum())
@@ -1629,8 +1624,6 @@ impl<'tcx> Ty<'tcx> {
             | ty::Error(_)
             // Extern types have metadata = ().
             | ty::Foreign(..)
-            // `dyn*` has metadata = ().
-            | ty::Dynamic(_, _, ty::DynStar)
             // If returned by `struct_tail_raw` this is a unit struct
             // without any fields, or not a struct, and therefore is Sized.
             | ty::Adt(..)
@@ -1820,8 +1813,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Never
-            | ty::Error(_)
-            | ty::Dynamic(_, _, ty::DynStar) => true,
+            | ty::Error(_) => true,
 
             ty::Str | ty::Slice(_) | ty::Dynamic(_, _, ty::Dyn) => match sizedness {
                 SizedTraitKind::Sized => false,
diff --git a/compiler/rustc_mir_transform/src/mentioned_items.rs b/compiler/rustc_mir_transform/src/mentioned_items.rs
index 9fd8d81d64a26..f011d394f6162 100644
--- a/compiler/rustc_mir_transform/src/mentioned_items.rs
+++ b/compiler/rustc_mir_transform/src/mentioned_items.rs
@@ -74,8 +74,7 @@ impl<'tcx> Visitor<'tcx> for MentionedItemsVisitor<'_, 'tcx> {
         match *rvalue {
             // We need to detect unsizing casts that required vtables.
             mir::Rvalue::Cast(
-                mir::CastKind::PointerCoercion(PointerCoercion::Unsize, _)
-                | mir::CastKind::PointerCoercion(PointerCoercion::DynStar, _),
+                mir::CastKind::PointerCoercion(PointerCoercion::Unsize, _),
                 ref operand,
                 target_ty,
             ) => {
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
index 7dcdd7999f285..cbb9bbfd12f9f 100644
--- a/compiler/rustc_mir_transform/src/validate.rs
+++ b/compiler/rustc_mir_transform/src/validate.rs
@@ -1260,9 +1260,6 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                             self.fail(location, format!("Unsize coercion, but `{op_ty}` isn't coercible to `{target_type}`"));
                         }
                     }
-                    CastKind::PointerCoercion(PointerCoercion::DynStar, _) => {
-                        // FIXME(dyn-star): make sure nothing needs to be done here.
-                    }
                     CastKind::IntToInt | CastKind::IntToFloat => {
                         let input_valid = op_ty.is_integral() || op_ty.is_char() || op_ty.is_bool();
                         let target_valid = target_type.is_numeric() || target_type.is_char();
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 798f4da9b3bbf..91e371d697dc6 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -694,8 +694,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirUsedCollector<'a, 'tcx> {
             // have to instantiate all methods of the trait being cast to, so we
             // can build the appropriate vtable.
             mir::Rvalue::Cast(
-                mir::CastKind::PointerCoercion(PointerCoercion::Unsize, _)
-                | mir::CastKind::PointerCoercion(PointerCoercion::DynStar, _),
+                mir::CastKind::PointerCoercion(PointerCoercion::Unsize, _),
                 ref operand,
                 target_ty,
             ) => {
@@ -710,9 +709,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirUsedCollector<'a, 'tcx> {
                 // This could also be a different Unsize instruction, like
                 // from a fixed sized array to a slice. But we are only
                 // interested in things that produce a vtable.
-                if (target_ty.is_trait() && !source_ty.is_trait())
-                    || (target_ty.is_dyn_star() && !source_ty.is_dyn_star())
-                {
+                if target_ty.is_trait() && !source_ty.is_trait() {
                     create_mono_items_for_vtable_methods(
                         self.tcx,
                         target_ty,
@@ -1109,14 +1106,6 @@ fn find_tails_for_unsizing<'tcx>(
             find_tails_for_unsizing(tcx, source_field, target_field)
         }
 
-        // `T` as `dyn* Trait` unsizes *directly*.
-        //
-        // FIXME(dyn_star): This case is a bit awkward, b/c we're not really computing
-        // a tail here. We probably should handle this separately in the *caller* of
-        // this function, rather than returning something that is semantically different
-        // than what we return above.
-        (_, &ty::Dynamic(_, _, ty::DynStar)) => (source_ty, target_ty),
-
         _ => bug!(
             "find_vtable_types_for_unsizing: invalid coercion {:?} -> {:?}",
             source_ty,
@@ -1344,9 +1333,7 @@ fn visit_mentioned_item<'tcx>(
             // This could also be a different Unsize instruction, like
             // from a fixed sized array to a slice. But we are only
             // interested in things that produce a vtable.
-            if (target_ty.is_trait() && !source_ty.is_trait())
-                || (target_ty.is_dyn_star() && !source_ty.is_dyn_star())
-            {
+            if target_ty.is_trait() && !source_ty.is_trait() {
                 create_mono_items_for_vtable_methods(tcx, target_ty, source_ty, span, output);
             }
         }
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
index 73bb1508de97a..c0bebdf6fb639 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
@@ -135,7 +135,6 @@ where
         | ty::Closure(..)
         | ty::CoroutineClosure(..)
         | ty::Never
-        | ty::Dynamic(_, _, ty::DynStar)
         | ty::Error(_) => Ok(ty::Binder::dummy(vec![])),
 
         // impl {Meta,}Sized for str, [T], dyn Trait
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
index edb354b4a8454..1e0a90eb2eefe 100644
--- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
@@ -657,8 +657,7 @@ where
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
             | ty::Never
-            | ty::Foreign(..)
-            | ty::Dynamic(_, _, ty::DynStar) => Ty::new_unit(cx),
+            | ty::Foreign(..) => Ty::new_unit(cx),
 
             ty::Error(e) => Ty::new_error(cx, e),
 
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index d874a071ceef1..8221c709027c2 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -796,16 +796,10 @@ impl<'a> Parser<'a> {
     ///
     /// Note that this does *not* parse bare trait objects.
     fn parse_dyn_ty(&mut self, impl_dyn_multi: &mut bool) -> PResult<'a, TyKind> {
-        let lo = self.token.span;
         self.bump(); // `dyn`
 
-        // parse dyn* types
-        let syntax = if self.eat(exp!(Star)) {
-            self.psess.gated_spans.gate(sym::dyn_star, lo.to(self.prev_token.span));
-            TraitObjectSyntax::DynStar
-        } else {
-            TraitObjectSyntax::Dyn
-        };
+        // We used to parse `*` for `dyn*` here.
+        let syntax = TraitObjectSyntax::Dyn;
 
         // Always parse bounds greedily for better error recovery.
         let bounds = self.parse_generic_bounds()?;
diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
index 9d1d3412f8d23..f4a14b36ce5cf 100644
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
@@ -631,7 +631,6 @@ pub(crate) fn encode_ty<'tcx>(
             // vendor extended type.
             let mut s = String::from(match kind {
                 ty::Dyn => "u3dynI",
-                ty::DynStar => "u7dynstarI",
             });
             s.push_str(&encode_predicates(tcx, predicates, dict, options));
             s.push_str(&encode_region(*region, dict));
diff --git a/compiler/rustc_smir/src/rustc_internal/internal.rs b/compiler/rustc_smir/src/rustc_internal/internal.rs
index 24351eee1c4c9..f878b6e6b7170 100644
--- a/compiler/rustc_smir/src/rustc_internal/internal.rs
+++ b/compiler/rustc_smir/src/rustc_internal/internal.rs
@@ -369,7 +369,6 @@ impl RustcInternal for DynKind {
     fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> {
         match self {
             DynKind::Dyn => rustc_ty::DynKind::Dyn,
-            DynKind::DynStar => rustc_ty::DynKind::DynStar,
         }
     }
 }
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs b/compiler/rustc_smir/src/rustc_smir/convert/mir.rs
index 85e71ed2c2550..daea4acc36c0c 100644
--- a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs
+++ b/compiler/rustc_smir/src/rustc_smir/convert/mir.rs
@@ -301,11 +301,9 @@ impl<'tcx> Stable<'tcx> for mir::CastKind {
     type T = stable_mir::mir::CastKind;
     fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
         use rustc_middle::mir::CastKind::*;
-        use rustc_middle::ty::adjustment::PointerCoercion;
         match self {
             PointerExposeProvenance => stable_mir::mir::CastKind::PointerExposeAddress,
             PointerWithExposedProvenance => stable_mir::mir::CastKind::PointerWithExposedProvenance,
-            PointerCoercion(PointerCoercion::DynStar, _) => stable_mir::mir::CastKind::DynStar,
             PointerCoercion(c, _) => stable_mir::mir::CastKind::PointerCoercion(c.stable(tables)),
             IntToInt => stable_mir::mir::CastKind::IntToInt,
             FloatToInt => stable_mir::mir::CastKind::FloatToInt,
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
index 7abec488151c7..ff0b8e833dcce 100644
--- a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
+++ b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
@@ -43,7 +43,6 @@ impl<'tcx> Stable<'tcx> for ty::DynKind {
     fn stable(&self, _: &mut Tables<'_>) -> Self::T {
         match self {
             ty::Dyn => stable_mir::ty::DynKind::Dyn,
-            ty::DynStar => stable_mir::ty::DynKind::DynStar,
         }
     }
 }
@@ -120,7 +119,6 @@ impl<'tcx> Stable<'tcx> for ty::adjustment::PointerCoercion {
             }
             PointerCoercion::ArrayToPointer => stable_mir::mir::PointerCoercion::ArrayToPointer,
             PointerCoercion::Unsize => stable_mir::mir::PointerCoercion::Unsize,
-            PointerCoercion::DynStar => unreachable!("represented as `CastKind::DynStar` in smir"),
         }
     }
 }
diff --git a/compiler/rustc_smir/src/stable_mir/mir/body.rs b/compiler/rustc_smir/src/stable_mir/mir/body.rs
index e4b7659ce7f91..90d4a06b177f0 100644
--- a/compiler/rustc_smir/src/stable_mir/mir/body.rs
+++ b/compiler/rustc_smir/src/stable_mir/mir/body.rs
@@ -1025,8 +1025,6 @@ pub enum CastKind {
     PointerExposeAddress,
     PointerWithExposedProvenance,
     PointerCoercion(PointerCoercion),
-    // FIXME(smir-rename): change this to PointerCoercion(DynStar)
-    DynStar,
     IntToInt,
     FloatToInt,
     FloatToFloat,
diff --git a/compiler/rustc_smir/src/stable_mir/ty.rs b/compiler/rustc_smir/src/stable_mir/ty.rs
index 7f6237e7062d2..4ea2bb04c5d39 100644
--- a/compiler/rustc_smir/src/stable_mir/ty.rs
+++ b/compiler/rustc_smir/src/stable_mir/ty.rs
@@ -1205,7 +1205,6 @@ pub enum BoundRegionKind {
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
 pub enum DynKind {
     Dyn,
-    DynStar,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index 1db8ad72b321c..fe0f8e6113ef7 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -576,8 +576,6 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
             ty::Dynamic(predicates, r, kind) => {
                 self.push(match kind {
                     ty::Dyn => "D",
-                    // FIXME(dyn-star): need to update v0 mangling docs
-                    ty::DynStar => "D*",
                 });
                 self.print_dyn_existential(predicates)?;
                 r.print(self)?;
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
index 0a4a9144c9407..aea42df4dfd95 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
@@ -353,26 +353,6 @@ impl<T> Trait<T> for X {
                             ));
                         }
                     }
-                    (ty::Dynamic(t, _, ty::DynKind::DynStar), _)
-                        if let Some(def_id) = t.principal_def_id() =>
-                    {
-                        let mut has_matching_impl = false;
-                        tcx.for_each_relevant_impl(def_id, values.found, |did| {
-                            if DeepRejectCtxt::relate_rigid_infer(tcx)
-                                .types_may_unify(values.found, tcx.type_of(did).skip_binder())
-                            {
-                                has_matching_impl = true;
-                            }
-                        });
-                        if has_matching_impl {
-                            let trait_name = tcx.item_name(def_id);
-                            diag.help(format!(
-                                "`{}` implements `{trait_name}`, `#[feature(dyn_star)]` is likely \
-                                 not enabled; that feature it is currently incomplete",
-                                values.found,
-                            ));
-                        }
-                    }
                     (_, ty::Alias(ty::Opaque, opaque_ty))
                     | (ty::Alias(ty::Opaque, opaque_ty), _) => {
                         if opaque_ty.def_id.is_local()
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 316b4dfc15fd2..af3641c22ed82 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -2129,7 +2129,6 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Never
-            | ty::Dynamic(_, _, ty::DynStar)
             | ty::Error(_) => {
                 // safe for everything
                 Where(ty::Binder::dummy(Vec::new()))
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
index d52228224614b..a225b712d4b20 100644
--- a/compiler/rustc_ty_utils/src/layout.rs
+++ b/compiler/rustc_ty_utils/src/layout.rs
@@ -449,14 +449,6 @@ fn layout_of_uncached<'tcx>(
             tcx.mk_layout(LayoutData::scalar_pair(cx, data_ptr, metadata))
         }
 
-        ty::Dynamic(_, _, ty::DynStar) => {
-            let mut data = scalar_unit(Pointer(AddressSpace::DATA));
-            data.valid_range_mut().start = 0;
-            let mut vtable = scalar_unit(Pointer(AddressSpace::DATA));
-            vtable.valid_range_mut().start = 1;
-            tcx.mk_layout(LayoutData::scalar_pair(cx, data, vtable))
-        }
-
         // Arrays and slices.
         ty::Array(element, count) => {
             let count = extract_const_value(cx, ty, count)?
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index 553f5e0e1b5d9..f8d793464a934 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -38,8 +38,7 @@ fn sizedness_constraint_for_ty<'tcx>(
         | ty::CoroutineClosure(..)
         | ty::Coroutine(..)
         | ty::CoroutineWitness(..)
-        | ty::Never
-        | ty::Dynamic(_, _, ty::DynStar) => None,
+        | ty::Never => None,
 
         ty::Str | ty::Slice(..) | ty::Dynamic(_, _, ty::Dyn) => match sizedness {
             // Never `Sized`
@@ -383,8 +382,7 @@ fn impl_self_is_guaranteed_unsized<'tcx>(tcx: TyCtxt<'tcx>, impl_def_id: DefId)
         | ty::Bound(_, _)
         | ty::Placeholder(_)
         | ty::Infer(_)
-        | ty::Error(_)
-        | ty::Dynamic(_, _, ty::DynStar) => false,
+        | ty::Error(_) => false,
     }
 }
 
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index 272fca5b026c5..2754d40fd36ce 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -183,8 +183,7 @@ pub trait Ty<I: Interner<Ty = Self>>:
             | ty::Bound(_, _)
             | ty::Placeholder(_)
             | ty::Infer(_)
-            | ty::Error(_)
-            | ty::Dynamic(_, _, ty::DynStar) => false,
+            | ty::Error(_) => false,
         }
     }
 }
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index 9669772d1a681..db6fbefcf05cc 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -20,6 +20,9 @@ use crate::{self as ty, DebruijnIndex, Interner};
 mod closure;
 
 /// Specifies how a trait object is represented.
+///
+/// This used to have a variant `DynStar`, but that variant has been removed,
+/// and it's likely this whole enum will be removed soon.
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 #[cfg_attr(
     feature = "nightly",
@@ -28,13 +31,6 @@ mod closure;
 pub enum DynKind {
     /// An unsized `dyn Trait` object
     Dyn,
-    /// A sized `dyn* Trait` object
-    ///
-    /// These objects are represented as a `(data, vtable)` pair where `data` is a value of some
-    /// ptr-sized and ptr-aligned dynamically determined type `T` and `vtable` is a pointer to the
-    /// vtable of `impl T for Trait`. This allows a `dyn*` object to be treated agnostically with
-    /// respect to whether it points to a `Box<T>`, `Rc<T>`, etc.
-    DynStar,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
@@ -371,7 +367,6 @@ impl<I: Interner> fmt::Debug for TyKind<I> {
             UnsafeBinder(binder) => write!(f, "{:?}", binder),
             Dynamic(p, r, repr) => match repr {
                 DynKind::Dyn => write!(f, "dyn {p:?} + {r:?}"),
-                DynKind::DynStar => write!(f, "dyn* {p:?} + {r:?}"),
             },
             Closure(d, s) => f.debug_tuple("Closure").field(d).field(&s).finish(),
             CoroutineClosure(d, s) => f.debug_tuple("CoroutineClosure").field(d).field(&s).finish(),
diff --git a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
index 8f1ebb8ada6e0..942c71ac33b85 100644
--- a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
+++ b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
@@ -175,10 +175,6 @@ fn check_rvalue<'tcx>(
         Rvalue::Cast(CastKind::PointerExposeProvenance, _, _) => {
             Err((span, "casting pointers to ints is unstable in const fn".into()))
         },
-        Rvalue::Cast(CastKind::PointerCoercion(PointerCoercion::DynStar, _), _, _) => {
-            // FIXME(dyn-star)
-            unimplemented!()
-        },
         Rvalue::Cast(CastKind::Transmute, _, _) => Err((
             span,
             "transmute can attempt to turn pointers into integers, so is unstable in const fn".into(),
diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
index ce4668c36c0e4..908f39af29902 100644
--- a/src/tools/miri/src/helpers.rs
+++ b/src/tools/miri/src/helpers.rs
@@ -595,10 +595,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 } else if matches!(v.layout.fields, FieldsShape::Union(..)) {
                     // A (non-frozen) union. We fall back to whatever the type says.
                     (self.unsafe_cell_action)(v)
-                } else if matches!(v.layout.ty.kind(), ty::Dynamic(_, _, ty::DynStar)) {
-                    // This needs to read the vtable pointer to proceed type-driven, but we don't
-                    // want to reentrantly read from memory here.
-                    (self.unsafe_cell_action)(v)
                 } else {
                     // We want to not actually read from memory for this visit. So, before
                     // walking this value, we have to make sure it is not a
diff --git a/src/tools/miri/tests/pass/dyn-star.rs b/src/tools/miri/tests/pass/dyn-star.rs
deleted file mode 100644
index 1ce0dd3c9d50d..0000000000000
--- a/src/tools/miri/tests/pass/dyn-star.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-#![feature(custom_inner_attributes)]
-// rustfmt destroys `dyn* Trait` syntax
-#![rustfmt::skip]
-
-use std::fmt::{Debug, Display};
-
-fn main() {
-    make_dyn_star();
-    method();
-    box_();
-    dispatch_on_pin_mut();
-    dyn_star_to_dyn();
-    dyn_to_dyn_star();
-}
-
-fn dyn_star_to_dyn() {
-    let x: dyn* Debug = &42;
-    let x = Box::new(x) as Box<dyn Debug>;
-    assert_eq!("42", format!("{x:?}"));
-}
-
-fn dyn_to_dyn_star() {
-    let x: Box<dyn Debug> = Box::new(42);
-    let x = &x as dyn* Debug;
-    assert_eq!("42", format!("{x:?}"));
-}
-
-fn make_dyn_star() {
-    fn make_dyn_star_coercion(i: usize) {
-        let _dyn_i: dyn* Debug = i;
-    }
-
-    fn make_dyn_star_explicit(i: usize) {
-        let _dyn_i: dyn* Debug = i as dyn* Debug;
-    }
-
-    make_dyn_star_coercion(42);
-    make_dyn_star_explicit(42);
-}
-
-fn method() {
-    trait Foo {
-        fn get(&self) -> usize;
-    }
-    
-    impl Foo for usize {
-        fn get(&self) -> usize {
-            *self
-        }
-    }
-    
-    fn invoke_dyn_star(i: dyn* Foo) -> usize {
-        i.get()
-    }
-    
-    fn make_and_invoke_dyn_star(i: usize) -> usize {
-        let dyn_i: dyn* Foo = i;
-        invoke_dyn_star(dyn_i)
-    }
-    
-    assert_eq!(make_and_invoke_dyn_star(42), 42);
-}
-
-fn box_() {
-    fn make_dyn_star() -> dyn* Display {
-        Box::new(42) as dyn* Display
-    }
-    
-    let x = make_dyn_star();
-    assert_eq!(format!("{x}"), "42");
-}
-
-fn dispatch_on_pin_mut() {
-    use std::future::Future;
-
-    async fn foo(f: dyn* Future<Output = i32>) {
-        println!("dispatch_on_pin_mut: value: {}", f.await);
-    }
-
-    async fn async_main() {
-        foo(Box::pin(async { 1 })).await
-    }
-
-    // ------------------------------------------------------------------------- //
-    // Implementation Details Below...
-
-    use std::pin::Pin;
-    use std::task::*;
-
-    let mut fut = async_main();
-
-    // Poll loop, just to test the future...
-    let ctx = &mut Context::from_waker(Waker::noop());
-
-    loop {
-        match unsafe { Pin::new_unchecked(&mut fut).poll(ctx) } {
-            Poll::Pending => {}
-            Poll::Ready(()) => break,
-        }
-    }
-}
diff --git a/src/tools/rustfmt/src/types.rs b/src/tools/rustfmt/src/types.rs
index 7ec1032dcb421..dd1515805e54b 100644
--- a/src/tools/rustfmt/src/types.rs
+++ b/src/tools/rustfmt/src/types.rs
@@ -835,12 +835,6 @@ impl Rewrite for ast::Ty {
                             .max_width_error(shape.width, self.span())?;
                         (shape, "dyn ")
                     }
-                    ast::TraitObjectSyntax::DynStar => {
-                        let shape = shape
-                            .offset_left(5)
-                            .max_width_error(shape.width, self.span())?;
-                        (shape, "dyn* ")
-                    }
                     ast::TraitObjectSyntax::None => (shape, ""),
                 };
                 let mut res = bounds.rewrite_result(context, shape)?;
diff --git a/src/tools/rustfmt/tests/target/issue_5542.rs b/src/tools/rustfmt/tests/target/issue_5542.rs
deleted file mode 100644
index 730bb7b681aed..0000000000000
--- a/src/tools/rustfmt/tests/target/issue_5542.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-use core::fmt::Debug;
-
-fn main() {
-    let i = 42;
-    let dyn_i = i as dyn* Debug;
-    dbg!(dyn_i);
-}
diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index 18da874dbef2e..49b4287e4e337 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -930,7 +930,6 @@ ui/dst/issue-90528-unsizing-suggestion-3.rs
 ui/dst/issue-90528-unsizing-suggestion-4.rs
 ui/dyn-keyword/issue-5153.rs
 ui/dyn-keyword/issue-56327-dyn-trait-in-macro-is-okay.rs
-ui/dyn-star/issue-102430.rs
 ui/empty/issue-37026.rs
 ui/entry-point/issue-118772.rs
 ui/enum-discriminant/auxiliary/issue-41394.rs
diff --git a/tests/codegen/function-arguments.rs b/tests/codegen/function-arguments.rs
index f0708a7a109f2..c8cd8526ae513 100644
--- a/tests/codegen/function-arguments.rs
+++ b/tests/codegen/function-arguments.rs
@@ -1,7 +1,6 @@
 //@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
 #![crate_type = "lib"]
 #![feature(rustc_attrs)]
-#![feature(dyn_star)]
 #![feature(allocator_api)]
 
 use std::marker::PhantomPinned;
@@ -277,11 +276,3 @@ pub fn enum_id_1(x: Option<Result<u16, u16>>) -> Option<Result<u16, u16>> {
 pub fn enum_id_2(x: Option<u8>) -> Option<u8> {
     x
 }
-
-// CHECK: { ptr, {{.+}} } @dyn_star(ptr noundef %x.0, {{.+}} noalias noundef readonly align {{.*}} dereferenceable({{.*}}) %x.1)
-// Expect an ABI something like `{ {}*, [3 x i64]* }`, but that's hard to match on generically,
-// so do like the `trait_box` test and just match on `{{.+}}` for the vtable.
-#[no_mangle]
-pub fn dyn_star(x: dyn* Drop) -> dyn* Drop {
-    x
-}
diff --git a/tests/crashes/116979.rs b/tests/crashes/116979.rs
deleted file mode 100644
index 28bbc972ea340..0000000000000
--- a/tests/crashes/116979.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ known-bug: #116979
-//@ compile-flags: -Csymbol-mangling-version=v0
-//@ needs-rustc-debug-assertions
-
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-use std::fmt::Display;
-
-pub fn require_dyn_star_display(_: dyn* Display) {}
-
-fn main() {
-    require_dyn_star_display(1usize);
-}
diff --git a/tests/crashes/119694.rs b/tests/crashes/119694.rs
deleted file mode 100644
index f655ea1cd343c..0000000000000
--- a/tests/crashes/119694.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ known-bug: #119694
-#![feature(dyn_star)]
-
-trait Trait {
-    fn foo(self);
-}
-
-impl Trait for usize {
-    fn foo(self) {}
-}
-
-fn bar(x: dyn* Trait) {
-    x.foo();
-}
-
-fn main() {
-    bar(0usize);
-}
diff --git a/tests/ui/SUMMARY.md b/tests/ui/SUMMARY.md
index 72b673dd50a21..8de74d41f39c2 100644
--- a/tests/ui/SUMMARY.md
+++ b/tests/ui/SUMMARY.md
@@ -484,10 +484,6 @@ The `dyn` keyword is used to highlight that calls to methods on the associated T
 
 See [`dyn` keyword](https://doc.rust-lang.org/std/keyword.dyn.html).
 
-## `tests/ui/dyn-star/`: `dyn*`, Sized `dyn`, `#![feature(dyn_star)]`
-
-See [Tracking issue for dyn-star #102425](https://github.com/rust-lang/rust/issues/102425).
-
 ## `tests/ui/editions/`: Rust edition-specific peculiarities
 
 These tests run in specific Rust editions, such as Rust 2015 or Rust 2018, and check errors and functionality related to specific now-deprecated idioms and features.
diff --git a/tests/ui/dyn-star/align.normal.stderr b/tests/ui/dyn-star/align.normal.stderr
deleted file mode 100644
index d3ee0d3e550ec..0000000000000
--- a/tests/ui/dyn-star/align.normal.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/align.rs:3:12
-   |
-LL | #![feature(dyn_star)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-error[E0277]: `AlignedUsize` needs to have the same ABI as a pointer
-  --> $DIR/align.rs:14:13
-   |
-LL |     let x = AlignedUsize(12) as dyn* Debug;
-   |             ^^^^^^^^^^^^^^^^ `AlignedUsize` needs to be a pointer-like type
-   |
-   = help: the trait `PointerLike` is not implemented for `AlignedUsize`
-
-error: aborting due to 1 previous error; 1 warning emitted
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/align.over_aligned.stderr b/tests/ui/dyn-star/align.over_aligned.stderr
deleted file mode 100644
index d3ee0d3e550ec..0000000000000
--- a/tests/ui/dyn-star/align.over_aligned.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/align.rs:3:12
-   |
-LL | #![feature(dyn_star)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-error[E0277]: `AlignedUsize` needs to have the same ABI as a pointer
-  --> $DIR/align.rs:14:13
-   |
-LL |     let x = AlignedUsize(12) as dyn* Debug;
-   |             ^^^^^^^^^^^^^^^^ `AlignedUsize` needs to be a pointer-like type
-   |
-   = help: the trait `PointerLike` is not implemented for `AlignedUsize`
-
-error: aborting due to 1 previous error; 1 warning emitted
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/align.rs b/tests/ui/dyn-star/align.rs
deleted file mode 100644
index f9ef7063231c9..0000000000000
--- a/tests/ui/dyn-star/align.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ revisions: normal over_aligned
-
-#![feature(dyn_star)]
-//~^ WARN the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-
-use std::fmt::Debug;
-
-#[cfg_attr(over_aligned,      repr(C, align(1024)))]
-#[cfg_attr(not(over_aligned), repr(C))]
-#[derive(Debug)]
-struct AlignedUsize(usize);
-
-fn main() {
-    let x = AlignedUsize(12) as dyn* Debug;
-    //~^ ERROR `AlignedUsize` needs to have the same ABI as a pointer
-}
diff --git a/tests/ui/dyn-star/async-block-dyn-star.rs b/tests/ui/dyn-star/async-block-dyn-star.rs
deleted file mode 100644
index db133d94c9187..0000000000000
--- a/tests/ui/dyn-star/async-block-dyn-star.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@ edition:2018
-
-#![feature(dyn_star, const_async_blocks)]
-//~^ WARN the feature `dyn_star` is incomplete
-
-static S: dyn* Send + Sync = async { 42 };
-//~^ ERROR needs to have the same ABI as a pointer
-
-pub fn main() {}
diff --git a/tests/ui/dyn-star/async-block-dyn-star.stderr b/tests/ui/dyn-star/async-block-dyn-star.stderr
deleted file mode 100644
index f62c85c0ad202..0000000000000
--- a/tests/ui/dyn-star/async-block-dyn-star.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/async-block-dyn-star.rs:3:12
-   |
-LL | #![feature(dyn_star, const_async_blocks)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-error[E0277]: `{async block@$DIR/async-block-dyn-star.rs:6:30: 6:35}` needs to have the same ABI as a pointer
-  --> $DIR/async-block-dyn-star.rs:6:30
-   |
-LL | static S: dyn* Send + Sync = async { 42 };
-   |                              ^^^^^^^^^^^^ `{async block@$DIR/async-block-dyn-star.rs:6:30: 6:35}` needs to be a pointer-like type
-   |
-   = help: the trait `PointerLike` is not implemented for `{async block@$DIR/async-block-dyn-star.rs:6:30: 6:35}`
-
-error: aborting due to 1 previous error; 1 warning emitted
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/auxiliary/dyn-star-foreign.rs b/tests/ui/dyn-star/auxiliary/dyn-star-foreign.rs
deleted file mode 100644
index ce892088f5000..0000000000000
--- a/tests/ui/dyn-star/auxiliary/dyn-star-foreign.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#![feature(dyn_star)]
-
-use std::fmt::Display;
-
-pub fn require_dyn_star_display(_: dyn* Display) {}
-
-fn works_locally() {
-    require_dyn_star_display(1usize);
-}
diff --git a/tests/ui/dyn-star/box.rs b/tests/ui/dyn-star/box.rs
deleted file mode 100644
index f1c9fd1a01e66..0000000000000
--- a/tests/ui/dyn-star/box.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ run-pass
-//@ revisions: current next
-//@ ignore-compare-mode-next-solver (explicit revisions)
-//@[current] compile-flags: -C opt-level=0
-//@[next] compile-flags: -Znext-solver -C opt-level=0
-
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-use std::fmt::Display;
-
-fn make_dyn_star() -> dyn* Display {
-    Box::new(42) as dyn* Display
-}
-
-fn main() {
-    let x = make_dyn_star();
-
-    println!("{x}");
-}
diff --git a/tests/ui/dyn-star/cell.rs b/tests/ui/dyn-star/cell.rs
deleted file mode 100644
index f4c7927a39dc9..0000000000000
--- a/tests/ui/dyn-star/cell.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-// This test with Cell also indirectly exercises UnsafeCell in dyn*.
-//
-//@ run-pass
-
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-use std::cell::Cell;
-
-trait Rw<T> {
-    fn read(&self) -> T;
-    fn write(&self, v: T);
-}
-
-impl<T: Copy> Rw<T> for Cell<T> {
-    fn read(&self) -> T {
-        self.get()
-    }
-    fn write(&self, v: T) {
-        self.set(v)
-    }
-}
-
-fn make_dyn_star() -> dyn* Rw<usize> {
-    Cell::new(42usize) as dyn* Rw<usize>
-}
-
-fn main() {
-    let x = make_dyn_star();
-
-    assert_eq!(x.read(), 42);
-    x.write(24);
-    assert_eq!(x.read(), 24);
-}
diff --git a/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.current.stderr b/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.current.stderr
deleted file mode 100644
index a0aff69f39681..0000000000000
--- a/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.current.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: `&T` needs to have the same ABI as a pointer
-  --> $DIR/check-size-at-cast-polymorphic-bad.rs:15:15
-   |
-LL | fn polymorphic<T: Debug + ?Sized>(t: &T) {
-   |                - this type parameter needs to be `Sized`
-LL |     dyn_debug(t);
-   |               ^ `&T` needs to be a pointer-like type
-   |
-   = note: required for `&T` to implement `PointerLike`
-help: consider removing the `?Sized` bound to make the type parameter `Sized`
-   |
-LL - fn polymorphic<T: Debug + ?Sized>(t: &T) {
-LL + fn polymorphic<T: Debug>(t: &T) {
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.next.stderr b/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.next.stderr
deleted file mode 100644
index a0aff69f39681..0000000000000
--- a/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.next.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: `&T` needs to have the same ABI as a pointer
-  --> $DIR/check-size-at-cast-polymorphic-bad.rs:15:15
-   |
-LL | fn polymorphic<T: Debug + ?Sized>(t: &T) {
-   |                - this type parameter needs to be `Sized`
-LL |     dyn_debug(t);
-   |               ^ `&T` needs to be a pointer-like type
-   |
-   = note: required for `&T` to implement `PointerLike`
-help: consider removing the `?Sized` bound to make the type parameter `Sized`
-   |
-LL - fn polymorphic<T: Debug + ?Sized>(t: &T) {
-LL + fn polymorphic<T: Debug>(t: &T) {
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.rs b/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.rs
deleted file mode 100644
index acc293a5956e6..0000000000000
--- a/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//@ revisions: current next
-//@ ignore-compare-mode-next-solver (explicit revisions)
-//@[next] compile-flags: -Znext-solver
-
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-use std::fmt::Debug;
-
-fn dyn_debug(_: (dyn* Debug + '_)) {
-
-}
-
-fn polymorphic<T: Debug + ?Sized>(t: &T) {
-    dyn_debug(t);
-    //~^ ERROR `&T` needs to have the same ABI as a pointer
-}
-
-fn main() {}
diff --git a/tests/ui/dyn-star/check-size-at-cast-polymorphic.rs b/tests/ui/dyn-star/check-size-at-cast-polymorphic.rs
deleted file mode 100644
index ceedbafd86b06..0000000000000
--- a/tests/ui/dyn-star/check-size-at-cast-polymorphic.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ check-pass
-
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-use std::fmt::Debug;
-
-fn dyn_debug(_: (dyn* Debug + '_)) {
-
-}
-
-fn polymorphic<T: Debug>(t: &T) {
-    dyn_debug(t);
-}
-
-fn main() {}
diff --git a/tests/ui/dyn-star/check-size-at-cast.rs b/tests/ui/dyn-star/check-size-at-cast.rs
deleted file mode 100644
index e15e090b529ab..0000000000000
--- a/tests/ui/dyn-star/check-size-at-cast.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-use std::fmt::Debug;
-
-fn main() {
-    let i = [1, 2, 3, 4] as dyn* Debug;
-    //~^ ERROR `[i32; 4]` needs to have the same ABI as a pointer
-    dbg!(i);
-}
diff --git a/tests/ui/dyn-star/check-size-at-cast.stderr b/tests/ui/dyn-star/check-size-at-cast.stderr
deleted file mode 100644
index b402403ee6fa1..0000000000000
--- a/tests/ui/dyn-star/check-size-at-cast.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error[E0277]: `[i32; 4]` needs to have the same ABI as a pointer
-  --> $DIR/check-size-at-cast.rs:7:13
-   |
-LL |     let i = [1, 2, 3, 4] as dyn* Debug;
-   |             ^^^^^^^^^^^^ `[i32; 4]` needs to be a pointer-like type
-   |
-   = help: the trait `PointerLike` is not implemented for `[i32; 4]`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/const-and-static.rs b/tests/ui/dyn-star/const-and-static.rs
deleted file mode 100644
index cbb64261a66c7..0000000000000
--- a/tests/ui/dyn-star/const-and-static.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ check-pass
-
-#![feature(dyn_star)]
-//~^ WARN the feature `dyn_star` is incomplete
-
-const C: dyn* Send + Sync = &();
-
-static S: dyn* Send + Sync = &();
-
-fn main() {}
diff --git a/tests/ui/dyn-star/const-and-static.stderr b/tests/ui/dyn-star/const-and-static.stderr
deleted file mode 100644
index df8f42fb0f573..0000000000000
--- a/tests/ui/dyn-star/const-and-static.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/const-and-static.rs:3:12
-   |
-LL | #![feature(dyn_star)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/dyn-star/const.rs b/tests/ui/dyn-star/const.rs
deleted file mode 100644
index 036d678dc022d..0000000000000
--- a/tests/ui/dyn-star/const.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ run-pass
-#![feature(dyn_star)]
-#![allow(unused, incomplete_features)]
-
-use std::fmt::Debug;
-
-fn make_dyn_star() {
-    let i = 42usize;
-    let dyn_i: dyn* Debug = i;
-}
-
-fn main() {
-    make_dyn_star();
-}
diff --git a/tests/ui/dyn-star/dispatch-on-pin-mut.rs b/tests/ui/dyn-star/dispatch-on-pin-mut.rs
deleted file mode 100644
index be40fa30f0d98..0000000000000
--- a/tests/ui/dyn-star/dispatch-on-pin-mut.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ run-pass
-//@ edition:2021
-//@ check-run-results
-
-#![feature(dyn_star)]
-//~^ WARN the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-
-use std::future::Future;
-
-async fn foo(f: dyn* Future<Output = i32>) {
-    println!("value: {}", f.await);
-}
-
-async fn async_main() {
-    foo(Box::pin(async { 1 })).await
-}
-
-// ------------------------------------------------------------------------- //
-// Implementation Details Below...
-
-use std::pin::pin;
-use std::task::*;
-
-fn main() {
-    let mut fut = pin!(async_main());
-
-    // Poll loop, just to test the future...
-    let ctx = &mut Context::from_waker(Waker::noop());
-
-    loop {
-        match fut.as_mut().poll(ctx) {
-            Poll::Pending => {}
-            Poll::Ready(()) => break,
-        }
-    }
-}
diff --git a/tests/ui/dyn-star/dispatch-on-pin-mut.run.stdout b/tests/ui/dyn-star/dispatch-on-pin-mut.run.stdout
deleted file mode 100644
index 96c5ca6985ffd..0000000000000
--- a/tests/ui/dyn-star/dispatch-on-pin-mut.run.stdout
+++ /dev/null
@@ -1 +0,0 @@
-value: 1
diff --git a/tests/ui/dyn-star/dispatch-on-pin-mut.stderr b/tests/ui/dyn-star/dispatch-on-pin-mut.stderr
deleted file mode 100644
index cb9c781581461..0000000000000
--- a/tests/ui/dyn-star/dispatch-on-pin-mut.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/dispatch-on-pin-mut.rs:5:12
-   |
-LL | #![feature(dyn_star)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/dyn-star/dont-unsize-coerce-dyn-star.rs b/tests/ui/dyn-star/dont-unsize-coerce-dyn-star.rs
deleted file mode 100644
index abc66df8b3635..0000000000000
--- a/tests/ui/dyn-star/dont-unsize-coerce-dyn-star.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ run-pass
-//@ check-run-results
-
-#![feature(dyn_star)]
-//~^ WARN the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-
-trait AddOne {
-    fn add1(&mut self) -> usize;
-}
-
-impl AddOne for usize {
-    fn add1(&mut self) -> usize {
-        *self += 1;
-        *self
-    }
-}
-
-fn add_one(i: &mut (dyn* AddOne + '_)) -> usize {
-    i.add1()
-}
-
-fn main() {
-    let mut x = 42usize as dyn* AddOne;
-
-    println!("{}", add_one(&mut x));
-    println!("{}", add_one(&mut x));
-}
diff --git a/tests/ui/dyn-star/dont-unsize-coerce-dyn-star.run.stdout b/tests/ui/dyn-star/dont-unsize-coerce-dyn-star.run.stdout
deleted file mode 100644
index b4db3ed707d8d..0000000000000
--- a/tests/ui/dyn-star/dont-unsize-coerce-dyn-star.run.stdout
+++ /dev/null
@@ -1,2 +0,0 @@
-43
-44
diff --git a/tests/ui/dyn-star/dont-unsize-coerce-dyn-star.stderr b/tests/ui/dyn-star/dont-unsize-coerce-dyn-star.stderr
deleted file mode 100644
index bcd014f8dc32d..0000000000000
--- a/tests/ui/dyn-star/dont-unsize-coerce-dyn-star.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/dont-unsize-coerce-dyn-star.rs:4:12
-   |
-LL | #![feature(dyn_star)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/dyn-star/drop.rs b/tests/ui/dyn-star/drop.rs
deleted file mode 100644
index bc74633152754..0000000000000
--- a/tests/ui/dyn-star/drop.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ run-pass
-//@ check-run-results
-#![feature(dyn_star, pointer_like_trait)]
-#![allow(incomplete_features)]
-
-use std::fmt::Debug;
-use std::marker::PointerLike;
-
-#[derive(Debug)]
-#[repr(transparent)]
-struct Foo(#[allow(dead_code)] usize);
-
-// FIXME(dyn_star): Make this into a derive.
-impl PointerLike for Foo {}
-
-impl Drop for Foo {
-    fn drop(&mut self) {
-        println!("destructor called");
-    }
-}
-
-fn make_dyn_star(i: Foo) {
-    let _dyn_i: dyn* Debug = i;
-}
-
-fn main() {
-    make_dyn_star(Foo(42));
-}
diff --git a/tests/ui/dyn-star/drop.run.stdout b/tests/ui/dyn-star/drop.run.stdout
deleted file mode 100644
index dadb33ccf3ac3..0000000000000
--- a/tests/ui/dyn-star/drop.run.stdout
+++ /dev/null
@@ -1 +0,0 @@
-destructor called
diff --git a/tests/ui/dyn-star/dyn-async-trait.rs b/tests/ui/dyn-star/dyn-async-trait.rs
deleted file mode 100644
index a673b26991085..0000000000000
--- a/tests/ui/dyn-star/dyn-async-trait.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ check-pass
-//@ edition: 2021
-
-// This test case is meant to demonstrate how close we can get to async
-// functions in dyn traits with the current level of dyn* support.
-
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-use std::future::Future;
-
-trait DynAsyncCounter {
-    fn increment<'a>(&'a mut self) -> dyn* Future<Output = usize> + 'a;
-}
-
-struct MyCounter {
-    count: usize,
-}
-
-impl DynAsyncCounter for MyCounter {
-    fn increment<'a>(&'a mut self) -> dyn* Future<Output = usize> + 'a {
-        Box::pin(async {
-            self.count += 1;
-            self.count
-        })
-    }
-}
-
-async fn do_counter(counter: &mut dyn DynAsyncCounter) -> usize {
-    counter.increment().await
-}
-
-fn main() {
-    let mut counter = MyCounter { count: 0 };
-    let _ = do_counter(&mut counter);
-}
diff --git a/tests/ui/dyn-star/dyn-pointer-like.rs b/tests/ui/dyn-star/dyn-pointer-like.rs
deleted file mode 100644
index f26fa90505cf7..0000000000000
--- a/tests/ui/dyn-star/dyn-pointer-like.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Test that `dyn PointerLike` and `dyn* PointerLike` do not implement `PointerLike`.
-// This used to ICE during codegen.
-
-#![crate_type = "lib"]
-
-#![feature(pointer_like_trait, dyn_star)]
-#![feature(unsized_fn_params)]
-#![expect(incomplete_features)]
-#![expect(internal_features)]
-
-use std::marker::PointerLike;
-
-pub fn lol(x: dyn* PointerLike) {
-    foo(x); //~ ERROR `dyn* PointerLike` needs to have the same ABI as a pointer
-}
-
-pub fn uwu(x: dyn PointerLike) {
-    foo(x); //~ ERROR `dyn PointerLike` needs to have the same ABI as a pointer
-}
-
-fn foo<T: PointerLike + ?Sized>(x: T) {
-    let _: dyn* PointerLike = x;
-}
diff --git a/tests/ui/dyn-star/dyn-pointer-like.stderr b/tests/ui/dyn-star/dyn-pointer-like.stderr
deleted file mode 100644
index 4c558e92d3f91..0000000000000
--- a/tests/ui/dyn-star/dyn-pointer-like.stderr
+++ /dev/null
@@ -1,39 +0,0 @@
-error[E0277]: `dyn* PointerLike` needs to have the same ABI as a pointer
-  --> $DIR/dyn-pointer-like.rs:14:9
-   |
-LL |     foo(x);
-   |     --- ^ the trait `PointerLike` is not implemented for `dyn* PointerLike`
-   |     |
-   |     required by a bound introduced by this call
-   |
-   = note: the trait bound `dyn* PointerLike: PointerLike` is not satisfied
-note: required by a bound in `foo`
-  --> $DIR/dyn-pointer-like.rs:21:11
-   |
-LL | fn foo<T: PointerLike + ?Sized>(x: T) {
-   |           ^^^^^^^^^^^ required by this bound in `foo`
-help: consider borrowing here
-   |
-LL |     foo(&x);
-   |         +
-LL |     foo(&mut x);
-   |         ++++
-
-error[E0277]: `dyn PointerLike` needs to have the same ABI as a pointer
-  --> $DIR/dyn-pointer-like.rs:18:9
-   |
-LL |     foo(x);
-   |     --- ^ `dyn PointerLike` needs to be a pointer-like type
-   |     |
-   |     required by a bound introduced by this call
-   |
-   = help: the trait `PointerLike` is not implemented for `dyn PointerLike`
-note: required by a bound in `foo`
-  --> $DIR/dyn-pointer-like.rs:21:11
-   |
-LL | fn foo<T: PointerLike + ?Sized>(x: T) {
-   |           ^^^^^^^^^^^ required by this bound in `foo`
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/dyn-star-to-dyn.rs b/tests/ui/dyn-star/dyn-star-to-dyn.rs
deleted file mode 100644
index 99f673df868c4..0000000000000
--- a/tests/ui/dyn-star/dyn-star-to-dyn.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ run-pass
-
-#![feature(dyn_star)]
-//~^ WARN the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-
-use std::fmt::Debug;
-
-fn main() {
-    let x: dyn* Debug = &42;
-    let x = Box::new(x) as Box<dyn Debug>;
-    assert_eq!("42", format!("{x:?}"));
-
-    // Also test opposite direction.
-    let x: Box<dyn Debug> = Box::new(42);
-    let x = &x as dyn* Debug;
-    assert_eq!("42", format!("{x:?}"));
-}
diff --git a/tests/ui/dyn-star/dyn-star-to-dyn.stderr b/tests/ui/dyn-star/dyn-star-to-dyn.stderr
deleted file mode 100644
index 03aedf5f797a5..0000000000000
--- a/tests/ui/dyn-star/dyn-star-to-dyn.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/dyn-star-to-dyn.rs:3:12
-   |
-LL | #![feature(dyn_star)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/dyn-star/dyn-to-rigid.rs b/tests/ui/dyn-star/dyn-to-rigid.rs
deleted file mode 100644
index dc33e288f24e6..0000000000000
--- a/tests/ui/dyn-star/dyn-to-rigid.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-trait Tr {}
-
-fn f(x: dyn* Tr) -> usize {
-    x as usize
-    //~^ ERROR non-primitive cast: `(dyn* Tr + 'static)` as `usize`
-}
-
-fn main() {}
diff --git a/tests/ui/dyn-star/dyn-to-rigid.stderr b/tests/ui/dyn-star/dyn-to-rigid.stderr
deleted file mode 100644
index 49b8f268aa4e9..0000000000000
--- a/tests/ui/dyn-star/dyn-to-rigid.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0605]: non-primitive cast: `(dyn* Tr + 'static)` as `usize`
-  --> $DIR/dyn-to-rigid.rs:7:5
-   |
-LL |     x as usize
-   |     ^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/dyn-star/enum-cast.rs b/tests/ui/dyn-star/enum-cast.rs
deleted file mode 100644
index 3cc7390eb1280..0000000000000
--- a/tests/ui/dyn-star/enum-cast.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ check-pass
-
-// This used to ICE, because the compiler confused a pointer-like to dyn* coercion
-// with a c-like enum to integer cast.
-
-#![feature(dyn_star, pointer_like_trait)]
-#![expect(incomplete_features)]
-
-use std::marker::PointerLike;
-
-#[repr(transparent)]
-enum E {
-    Num(usize),
-}
-
-impl PointerLike for E {}
-
-trait Trait {}
-impl Trait for E {}
-
-fn main() {
-    let _ = E::Num(42) as dyn* Trait;
-}
diff --git a/tests/ui/dyn-star/error.rs b/tests/ui/dyn-star/error.rs
deleted file mode 100644
index 1d252d2ce42b2..0000000000000
--- a/tests/ui/dyn-star/error.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-use std::fmt::Debug;
-
-trait Foo {}
-
-fn make_dyn_star() {
-    let i = 42usize;
-    let dyn_i: dyn* Foo = i; //~ ERROR trait bound `usize: Foo` is not satisfied
-}
-
-fn main() {}
diff --git a/tests/ui/dyn-star/error.stderr b/tests/ui/dyn-star/error.stderr
deleted file mode 100644
index 55981c03bac2b..0000000000000
--- a/tests/ui/dyn-star/error.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error[E0277]: the trait bound `usize: Foo` is not satisfied
-  --> $DIR/error.rs:10:27
-   |
-LL |     let dyn_i: dyn* Foo = i;
-   |                           ^ the trait `Foo` is not implemented for `usize`
-   |
-help: this trait has no implementations, consider adding one
-  --> $DIR/error.rs:6:1
-   |
-LL | trait Foo {}
-   | ^^^^^^^^^
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/feature-gate-dyn_star.rs b/tests/ui/dyn-star/feature-gate-dyn_star.rs
deleted file mode 100644
index b12fd7755be04..0000000000000
--- a/tests/ui/dyn-star/feature-gate-dyn_star.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-// Feature gate test for dyn_star
-
-/// dyn* is not necessarily the final surface syntax (if we have one at all),
-/// but for now we will support it to aid in writing tests independently.
-pub fn dyn_star_parameter(_: &dyn* Send) {
-    //~^ ERROR `dyn*` trait objects are experimental
-}
-
-fn main() {}
diff --git a/tests/ui/dyn-star/feature-gate-dyn_star.stderr b/tests/ui/dyn-star/feature-gate-dyn_star.stderr
deleted file mode 100644
index c3e99b20d06ab..0000000000000
--- a/tests/ui/dyn-star/feature-gate-dyn_star.stderr
+++ /dev/null
@@ -1,13 +0,0 @@
-error[E0658]: `dyn*` trait objects are experimental
-  --> $DIR/feature-gate-dyn_star.rs:5:31
-   |
-LL | pub fn dyn_star_parameter(_: &dyn* Send) {
-   |                               ^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = help: add `#![feature(dyn_star)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/dyn-star/float-as-dyn-star.rs b/tests/ui/dyn-star/float-as-dyn-star.rs
deleted file mode 100644
index 1b629c64c25a9..0000000000000
--- a/tests/ui/dyn-star/float-as-dyn-star.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ only-x86_64
-
-#![feature(dyn_star, pointer_like_trait)]
-//~^ WARN the feature `dyn_star` is incomplete
-
-use std::fmt::Debug;
-use std::marker::PointerLike;
-
-fn make_dyn_star() -> dyn* Debug + 'static {
-    f32::from_bits(0x1) as f64
-    //~^ ERROR `f64` needs to have the same ABI as a pointer
-}
-
-fn main() {
-    println!("{:?}", make_dyn_star());
-}
diff --git a/tests/ui/dyn-star/float-as-dyn-star.stderr b/tests/ui/dyn-star/float-as-dyn-star.stderr
deleted file mode 100644
index 06071a27afc61..0000000000000
--- a/tests/ui/dyn-star/float-as-dyn-star.stderr
+++ /dev/null
@@ -1,23 +0,0 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/float-as-dyn-star.rs:3:12
-   |
-LL | #![feature(dyn_star, pointer_like_trait)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-error[E0277]: `f64` needs to have the same ABI as a pointer
-  --> $DIR/float-as-dyn-star.rs:10:5
-   |
-LL |     f32::from_bits(0x1) as f64
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ `f64` needs to be a pointer-like type
-   |
-   = help: the trait `PointerLike` is not implemented for `f64`
-   = help: the following other types implement trait `PointerLike`:
-             isize
-             usize
-
-error: aborting due to 1 previous error; 1 warning emitted
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/gated-span.rs b/tests/ui/dyn-star/gated-span.rs
deleted file mode 100644
index a747987bd2483..0000000000000
--- a/tests/ui/dyn-star/gated-span.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-macro_rules! t {
-    ($t:ty) => {}
-}
-
-t!(dyn* Send);
-//~^ ERROR `dyn*` trait objects are experimental
-
-fn main() {}
diff --git a/tests/ui/dyn-star/gated-span.stderr b/tests/ui/dyn-star/gated-span.stderr
deleted file mode 100644
index 8ba6d7969fc4f..0000000000000
--- a/tests/ui/dyn-star/gated-span.stderr
+++ /dev/null
@@ -1,13 +0,0 @@
-error[E0658]: `dyn*` trait objects are experimental
-  --> $DIR/gated-span.rs:5:4
-   |
-LL | t!(dyn* Send);
-   |    ^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = help: add `#![feature(dyn_star)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/dyn-star/illegal.rs b/tests/ui/dyn-star/illegal.rs
deleted file mode 100644
index ce0d784fcd22e..0000000000000
--- a/tests/ui/dyn-star/illegal.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![feature(dyn_star)]
-//~^ WARN the feature `dyn_star` is incomplete
-
-trait Foo {}
-
-pub fn lol(x: dyn* Foo + Send) {
-    x as dyn* Foo;
-    //~^ ERROR casting `(dyn* Foo + Send + 'static)` as `dyn* Foo` is invalid
-}
-
-fn lol2(x: &dyn Foo) {
-    *x as dyn* Foo;
-    //~^ ERROR `dyn Foo` needs to have the same ABI as a pointer
-}
-
-fn main() {}
diff --git a/tests/ui/dyn-star/illegal.stderr b/tests/ui/dyn-star/illegal.stderr
deleted file mode 100644
index fdf3c813a231c..0000000000000
--- a/tests/ui/dyn-star/illegal.stderr
+++ /dev/null
@@ -1,27 +0,0 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/illegal.rs:1:12
-   |
-LL | #![feature(dyn_star)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-error[E0606]: casting `(dyn* Foo + Send + 'static)` as `dyn* Foo` is invalid
-  --> $DIR/illegal.rs:7:5
-   |
-LL |     x as dyn* Foo;
-   |     ^^^^^^^^^^^^^
-
-error[E0277]: `dyn Foo` needs to have the same ABI as a pointer
-  --> $DIR/illegal.rs:12:5
-   |
-LL |     *x as dyn* Foo;
-   |     ^^ `dyn Foo` needs to be a pointer-like type
-   |
-   = help: the trait `PointerLike` is not implemented for `dyn Foo`
-
-error: aborting due to 2 previous errors; 1 warning emitted
-
-Some errors have detailed explanations: E0277, E0606.
-For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/issue-102430.rs b/tests/ui/dyn-star/issue-102430.rs
deleted file mode 100644
index 4e48d5e2f5df0..0000000000000
--- a/tests/ui/dyn-star/issue-102430.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//@ check-pass
-
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-trait AddOne {
-    fn add1(&mut self) -> usize;
-}
-
-impl AddOne for usize {
-    fn add1(&mut self) -> usize {
-        *self += 1;
-        *self
-    }
-}
-
-impl AddOne for &mut usize {
-    fn add1(&mut self) -> usize {
-        (*self).add1()
-    }
-}
-
-fn add_one(mut i: dyn* AddOne + '_) -> usize {
-    i.add1()
-}
-
-fn main() {
-    let mut x = 42usize;
-    let y = &mut x as (dyn* AddOne + '_);
-
-    println!("{}", add_one(y));
-}
diff --git a/tests/ui/dyn-star/make-dyn-star.rs b/tests/ui/dyn-star/make-dyn-star.rs
deleted file mode 100644
index 24004335f0607..0000000000000
--- a/tests/ui/dyn-star/make-dyn-star.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ run-pass
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-use std::fmt::Debug;
-
-fn make_dyn_star(i: usize) {
-    let _dyn_i: dyn* Debug = i;
-}
-
-fn make_dyn_star_explicit(i: usize) {
-    let _dyn_i: dyn* Debug = i as dyn* Debug;
-}
-
-fn main() {
-    make_dyn_star(42);
-    make_dyn_star_explicit(42);
-}
diff --git a/tests/ui/dyn-star/method.rs b/tests/ui/dyn-star/method.rs
deleted file mode 100644
index 0d0855eec7fbd..0000000000000
--- a/tests/ui/dyn-star/method.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ run-pass
-
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-trait Foo {
-    fn get(&self) -> usize;
-}
-
-impl Foo for usize {
-    fn get(&self) -> usize {
-        *self
-    }
-}
-
-fn invoke_dyn_star(i: dyn* Foo) -> usize {
-    i.get()
-}
-
-fn make_and_invoke_dyn_star(i: usize) -> usize {
-    let dyn_i: dyn* Foo = i;
-    invoke_dyn_star(dyn_i)
-}
-
-fn main() {
-    println!("{}", make_and_invoke_dyn_star(42));
-}
diff --git a/tests/ui/dyn-star/no-explicit-dyn-star-cast.rs b/tests/ui/dyn-star/no-explicit-dyn-star-cast.rs
deleted file mode 100644
index 2d28f516ab5a7..0000000000000
--- a/tests/ui/dyn-star/no-explicit-dyn-star-cast.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use std::fmt::Debug;
-
-fn make_dyn_star() {
-    let i = 42usize;
-    let dyn_i: dyn* Debug = i as dyn* Debug;
-    //~^ ERROR casting `usize` as `dyn* Debug` is invalid
-    //~| ERROR `dyn*` trait objects are experimental
-    //~| ERROR `dyn*` trait objects are experimental
-}
-
-fn main() {
-    make_dyn_star();
-}
diff --git a/tests/ui/dyn-star/no-explicit-dyn-star-cast.stderr b/tests/ui/dyn-star/no-explicit-dyn-star-cast.stderr
deleted file mode 100644
index bb4c612cedd9b..0000000000000
--- a/tests/ui/dyn-star/no-explicit-dyn-star-cast.stderr
+++ /dev/null
@@ -1,30 +0,0 @@
-error[E0658]: `dyn*` trait objects are experimental
-  --> $DIR/no-explicit-dyn-star-cast.rs:5:16
-   |
-LL |     let dyn_i: dyn* Debug = i as dyn* Debug;
-   |                ^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = help: add `#![feature(dyn_star)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: `dyn*` trait objects are experimental
-  --> $DIR/no-explicit-dyn-star-cast.rs:5:34
-   |
-LL |     let dyn_i: dyn* Debug = i as dyn* Debug;
-   |                                  ^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = help: add `#![feature(dyn_star)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0606]: casting `usize` as `dyn* Debug` is invalid
-  --> $DIR/no-explicit-dyn-star-cast.rs:5:29
-   |
-LL |     let dyn_i: dyn* Debug = i as dyn* Debug;
-   |                             ^^^^^^^^^^^^^^^
-
-error: aborting due to 3 previous errors
-
-Some errors have detailed explanations: E0606, E0658.
-For more information about an error, try `rustc --explain E0606`.
diff --git a/tests/ui/dyn-star/no-explicit-dyn-star.rs b/tests/ui/dyn-star/no-explicit-dyn-star.rs
deleted file mode 100644
index 0847597450e5c..0000000000000
--- a/tests/ui/dyn-star/no-explicit-dyn-star.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ aux-build:dyn-star-foreign.rs
-
-extern crate dyn_star_foreign;
-
-fn main() {
-    dyn_star_foreign::require_dyn_star_display(1usize as _);
-    //~^ ERROR casting `usize` as `dyn* std::fmt::Display` is invalid
-}
diff --git a/tests/ui/dyn-star/no-explicit-dyn-star.stderr b/tests/ui/dyn-star/no-explicit-dyn-star.stderr
deleted file mode 100644
index 641404aa09e20..0000000000000
--- a/tests/ui/dyn-star/no-explicit-dyn-star.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0606]: casting `usize` as `dyn* std::fmt::Display` is invalid
-  --> $DIR/no-explicit-dyn-star.rs:6:48
-   |
-LL |     dyn_star_foreign::require_dyn_star_display(1usize as _);
-   |                                                ^^^^^^^^^^^
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0606`.
diff --git a/tests/ui/dyn-star/no-implicit-dyn-star.rs b/tests/ui/dyn-star/no-implicit-dyn-star.rs
deleted file mode 100644
index 7af3f9a734bce..0000000000000
--- a/tests/ui/dyn-star/no-implicit-dyn-star.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ aux-build:dyn-star-foreign.rs
-
-extern crate dyn_star_foreign;
-
-fn main() {
-    dyn_star_foreign::require_dyn_star_display(1usize);
-    //~^ ERROR mismatched types
-}
diff --git a/tests/ui/dyn-star/no-implicit-dyn-star.stderr b/tests/ui/dyn-star/no-implicit-dyn-star.stderr
deleted file mode 100644
index d1d3da9ca7024..0000000000000
--- a/tests/ui/dyn-star/no-implicit-dyn-star.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error[E0308]: mismatched types
-  --> $DIR/no-implicit-dyn-star.rs:6:48
-   |
-LL |     dyn_star_foreign::require_dyn_star_display(1usize);
-   |     ------------------------------------------ ^^^^^^ expected `dyn Display`, found `usize`
-   |     |
-   |     arguments to this function are incorrect
-   |
-   = note: expected trait object `(dyn* std::fmt::Display + 'static)`
-                      found type `usize`
-   = help: `usize` implements `Display`, `#[feature(dyn_star)]` is likely not enabled; that feature it is currently incomplete
-note: function defined here
-  --> $DIR/auxiliary/dyn-star-foreign.rs:5:8
-   |
-LL | pub fn require_dyn_star_display(_: dyn* Display) {}
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/dyn-star/no-unsize-coerce-dyn-trait.rs b/tests/ui/dyn-star/no-unsize-coerce-dyn-trait.rs
deleted file mode 100644
index 1702fc1ed490e..0000000000000
--- a/tests/ui/dyn-star/no-unsize-coerce-dyn-trait.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![expect(incomplete_features)]
-#![feature(dyn_star)]
-
-trait A: B {}
-trait B {}
-impl A for usize {}
-impl B for usize {}
-
-fn main() {
-    let x: Box<dyn* A> = Box::new(1usize as dyn* A);
-    let y: Box<dyn* B> = x;
-    //~^ ERROR mismatched types
-}
diff --git a/tests/ui/dyn-star/no-unsize-coerce-dyn-trait.stderr b/tests/ui/dyn-star/no-unsize-coerce-dyn-trait.stderr
deleted file mode 100644
index 289d85072e615..0000000000000
--- a/tests/ui/dyn-star/no-unsize-coerce-dyn-trait.stderr
+++ /dev/null
@@ -1,14 +0,0 @@
-error[E0308]: mismatched types
-  --> $DIR/no-unsize-coerce-dyn-trait.rs:11:26
-   |
-LL |     let y: Box<dyn* B> = x;
-   |            -----------   ^ expected trait `B`, found trait `A`
-   |            |
-   |            expected due to this
-   |
-   = note: expected struct `Box<dyn* B>`
-              found struct `Box<dyn* A>`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/dyn-star/param-env-region-infer.current.stderr b/tests/ui/dyn-star/param-env-region-infer.current.stderr
deleted file mode 100644
index 6e464c17014cc..0000000000000
--- a/tests/ui/dyn-star/param-env-region-infer.current.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0282]: type annotations needed
-  --> $DIR/param-env-region-infer.rs:20:10
-   |
-LL |     t as _
-   |          ^ cannot infer type
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/dyn-star/param-env-region-infer.rs b/tests/ui/dyn-star/param-env-region-infer.rs
deleted file mode 100644
index 842964ad284cc..0000000000000
--- a/tests/ui/dyn-star/param-env-region-infer.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//@ revisions: current
-//@ incremental
-
-// FIXME(-Znext-solver): This currently results in unstable query results:
-// `normalizes-to(opaque, opaque)` changes from `Maybe(Ambiguous)` to `Maybe(Overflow)`
-// once the hidden type of the opaque is already defined to be itself.
-//@ unused-revision-names: next
-
-// checks that we don't ICE if there are region inference variables in the environment
-// when computing `PointerLike` builtin candidates.
-
-#![feature(dyn_star, pointer_like_trait)]
-#![allow(incomplete_features)]
-
-use std::fmt::Debug;
-use std::marker::PointerLike;
-
-fn make_dyn_star<'a, T: PointerLike + Debug + 'a>(t: T) -> impl PointerLike + Debug + 'a {
-    //[next]~^ ERROR cycle detected when computing
-    t as _
-    //[current]~^ ERROR type annotations needed
-}
-
-fn main() {}
diff --git a/tests/ui/dyn-star/pointer-like-impl-rules.rs b/tests/ui/dyn-star/pointer-like-impl-rules.rs
deleted file mode 100644
index c234e86e09a84..0000000000000
--- a/tests/ui/dyn-star/pointer-like-impl-rules.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-//@ check-fail
-
-#![feature(extern_types)]
-#![feature(pointer_like_trait)]
-
-use std::marker::PointerLike;
-
-struct NotReprTransparent;
-impl PointerLike for NotReprTransparent {}
-//~^ ERROR: implementation must be applied to type that
-//~| NOTE: the struct `NotReprTransparent` is not `repr(transparent)`
-
-#[repr(transparent)]
-struct FieldIsPl(usize);
-impl PointerLike for FieldIsPl {}
-
-#[repr(transparent)]
-struct FieldIsPlAndHasOtherField(usize, ());
-impl PointerLike for FieldIsPlAndHasOtherField {}
-
-#[repr(transparent)]
-struct FieldIsNotPl(u8);
-impl PointerLike for FieldIsNotPl {}
-//~^ ERROR: implementation must be applied to type that
-//~| NOTE: the field `0` of struct `FieldIsNotPl` does not implement `PointerLike`
-
-#[repr(transparent)]
-struct GenericFieldIsNotPl<T>(T);
-impl<T> PointerLike for GenericFieldIsNotPl<T> {}
-//~^ ERROR: implementation must be applied to type that
-//~| NOTE: the field `0` of struct `GenericFieldIsNotPl<T>` does not implement `PointerLike`
-
-#[repr(transparent)]
-struct GenericFieldIsPl<T>(T);
-impl<T: PointerLike> PointerLike for GenericFieldIsPl<T> {}
-
-#[repr(transparent)]
-struct IsZeroSized(());
-impl PointerLike for IsZeroSized {}
-//~^ ERROR: implementation must be applied to type that
-//~| NOTE: the struct `IsZeroSized` is `repr(transparent)`, but does not have a non-trivial field
-
-trait SomeTrait {}
-impl PointerLike for dyn SomeTrait {}
-//~^ ERROR: implementation must be applied to type that
-//~| NOTE: types of dynamic or unknown size
-
-extern "C" {
-    type ExternType;
-}
-impl PointerLike for ExternType {}
-//~^ ERROR: implementation must be applied to type that
-//~| NOTE: types of dynamic or unknown size
-
-struct LocalSizedType(&'static str);
-struct LocalUnsizedType(str);
-
-// This is not a special error but a normal coherence error,
-// which should still happen.
-impl PointerLike for &LocalSizedType {}
-//~^ ERROR: conflicting implementations of trait `PointerLike`
-//~| NOTE: conflicting implementation in crate `core`
-
-impl PointerLike for &LocalUnsizedType {}
-//~^ ERROR: implementation must be applied to type that
-//~| NOTE: references to dynamically-sized types are too large to be `PointerLike`
-
-impl PointerLike for Box<LocalSizedType> {}
-//~^ ERROR: conflicting implementations of trait `PointerLike`
-//~| NOTE: conflicting implementation in crate `alloc`
-
-impl PointerLike for Box<LocalUnsizedType> {}
-//~^ ERROR: implementation must be applied to type that
-//~| NOTE: boxes of dynamically-sized types are too large to be `PointerLike`
-
-fn expects_pointer_like(x: impl PointerLike) {}
-
-fn main() {
-    expects_pointer_like(FieldIsPl(1usize));
-    expects_pointer_like(FieldIsPlAndHasOtherField(1usize, ()));
-    expects_pointer_like(GenericFieldIsPl(1usize));
-}
diff --git a/tests/ui/dyn-star/pointer-like-impl-rules.stderr b/tests/ui/dyn-star/pointer-like-impl-rules.stderr
deleted file mode 100644
index 39f08f442c443..0000000000000
--- a/tests/ui/dyn-star/pointer-like-impl-rules.stderr
+++ /dev/null
@@ -1,85 +0,0 @@
-error[E0119]: conflicting implementations of trait `PointerLike` for type `&LocalSizedType`
-  --> $DIR/pointer-like-impl-rules.rs:60:1
-   |
-LL | impl PointerLike for &LocalSizedType {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: conflicting implementation in crate `core`:
-           - impl<T> PointerLike for &T;
-
-error[E0119]: conflicting implementations of trait `PointerLike` for type `Box<LocalSizedType>`
-  --> $DIR/pointer-like-impl-rules.rs:68:1
-   |
-LL | impl PointerLike for Box<LocalSizedType> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: conflicting implementation in crate `alloc`:
-           - impl<T> PointerLike for Box<T>;
-
-error: implementation must be applied to type that has the same ABI as a pointer, or is `repr(transparent)` and whose field is `PointerLike`
-  --> $DIR/pointer-like-impl-rules.rs:9:1
-   |
-LL | impl PointerLike for NotReprTransparent {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: the struct `NotReprTransparent` is not `repr(transparent)`
-
-error: implementation must be applied to type that has the same ABI as a pointer, or is `repr(transparent)` and whose field is `PointerLike`
-  --> $DIR/pointer-like-impl-rules.rs:23:1
-   |
-LL | impl PointerLike for FieldIsNotPl {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: the field `0` of struct `FieldIsNotPl` does not implement `PointerLike`
-
-error: implementation must be applied to type that has the same ABI as a pointer, or is `repr(transparent)` and whose field is `PointerLike`
-  --> $DIR/pointer-like-impl-rules.rs:29:1
-   |
-LL | impl<T> PointerLike for GenericFieldIsNotPl<T> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: the field `0` of struct `GenericFieldIsNotPl<T>` does not implement `PointerLike`
-
-error: implementation must be applied to type that has the same ABI as a pointer, or is `repr(transparent)` and whose field is `PointerLike`
-  --> $DIR/pointer-like-impl-rules.rs:39:1
-   |
-LL | impl PointerLike for IsZeroSized {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: the struct `IsZeroSized` is `repr(transparent)`, but does not have a non-trivial field (it is zero-sized)
-
-error: implementation must be applied to type that has the same ABI as a pointer, or is `repr(transparent)` and whose field is `PointerLike`
-  --> $DIR/pointer-like-impl-rules.rs:44:1
-   |
-LL | impl PointerLike for dyn SomeTrait {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: types of dynamic or unknown size may not implement `PointerLike`
-
-error: implementation must be applied to type that has the same ABI as a pointer, or is `repr(transparent)` and whose field is `PointerLike`
-  --> $DIR/pointer-like-impl-rules.rs:51:1
-   |
-LL | impl PointerLike for ExternType {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: types of dynamic or unknown size may not implement `PointerLike`
-
-error: implementation must be applied to type that has the same ABI as a pointer, or is `repr(transparent)` and whose field is `PointerLike`
-  --> $DIR/pointer-like-impl-rules.rs:64:1
-   |
-LL | impl PointerLike for &LocalUnsizedType {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: references to dynamically-sized types are too large to be `PointerLike`
-
-error: implementation must be applied to type that has the same ABI as a pointer, or is `repr(transparent)` and whose field is `PointerLike`
-  --> $DIR/pointer-like-impl-rules.rs:72:1
-   |
-LL | impl PointerLike for Box<LocalUnsizedType> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: boxes of dynamically-sized types are too large to be `PointerLike`
-
-error: aborting due to 10 previous errors
-
-For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/dyn-star/return.rs b/tests/ui/dyn-star/return.rs
deleted file mode 100644
index 47d95d1d643e7..0000000000000
--- a/tests/ui/dyn-star/return.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ check-pass
-
-#![feature(dyn_star)]
-//~^ WARN the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-
-fn _foo() -> dyn* Unpin {
-    4usize
-}
-
-fn main() {}
diff --git a/tests/ui/dyn-star/return.stderr b/tests/ui/dyn-star/return.stderr
deleted file mode 100644
index 9c26568290443..0000000000000
--- a/tests/ui/dyn-star/return.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/return.rs:3:12
-   |
-LL | #![feature(dyn_star)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/dyn-star/syntax.rs b/tests/ui/dyn-star/syntax.rs
deleted file mode 100644
index d4983404de2b3..0000000000000
--- a/tests/ui/dyn-star/syntax.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Make sure we can parse the `dyn* Trait` syntax
-//
-//@ check-pass
-
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-pub fn dyn_star_parameter(_: dyn* Send) {
-}
-
-fn main() {}
diff --git a/tests/ui/dyn-star/thin.next.stderr b/tests/ui/dyn-star/thin.next.stderr
deleted file mode 100644
index ef251062afcf7..0000000000000
--- a/tests/ui/dyn-star/thin.next.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/thin.rs:6:12
-   |
-LL | #![feature(dyn_star)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/dyn-star/thin.old.stderr b/tests/ui/dyn-star/thin.old.stderr
deleted file mode 100644
index ef251062afcf7..0000000000000
--- a/tests/ui/dyn-star/thin.old.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/thin.rs:6:12
-   |
-LL | #![feature(dyn_star)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/dyn-star/thin.rs b/tests/ui/dyn-star/thin.rs
deleted file mode 100644
index 6df70f560dec9..0000000000000
--- a/tests/ui/dyn-star/thin.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@check-pass
-//@revisions: old next
-//@[next] compile-flags: -Znext-solver
-
-#![feature(ptr_metadata)]
-#![feature(dyn_star)]
-//~^ WARN the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-
-use std::fmt::Debug;
-use std::ptr::Thin;
-
-fn check_thin<T: ?Sized + Thin>() {}
-
-fn main() {
-    check_thin::<dyn* Debug>();
-}
diff --git a/tests/ui/dyn-star/union.rs b/tests/ui/dyn-star/union.rs
deleted file mode 100644
index ad3a85a937ae7..0000000000000
--- a/tests/ui/dyn-star/union.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![feature(dyn_star)]
-//~^ WARN the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-
-union Union {
-    x: usize,
-}
-
-trait Trait {}
-impl Trait for Union {}
-
-fn bar(_: dyn* Trait) {}
-
-fn main() {
-    bar(Union { x: 0usize });
-    //~^ ERROR `Union` needs to have the same ABI as a pointer
-}
diff --git a/tests/ui/dyn-star/union.stderr b/tests/ui/dyn-star/union.stderr
deleted file mode 100644
index 906eb4f5163e5..0000000000000
--- a/tests/ui/dyn-star/union.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/union.rs:1:12
-   |
-LL | #![feature(dyn_star)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-error[E0277]: `Union` needs to have the same ABI as a pointer
-  --> $DIR/union.rs:14:9
-   |
-LL |     bar(Union { x: 0usize });
-   |         ^^^^^^^^^^^^^^^^^^^ `Union` needs to be a pointer-like type
-   |
-   = help: the trait `PointerLike` is not implemented for `Union`
-
-error: aborting due to 1 previous error; 1 warning emitted
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/unsize-into-ref-dyn-star.rs b/tests/ui/dyn-star/unsize-into-ref-dyn-star.rs
deleted file mode 100644
index 1e8cafe1561e8..0000000000000
--- a/tests/ui/dyn-star/unsize-into-ref-dyn-star.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-use std::fmt::Debug;
-
-fn main() {
-    let i = 42 as &dyn* Debug;
-    //~^ ERROR non-primitive cast: `i32` as `&dyn* Debug`
-}
diff --git a/tests/ui/dyn-star/unsize-into-ref-dyn-star.stderr b/tests/ui/dyn-star/unsize-into-ref-dyn-star.stderr
deleted file mode 100644
index b3274580afe0e..0000000000000
--- a/tests/ui/dyn-star/unsize-into-ref-dyn-star.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0605]: non-primitive cast: `i32` as `&dyn* Debug`
-  --> $DIR/unsize-into-ref-dyn-star.rs:7:13
-   |
-LL |     let i = 42 as &dyn* Debug;
-   |             ^^^^^^^^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/dyn-star/upcast.rs b/tests/ui/dyn-star/upcast.rs
deleted file mode 100644
index 01e1b94f87e27..0000000000000
--- a/tests/ui/dyn-star/upcast.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//@ known-bug: #104800
-
-#![feature(dyn_star)]
-
-trait Foo: Bar {
-    fn hello(&self);
-}
-
-trait Bar {
-    fn world(&self);
-}
-
-struct W(usize);
-
-impl Foo for W {
-    fn hello(&self) {
-        println!("hello!");
-    }
-}
-
-impl Bar for W {
-    fn world(&self) {
-        println!("world!");
-    }
-}
-
-fn main() {
-    let w: dyn* Foo = W(0);
-    w.hello();
-    let w: dyn* Bar = w;
-    w.world();
-}
diff --git a/tests/ui/dyn-star/upcast.stderr b/tests/ui/dyn-star/upcast.stderr
deleted file mode 100644
index 3f244d4b6ae8d..0000000000000
--- a/tests/ui/dyn-star/upcast.stderr
+++ /dev/null
@@ -1,28 +0,0 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/upcast.rs:3:12
-   |
-LL | #![feature(dyn_star)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-error[E0277]: `W` needs to have the same ABI as a pointer
-  --> $DIR/upcast.rs:28:23
-   |
-LL |     let w: dyn* Foo = W(0);
-   |                       ^^^^ `W` needs to be a pointer-like type
-   |
-   = help: the trait `PointerLike` is not implemented for `W`
-
-error[E0277]: `dyn* Foo` needs to have the same ABI as a pointer
-  --> $DIR/upcast.rs:30:23
-   |
-LL |     let w: dyn* Bar = w;
-   |                       ^ `dyn* Foo` needs to be a pointer-like type
-   |
-   = help: the trait `PointerLike` is not implemented for `dyn* Foo`
-
-error: aborting due to 2 previous errors; 1 warning emitted
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/parser/trait-object-delimiters.rs b/tests/ui/parser/trait-object-delimiters.rs
index 1cbd2ff1bdfb6..2c75840bc0abf 100644
--- a/tests/ui/parser/trait-object-delimiters.rs
+++ b/tests/ui/parser/trait-object-delimiters.rs
@@ -8,7 +8,7 @@ fn foo2(_: &dyn (Drop + AsRef<str>)) {} //~ ERROR incorrect parentheses around t
 fn foo2_no_space(_: &dyn(Drop + AsRef<str>)) {} //~ ERROR incorrect parentheses around trait bounds
 
 fn foo3(_: &dyn {Drop + AsRef<str>}) {} //~ ERROR expected parameter name, found `{`
-//~^ ERROR expected one of `!`, `(`, `)`, `*`, `,`, `?`, `[`, `async`, `const`, `for`, `use`, `~`, lifetime, or path, found `{`
+//~^ ERROR expected one of `!`, `(`, `)`, `,`, `?`, `[`, `async`, `const`, `for`, `use`, `~`, lifetime, or path, found `{`
 //~| ERROR at least one trait is required for an object type
 
 fn foo4(_: &dyn <Drop + AsRef<str>>) {} //~ ERROR expected identifier, found `<`
diff --git a/tests/ui/parser/trait-object-delimiters.stderr b/tests/ui/parser/trait-object-delimiters.stderr
index 16d5392eec84a..a2c9161cfbe11 100644
--- a/tests/ui/parser/trait-object-delimiters.stderr
+++ b/tests/ui/parser/trait-object-delimiters.stderr
@@ -39,11 +39,11 @@ error: expected parameter name, found `{`
 LL | fn foo3(_: &dyn {Drop + AsRef<str>}) {}
    |                 ^ expected parameter name
 
-error: expected one of `!`, `(`, `)`, `*`, `,`, `?`, `[`, `async`, `const`, `for`, `use`, `~`, lifetime, or path, found `{`
+error: expected one of `!`, `(`, `)`, `,`, `?`, `[`, `async`, `const`, `for`, `use`, `~`, lifetime, or path, found `{`
   --> $DIR/trait-object-delimiters.rs:10:17
    |
 LL | fn foo3(_: &dyn {Drop + AsRef<str>}) {}
-   |                -^ expected one of 14 possible tokens
+   |                -^ expected one of 13 possible tokens
    |                |
    |                help: missing `,`
 
diff --git a/tests/ui/sized-hierarchy/impls.rs b/tests/ui/sized-hierarchy/impls.rs
index 46697e47c4bfa..643f7bc7c46cb 100644
--- a/tests/ui/sized-hierarchy/impls.rs
+++ b/tests/ui/sized-hierarchy/impls.rs
@@ -3,7 +3,7 @@
 
 #![allow(incomplete_features, internal_features)]
 #![feature(sized_hierarchy)]
-#![feature(coroutines, dyn_star, extern_types, f16, never_type, unsized_fn_params)]
+#![feature(coroutines, extern_types, f16, never_type, unsized_fn_params)]
 
 use std::fmt::Debug;
 use std::marker::{MetaSized, PointeeSized};
@@ -151,11 +151,6 @@ fn main() {
     needs_metasized::<!>();
     needs_pointeesized::<!>();
 
-    // `dyn*`
-    needs_sized::<dyn* Debug>();
-    needs_metasized::<dyn* Debug>();
-    needs_pointeesized::<dyn* Debug>();
-
     // `str`
     needs_sized::<str>();
     //~^ ERROR the size for values of type `str` cannot be known at compilation time
diff --git a/tests/ui/sized-hierarchy/impls.stderr b/tests/ui/sized-hierarchy/impls.stderr
index eebe4e0d706a0..ca70822aad287 100644
--- a/tests/ui/sized-hierarchy/impls.stderr
+++ b/tests/ui/sized-hierarchy/impls.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
-  --> $DIR/impls.rs:240:42
+  --> $DIR/impls.rs:235:42
    |
 LL |     struct StructAllFieldsMetaSized { x: [u8], y: [u8] }
    |                                          ^^^^ doesn't have a size known at compile-time
@@ -17,7 +17,7 @@ LL |     struct StructAllFieldsMetaSized { x: Box<[u8]>, y: [u8] }
    |                                          ++++    +
 
 error[E0277]: the size for values of type `main::Foo` cannot be known at compilation time
-  --> $DIR/impls.rs:248:40
+  --> $DIR/impls.rs:243:40
    |
 LL |     struct StructAllFieldsUnsized { x: Foo, y: Foo }
    |                                        ^^^ doesn't have a size known at compile-time
@@ -35,7 +35,7 @@ LL |     struct StructAllFieldsUnsized { x: Box<Foo>, y: Foo }
    |                                        ++++   +
 
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
-  --> $DIR/impls.rs:284:44
+  --> $DIR/impls.rs:279:44
    |
 LL |     enum EnumAllFieldsMetaSized { Qux { x: [u8], y: [u8] } }
    |                                            ^^^^ doesn't have a size known at compile-time
@@ -53,7 +53,7 @@ LL |     enum EnumAllFieldsMetaSized { Qux { x: Box<[u8]>, y: [u8] } }
    |                                            ++++    +
 
 error[E0277]: the size for values of type `main::Foo` cannot be known at compilation time
-  --> $DIR/impls.rs:291:42
+  --> $DIR/impls.rs:286:42
    |
 LL |     enum EnumAllFieldsUnsized { Qux { x: Foo, y: Foo } }
    |                                          ^^^ doesn't have a size known at compile-time
@@ -71,7 +71,7 @@ LL |     enum EnumAllFieldsUnsized { Qux { x: Box<Foo>, y: Foo } }
    |                                          ++++   +
 
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
-  --> $DIR/impls.rs:298:52
+  --> $DIR/impls.rs:293:52
    |
 LL |     enum EnumLastFieldMetaSized { Qux { x: u32, y: [u8] } }
    |                                                    ^^^^ doesn't have a size known at compile-time
@@ -89,7 +89,7 @@ LL |     enum EnumLastFieldMetaSized { Qux { x: u32, y: Box<[u8]> } }
    |                                                    ++++    +
 
 error[E0277]: the size for values of type `main::Foo` cannot be known at compilation time
-  --> $DIR/impls.rs:305:50
+  --> $DIR/impls.rs:300:50
    |
 LL |     enum EnumLastFieldUnsized { Qux { x: u32, y: Foo } }
    |                                                  ^^^ doesn't have a size known at compile-time
@@ -107,7 +107,7 @@ LL |     enum EnumLastFieldUnsized { Qux { x: u32, y: Box<Foo> } }
    |                                                  ++++   +
 
 error[E0277]: the size for values of type `str` cannot be known at compilation time
-  --> $DIR/impls.rs:160:19
+  --> $DIR/impls.rs:155:19
    |
 LL |     needs_sized::<str>();
    |                   ^^^ doesn't have a size known at compile-time
@@ -120,7 +120,7 @@ LL | fn needs_sized<T: Sized>() { }
    |                   ^^^^^ required by this bound in `needs_sized`
 
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
-  --> $DIR/impls.rs:166:19
+  --> $DIR/impls.rs:161:19
    |
 LL |     needs_sized::<[u8]>();
    |                   ^^^^ doesn't have a size known at compile-time
@@ -133,7 +133,7 @@ LL | fn needs_sized<T: Sized>() { }
    |                   ^^^^^ required by this bound in `needs_sized`
 
 error[E0277]: the size for values of type `dyn Debug` cannot be known at compilation time
-  --> $DIR/impls.rs:172:19
+  --> $DIR/impls.rs:167:19
    |
 LL |     needs_sized::<dyn Debug>();
    |                   ^^^^^^^^^ doesn't have a size known at compile-time
@@ -146,7 +146,7 @@ LL | fn needs_sized<T: Sized>() { }
    |                   ^^^^^ required by this bound in `needs_sized`
 
 error[E0277]: the size for values of type `main::Foo` cannot be known at compilation time
-  --> $DIR/impls.rs:181:19
+  --> $DIR/impls.rs:176:19
    |
 LL |     needs_sized::<Foo>();
    |                   ^^^ doesn't have a size known at compile-time
@@ -159,7 +159,7 @@ LL | fn needs_sized<T: Sized>() { }
    |                   ^^^^^ required by this bound in `needs_sized`
 
 error[E0277]: the size for values of type `main::Foo` cannot be known
-  --> $DIR/impls.rs:183:23
+  --> $DIR/impls.rs:178:23
    |
 LL |     needs_metasized::<Foo>();
    |                       ^^^ doesn't have a known size
@@ -172,7 +172,7 @@ LL | fn needs_metasized<T: MetaSized>() { }
    |                       ^^^^^^^^^ required by this bound in `needs_metasized`
 
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
-  --> $DIR/impls.rs:198:19
+  --> $DIR/impls.rs:193:19
    |
 LL |     needs_sized::<([u8], [u8])>();
    |                   ^^^^^^^^^^^^ doesn't have a size known at compile-time
@@ -181,7 +181,7 @@ LL |     needs_sized::<([u8], [u8])>();
    = note: only the last element of a tuple may have a dynamically sized type
 
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
-  --> $DIR/impls.rs:200:23
+  --> $DIR/impls.rs:195:23
    |
 LL |     needs_metasized::<([u8], [u8])>();
    |                       ^^^^^^^^^^^^ doesn't have a size known at compile-time
@@ -190,7 +190,7 @@ LL |     needs_metasized::<([u8], [u8])>();
    = note: only the last element of a tuple may have a dynamically sized type
 
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
-  --> $DIR/impls.rs:202:26
+  --> $DIR/impls.rs:197:26
    |
 LL |     needs_pointeesized::<([u8], [u8])>();
    |                          ^^^^^^^^^^^^ doesn't have a size known at compile-time
@@ -199,7 +199,7 @@ LL |     needs_pointeesized::<([u8], [u8])>();
    = note: only the last element of a tuple may have a dynamically sized type
 
 error[E0277]: the size for values of type `main::Foo` cannot be known at compilation time
-  --> $DIR/impls.rs:206:19
+  --> $DIR/impls.rs:201:19
    |
 LL |     needs_sized::<(Foo, Foo)>();
    |                   ^^^^^^^^^^ doesn't have a size known at compile-time
@@ -208,7 +208,7 @@ LL |     needs_sized::<(Foo, Foo)>();
    = note: only the last element of a tuple may have a dynamically sized type
 
 error[E0277]: the size for values of type `main::Foo` cannot be known at compilation time
-  --> $DIR/impls.rs:208:23
+  --> $DIR/impls.rs:203:23
    |
 LL |     needs_metasized::<(Foo, Foo)>();
    |                       ^^^^^^^^^^ doesn't have a size known at compile-time
@@ -217,7 +217,7 @@ LL |     needs_metasized::<(Foo, Foo)>();
    = note: only the last element of a tuple may have a dynamically sized type
 
 error[E0277]: the size for values of type `main::Foo` cannot be known
-  --> $DIR/impls.rs:208:23
+  --> $DIR/impls.rs:203:23
    |
 LL |     needs_metasized::<(Foo, Foo)>();
    |                       ^^^^^^^^^^ doesn't have a known size
@@ -231,7 +231,7 @@ LL | fn needs_metasized<T: MetaSized>() { }
    |                       ^^^^^^^^^ required by this bound in `needs_metasized`
 
 error[E0277]: the size for values of type `main::Foo` cannot be known at compilation time
-  --> $DIR/impls.rs:211:26
+  --> $DIR/impls.rs:206:26
    |
 LL |     needs_pointeesized::<(Foo, Foo)>();
    |                          ^^^^^^^^^^ doesn't have a size known at compile-time
@@ -240,7 +240,7 @@ LL |     needs_pointeesized::<(Foo, Foo)>();
    = note: only the last element of a tuple may have a dynamically sized type
 
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
-  --> $DIR/impls.rs:215:19
+  --> $DIR/impls.rs:210:19
    |
 LL |     needs_sized::<(u32, [u8])>();
    |                   ^^^^^^^^^^^ doesn't have a size known at compile-time
@@ -254,7 +254,7 @@ LL | fn needs_sized<T: Sized>() { }
    |                   ^^^^^ required by this bound in `needs_sized`
 
 error[E0277]: the size for values of type `main::Foo` cannot be known at compilation time
-  --> $DIR/impls.rs:221:19
+  --> $DIR/impls.rs:216:19
    |
 LL |     needs_sized::<(u32, Foo)>();
    |                   ^^^^^^^^^^ doesn't have a size known at compile-time
@@ -268,7 +268,7 @@ LL | fn needs_sized<T: Sized>() { }
    |                   ^^^^^ required by this bound in `needs_sized`
 
 error[E0277]: the size for values of type `main::Foo` cannot be known
-  --> $DIR/impls.rs:223:23
+  --> $DIR/impls.rs:218:23
    |
 LL |     needs_metasized::<(u32, Foo)>();
    |                       ^^^^^^^^^^ doesn't have a known size
@@ -282,14 +282,14 @@ LL | fn needs_metasized<T: MetaSized>() { }
    |                       ^^^^^^^^^ required by this bound in `needs_metasized`
 
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
-  --> $DIR/impls.rs:242:19
+  --> $DIR/impls.rs:237:19
    |
 LL |     needs_sized::<StructAllFieldsMetaSized>();
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: within `StructAllFieldsMetaSized`, the trait `Sized` is not implemented for `[u8]`
 note: required because it appears within the type `StructAllFieldsMetaSized`
-  --> $DIR/impls.rs:240:12
+  --> $DIR/impls.rs:235:12
    |
 LL |     struct StructAllFieldsMetaSized { x: [u8], y: [u8] }
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -300,14 +300,14 @@ LL | fn needs_sized<T: Sized>() { }
    |                   ^^^^^ required by this bound in `needs_sized`
 
 error[E0277]: the size for values of type `main::Foo` cannot be known at compilation time
-  --> $DIR/impls.rs:250:19
+  --> $DIR/impls.rs:245:19
    |
 LL |     needs_sized::<StructAllFieldsUnsized>();
    |                   ^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: within `StructAllFieldsUnsized`, the trait `Sized` is not implemented for `main::Foo`
 note: required because it appears within the type `StructAllFieldsUnsized`
-  --> $DIR/impls.rs:248:12
+  --> $DIR/impls.rs:243:12
    |
 LL |     struct StructAllFieldsUnsized { x: Foo, y: Foo }
    |            ^^^^^^^^^^^^^^^^^^^^^^
@@ -318,14 +318,14 @@ LL | fn needs_sized<T: Sized>() { }
    |                   ^^^^^ required by this bound in `needs_sized`
 
 error[E0277]: the size for values of type `main::Foo` cannot be known
-  --> $DIR/impls.rs:252:23
+  --> $DIR/impls.rs:247:23
    |
 LL |     needs_metasized::<StructAllFieldsUnsized>();
    |                       ^^^^^^^^^^^^^^^^^^^^^^ doesn't have a known size
    |
    = help: within `StructAllFieldsUnsized`, the trait `MetaSized` is not implemented for `main::Foo`
 note: required because it appears within the type `StructAllFieldsUnsized`
-  --> $DIR/impls.rs:248:12
+  --> $DIR/impls.rs:243:12
    |
 LL |     struct StructAllFieldsUnsized { x: Foo, y: Foo }
    |            ^^^^^^^^^^^^^^^^^^^^^^
@@ -336,14 +336,14 @@ LL | fn needs_metasized<T: MetaSized>() { }
    |                       ^^^^^^^^^ required by this bound in `needs_metasized`
 
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
-  --> $DIR/impls.rs:258:19
+  --> $DIR/impls.rs:253:19
    |
 LL |     needs_sized::<StructLastFieldMetaSized>();
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: within `StructLastFieldMetaSized`, the trait `Sized` is not implemented for `[u8]`
 note: required because it appears within the type `StructLastFieldMetaSized`
-  --> $DIR/impls.rs:257:12
+  --> $DIR/impls.rs:252:12
    |
 LL |     struct StructLastFieldMetaSized { x: u32, y: [u8] }
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -354,14 +354,14 @@ LL | fn needs_sized<T: Sized>() { }
    |                   ^^^^^ required by this bound in `needs_sized`
 
 error[E0277]: the size for values of type `main::Foo` cannot be known at compilation time
-  --> $DIR/impls.rs:265:19
+  --> $DIR/impls.rs:260:19
    |
 LL |     needs_sized::<StructLastFieldUnsized>();
    |                   ^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: within `StructLastFieldUnsized`, the trait `Sized` is not implemented for `main::Foo`
 note: required because it appears within the type `StructLastFieldUnsized`
-  --> $DIR/impls.rs:264:12
+  --> $DIR/impls.rs:259:12
    |
 LL |     struct StructLastFieldUnsized { x: u32, y: Foo }
    |            ^^^^^^^^^^^^^^^^^^^^^^
@@ -372,14 +372,14 @@ LL | fn needs_sized<T: Sized>() { }
    |                   ^^^^^ required by this bound in `needs_sized`
 
 error[E0277]: the size for values of type `main::Foo` cannot be known
-  --> $DIR/impls.rs:267:23
+  --> $DIR/impls.rs:262:23
    |
 LL |     needs_metasized::<StructLastFieldUnsized>();
    |                       ^^^^^^^^^^^^^^^^^^^^^^ doesn't have a known size
    |
    = help: within `StructLastFieldUnsized`, the trait `MetaSized` is not implemented for `main::Foo`
 note: required because it appears within the type `StructLastFieldUnsized`
-  --> $DIR/impls.rs:264:12
+  --> $DIR/impls.rs:259:12
    |
 LL |     struct StructLastFieldUnsized { x: u32, y: Foo }
    |            ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/suggestions/wrap-dyn-in-suggestion-issue-120223.rs b/tests/ui/suggestions/wrap-dyn-in-suggestion-issue-120223.rs
index 6a273997ee630..2ee6ad91056c5 100644
--- a/tests/ui/suggestions/wrap-dyn-in-suggestion-issue-120223.rs
+++ b/tests/ui/suggestions/wrap-dyn-in-suggestion-issue-120223.rs
@@ -1,5 +1,3 @@
-#![feature(dyn_star)] //~ WARNING the feature `dyn_star` is incomplete
-
 use std::future::Future;
 
 pub fn dyn_func<T>(
@@ -8,12 +6,6 @@ pub fn dyn_func<T>(
     Box::new(executor) //~ ERROR may not live long enough
 }
 
-pub fn dyn_star_func<T>(
-    executor: impl FnOnce(T) -> dyn* Future<Output = ()>,
-) -> Box<dyn FnOnce(T) -> dyn* Future<Output = ()>> {
-    Box::new(executor) //~ ERROR may not live long enough
-}
-
 trait Trait {
     fn method(&self) {}
 }
diff --git a/tests/ui/suggestions/wrap-dyn-in-suggestion-issue-120223.stderr b/tests/ui/suggestions/wrap-dyn-in-suggestion-issue-120223.stderr
index 1fb3e7d211edb..62943616e3ad0 100644
--- a/tests/ui/suggestions/wrap-dyn-in-suggestion-issue-120223.stderr
+++ b/tests/ui/suggestions/wrap-dyn-in-suggestion-issue-120223.stderr
@@ -1,14 +1,5 @@
-warning: the feature `dyn_star` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/wrap-dyn-in-suggestion-issue-120223.rs:1:12
-   |
-LL | #![feature(dyn_star)]
-   |            ^^^^^^^^
-   |
-   = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0599]: no method named `method` found for type parameter `T` in the current scope
-  --> $DIR/wrap-dyn-in-suggestion-issue-120223.rs:24:7
+  --> $DIR/wrap-dyn-in-suggestion-issue-120223.rs:16:7
    |
 LL | pub fn in_ty_param<T: Fn() -> dyn std::fmt::Debug> (t: T) {
    |                    - method `method` not found for this type parameter
@@ -22,7 +13,7 @@ LL | pub fn in_ty_param<T: Fn() -> (dyn std::fmt::Debug) + Trait> (t: T) {
    |                               +                   +++++++++
 
 error[E0277]: the size for values of type `T` cannot be known at compilation time
-  --> $DIR/wrap-dyn-in-suggestion-issue-120223.rs:29:21
+  --> $DIR/wrap-dyn-in-suggestion-issue-120223.rs:21:21
    |
 LL | fn with_sized<T: Fn() -> &'static (dyn std::fmt::Debug) + ?Sized>() {
    |               - this type parameter needs to be `Sized`
@@ -30,7 +21,7 @@ LL |     without_sized::<T>();
    |                     ^ doesn't have a size known at compile-time
    |
 note: required by an implicit `Sized` bound in `without_sized`
-  --> $DIR/wrap-dyn-in-suggestion-issue-120223.rs:33:18
+  --> $DIR/wrap-dyn-in-suggestion-issue-120223.rs:25:18
    |
 LL | fn without_sized<T: Fn() -> &'static dyn std::fmt::Debug>() {}
    |                  ^ required by the implicit `Sized` requirement on this type parameter in `without_sized`
@@ -45,7 +36,7 @@ LL | fn without_sized<T: Fn() -> &'static (dyn std::fmt::Debug) + ?Sized>() {}
    |                                      +                   ++++++++++
 
 error[E0310]: the parameter type `impl FnOnce(T) -> dyn Future<Output = ()>` may not live long enough
-  --> $DIR/wrap-dyn-in-suggestion-issue-120223.rs:8:5
+  --> $DIR/wrap-dyn-in-suggestion-issue-120223.rs:6:5
    |
 LL |     Box::new(executor)
    |     ^^^^^^^^^^^^^^^^^^
@@ -58,21 +49,7 @@ help: consider adding an explicit lifetime bound
 LL |     executor: impl FnOnce(T) -> (dyn Future<Output = ()>) + 'static,
    |                                 +                       +++++++++++
 
-error[E0310]: the parameter type `impl FnOnce(T) -> dyn* Future<Output = ()>` may not live long enough
-  --> $DIR/wrap-dyn-in-suggestion-issue-120223.rs:14:5
-   |
-LL |     Box::new(executor)
-   |     ^^^^^^^^^^^^^^^^^^
-   |     |
-   |     the parameter type `impl FnOnce(T) -> dyn* Future<Output = ()>` must be valid for the static lifetime...
-   |     ...so that the type `impl FnOnce(T) -> dyn* Future<Output = ()>` will meet its required lifetime bounds
-   |
-help: consider adding an explicit lifetime bound
-   |
-LL |     executor: impl FnOnce(T) -> (dyn* Future<Output = ()>) + 'static,
-   |                                 +                        +++++++++++
-
-error: aborting due to 4 previous errors; 1 warning emitted
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0277, E0310, E0599.
 For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/dyn-star-drop-principal.rs b/tests/ui/traits/dyn-star-drop-principal.rs
deleted file mode 100644
index 1ad99070339ad..0000000000000
--- a/tests/ui/traits/dyn-star-drop-principal.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![feature(dyn_star)]
-#![allow(incomplete_features)]
-
-trait Trait {}
-impl Trait for usize {}
-
-fn main() {
-    // We allow &dyn Trait + Send -> &dyn Send (i.e. dropping principal),
-    // but we don't (currently?) allow the same for dyn*
-    let x: dyn* Trait + Send = 1usize;
-    x as dyn* Send; //~ error: `dyn* Trait + Send` needs to have the same ABI as a pointer
-}
diff --git a/tests/ui/traits/dyn-star-drop-principal.stderr b/tests/ui/traits/dyn-star-drop-principal.stderr
deleted file mode 100644
index 721ae7e191ef0..0000000000000
--- a/tests/ui/traits/dyn-star-drop-principal.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error[E0277]: `dyn* Trait + Send` needs to have the same ABI as a pointer
-  --> $DIR/dyn-star-drop-principal.rs:11:5
-   |
-LL |     x as dyn* Send;
-   |     ^ `dyn* Trait + Send` needs to be a pointer-like type
-   |
-   = help: the trait `PointerLike` is not implemented for `dyn* Trait + Send`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/trait-upcasting/dyn-to-dyn-star.rs b/tests/ui/traits/trait-upcasting/dyn-to-dyn-star.rs
deleted file mode 100644
index 5936c93efad31..0000000000000
--- a/tests/ui/traits/trait-upcasting/dyn-to-dyn-star.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-// While somewhat nonsensical, this is a cast from a wide pointer to a thin pointer.
-// Thus, we don't need to check an unsize goal here; there isn't any vtable casting
-// happening at all.
-
-// Regression test for <https://github.com/rust-lang/rust/issues/137579>.
-
-//@ check-pass
-
-#![allow(incomplete_features)]
-#![feature(dyn_star)]
-
-trait Foo {}
-trait Bar {}
-
-fn cast(x: *const dyn Foo) {
-    x as *const dyn* Bar;
-}
-
-fn main() {}
diff --git a/tests/ui/unpretty/exhaustive.expanded.stdout b/tests/ui/unpretty/exhaustive.expanded.stdout
index 9df027b69b2ff..53ca3c8e39156 100644
--- a/tests/ui/unpretty/exhaustive.expanded.stdout
+++ b/tests/ui/unpretty/exhaustive.expanded.stdout
@@ -15,7 +15,6 @@
 #![feature(const_trait_impl)]
 #![feature(decl_macro)]
 #![feature(deref_patterns)]
-#![feature(dyn_star)]
 #![feature(explicit_tail_calls)]
 #![feature(gen_blocks)]
 #![feature(more_qualified_paths)]
@@ -596,7 +595,6 @@ mod types {
         let _: dyn Send + 'static;
         let _: dyn 'static + Send;
         let _: dyn for<'a> Send;
-        let _: dyn* Send;
     }
     /// TyKind::ImplTrait
     const fn ty_impl_trait() {
diff --git a/tests/ui/unpretty/exhaustive.hir.stderr b/tests/ui/unpretty/exhaustive.hir.stderr
index ac8079ae089e6..aa411ce81eb4c 100644
--- a/tests/ui/unpretty/exhaustive.hir.stderr
+++ b/tests/ui/unpretty/exhaustive.hir.stderr
@@ -1,17 +1,17 @@
 error[E0697]: closures cannot be static
-  --> $DIR/exhaustive.rs:210:9
+  --> $DIR/exhaustive.rs:209:9
    |
 LL |         static || value;
    |         ^^^^^^^^^
 
 error[E0697]: closures cannot be static
-  --> $DIR/exhaustive.rs:211:9
+  --> $DIR/exhaustive.rs:210:9
    |
 LL |         static move || value;
    |         ^^^^^^^^^^^^^^
 
 error[E0728]: `await` is only allowed inside `async` functions and blocks
-  --> $DIR/exhaustive.rs:240:13
+  --> $DIR/exhaustive.rs:239:13
    |
 LL |     fn expr_await() {
    |     --------------- this is not `async`
@@ -20,19 +20,19 @@ LL |         fut.await;
    |             ^^^^^ only allowed inside `async` functions and blocks
 
 error: in expressions, `_` can only be used on the left-hand side of an assignment
-  --> $DIR/exhaustive.rs:289:9
+  --> $DIR/exhaustive.rs:288:9
    |
 LL |         _;
    |         ^ `_` not allowed here
 
 error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/exhaustive.rs:299:9
+  --> $DIR/exhaustive.rs:298:9
    |
 LL |         x::();
    |         ^^^^^ only `Fn` traits may use parentheses
 
 error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/exhaustive.rs:300:9
+  --> $DIR/exhaustive.rs:299:9
    |
 LL |         x::(T, T) -> T;
    |         ^^^^^^^^^^^^^^ only `Fn` traits may use parentheses
@@ -44,31 +44,31 @@ LL +         x::<T, T> -> T;
    |
 
 error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/exhaustive.rs:301:9
+  --> $DIR/exhaustive.rs:300:9
    |
 LL |         crate::() -> ()::expressions::() -> ()::expr_path;
    |         ^^^^^^^^^^^^^^^ only `Fn` traits may use parentheses
 
 error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/exhaustive.rs:301:26
+  --> $DIR/exhaustive.rs:300:26
    |
 LL |         crate::() -> ()::expressions::() -> ()::expr_path;
    |                          ^^^^^^^^^^^^^^^^^^^^^ only `Fn` traits may use parentheses
 
 error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/exhaustive.rs:304:9
+  --> $DIR/exhaustive.rs:303:9
    |
 LL |         core::()::marker::()::PhantomData;
    |         ^^^^^^^^ only `Fn` traits may use parentheses
 
 error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/exhaustive.rs:304:19
+  --> $DIR/exhaustive.rs:303:19
    |
 LL |         core::()::marker::()::PhantomData;
    |                   ^^^^^^^^^^ only `Fn` traits may use parentheses
 
 error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
-  --> $DIR/exhaustive.rs:391:9
+  --> $DIR/exhaustive.rs:390:9
    |
 LL |         yield;
    |         ^^^^^
@@ -79,7 +79,7 @@ LL |     #[coroutine] fn expr_yield() {
    |     ++++++++++++
 
 error[E0703]: invalid ABI: found `C++`
-  --> $DIR/exhaustive.rs:471:23
+  --> $DIR/exhaustive.rs:470:23
    |
 LL |         unsafe extern "C++" {}
    |                       ^^^^^ invalid ABI
@@ -87,7 +87,7 @@ LL |         unsafe extern "C++" {}
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
 
 error: `..` patterns are not allowed here
-  --> $DIR/exhaustive.rs:678:13
+  --> $DIR/exhaustive.rs:677:13
    |
 LL |         let ..;
    |             ^^
@@ -95,13 +95,13 @@ LL |         let ..;
    = note: only allowed in tuple, tuple struct, and slice patterns
 
 error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/exhaustive.rs:793:16
+  --> $DIR/exhaustive.rs:792:16
    |
 LL |         let _: T() -> !;
    |                ^^^^^^^^ only `Fn` traits may use parentheses
 
 error[E0562]: `impl Trait` is not allowed in the type of variable bindings
-  --> $DIR/exhaustive.rs:808:16
+  --> $DIR/exhaustive.rs:806:16
    |
 LL |         let _: impl Send;
    |                ^^^^^^^^^
@@ -112,7 +112,7 @@ LL |         let _: impl Send;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0562]: `impl Trait` is not allowed in the type of variable bindings
-  --> $DIR/exhaustive.rs:809:16
+  --> $DIR/exhaustive.rs:807:16
    |
 LL |         let _: impl Send + 'static;
    |                ^^^^^^^^^^^^^^^^^^^
@@ -123,7 +123,7 @@ LL |         let _: impl Send + 'static;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0562]: `impl Trait` is not allowed in the type of variable bindings
-  --> $DIR/exhaustive.rs:810:16
+  --> $DIR/exhaustive.rs:808:16
    |
 LL |         let _: impl 'static + Send;
    |                ^^^^^^^^^^^^^^^^^^^
@@ -134,7 +134,7 @@ LL |         let _: impl 'static + Send;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0562]: `impl Trait` is not allowed in the type of variable bindings
-  --> $DIR/exhaustive.rs:811:16
+  --> $DIR/exhaustive.rs:809:16
    |
 LL |         let _: impl ?Sized;
    |                ^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL |         let _: impl ?Sized;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0562]: `impl Trait` is not allowed in the type of variable bindings
-  --> $DIR/exhaustive.rs:812:16
+  --> $DIR/exhaustive.rs:810:16
    |
 LL |         let _: impl [const] Clone;
    |                ^^^^^^^^^^^^^^^^^^
@@ -156,7 +156,7 @@ LL |         let _: impl [const] Clone;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0562]: `impl Trait` is not allowed in the type of variable bindings
-  --> $DIR/exhaustive.rs:813:16
+  --> $DIR/exhaustive.rs:811:16
    |
 LL |         let _: impl for<'a> Send;
    |                ^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/unpretty/exhaustive.hir.stdout b/tests/ui/unpretty/exhaustive.hir.stdout
index 2d347ec6e88d3..2b8f3b21396be 100644
--- a/tests/ui/unpretty/exhaustive.hir.stdout
+++ b/tests/ui/unpretty/exhaustive.hir.stdout
@@ -14,7 +14,6 @@
 #![feature(const_trait_impl)]
 #![feature(decl_macro)]
 #![feature(deref_patterns)]
-#![feature(dyn_star)]
 #![feature(explicit_tail_calls)]
 #![feature(gen_blocks)]
 #![feature(more_qualified_paths)]
@@ -661,7 +660,6 @@ mod types {
         let _: dyn Send + 'static;
         let _: dyn Send + 'static;
         let _: dyn for<'a> Send;
-        let _: dyn* Send;
     }
     /// TyKind::ImplTrait
     const fn ty_impl_trait() {
diff --git a/tests/ui/unpretty/exhaustive.rs b/tests/ui/unpretty/exhaustive.rs
index 5bf1118058cba..5292ddad4f6b2 100644
--- a/tests/ui/unpretty/exhaustive.rs
+++ b/tests/ui/unpretty/exhaustive.rs
@@ -14,7 +14,6 @@
 #![feature(const_trait_impl)]
 #![feature(decl_macro)]
 #![feature(deref_patterns)]
-#![feature(dyn_star)]
 #![feature(explicit_tail_calls)]
 #![feature(gen_blocks)]
 #![feature(more_qualified_paths)]
@@ -800,7 +799,6 @@ mod types {
         let _: dyn Send + 'static;
         let _: dyn 'static + Send;
         let _: dyn for<'a> Send;
-        let _: dyn* Send;
     }
 
     /// TyKind::ImplTrait