got autodiff macro to do something

Author: ZuseZ4

compiler/rustc_builtin_macros/messages.ftl

@@ -1,6 +1,8 @@
 builtin_macros_alloc_error_must_be_fn = alloc_error_handler must be a function
 builtin_macros_alloc_must_statics = allocators must be statics
 
+builtin_macros_autodiff = autodiff must be applied to function
+
 builtin_macros_asm_clobber_abi = clobber_abi
 builtin_macros_asm_clobber_no_reg = asm with `clobber_abi` must specify explicit registers for outputs
 builtin_macros_asm_clobber_outputs = generic outputs

compiler/rustc_builtin_macros/src/autodiff.rs

@@ -1,5 +1,7 @@
+#![allow(unused)]
+
 use crate::errors;
-use crate::util::check_builtin_macro_attribute;
+//use crate::util::check_builtin_macro_attribute;
 
 use rustc_ast::ptr::P;
 use rustc_ast::{self as ast, FnHeader, FnSig, Generics, StmtKind};
@@ -8,6 +10,7 @@ use rustc_expand::base::{Annotatable, ExtCtxt};
 use rustc_span::symbol::{kw, sym, Ident};
 use rustc_span::Span;
 use thin_vec::{thin_vec, ThinVec};
+use rustc_span::Symbol;
 
 pub fn expand(
     ecx: &mut ExtCtxt<'_>,
@@ -18,80 +21,67 @@ pub fn expand(
     //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();
+    dbg!(&meta_item);
+    let input = item.clone();
+    let orig_item: P<ast::Item> = item.clone().expect_item();
+    let mut d_item: P<ast::Item> = item.clone().expect_item();
 
-    // 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
+    // Allow using `#[autodiff(...)]` on a Fn
+    let (fn_item, _ty_span)  = if let Annotatable::Item(item) = &item
+        && let ItemKind::Fn(box ast::Fn { sig, .. }) = &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)))
+        dbg!(&item);
+        (item, ecx.with_def_site_ctxt(sig.span))
     } else {
-        Annotatable::Item(const_item)
+        ecx.sess
+            .dcx()
+            .emit_err(errors::AutoDiffInvalidApplication { span: item.span() });
+        return vec![input];
     };
-
-    // Return the original item and the new methods.
-    vec![orig_item, const_item]
+    let _x: &ItemKind = &fn_item.kind;
+    d_item.ident.name =
+        Symbol::intern(format!("d_{}", fn_item.ident.name).as_str());
+    let orig_annotatable = Annotatable::Item(orig_item.clone());
+    let d_annotatable = Annotatable::Item(d_item.clone());
+    return vec![orig_annotatable, d_annotatable];
 }
 
 // #[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)
-}
+//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/errors.rs

@@ -164,6 +164,13 @@ pub(crate) struct AllocMustStatics {
     pub(crate) span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(builtin_macros_autodiff)]
+pub(crate) struct AutoDiffInvalidApplication {
+    #[primary_span]
+    pub(crate) span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(builtin_macros_concat_bytes_invalid)]
 pub(crate) struct ConcatBytesInvalid {