wip

Author: ZuseZ4

compiler/rustc_builtin_macros/src/autodiff.rs

@@ -0,0 +1,97 @@
+use crate::errors;
+use crate::util::check_builtin_macro_attribute;
+
+use rustc_ast::ptr::P;
+use rustc_ast::{self as ast, FnHeader, FnSig, Generics, StmtKind};
+use rustc_ast::{Fn, ItemKind, Stmt, TyKind, Unsafe};
+use rustc_expand::base::{Annotatable, ExtCtxt};
+use rustc_span::symbol::{kw, sym, Ident};
+use rustc_span::Span;
+use thin_vec::{thin_vec, ThinVec};
+
+pub fn expand(
+    ecx: &mut ExtCtxt<'_>,
+    _span: Span,
+    meta_item: &ast::MetaItem,
+    item: Annotatable,
+) -> Vec<Annotatable> {
+    //check_builtin_macro_attribute(ecx, meta_item, sym::alloc_error_handler);
+    //check_builtin_macro_attribute(ecx, meta_item, sym::autodiff);
+
+    let orig_item = item.clone();
+
+    // Allow using `#[alloc_error_handler]` on an item statement
+    // FIXME - if we get deref patterns, use them to reduce duplication here
+    let (item, is_stmt, sig_span) = if let Annotatable::Item(item) = &item
+        && let ItemKind::Fn(fn_kind) = &item.kind
+    {
+        (item, false, ecx.with_def_site_ctxt(fn_kind.sig.span))
+    } else if let Annotatable::Stmt(stmt) = &item
+        && let StmtKind::Item(item) = &stmt.kind
+        && let ItemKind::Fn(fn_kind) = &item.kind
+    {
+        (item, true, ecx.with_def_site_ctxt(fn_kind.sig.span))
+    } else {
+        ecx.sess.dcx().emit_err(errors::AllocErrorMustBeFn { span: item.span() });
+        return vec![orig_item];
+    };
+
+    // Generate a bunch of new items using the AllocFnFactory
+    let span = ecx.with_def_site_ctxt(item.span);
+
+    // Generate item statements for the allocator methods.
+    let stmts = thin_vec![generate_handler(ecx, item.ident, span, sig_span)];
+
+    // Generate anonymous constant serving as container for the allocator methods.
+    let const_ty = ecx.ty(sig_span, TyKind::Tup(ThinVec::new()));
+    let const_body = ecx.expr_block(ecx.block(span, stmts));
+    let const_item = ecx.item_const(span, Ident::new(kw::Underscore, span), const_ty, const_body);
+    let const_item = if is_stmt {
+        Annotatable::Stmt(P(ecx.stmt_item(span, const_item)))
+    } else {
+        Annotatable::Item(const_item)
+    };
+
+    // Return the original item and the new methods.
+    vec![orig_item, const_item]
+}
+
+// #[rustc_std_internal_symbol]
+// unsafe fn __rg_oom(size: usize, align: usize) -> ! {
+//     handler(core::alloc::Layout::from_size_align_unchecked(size, align))
+// }
+fn generate_handler(cx: &ExtCtxt<'_>, handler: Ident, span: Span, sig_span: Span) -> Stmt {
+    let usize = cx.path_ident(span, Ident::new(sym::usize, span));
+    let ty_usize = cx.ty_path(usize);
+    let size = Ident::from_str_and_span("size", span);
+    let align = Ident::from_str_and_span("align", span);
+
+    let layout_new = cx.std_path(&[sym::alloc, sym::Layout, sym::from_size_align_unchecked]);
+    let layout_new = cx.expr_path(cx.path(span, layout_new));
+    let layout = cx.expr_call(
+        span,
+        layout_new,
+        thin_vec![cx.expr_ident(span, size), cx.expr_ident(span, align)],
+    );
+
+    let call = cx.expr_call_ident(sig_span, handler, thin_vec![layout]);
+
+    let never = ast::FnRetTy::Ty(cx.ty(span, TyKind::Never));
+    let params = thin_vec![cx.param(span, size, ty_usize.clone()), cx.param(span, align, ty_usize)];
+    let decl = cx.fn_decl(params, never);
+    let header = FnHeader { unsafety: Unsafe::Yes(span), ..FnHeader::default() };
+    let sig = FnSig { decl, header, span: span };
+
+    let body = Some(cx.block_expr(call));
+    let kind = ItemKind::Fn(Box::new(Fn {
+        defaultness: ast::Defaultness::Final,
+        sig,
+        generics: Generics::default(),
+        body,
+    }));
+
+    let attrs = thin_vec![cx.attr_word(sym::rustc_std_internal_symbol, span)];
+
+    let item = cx.item(span, Ident::from_str_and_span("__rg_oom", span), attrs, kind);
+    cx.stmt_item(sig_span, item)
+}

compiler/rustc_builtin_macros/src/lib.rs

@@ -14,6 +14,7 @@
 #![feature(lint_reasons)]
 #![feature(proc_macro_internals)]
 #![feature(proc_macro_quote)]
+#![cfg_attr(not(bootstrap), feature(autodiff))]
 #![recursion_limit = "256"]
 
 extern crate proc_macro;
@@ -29,6 +30,7 @@ use rustc_span::symbol::sym;
 
 mod alloc_error_handler;
 mod assert;
+mod autodiff;
 mod cfg;
 mod cfg_accessible;
 mod cfg_eval;
@@ -105,6 +107,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
 
     register_attr! {
         alloc_error_handler: alloc_error_handler::expand,
+        autodiff: autodiff::expand,
         bench: test::expand_bench,
         cfg_accessible: cfg_accessible::Expander,
         cfg_eval: cfg_eval::expand,

compiler/rustc_expand/src/base.rs

@@ -917,6 +917,8 @@ pub trait ResolverExpand {
 
     fn check_unused_macros(&mut self);
 
+    //fn autodiff() -> bool;
+
     // Resolver interfaces for specific built-in macros.
     /// Does `#[derive(...)]` attribute with the given `ExpnId` have built-in `Copy` inside it?
     fn has_derive_copy(&self, expn_id: LocalExpnId) -> bool;

compiler/rustc_resolve/src/macros.rs

@@ -344,6 +344,8 @@ impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx> {
         self.containers_deriving_copy.contains(&expn_id)
     }
 
+    // TODO: add autodiff?
+
     fn resolve_derives(
         &mut self,
         expn_id: LocalExpnId,

compiler/rustc_span/src/symbol.rs

@@ -69,6 +69,7 @@ symbols! {
 
         // Keywords that are used in unstable Rust or reserved for future use.
         Abstract:           "abstract",
+        //Autodiff:           "autodiff",
         Become:             "become",
         Box:                "box",
         Do:                 "do",
@@ -438,6 +439,7 @@ symbols! {
         attributes,
         augmented_assignments,
         auto_traits,
+        autodiff,
         automatically_derived,
         avx,
         avx512_target_feature,

library/core/src/macros/mod.rs

@@ -1486,6 +1486,19 @@ pub(crate) mod builtin {
         ($file:expr $(,)?) => {{ /* compiler built-in */ }};
     }
 
+    /// Attribute macro used to apply derive macros for implementing traits
+    /// in a const context. Autodiff
+    ///
+    /// See [the reference] for more info.
+    ///
+    /// [the reference]: ../../../reference/attributes/derive.html
+    #[unstable(feature = "autodiff", issue = "none")]
+    #[rustc_builtin_macro]
+    #[cfg(not(bootstrap))]
+    pub macro autodiff($item:item) {
+        /* compiler built-in */
+    }
+
     /// Asserts that a boolean expression is `true` at runtime.
     ///
     /// This will invoke the [`panic!`] macro if the provided expression cannot be

library/core/src/prelude/v1.rs

@@ -83,6 +83,11 @@ pub use crate::macros::builtin::{
 #[unstable(feature = "derive_const", issue = "none")]
 pub use crate::macros::builtin::derive_const;
 
+#[cfg(not(bootstrap))]
+#[unstable(feature = "autodiff", issue = "none")]
+#[rustc_builtin_macro]
+pub use crate::macros::builtin::autodiff;
+
 #[unstable(
     feature = "cfg_accessible",
     issue = "64797",

library/std/src/lib.rs

@@ -255,6 +255,8 @@
 #![allow(unused_features)]
 //
 // Features:
+
+#![cfg_attr(not(bootstrap), feature(autodiff))]
 #![cfg_attr(test, feature(internal_output_capture, print_internals, update_panic_count, rt))]
 #![cfg_attr(
     all(target_vendor = "fortanix", target_env = "sgx"),
@@ -662,6 +664,17 @@ pub use core::{
     module_path, option_env, stringify, trace_macros,
 };
 
+
+// #[unstable(
+//     feature = "autodiff",
+//     issue = "87555",
+//     reason = "`autodiff` is not stable enough for use and is subject to change"
+// )]
+// #[cfg(not(bootstrap))]
+// pub use core::autodiff;
+
+
+
 #[unstable(
     feature = "concat_bytes",
     issue = "87555",

library/std/src/prelude/v1.rs

@@ -67,6 +67,11 @@ pub use core::prelude::v1::{
 #[unstable(feature = "derive_const", issue = "none")]
 pub use core::prelude::v1::derive_const;
 
+#[unstable(feature = "autodiff", issue = "none")]
+#[cfg(not(bootstrap))]
+#[rustc_builtin_macro]
+pub use core::prelude::v1::autodiff;
+
 // Do not `doc(no_inline)` either.
 #[unstable(
     feature = "cfg_accessible",