Rollup of 6 pull requests

compiler/rustc_attr_parsing/src/attributes/crate_level.rs

@@ -301,3 +301,50 @@ impl<S: Stage> NoArgsAttributeParser<S> for DefaultLibAllocatorParser {
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::DefaultLibAllocator;
 }
+
+pub(crate) struct RegisterToolParser;
+
+impl<S: Stage> CombineAttributeParser<S> for RegisterToolParser {
+    const PATH: &[Symbol] = &[sym::register_tool];
+    type Item = Ident;
+    const CONVERT: ConvertFn<Self::Item> = AttributeKind::RegisterTool;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+    const TEMPLATE: AttributeTemplate = template!(List: &["tool1, tool2, ..."]);
+
+    fn extend(
+        cx: &mut AcceptContext<'_, '_, S>,
+        args: &ArgParser,
+    ) -> impl IntoIterator<Item = Self::Item> {
+        let ArgParser::List(list) = args else {
+            cx.expected_list(cx.attr_span, args);
+            return Vec::new();
+        };
+
+        if list.is_empty() {
+            cx.warn_empty_attribute(cx.attr_span);
+        }
+
+        let mut res = Vec::new();
+
+        for elem in list.mixed() {
+            let Some(elem) = elem.meta_item() else {
+                cx.expected_identifier(elem.span());
+                continue;
+            };
+            if let Err(arg_span) = elem.args().no_args() {
+                cx.expected_no_args(arg_span);
+                continue;
+            }
+
+            let path = elem.path();
+            let Some(ident) = path.word() else {
+                cx.expected_identifier(path.span());
+                continue;
+            };
+
+            res.push(ident);
+        }
+
+        res
+    }
+}

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -175,6 +175,20 @@ impl<S: Stage> SingleAttributeParser<S> for RustcLegacyConstGenericsParser {
     }
 }
 
+pub(crate) struct RustcInheritOverflowChecksParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcInheritOverflowChecksParser {
+    const PATH: &[Symbol] = &[sym::rustc_inherit_overflow_checks];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::Fn),
+        Allow(Target::Method(MethodKind::Inherent)),
+        Allow(Target::Method(MethodKind::TraitImpl)),
+        Allow(Target::Closure),
+    ]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcInheritOverflowChecks;
+}
+
 pub(crate) struct RustcLintOptDenyFieldAccessParser;
 
 impl<S: Stage> SingleAttributeParser<S> for RustcLintOptDenyFieldAccessParser {

compiler/rustc_attr_parsing/src/context.rs

@@ -159,6 +159,7 @@ attribute_parsers!(
         Combine<DebuggerViualizerParser>,
         Combine<ForceTargetFeatureParser>,
         Combine<LinkParser>,
+        Combine<RegisterToolParser>,
         Combine<ReprParser>,
         Combine<RustcCleanParser>,
         Combine<RustcLayoutParser>,
@@ -286,6 +287,7 @@ attribute_parsers!(
         Single<WithoutArgs<RustcEvaluateWhereClausesParser>>,
         Single<WithoutArgs<RustcHasIncoherentInherentImplsParser>>,
         Single<WithoutArgs<RustcHiddenTypeOfOpaquesParser>>,
+        Single<WithoutArgs<RustcInheritOverflowChecksParser>>,
         Single<WithoutArgs<RustcInsignificantDtorParser>>,
         Single<WithoutArgs<RustcIntrinsicConstStableIndirectParser>>,
         Single<WithoutArgs<RustcIntrinsicParser>>,

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -2,7 +2,7 @@ use std::borrow::{Borrow, Cow};
 use std::fmt;
 use std::hash::Hash;
 
-use rustc_abi::{Align, Size};
+use rustc_abi::{Align, FIRST_VARIANT, Size};
 use rustc_ast::Mutability;
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap, IndexEntry};
 use rustc_errors::msg;
@@ -24,7 +24,7 @@ use crate::interpret::{
     self, AllocId, AllocInit, AllocRange, ConstAllocation, CtfeProvenance, FnArg, Frame,
     GlobalAlloc, ImmTy, InterpCx, InterpResult, OpTy, PlaceTy, Pointer, RangeSet, Scalar,
     compile_time_machine, err_inval, interp_ok, throw_exhaust, throw_inval, throw_ub,
-    throw_ub_custom, throw_unsup, throw_unsup_format,
+    throw_ub_custom, throw_unsup, throw_unsup_format, type_implements_dyn_trait,
 };
 
 /// When hitting this many interpreted terminators we emit a deny by default lint
@@ -598,6 +598,22 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 }
             }
 
+            sym::type_id_vtable => {
+                let tp_ty = ecx.read_type_id(&args[0])?;
+                let result_ty = ecx.read_type_id(&args[1])?;
+
+                let (implements_trait, preds) = type_implements_dyn_trait(ecx, tp_ty, result_ty)?;
+
+                if implements_trait {
+                    let vtable_ptr = ecx.get_vtable_ptr(tp_ty, preds)?;
+                    // Writing a non-null pointer into an `Option<NonNull>` will automatically make it `Some`.
+                    ecx.write_pointer(vtable_ptr, dest)?;
+                } else {
+                    // Write `None`
+                    ecx.write_discriminant(FIRST_VARIANT, dest)?;
+                }
+            }
+
             sym::type_of => {
                 let ty = ecx.read_type_id(&args[0])?;
                 ecx.write_type_info(ty, dest)?;

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -4,19 +4,16 @@
 
 mod simd;
 
-use rustc_abi::{FIRST_VARIANT, FieldIdx, HasDataLayout, Size, VariantIdx};
+use rustc_abi::{FieldIdx, HasDataLayout, Size, VariantIdx};
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
 use rustc_data_structures::assert_matches;
 use rustc_errors::msg;
-use rustc_hir::def_id::CRATE_DEF_ID;
-use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::mir::interpret::{CTFE_ALLOC_SALT, read_target_uint, write_target_uint};
 use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic};
 use rustc_middle::ty::layout::TyAndLayout;
-use rustc_middle::ty::{FloatTy, PolyExistentialPredicate, Ty, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{FloatTy, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::{bug, span_bug, ty};
 use rustc_span::{Symbol, sym};
-use rustc_trait_selection::traits::{Obligation, ObligationCause, ObligationCtxt};
 use tracing::trace;
 
 use super::memory::MemoryKind;
@@ -227,44 +224,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 
                 self.write_scalar(Scalar::from_target_usize(offset, self), dest)?;
             }
-            sym::vtable_for => {
-                let tp_ty = instance.args.type_at(0);
-                let result_ty = instance.args.type_at(1);
-
-                ensure_monomorphic_enough(tcx, tp_ty)?;
-                ensure_monomorphic_enough(tcx, result_ty)?;
-                let ty::Dynamic(preds, _) = result_ty.kind() else {
-                    span_bug!(
-                        self.find_closest_untracked_caller_location(),
-                        "Invalid type provided to vtable_for::<T, U>. U must be dyn Trait, got {result_ty}."
-                    );
-                };
-
-                let (infcx, param_env) =
-                    self.tcx.infer_ctxt().build_with_typing_env(self.typing_env);
-
-                let ocx = ObligationCtxt::new(&infcx);
-                ocx.register_obligations(preds.iter().map(|pred: PolyExistentialPredicate<'_>| {
-                    let pred = pred.with_self_ty(tcx, tp_ty);
-                    // Lifetimes can only be 'static because of the bound on T
-                    let pred = ty::fold_regions(tcx, pred, |r, _| {
-                        if r == tcx.lifetimes.re_erased { tcx.lifetimes.re_static } else { r }
-                    });
-                    Obligation::new(tcx, ObligationCause::dummy(), param_env, pred)
-                }));
-                let type_impls_trait = ocx.evaluate_obligations_error_on_ambiguity().is_empty();
-                // Since `assumed_wf_tys=[]` the choice of LocalDefId is irrelevant, so using the "default"
-                let regions_are_valid = ocx.resolve_regions(CRATE_DEF_ID, param_env, []).is_empty();
-
-                if regions_are_valid && type_impls_trait {
-                    let vtable_ptr = self.get_vtable_ptr(tp_ty, preds)?;
-                    // Writing a non-null pointer into an `Option<NonNull>` will automatically make it `Some`.
-                    self.write_pointer(vtable_ptr, dest)?;
-                } else {
-                    // Write `None`
-                    self.write_discriminant(FIRST_VARIANT, dest)?;
-                }
-            }
             sym::variant_count => {
                 let tp_ty = instance.args.type_at(0);
                 let ty = match tp_ty.kind() {

compiler/rustc_const_eval/src/interpret/mod.rs

@@ -38,6 +38,6 @@ use self::place::{MemPlace, Place};
 pub use self::projection::{OffsetMode, Projectable};
 pub use self::stack::{Frame, FrameInfo, LocalState, ReturnContinuation};
 pub use self::util::EnteredTraceSpan;
-pub(crate) use self::util::create_static_alloc;
+pub(crate) use self::util::{create_static_alloc, type_implements_dyn_trait};
 pub use self::validity::{CtfeValidationMode, RangeSet, RefTracking};
 pub use self::visitor::ValueVisitor;

compiler/rustc_const_eval/src/interpret/step.rs

@@ -86,7 +86,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             span = ?stmt.source_info.span,
             tracing_separate_thread = Empty,
         )
-        .or_if_tracing_disabled(|| info!(stmt = ?stmt.kind));
+        .or_if_tracing_disabled(|| info!("{:?}", stmt.kind));
 
         use rustc_middle::mir::StatementKind::*;
 
@@ -490,7 +490,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             span = ?terminator.source_info.span,
             tracing_separate_thread = Empty,
         )
-        .or_if_tracing_disabled(|| info!(terminator = ?terminator.kind));
+        .or_if_tracing_disabled(|| info!("{:?}", terminator.kind));
 
         use rustc_middle::mir::TerminatorKind::*;
         match terminator.kind {

compiler/rustc_const_eval/src/interpret/util.rs

@@ -1,12 +1,51 @@
-use rustc_hir::def_id::LocalDefId;
-use rustc_middle::mir;
+use rustc_hir::def_id::{CRATE_DEF_ID, LocalDefId};
+use rustc_infer::infer::TyCtxtInferExt;
+use rustc_infer::traits::{Obligation, ObligationCause};
 use rustc_middle::mir::interpret::{AllocInit, Allocation, GlobalAlloc, InterpResult, Pointer};
 use rustc_middle::ty::layout::TyAndLayout;
-use rustc_middle::ty::{TyCtxt, TypeVisitable, TypeVisitableExt};
+use rustc_middle::ty::{PolyExistentialPredicate, Ty, TyCtxt, TypeVisitable, TypeVisitableExt};
+use rustc_middle::{mir, span_bug, ty};
+use rustc_trait_selection::traits::ObligationCtxt;
 use tracing::debug;
 
 use super::{InterpCx, MPlaceTy, MemoryKind, interp_ok, throw_inval};
 use crate::const_eval::{CompileTimeInterpCx, CompileTimeMachine, InterpretationResult};
+use crate::interpret::Machine;
+
+/// Checks if a type implements predicates.
+/// Calls `ensure_monomorphic_enough` on `ty` and `trait_ty` for you.
+pub(crate) fn type_implements_dyn_trait<'tcx, M: Machine<'tcx>>(
+    ecx: &mut InterpCx<'tcx, M>,
+    ty: Ty<'tcx>,
+    trait_ty: Ty<'tcx>,
+) -> InterpResult<'tcx, (bool, &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>)> {
+    ensure_monomorphic_enough(ecx.tcx.tcx, ty)?;
+    ensure_monomorphic_enough(ecx.tcx.tcx, trait_ty)?;
+
+    let ty::Dynamic(preds, _) = trait_ty.kind() else {
+        span_bug!(
+            ecx.find_closest_untracked_caller_location(),
+            "Invalid type provided to type_implements_predicates. U must be dyn Trait, got {trait_ty}."
+        );
+    };
+
+    let (infcx, param_env) = ecx.tcx.infer_ctxt().build_with_typing_env(ecx.typing_env);
+
+    let ocx = ObligationCtxt::new(&infcx);
+    ocx.register_obligations(preds.iter().map(|pred: PolyExistentialPredicate<'_>| {
+        let pred = pred.with_self_ty(ecx.tcx.tcx, ty);
+        // Lifetimes can only be 'static because of the bound on T
+        let pred = rustc_middle::ty::fold_regions(ecx.tcx.tcx, pred, |r, _| {
+            if r == ecx.tcx.tcx.lifetimes.re_erased { ecx.tcx.tcx.lifetimes.re_static } else { r }
+        });
+        Obligation::new(ecx.tcx.tcx, ObligationCause::dummy(), param_env, pred)
+    }));
+    let type_impls_trait = ocx.evaluate_obligations_error_on_ambiguity().is_empty();
+    // Since `assumed_wf_tys=[]` the choice of LocalDefId is irrelevant, so using the "default"
+    let regions_are_valid = ocx.resolve_regions(CRATE_DEF_ID, param_env, []).is_empty();
+
+    interp_ok((regions_are_valid && type_impls_trait, preds))
+}
 
 /// Checks whether a type contains generic parameters which must be instantiated.
 ///

compiler/rustc_driver_impl/src/lib.rs

@@ -707,8 +707,9 @@ fn print_crate_info(
                 };
                 let crate_name = passes::get_crate_name(sess, attrs);
                 let lint_store = crate::unerased_lint_store(sess);
-                let registered_tools = rustc_resolve::registered_tools_ast(sess.dcx(), attrs);
                 let features = rustc_expand::config::features(sess, attrs, crate_name);
+                let registered_tools =
+                    rustc_resolve::registered_tools_ast(sess.dcx(), attrs, sess, &features);
                 let lint_levels = rustc_lint::LintLevelsBuilder::crate_root(
                     sess,
                     &features,

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -1136,6 +1136,9 @@ pub enum AttributeKind {
     /// Represents `#[reexport_test_harness_main]`
     ReexportTestHarnessMain(Symbol),
 
+    /// Represents `#[register_tool]`
+    RegisterTool(ThinVec<Ident>, Span),
+
     /// Represents [`#[repr]`](https://doc.rust-lang.org/stable/reference/type-layout.html#representations).
     Repr {
         reprs: ThinVec<(ReprAttr, Span)>,
@@ -1274,6 +1277,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_if_this_changed]`
     RustcIfThisChanged(Span, Option<Symbol>),
 
+    /// Represents `#[rustc_inherit_overflow_checks]`
+    RustcInheritOverflowChecks,
+
     /// Represents `#[rustc_insignificant_dtor]`
     RustcInsignificantDtor,
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -91,6 +91,7 @@ impl AttributeKind {
             ProfilerRuntime => No,
             RecursionLimit { .. } => No,
             ReexportTestHarnessMain(..) => No,
+            RegisterTool(..) => No,
             Repr { .. } => No,
             RustcAbi { .. } => No,
             RustcAllocator => No,
@@ -130,6 +131,7 @@ impl AttributeKind {
             RustcHasIncoherentInherentImpls => Yes,
             RustcHiddenTypeOfOpaques => No,
             RustcIfThisChanged(..) => No,
+            RustcInheritOverflowChecks => No,
             RustcInsignificantDtor => Yes,
             RustcIntrinsic => Yes,
             RustcIntrinsicConstStableIndirect => No,

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -213,12 +213,12 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::truncf128
         | sym::type_id
         | sym::type_id_eq
+        | sym::type_id_vtable
         | sym::type_name
         | sym::type_of
         | sym::ub_checks
         | sym::va_copy
         | sym::variant_count
-        | sym::vtable_for
         | sym::wrapping_add
         | sym::wrapping_mul
         | sym::wrapping_sub
@@ -323,6 +323,25 @@ pub(crate) fn check_intrinsic_type(
             let type_id = tcx.type_of(tcx.lang_items().type_id().unwrap()).no_bound_vars().unwrap();
             (0, 0, vec![type_id, type_id], tcx.types.bool)
         }
+        sym::type_id_vtable => {
+            let dyn_metadata = tcx.require_lang_item(LangItem::DynMetadata, span);
+            let dyn_metadata_adt_ref = tcx.adt_def(dyn_metadata);
+            let dyn_metadata_args =
+                tcx.mk_args(&[Ty::new_ptr(tcx, tcx.types.unit, ty::Mutability::Not).into()]);
+            let dyn_ty = Ty::new_adt(tcx, dyn_metadata_adt_ref, dyn_metadata_args);
+
+            let option_did = tcx.require_lang_item(LangItem::Option, span);
+            let option_adt_ref = tcx.adt_def(option_did);
+            let option_args = tcx.mk_args(&[dyn_ty.into()]);
+            let ret_ty = Ty::new_adt(tcx, option_adt_ref, option_args);
+
+            (
+                0,
+                0,
+                vec![tcx.type_of(tcx.lang_items().type_id().unwrap()).no_bound_vars().unwrap(); 2],
+                ret_ty,
+            )
+        }
         sym::type_of => (
             0,
             0,
@@ -675,20 +694,6 @@ pub(crate) fn check_intrinsic_type(
             (0, 0, vec![Ty::new_imm_ptr(tcx, tcx.types.unit)], tcx.types.usize)
         }
 
-        sym::vtable_for => {
-            let dyn_metadata = tcx.require_lang_item(LangItem::DynMetadata, span);
-            let dyn_metadata_adt_ref = tcx.adt_def(dyn_metadata);
-            let dyn_metadata_args = tcx.mk_args(&[param(1).into()]);
-            let dyn_ty = Ty::new_adt(tcx, dyn_metadata_adt_ref, dyn_metadata_args);
-
-            let option_did = tcx.require_lang_item(LangItem::Option, span);
-            let option_adt_ref = tcx.adt_def(option_did);
-            let option_args = tcx.mk_args(&[dyn_ty.into()]);
-            let ret_ty = Ty::new_adt(tcx, option_adt_ref, option_args);
-
-            (2, 0, vec![], ret_ty)
-        }
-
         // This type check is not particularly useful, but the `where` bounds
         // on the definition in `core` do the heavy lifting for checking it.
         sym::aggregate_raw_ptr => (3, 0, vec![param(1), param(2)], param(0)),