Auto merge of #150146 - JonathanBrouwer:rollup-s1jdwck, r=JonathanBrouwer

Rollup of 4 pull requests

Successful merges:

 - #147430 (cg_llvm: More preparation for moving FFI bindings to `rustc_llvm`)
 - #149815 (Add regression test for #120189)
 - #149947 (add several older crashtests)
 - #150127 (Port `#[rustc_lint_untracked_query_information]` and `#[rustc_lint_diagnostics]` to using attribute parsers)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -117,6 +117,21 @@ impl<S: Stage> SingleAttributeParser<S> for RustcLegacyConstGenericsParser {
     }
 }
 
+pub(crate) struct RustcLintDiagnosticsParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcLintDiagnosticsParser {
+    const PATH: &[Symbol] = &[sym::rustc_lint_diagnostics];
+    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::Trait { body: false })),
+        Allow(Target::Method(MethodKind::Trait { body: true })),
+        Allow(Target::Method(MethodKind::TraitImpl)),
+    ]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcLintDiagnostics;
+}
+
 pub(crate) struct RustcLintOptDenyFieldAccessParser;
 
 impl<S: Stage> SingleAttributeParser<S> for RustcLintOptDenyFieldAccessParser {
@@ -165,6 +180,22 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcLintQueryInstabilityParser {
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcLintQueryInstability;
 }
 
+pub(crate) struct RustcLintUntrackedQueryInformationParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcLintUntrackedQueryInformationParser {
+    const PATH: &[Symbol] = &[sym::rustc_lint_untracked_query_information];
+    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::Trait { body: false })),
+        Allow(Target::Method(MethodKind::Trait { body: true })),
+        Allow(Target::Method(MethodKind::TraitImpl)),
+    ]);
+
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcLintUntrackedQueryInformation;
+}
+
 pub(crate) struct RustcObjectLifetimeDefaultParser;
 
 impl<S: Stage> SingleAttributeParser<S> for RustcObjectLifetimeDefaultParser {

compiler/rustc_attr_parsing/src/context.rs

@@ -61,8 +61,9 @@ use crate::attributes::prototype::CustomMirParser;
 use crate::attributes::repr::{AlignParser, AlignStaticParser, ReprParser};
 use crate::attributes::rustc_internal::{
     RustcLayoutScalarValidRangeEndParser, RustcLayoutScalarValidRangeStartParser,
-    RustcLegacyConstGenericsParser, RustcLintOptDenyFieldAccessParser, RustcLintOptTyParser,
-    RustcLintQueryInstabilityParser, RustcMainParser, RustcNeverReturnsNullPointerParser,
+    RustcLegacyConstGenericsParser, RustcLintDiagnosticsParser, RustcLintOptDenyFieldAccessParser,
+    RustcLintOptTyParser, RustcLintQueryInstabilityParser,
+    RustcLintUntrackedQueryInformationParser, RustcMainParser, RustcNeverReturnsNullPointerParser,
     RustcNoImplicitAutorefsParser, RustcObjectLifetimeDefaultParser, RustcScalableVectorParser,
     RustcSimdMonomorphizeLaneLimitParser,
 };
@@ -257,8 +258,10 @@ attribute_parsers!(
         Single<WithoutArgs<ProcMacroParser>>,
         Single<WithoutArgs<PubTransparentParser>>,
         Single<WithoutArgs<RustcCoherenceIsCoreParser>>,
+        Single<WithoutArgs<RustcLintDiagnosticsParser>>,
         Single<WithoutArgs<RustcLintOptTyParser>>,
         Single<WithoutArgs<RustcLintQueryInstabilityParser>>,
+        Single<WithoutArgs<RustcLintUntrackedQueryInformationParser>>,
         Single<WithoutArgs<RustcMainParser>>,
         Single<WithoutArgs<RustcNeverReturnsNullPointerParser>>,
         Single<WithoutArgs<RustcNoImplicitAutorefsParser>>,

compiler/rustc_codegen_llvm/src/debuginfo/di_builder.rs

@@ -1,8 +1,37 @@
+use std::ptr;
+
 use libc::c_uint;
 use rustc_abi::Align;
 
 use crate::llvm::debuginfo::DIBuilder;
-use crate::llvm::{self, ToLlvmBool};
+use crate::llvm::{self, Module, ToLlvmBool};
+
+/// Owning pointer to a `DIBuilder<'ll>` that will dispose of the builder
+/// when dropped. Use `.as_ref()` to get the underlying `&DIBuilder`
+/// needed for debuginfo FFI calls.
+pub(crate) struct DIBuilderBox<'ll> {
+    raw: ptr::NonNull<DIBuilder<'ll>>,
+}
+
+impl<'ll> DIBuilderBox<'ll> {
+    pub(crate) fn new(llmod: &'ll Module) -> Self {
+        let raw = unsafe { llvm::LLVMCreateDIBuilder(llmod) };
+        let raw = ptr::NonNull::new(raw).unwrap();
+        Self { raw }
+    }
+
+    pub(crate) fn as_ref(&self) -> &DIBuilder<'ll> {
+        // SAFETY: This is an owning pointer, so `&DIBuilder` is valid
+        // for as long as `&self` is.
+        unsafe { self.raw.as_ref() }
+    }
+}
+
+impl<'ll> Drop for DIBuilderBox<'ll> {
+    fn drop(&mut self) {
+        unsafe { llvm::LLVMDisposeDIBuilder(self.raw) };
+    }
+}
 
 /// Extension trait for defining safe wrappers and helper methods on
 /// `&DIBuilder<'ll>`, without requiring it to be defined in the same crate.

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -38,8 +38,9 @@ use self::namespace::mangled_name_of_instance;
 use self::utils::{DIB, create_DIArray, is_node_local_to_unit};
 use crate::builder::Builder;
 use crate::common::{AsCCharPtr, CodegenCx};
+use crate::debuginfo::di_builder::DIBuilderBox;
 use crate::llvm::debuginfo::{
-    DIArray, DIBuilderBox, DIFile, DIFlags, DILexicalBlock, DILocation, DISPFlags, DIScope,
+    DIArray, DIFile, DIFlags, DILexicalBlock, DILocation, DISPFlags, DIScope,
     DITemplateTypeParameter, DIType, DIVariable,
 };
 use crate::llvm::{self, Value};

compiler/rustc_codegen_llvm/src/llvm/conversions.rs

@@ -1,6 +1,6 @@
 //! Conversions from backend-independent data types to/from LLVM FFI types.
 
-use rustc_codegen_ssa::common::{AtomicRmwBinOp, IntPredicate, RealPredicate};
+use rustc_codegen_ssa::common::{AtomicRmwBinOp, IntPredicate, RealPredicate, TypeKind};
 use rustc_middle::ty::AtomicOrdering;
 use rustc_session::config::DebugInfo;
 use rustc_target::spec::SymbolVisibility;
@@ -9,10 +9,22 @@ use crate::llvm;
 
 /// Helper trait for converting backend-independent types to LLVM-specific
 /// types, for FFI purposes.
+///
+/// FIXME(#147327): These trait/method names were chosen to avoid churn in
+/// existing code, but are not great and could probably be made clearer.
 pub(crate) trait FromGeneric<T> {
     fn from_generic(other: T) -> Self;
 }
 
+/// Helper trait for converting LLVM-specific types to backend-independent
+/// types, for FFI purposes.
+///
+/// FIXME(#147327): These trait/method names were chosen to avoid churn in
+/// existing code, but are not great and could probably be made clearer.
+pub(crate) trait ToGeneric<T> {
+    fn to_generic(&self) -> T;
+}
+
 impl FromGeneric<SymbolVisibility> for llvm::Visibility {
     fn from_generic(visibility: SymbolVisibility) -> Self {
         match visibility {
@@ -113,3 +125,29 @@ impl FromGeneric<DebugInfo> for llvm::debuginfo::DebugEmissionKind {
         }
     }
 }
+
+impl ToGeneric<TypeKind> for llvm::TypeKind {
+    fn to_generic(&self) -> TypeKind {
+        match self {
+            Self::Void => TypeKind::Void,
+            Self::Half => TypeKind::Half,
+            Self::Float => TypeKind::Float,
+            Self::Double => TypeKind::Double,
+            Self::X86_FP80 => TypeKind::X86_FP80,
+            Self::FP128 => TypeKind::FP128,
+            Self::PPC_FP128 => TypeKind::PPC_FP128,
+            Self::Label => TypeKind::Label,
+            Self::Integer => TypeKind::Integer,
+            Self::Function => TypeKind::Function,
+            Self::Struct => TypeKind::Struct,
+            Self::Array => TypeKind::Array,
+            Self::Pointer => TypeKind::Pointer,
+            Self::Vector => TypeKind::Vector,
+            Self::Metadata => TypeKind::Metadata,
+            Self::Token => TypeKind::Token,
+            Self::ScalableVector => TypeKind::ScalableVector,
+            Self::BFloat => TypeKind::BFloat,
+            Self::X86_AMX => TypeKind::X86_AMX,
+        }
+    }
+}

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -363,33 +363,6 @@ pub(crate) enum TypeKind {
     X86_AMX = 19,
 }
 
-impl TypeKind {
-    pub(crate) fn to_generic(self) -> rustc_codegen_ssa::common::TypeKind {
-        use rustc_codegen_ssa::common::TypeKind as Common;
-        match self {
-            Self::Void => Common::Void,
-            Self::Half => Common::Half,
-            Self::Float => Common::Float,
-            Self::Double => Common::Double,
-            Self::X86_FP80 => Common::X86_FP80,
-            Self::FP128 => Common::FP128,
-            Self::PPC_FP128 => Common::PPC_FP128,
-            Self::Label => Common::Label,
-            Self::Integer => Common::Integer,
-            Self::Function => Common::Function,
-            Self::Struct => Common::Struct,
-            Self::Array => Common::Array,
-            Self::Pointer => Common::Pointer,
-            Self::Vector => Common::Vector,
-            Self::Metadata => Common::Metadata,
-            Self::Token => Common::Token,
-            Self::ScalableVector => Common::ScalableVector,
-            Self::BFloat => Common::BFloat,
-            Self::X86_AMX => Common::X86_AMX,
-        }
-    }
-}
-
 /// LLVMAtomicRmwBinOp
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -738,12 +711,9 @@ unsafe extern "C" {
 pub(crate) type DiagnosticHandlerTy = unsafe extern "C" fn(&DiagnosticInfo, *mut c_void);
 
 pub(crate) mod debuginfo {
-    use std::ptr;
-
     use bitflags::bitflags;
 
     use super::{InvariantOpaque, Metadata};
-    use crate::llvm::{self, Module};
 
     /// Opaque target type for references to an LLVM debuginfo builder.
     ///
@@ -756,33 +726,6 @@ pub(crate) mod debuginfo {
     #[repr(C)]
     pub(crate) struct DIBuilder<'ll>(InvariantOpaque<'ll>);
 
-    /// Owning pointer to a `DIBuilder<'ll>` that will dispose of the builder
-    /// when dropped. Use `.as_ref()` to get the underlying `&DIBuilder`
-    /// needed for debuginfo FFI calls.
-    pub(crate) struct DIBuilderBox<'ll> {
-        raw: ptr::NonNull<DIBuilder<'ll>>,
-    }
-
-    impl<'ll> DIBuilderBox<'ll> {
-        pub(crate) fn new(llmod: &'ll Module) -> Self {
-            let raw = unsafe { llvm::LLVMCreateDIBuilder(llmod) };
-            let raw = ptr::NonNull::new(raw).unwrap();
-            Self { raw }
-        }
-
-        pub(crate) fn as_ref(&self) -> &DIBuilder<'ll> {
-            // SAFETY: This is an owning pointer, so `&DIBuilder` is valid
-            // for as long as `&self` is.
-            unsafe { self.raw.as_ref() }
-        }
-    }
-
-    impl<'ll> Drop for DIBuilderBox<'ll> {
-        fn drop(&mut self) {
-            unsafe { llvm::LLVMDisposeDIBuilder(self.raw) };
-        }
-    }
-
     pub(crate) type DIDescriptor = Metadata;
     pub(crate) type DILocation = Metadata;
     pub(crate) type DIScope = DIDescriptor;

compiler/rustc_codegen_llvm/src/type_.rs

@@ -15,7 +15,7 @@ use rustc_target::callconv::{CastTarget, FnAbi};
 use crate::abi::{FnAbiLlvmExt, LlvmType};
 use crate::common;
 use crate::context::{CodegenCx, GenericCx, SCx};
-use crate::llvm::{self, FALSE, Metadata, TRUE, ToLlvmBool, Type, Value};
+use crate::llvm::{self, FALSE, Metadata, TRUE, ToGeneric, ToLlvmBool, Type, Value};
 use crate::type_of::LayoutLlvmExt;
 
 impl PartialEq for Type {

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -931,6 +931,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_legacy_const_generics]`
     RustcLegacyConstGenerics { fn_indexes: ThinVec<(usize, Span)>, attr_span: Span },
 
+    /// Represents `#[rustc_lint_diagnostics]`
+    RustcLintDiagnostics,
+
     /// Represents `#[rustc_lint_opt_deny_field_access]`
     RustcLintOptDenyFieldAccess { lint_message: Symbol },
 
@@ -940,6 +943,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_lint_query_instability]`
     RustcLintQueryInstability,
 
+    /// Represents `#[rustc_lint_untracked_query_information]`
+    RustcLintUntrackedQueryInformation,
+
     /// Represents `#[rustc_main]`.
     RustcMain,
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -94,9 +94,11 @@ impl AttributeKind {
             RustcLayoutScalarValidRangeEnd(..) => Yes,
             RustcLayoutScalarValidRangeStart(..) => Yes,
             RustcLegacyConstGenerics { .. } => Yes,
+            RustcLintDiagnostics => Yes,
             RustcLintOptDenyFieldAccess { .. } => Yes,
             RustcLintOptTy => Yes,
             RustcLintQueryInstability => Yes,
+            RustcLintUntrackedQueryInformation => Yes,
             RustcMain => No,
             RustcNeverReturnsNullPointer => Yes,
             RustcNoImplicitAutorefs => Yes,

compiler/rustc_lint/src/internal.rs

@@ -106,7 +106,10 @@ impl<'tcx> LateLintPass<'tcx> for QueryStability {
                 );
             }
 
-            if cx.tcx.has_attr(def_id, sym::rustc_lint_untracked_query_information) {
+            if find_attr!(
+                cx.tcx.get_all_attrs(def_id),
+                AttributeKind::RustcLintUntrackedQueryInformation
+            ) {
                 cx.emit_span_lint(
                     UNTRACKED_QUERY_INFORMATION,
                     span,
@@ -606,14 +609,14 @@ impl Diagnostics {
         else {
             return;
         };
-        let has_attr = cx.tcx.has_attr(inst.def_id(), sym::rustc_lint_diagnostics);
-        if !has_attr {
+
+        if !find_attr!(cx.tcx.get_all_attrs(inst.def_id()), AttributeKind::RustcLintDiagnostics) {
             return;
         };
 
         for (hir_id, _parent) in cx.tcx.hir_parent_iter(current_id) {
             if let Some(owner_did) = hir_id.as_owner()
-                && cx.tcx.has_attr(owner_did, sym::rustc_lint_diagnostics)
+                && find_attr!(cx.tcx.get_all_attrs(owner_did), AttributeKind::RustcLintDiagnostics)
             {
                 // The parent method is marked with `#[rustc_lint_diagnostics]`
                 return;