Rollup of 7 pull requests

.mailmap

@@ -579,6 +579,9 @@ Ralph Giles <giles@thaumas.net> Ralph Giles <giles@mozilla.com>
 Ramkumar Ramachandra <r@artagnon.com> <artagnon@gmail.com>
 Raphaël Huchet <rap2hpoutre@users.noreply.github.com>
 rChaser53 <tayoshizawa29@gmail.com>
+Redddy <rust@redddy.com>
+Redddy <rust@redddy.com> <midzy0228@gmail.com>
+Redddy <rust@redddy.com> <78539407+reddevilmidzy@users.noreply.github.com>
 Rémy Rakic <remy.rakic@gmail.com>
 Rémy Rakic <remy.rakic@gmail.com> <remy.rakic+github@gmail.com>
 Rémy Rakic <remy.rakic@gmail.com> <remy.rakic+rust@gmail.com>

compiler/rustc_ast/src/expand/autodiff_attrs.rs

@@ -1,12 +1,13 @@
 //! This crate handles the user facing autodiff macro. For each `#[autodiff(...)]` attribute,
-//! we create an [`AutoDiffItem`] which contains the source and target function names. The source
+//! we create an `RustcAutodiff` which contains the source and target function names. The source
 //! is the function to which the autodiff attribute is applied, and the target is the function
 //! getting generated by us (with a name given by the user as the first autodiff arg).
 
 use std::fmt::{self, Display, Formatter};
 use std::str::FromStr;
 
-use crate::expand::typetree::TypeTree;
+use rustc_span::{Symbol, sym};
+
 use crate::expand::{Decodable, Encodable, HashStable_Generic};
 use crate::{Ty, TyKind};
 
@@ -31,6 +32,12 @@ pub enum DiffMode {
     Reverse,
 }
 
+impl DiffMode {
+    pub fn all_modes() -> &'static [Symbol] {
+        &[sym::Source, sym::Forward, sym::Reverse]
+    }
+}
+
 /// Dual and Duplicated (and their Only variants) are getting lowered to the same Enzyme Activity.
 /// However, under forward mode we overwrite the previous shadow value, while for reverse mode
 /// we add to the previous shadow value. To not surprise users, we picked different names.
@@ -76,43 +83,20 @@ impl DiffActivity {
         use DiffActivity::*;
         matches!(self, |Dual| DualOnly | Dualv | DualvOnly | Const)
     }
-}
-/// We generate one of these structs for each `#[autodiff(...)]` attribute.
-#[derive(Clone, Eq, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
-pub struct AutoDiffItem {
-    /// The name of the function getting differentiated
-    pub source: String,
-    /// The name of the function being generated
-    pub target: String,
-    pub attrs: AutoDiffAttrs,
-    pub inputs: Vec<TypeTree>,
-    pub output: TypeTree,
-}
 
-#[derive(Clone, Eq, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
-pub struct AutoDiffAttrs {
-    /// Conceptually either forward or reverse mode AD, as described in various autodiff papers and
-    /// e.g. in the [JAX
-    /// Documentation](https://jax.readthedocs.io/en/latest/_tutorials/advanced-autodiff.html#how-it-s-made-two-foundational-autodiff-functions).
-    pub mode: DiffMode,
-    /// A user-provided, batching width. If not given, we will default to 1 (no batching).
-    /// Calling a differentiated, non-batched function through a loop 100 times is equivalent to:
-    /// - Calling the function 50 times with a batch size of 2
-    /// - Calling the function 25 times with a batch size of 4,
-    /// etc. A batched function takes more (or longer) arguments, and might be able to benefit from
-    /// cache locality, better re-usal of primal values, and other optimizations.
-    /// We will (before LLVM's vectorizer runs) just generate most LLVM-IR instructions `width`
-    /// times, so this massively increases code size. As such, values like 1024 are unlikely to
-    /// work. We should consider limiting this to u8 or u16, but will leave it at u32 for
-    /// experiments for now and focus on documenting the implications of a large width.
-    pub width: u32,
-    pub ret_activity: DiffActivity,
-    pub input_activity: Vec<DiffActivity>,
-}
-
-impl AutoDiffAttrs {
-    pub fn has_primal_ret(&self) -> bool {
-        matches!(self.ret_activity, DiffActivity::Active | DiffActivity::Dual)
+    pub fn all_activities() -> &'static [Symbol] {
+        &[
+            sym::None,
+            sym::Active,
+            sym::ActiveOnly,
+            sym::Const,
+            sym::Dual,
+            sym::Dualv,
+            sym::DualOnly,
+            sym::DualvOnly,
+            sym::Duplicated,
+            sym::DuplicatedOnly,
+        ]
     }
 }
 
@@ -241,59 +225,3 @@ impl FromStr for DiffActivity {
         }
     }
 }
-
-impl AutoDiffAttrs {
-    pub fn has_ret_activity(&self) -> bool {
-        self.ret_activity != DiffActivity::None
-    }
-    pub fn has_active_only_ret(&self) -> bool {
-        self.ret_activity == DiffActivity::ActiveOnly
-    }
-
-    pub const fn error() -> Self {
-        AutoDiffAttrs {
-            mode: DiffMode::Error,
-            width: 0,
-            ret_activity: DiffActivity::None,
-            input_activity: Vec::new(),
-        }
-    }
-    pub fn source() -> Self {
-        AutoDiffAttrs {
-            mode: DiffMode::Source,
-            width: 0,
-            ret_activity: DiffActivity::None,
-            input_activity: Vec::new(),
-        }
-    }
-
-    pub fn is_active(&self) -> bool {
-        self.mode != DiffMode::Error
-    }
-
-    pub fn is_source(&self) -> bool {
-        self.mode == DiffMode::Source
-    }
-    pub fn apply_autodiff(&self) -> bool {
-        !matches!(self.mode, DiffMode::Error | DiffMode::Source)
-    }
-
-    pub fn into_item(
-        self,
-        source: String,
-        target: String,
-        inputs: Vec<TypeTree>,
-        output: TypeTree,
-    ) -> AutoDiffItem {
-        AutoDiffItem { source, target, inputs, output, attrs: self }
-    }
-}
-
-impl fmt::Display for AutoDiffItem {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Differentiating {} -> {}", self.source, self.target)?;
-        write!(f, " with attributes: {:?}", self.attrs)?;
-        write!(f, " with inputs: {:?}", self.inputs)?;
-        write!(f, " with output: {:?}", self.output)
-    }
-}

compiler/rustc_attr_parsing/src/attributes/autodiff.rs

@@ -0,0 +1,117 @@
+use std::str::FromStr;
+
+use rustc_ast::LitKind;
+use rustc_ast::expand::autodiff_attrs::{DiffActivity, DiffMode};
+use rustc_feature::{AttributeTemplate, template};
+use rustc_hir::attrs::{AttributeKind, RustcAutodiff};
+use rustc_hir::{MethodKind, Target};
+use rustc_span::{Symbol, sym};
+use thin_vec::ThinVec;
+
+use crate::attributes::prelude::Allow;
+use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
+use crate::context::{AcceptContext, Stage};
+use crate::parser::{ArgParser, MetaItemOrLitParser};
+use crate::target_checking::AllowedTargets;
+
+pub(crate) struct RustcAutodiffParser;
+
+impl<S: Stage> SingleAttributeParser<S> for RustcAutodiffParser {
+    const PATH: &[Symbol] = &[sym::rustc_autodiff];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
+    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: true })),
+        Allow(Target::Method(MethodKind::TraitImpl)),
+    ]);
+    const TEMPLATE: AttributeTemplate = template!(
+        List: &["MODE", "WIDTH", "INPUT_ACTIVITIES", "OUTPUT_ACTIVITY"],
+        "https://doc.rust-lang.org/std/autodiff/index.html"
+    );
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
+        let list = match args {
+            ArgParser::NoArgs => return Some(AttributeKind::RustcAutodiff(None)),
+            ArgParser::List(list) => list,
+            ArgParser::NameValue(_) => {
+                cx.expected_list_or_no_args(cx.attr_span);
+                return None;
+            }
+        };
+
+        let mut items = list.mixed().peekable();
+
+        // Parse name
+        let Some(mode) = items.next() else {
+            cx.expected_at_least_one_argument(list.span);
+            return None;
+        };
+        let Some(mode) = mode.meta_item() else {
+            cx.expected_identifier(mode.span());
+            return None;
+        };
+        let Ok(()) = mode.args().no_args() else {
+            cx.expected_identifier(mode.span());
+            return None;
+        };
+        let Some(mode) = mode.path().word() else {
+            cx.expected_identifier(mode.span());
+            return None;
+        };
+        let Ok(mode) = DiffMode::from_str(mode.as_str()) else {
+            cx.expected_specific_argument(mode.span, DiffMode::all_modes());
+            return None;
+        };
+
+        // Parse width
+        let width = if let Some(width) = items.peek()
+            && let MetaItemOrLitParser::Lit(width) = width
+            && let LitKind::Int(width, _) = width.kind
+            && let Ok(width) = width.0.try_into()
+        {
+            _ = items.next();
+            width
+        } else {
+            1
+        };
+
+        // Parse activities
+        let mut activities = ThinVec::new();
+        for activity in items {
+            let MetaItemOrLitParser::MetaItemParser(activity) = activity else {
+                cx.expected_specific_argument(activity.span(), DiffActivity::all_activities());
+                return None;
+            };
+            let Ok(()) = activity.args().no_args() else {
+                cx.expected_specific_argument(activity.span(), DiffActivity::all_activities());
+                return None;
+            };
+            let Some(activity) = activity.path().word() else {
+                cx.expected_specific_argument(activity.span(), DiffActivity::all_activities());
+                return None;
+            };
+            let Ok(activity) = DiffActivity::from_str(activity.as_str()) else {
+                cx.expected_specific_argument(activity.span, DiffActivity::all_activities());
+                return None;
+            };
+
+            activities.push(activity);
+        }
+        let Some(ret_activity) = activities.pop() else {
+            cx.expected_specific_argument(
+                list.span.with_lo(list.span.hi()),
+                DiffActivity::all_activities(),
+            );
+            return None;
+        };
+
+        Some(AttributeKind::RustcAutodiff(Some(Box::new(RustcAutodiff {
+            mode,
+            width,
+            input_activity: activities,
+            ret_activity,
+        }))))
+    }
+}

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -30,6 +30,7 @@ use crate::target_checking::AllowedTargets;
 mod prelude;
 
 pub(crate) mod allow_unstable;
+pub(crate) mod autodiff;
 pub(crate) mod body;
 pub(crate) mod cfg;
 pub(crate) mod cfg_select;

compiler/rustc_attr_parsing/src/context.rs

@@ -19,6 +19,7 @@ use rustc_span::{ErrorGuaranteed, Span, Symbol};
 use crate::AttributeParser;
 // Glob imports to avoid big, bitrotty import lists
 use crate::attributes::allow_unstable::*;
+use crate::attributes::autodiff::*;
 use crate::attributes::body::*;
 use crate::attributes::cfi_encoding::*;
 use crate::attributes::codegen_attrs::*;
@@ -204,6 +205,7 @@ attribute_parsers!(
         Single<ReexportTestHarnessMainParser>,
         Single<RustcAbiParser>,
         Single<RustcAllocatorZeroedVariantParser>,
+        Single<RustcAutodiffParser>,
         Single<RustcBuiltinMacroParser>,
         Single<RustcDefPathParser>,
         Single<RustcDeprecatedSafe2024Parser>,

compiler/rustc_borrowck/src/lib.rs

@@ -27,7 +27,6 @@ use rustc_abi::FieldIdx;
 use rustc_data_structures::frozen::Frozen;
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_data_structures::graph::dominators::Dominators;
-use rustc_errors::LintDiagnostic;
 use rustc_hir as hir;
 use rustc_hir::CRATE_HIR_ID;
 use rustc_hir::def_id::LocalDefId;
@@ -715,7 +714,7 @@ impl<'tcx> Deref for BorrowckInferCtxt<'tcx> {
     }
 }
 
-struct MirBorrowckCtxt<'a, 'infcx, 'tcx> {
+pub(crate) struct MirBorrowckCtxt<'a, 'infcx, 'tcx> {
     root_cx: &'a mut BorrowCheckRootCtxt<'tcx>,
     infcx: &'infcx BorrowckInferCtxt<'tcx>,
     body: &'a Body<'tcx>,
@@ -1428,13 +1427,15 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     borrow,
                     Some((WriteKind::StorageDeadOrDrop, place)),
                 );
-                this.infcx.tcx.node_span_lint(
+                this.infcx.tcx.emit_node_span_lint(
                     TAIL_EXPR_DROP_ORDER,
                     CRATE_HIR_ID,
                     borrowed,
-                    |diag| {
-                        session_diagnostics::TailExprDropOrder { borrowed }.decorate_lint(diag);
-                        explain.add_explanation_to_diagnostic(&this, diag, "", None, None);
+                    session_diagnostics::TailExprDropOrder {
+                        borrowed,
+                        callback: |diag| {
+                            explain.add_explanation_to_diagnostic(&this, diag, "", None, None);
+                        },
                     },
                 );
                 // We may stop at the first case

compiler/rustc_borrowck/src/session_diagnostics.rs

@@ -1,6 +1,6 @@
-use rustc_errors::MultiSpan;
 use rustc_errors::codes::*;
-use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
+use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, Level, MultiSpan};
+use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_middle::ty::{GenericArg, Ty};
 use rustc_span::Span;
 
@@ -595,9 +595,20 @@ pub(crate) struct SimdIntrinsicArgConst {
     pub intrinsic: String,
 }
 
-#[derive(LintDiagnostic)]
-#[diag("relative drop order changing in Rust 2024")]
-pub(crate) struct TailExprDropOrder {
-    #[label("this temporary value will be dropped at the end of the block")]
+pub(crate) struct TailExprDropOrder<F: FnOnce(&mut Diag<'_, ()>)> {
     pub borrowed: Span,
+    pub callback: F,
+}
+
+impl<'a, F: FnOnce(&mut Diag<'_, ()>)> Diagnostic<'a, ()> for TailExprDropOrder<F> {
+    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
+        let Self { borrowed, callback } = self;
+        let mut diag = Diag::new(dcx, level, "relative drop order changing in Rust 2024")
+            .with_span_label(
+                borrowed,
+                "this temporary value will be dropped at the end of the block",
+            );
+        callback(&mut diag);
+        diag
+    }
 }