1mod altrep;
154mod c_wrapper_builder;
155mod call_method_def;
156mod cfg_gates;
157mod dots_policy;
158mod externalptr_args;
159mod list_macro;
160mod match_arg_keys;
161mod miniextendr_fn;
162mod receiver_body;
163mod return_wrap;
164mod s7_conversion;
165mod trait_receiver;
166mod trait_self_ref;
167mod trait_signature;
168mod type_inspect;
169mod typed_dataframe;
170mod typed_list;
171mod util;
172use crate::miniextendr_fn::{MiniextendrFnAttrs, MiniextendrFunctionParsed};
173mod miniextendr_impl;
174mod r_wrapper_builder;
175pub(crate) use r_wrapper_builder::RArgumentBuilder;
177mod rust_conversion_builder;
178pub(crate) use rust_conversion_builder::RustConversionBuilder;
180mod method_return_builder;
181pub(crate) use method_return_builder::{MethodReturnBuilder, ReturnStrategy};
183mod altrep_derive;
184mod condition_derive;
185mod dataframe_derive;
186mod lifecycle;
187mod list_derive;
188mod r_class_formatter;
189mod r_preconditions;
190mod r_shadowing;
191mod return_type_analysis;
192mod roxygen;
193
194mod all_equal_derive;
196mod externalptr_derive;
197mod miniextendr_impl_trait;
198mod miniextendr_trait;
199mod typed_external_macro;
200
201mod factor_derive;
203mod match_arg_derive;
204mod newtype_derive;
205
206mod struct_enum_dispatch;
208mod misplaced_dots;
210
211mod r_macro;
213
214mod reexport;
216
217#[cfg(feature = "vctrs")]
219mod vctrs_derive;
220mod vctrs_generics;
221
222mod crate_config;
223mod naming;
224pub(crate) use naming::r_wrapper_const_ident_for;
225
226#[cfg(all(feature = "r6-default", feature = "s7-default"))]
228compile_error!(
229 "features \"r6-default\" and \"s7-default\" are mutually exclusive — \
230 enable exactly one, or omit both to fall back to the unspecified default"
231);
232pub(crate) use type_inspect::{
233 SeveralOkContainer, classify_several_ok_container, first_type_argument, match_arg_choices_ty,
234 second_type_argument,
235};
236pub(crate) use util::{
237 extract_cfg_attrs, r_wrapper_raw_literal, source_location_doc, source_position,
238};
239
240fn validate_extern_signature(
250 abi: &syn::Abi,
251 attrs: &[syn::Attribute],
252 inputs: &syn::punctuated::Punctuated<syn::FnArg, ::syn::token::Commasyn::Token![,]>,
253 output: &syn::ReturnType,
254) -> syn::Result<()> {
255 use syn::spanned::Spanned;
256
257 for input in inputs.iter() {
261 if let syn::FnArg::Receiver(recv) = input {
262 return Err(syn::Error::new_spanned(
263 recv,
264 "self parameter not allowed in standalone functions; \
265 use #[miniextendr(env|r6|s3|s4|s7)] on impl blocks instead",
266 ));
267 }
268 }
269
270 let has_no_mangle = attrs.iter().any(|attr| {
272 attr.path().is_ident("no_mangle")
273 || attr
274 .parse_nested_meta(|meta| {
275 if meta.path.is_ident("no_mangle") {
276 Err(meta.error("found #[no_mangle]"))
277 } else {
278 Ok(())
279 }
280 })
281 .is_err()
282 });
283 let has_export_name = attrs.iter().any(|attr| attr.path().is_ident("export_name"));
284 if !has_no_mangle && !has_export_name {
285 return Err(syn::Error::new(
286 attrs
287 .first()
288 .map(|attr| attr.span())
289 .unwrap_or_else(|| abi.span()),
290 "extern \"C-unwind\" functions need a visible C symbol for R's .Call interface. \
291 Add one of:\n \
292 - `#[unsafe(no_mangle)]` (Rust 2024 edition)\n \
293 - `#[no_mangle]` (Rust 2021 edition)\n \
294 - `#[export_name = \"my_symbol\"]` (custom symbol name)",
295 ));
296 }
297
298 match output {
300 non_return_type @ syn::ReturnType::Default => {
301 return Err(syn::Error::new(
302 non_return_type.span(),
303 "extern \"C-unwind\" functions used with #[miniextendr] must return SEXP. \
304 Add `-> miniextendr_api::SEXP` as the return type. \
305 If you want automatic type conversion, remove `extern \"C-unwind\"` and let \
306 the macro generate the C wrapper.",
307 ));
308 }
309 syn::ReturnType::Type(_rarrow, output_type) => match output_type.as_ref() {
310 syn::Type::Path(type_path) => {
311 if let Some(path_to_sexp) = type_path.path.segments.last().map(|x| &x.ident)
312 && path_to_sexp != "SEXP"
313 {
314 return Err(syn::Error::new(
315 path_to_sexp.span(),
316 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("extern \"C-unwind\" functions must return SEXP, found `{0}`. R\'s .Call interface expects SEXP return values. Change the return type to `miniextendr_api::SEXP`, or remove `extern \"C-unwind\"` to let the macro handle type conversion.",
path_to_sexp))
})format!(
317 "extern \"C-unwind\" functions must return SEXP, found `{path_to_sexp}`. \
318 R's .Call interface expects SEXP return values. \
319 Change the return type to `miniextendr_api::SEXP`, or remove \
320 `extern \"C-unwind\"` to let the macro handle type conversion.",
321 ),
322 ));
323 }
324 }
325 _ => {
326 return Err(syn::Error::new(
327 output_type.span(),
328 "extern \"C-unwind\" functions must return SEXP. \
329 R's .Call interface expects SEXP return values. \
330 Change the return type to `miniextendr_api::SEXP`, or remove \
331 `extern \"C-unwind\"` to let the macro handle type conversion.",
332 ));
333 }
334 },
335 }
336
337 for input in inputs.iter() {
339 match input {
340 syn::FnArg::Receiver(recv) => {
341 return Err(syn::Error::new_spanned(
342 recv,
343 "extern \"C-unwind\" functions cannot have a `self` parameter. \
344 R's .Call interface only accepts SEXP arguments. \
345 Use `#[miniextendr(env|r6|s3|s4|s7)]` on an impl block for methods.",
346 ));
347 }
348 syn::FnArg::Typed(pat_type) => {
349 if let syn::Pat::Rest(_) = pat_type.pat.as_ref() {
350 return Err(syn::Error::new_spanned(
351 pat_type,
352 "extern functions cannot use variadic (...) - .Call passes fixed arguments",
353 ));
354 }
355 let is_sexp = match pat_type.ty.as_ref() {
356 syn::Type::Path(type_path) => type_path
357 .path
358 .segments
359 .last()
360 .is_some_and(|seg| seg.ident == "SEXP"),
361 _ => false,
362 };
363 if !is_sexp && crate::type_inspect::is_lazy_dots_marker(&pat_type.ty) {
364 return Err(syn::Error::new_spanned(
365 &pat_type.ty,
366 "extern functions cannot take `LazyDots`: it is the generated R \
367 wrapper's frame (`environment()`), and `.Call()` reaches an extern \
368 function directly. Drop the `extern \"C-unwind\"` to let the macro \
369 generate the wrapper",
370 ));
371 }
372 if !is_sexp {
373 let is_dots_type = if let syn::Type::Reference(type_ref) = pat_type.ty.as_ref()
374 {
375 if let syn::Type::Path(inner) = type_ref.elem.as_ref() {
376 inner
377 .path
378 .segments
379 .last()
380 .is_some_and(|seg| seg.ident == "Dots")
381 } else {
382 false
383 }
384 } else if let syn::Type::Path(type_path) = pat_type.ty.as_ref() {
385 type_path
386 .path
387 .segments
388 .last()
389 .is_some_and(|seg| seg.ident == "Dots")
390 } else {
391 false
392 };
393 let msg = if is_dots_type {
394 "extern functions cannot use Dots; use `...` syntax in non-extern #[miniextendr] functions instead"
395 } else {
396 "extern function parameters must be SEXP - .Call passes all arguments as SEXP"
397 };
398 return Err(syn::Error::new_spanned(&pat_type.ty, msg));
399 }
400 }
401 }
402 }
403
404 Ok(())
405}
406
407pub(crate) fn build_dots_validation_stmt(
415 dots_param: &syn::Ident,
416 spec_tokens: &proc_macro2::TokenStream,
417) -> syn::Stmt {
418 ::syn::__private::parse_quote({
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "let");
::quote::__private::push_ident(&mut _s, "dots_typed");
::quote::__private::push_eq(&mut _s);
::quote::ToTokens::to_tokens(&dots_param, &mut _s);
::quote::__private::push_dot(&mut _s);
::quote::__private::push_ident(&mut _s, "typed");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::ToTokens::to_tokens(&spec_tokens, &mut _s);
_s
});
::quote::__private::push_dot(&mut _s);
::quote::__private::push_ident(&mut _s, "unwrap_or_else");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_or(&mut _s);
::quote::__private::push_ident(&mut _s, "e");
::quote::__private::push_or(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "arg_error");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "param");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s, "\"...\"");
::quote::__private::push_comma(&mut _s);
::quote::__private::parse(&mut _s,
"\"dots validation failed: {e}\"");
_s
});
_s
});
::quote::__private::push_semi(&mut _s);
_s
});syn::parse_quote! {
419 let dots_typed = #dots_param.typed(#spec_tokens)
420 .unwrap_or_else(|e| ::miniextendr_api::arg_error!(
421 param = "...", "dots validation failed: {e}"
422 ));
423 }
424}
425
426#[proc_macro_attribute]
770pub fn miniextendr(
771 attr: proc_macro::TokenStream,
772 item: proc_macro::TokenStream,
773) -> proc_macro::TokenStream {
774 if let Ok(parsed) = syn::parse::<syn::Item>(item.clone()) {
776 match cfg_gates::select(&attr.clone().into(), &parsed) {
777 Ok(Some(selected)) => return selected.into(),
778 Ok(None) => {}
779 Err(error) => return error.into_compile_error().into(),
780 }
781 }
782
783 if syn::parse::<syn::ItemFn>(item.clone()).is_ok() {
785 expand_fn(attr.into(), item.into())
786 } else if syn::parse::<syn::ItemImpl>(item.clone()).is_ok() {
787 miniextendr_impl::expand_impl(attr, item)
789 } else if syn::parse::<syn::ItemTrait>(item.clone()).is_ok() {
790 miniextendr_trait::expand_trait(attr, item)
792 } else {
793 struct_enum_dispatch::expand_struct_or_enum(attr, item)
795 }
796}
797
798fn expand_fn<T: From<proc_macro2::TokenStream>>(
802 attr: proc_macro2::TokenStream,
803 item: proc_macro2::TokenStream,
804) -> T {
805 let MiniextendrFnAttrs {
806 force_invisible,
807 check_interrupt,
808 coerce_all,
809 rng,
810 rng_seed,
811 unwrap_in_r,
812 serialize,
813 wrap,
814 serde_error,
815 preconditions,
816 call_attribution: call_attribution_attr,
817 call_arg,
818 return_pref,
819 return_pref_span,
820 s3_generic,
821 s3_class,
822 dots_spec,
823 dots_policy,
824 dots_span,
825 lifecycle,
826 strict,
827 internal,
828 noexport,
829 export,
830 doc,
831 c_symbol,
832 r_name: fn_r_name,
833 postfix: fn_postfix,
834 r_entry,
835 r_post_checks,
836 r_on_exit,
837 } = match syn::parse2(attr) {
838 Ok(attrs) => attrs,
839 Err(err) => return err.into_compile_error().into(),
840 };
841
842 let mut parsed = match syn::parse2::<MiniextendrFunctionParsed>(item) {
843 Ok(parsed) => parsed,
844 Err(err) => return err.into_compile_error().into(),
845 };
846
847 if let Some(asyncness) = &parsed.item().sig.asyncness {
849 return syn::Error::new_spanned(
850 asyncness,
851 "async functions are not supported by #[miniextendr]; \
852 R's C API is synchronous and incompatible with async executors",
853 )
854 .into_compile_error()
855 .into();
856 }
857
858 {
863 let params = &parsed.item().sig.generics.params;
864 let has_type_or_const = params
865 .iter()
866 .any(|p| #[allow(non_exhaustive_omitted_patterns)] match p {
syn::GenericParam::Type(_) | syn::GenericParam::Const(_) => true,
_ => false,
}matches!(p, syn::GenericParam::Type(_) | syn::GenericParam::Const(_)));
867
868 if has_type_or_const {
869 let err = syn::Error::new_spanned(
870 &parsed.item().sig.generics,
871 "#[miniextendr] functions cannot have generic type or const parameters. \
872 Generic functions are incompatible with `extern \"C-unwind\"` and `#[no_mangle]` \
873 required for R FFI. Consider using trait objects or monomorphization instead. \
874 Explicit lifetime parameters are allowed (lifetimes are erased at codegen).",
875 );
876 return err.into_compile_error().into();
877 }
878 }
879
880 parsed.add_inline_never_if_needed();
885
886 let uses_internal_c_wrapper = parsed.uses_internal_c_wrapper();
888 let c_ident = if let Some(ref sym) = c_symbol {
889 syn::Ident::new(sym, parsed.c_wrapper_ident().span())
890 } else {
891 parsed.c_wrapper_ident()
892 };
893 let r_wrapper_generator = parsed.r_wrapper_const_ident();
894
895 let rust_ident = parsed.ident();
897 let all_inputs = parsed.inputs();
898 let (visibility_marker, peeled_output) = {
902 let output = parsed.output();
903 if let syn::ReturnType::Type(_, ty) = output
904 && let Some(err) = crate::type_inspect::visibility_marker_error(ty, "return")
905 {
906 return err.into_compile_error().into();
907 }
908 crate::type_inspect::peel_return_visibility(output)
909 };
910 let (return_wrap, peeled_output) = match crate::return_wrap::resolve(&peeled_output, wrap) {
911 Ok(resolved) => resolved,
912 Err(error) => return error.into_compile_error().into(),
913 };
914 if return_wrap
915 .as_ref()
916 .is_some_and(|wrap| wrap.conversion.is_some())
917 {
918 return syn::Error::new_spanned(
919 parsed.output(),
920 "ConvertTo/ConvertFrom require an inherent S7 impl method",
921 )
922 .into_compile_error()
923 .into();
924 }
925 if return_wrap.is_some() && (serialize || unwrap_in_r) {
926 return syn::Error::new_spanned(
927 parsed.output(),
928 "explicit class wrapping cannot be combined with serialize or unwrap_in_r",
929 )
930 .into_compile_error()
931 .into();
932 }
933 if return_wrap.is_some() && parsed.abi().is_some() {
934 return syn::Error::new_spanned(parsed.output(), "explicit class wrapping requires a generated Rust-to-R wrapper, not an extern function").into_compile_error().into();
935 }
936 let converted_output = crate::type_inspect::serialize_return_type(&peeled_output, serialize);
937 let output = &converted_output;
938 let abi = parsed.abi();
939 if serialize && abi.is_some() {
940 return syn::Error::new_spanned(
941 parsed.output(),
942 "`serialize` requires a generated Rust-to-R conversion and cannot be used on an extern function",
943 )
944 .into_compile_error()
945 .into();
946 }
947 let attrs = parsed.attrs();
948 let vis = parsed.vis();
949 let generics = parsed.generics();
950 let has_dots = parsed.has_dots();
951 let dots_ident = parsed.dots_ident().cloned();
952 let formals = parsed.formals();
955
956 if let Some(user_abi) = abi
959 && let Err(e) = validate_extern_signature(user_abi, attrs, all_inputs, output)
960 {
961 return e.into_compile_error().into();
962 }
963
964 let mut call_marker: Option<(syn::Ident, r_wrapper_builder::CallAttribution)> = None;
970 for arg in all_inputs.iter() {
971 let syn::FnArg::Typed(pt) = arg else {
972 continue;
973 };
974 let Some(kind) = crate::type_inspect::call_marker(&pt.ty) else {
975 continue;
976 };
977 let syn::Pat::Ident(pat_ident) = pt.pat.as_ref() else {
978 continue;
979 };
980 let marker = kind
981 .marker_name()
982 .expect("a marker type selects an attribution that has a marker");
983 if let Some((first, _)) = &call_marker {
984 return syn::Error::new_spanned(
985 pt,
986 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("a `#[miniextendr]` function takes at most one `Call` / `CallerCall` parameter (`{0}` already receives the condition call); the call slot is a single value",
first))
})format!(
987 "a `#[miniextendr]` function takes at most one `Call` / `CallerCall` \
988 parameter (`{first}` already receives the condition call); the call \
989 slot is a single value"
990 ),
991 )
992 .into_compile_error()
993 .into();
994 }
995 if parsed.has_param_attrs(&crate::naming::ident_name(&pat_ident.ident)) {
996 return syn::Error::new_spanned(
997 pt,
998 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("per-parameter options (`coerce`, `match_arg`, `choices`, `default`, `several_ok`, `formal`) do not apply to a `{0}` parameter: it is bound from the call slot, not from an R argument",
marker))
})format!(
999 "per-parameter options (`coerce`, `match_arg`, `choices`, `default`, \
1000 `several_ok`, `formal`) do not apply to a `{marker}` parameter: it is \
1001 bound from the call slot, not from an R argument"
1002 ),
1003 )
1004 .into_compile_error()
1005 .into();
1006 }
1007 if kind == r_wrapper_builder::CallAttribution::Caller && !(noexport || internal) {
1008 return syn::Error::new_spanned(
1009 pt,
1010 "a `CallerCall` parameter attributes conditions to the wrapper's caller, which \
1011 is only meaningful for a package-internal entry point; add `noexport` or \
1012 `internal`.",
1013 )
1014 .into_compile_error()
1015 .into();
1016 }
1017 if kind == r_wrapper_builder::CallAttribution::Caller && call_arg {
1018 return syn::Error::new_spanned(
1019 pt,
1020 "a `CallerCall` parameter cannot be combined with `call_arg`: a `caller` wrapper \
1021 already takes `.call`, where NULL means the caller's call. Keep the \
1022 `CallerCall` parameter, or make it `Call` so that NULL means this function's \
1023 own call.",
1024 )
1025 .into_compile_error()
1026 .into();
1027 }
1028 if call_attribution_attr == Some(r_wrapper_builder::CallAttribution::NoCall) {
1029 return syn::Error::new_spanned(
1030 pt,
1031 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("`call = none` passes no call, so a `{0}` parameter has nothing to receive; drop the parameter or the option",
marker))
})format!(
1032 "`call = none` passes no call, so a `{marker}` parameter has nothing to \
1033 receive; drop the parameter or the option"
1034 ),
1035 )
1036 .into_compile_error()
1037 .into();
1038 }
1039 if let Some(attr) = call_attribution_attr
1040 && attr != kind
1041 {
1042 return syn::Error::new_spanned(
1043 pt,
1044 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("the `{3}` parameter selects `{0}` attribution but the attribute selects `{1}` (`call = {2}`); keep one of them (or make them agree)",
kind.name(), attr.name(), attr.name(), marker))
})format!(
1045 "the `{marker}` parameter selects `{}` attribution but the attribute \
1046 selects `{}` (`call = {}`); keep one of them (or make them agree)",
1047 kind.name(),
1048 attr.name(),
1049 attr.name(),
1050 ),
1051 )
1052 .into_compile_error()
1053 .into();
1054 }
1055 call_marker = Some((pat_ident.ident.clone(), kind));
1056 }
1057 let mut unevaluated_r_names: Vec<String> = Vec::new();
1068 for arg in all_inputs.iter() {
1069 let syn::FnArg::Typed(pt) = arg else {
1070 continue;
1071 };
1072 let Some(param) = crate::type_inspect::unevaluated_param(&pt.ty) else {
1073 if crate::type_inspect::mentions_unevaluated_marker(&pt.ty) {
1074 return syn::Error::new_spanned(
1075 &pt.ty,
1076 "`Quoted` / `Quosure` must be the parameter's whole type, or the type \
1077 argument of `Missing<..>`: the wrapper passes the argument unevaluated \
1078 only for those shapes",
1079 )
1080 .into_compile_error()
1081 .into();
1082 }
1083 continue;
1084 };
1085 let syn::Pat::Ident(pat_ident) = pt.pat.as_ref() else {
1086 continue;
1087 };
1088 let marker = param.kind.name();
1089 let rust_name = crate::naming::ident_name(&pat_ident.ident);
1090 if parsed
1092 .param_attrs(&rust_name)
1093 .is_some_and(|attrs| !attrs.leaves_argument_unforced(param.optional))
1094 {
1095 let hint = if param.optional {
1096 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("`Missing<{0}>` takes `default` alone, which only writes the formal and is never evaluated",
marker))
})format!(
1097 "`Missing<{marker}>` takes `default` alone, which only writes the \
1098 formal and is never evaluated"
1099 )
1100 } else {
1101 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("Use `Missing<{0}>` for an optional argument",
marker))
})format!("Use `Missing<{marker}>` for an optional argument")
1102 };
1103 return syn::Error::new_spanned(
1104 pt,
1105 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("per-parameter options (`coerce`, `match_arg`, `choices`, `several_ok`, `default`, `no_na`, `inherits`, `not_inherits`, `preconditions`) do not apply to a `{0}` parameter: the wrapper passes the argument unevaluated, and each of them would force it (`formal`, which only names it, does apply). {1}",
marker, hint))
})format!(
1106 "per-parameter options (`coerce`, `match_arg`, `choices`, `several_ok`, \
1107 `default`, `no_na`, `inherits`, `not_inherits`, `preconditions`) do not \
1108 apply to a `{marker}` parameter: the wrapper passes the argument \
1109 unevaluated, and each of them would force it (`formal`, which only \
1110 names it, does apply). {hint}"
1111 ),
1112 )
1113 .into_compile_error()
1114 .into();
1115 }
1116 unevaluated_r_names.push(formals.of(&rust_name));
1119 }
1120 if let Err(err) =
1126 miniextendr_fn::check_nargs_params(all_inputs, |name| parsed.has_param_attrs(name))
1127 {
1128 return err.into_compile_error().into();
1129 }
1130 if let Err(err) =
1134 miniextendr_fn::check_lazy_dots_params(all_inputs, |name| parsed.has_param_attrs(name))
1135 {
1136 return err.into_compile_error().into();
1137 }
1138 if let Err(err) =
1141 miniextendr_fn::check_rng_guard_params(all_inputs, rng, |name| parsed.has_param_attrs(name))
1142 {
1143 return err.into_compile_error().into();
1144 }
1145 let r_inputs: syn::punctuated::Punctuated<syn::FnArg, ::syn::token::Commasyn::Token![,]> = all_inputs
1146 .iter()
1147 .filter(|arg| match arg {
1148 syn::FnArg::Typed(pt) => {
1149 crate::type_inspect::call_marker(&pt.ty).is_none()
1150 && !crate::type_inspect::is_rng_guard_param(&pt.ty)
1151 }
1152 syn::FnArg::Receiver(_) => true,
1153 })
1154 .cloned()
1155 .collect();
1156 let inputs = &r_inputs;
1157
1158 if let Some(generic) = &s3_generic
1162 && let Err(err) = miniextendr_fn::check_replacement_value_param(
1163 crate::naming::split_generic(generic).1,
1164 inputs,
1165 &formals,
1166 rust_ident.span(),
1167 )
1168 {
1169 return err.into_compile_error().into();
1170 }
1171
1172 let doc_lint_warnings = if doc.is_some() {
1175 proc_macro2::TokenStream::new()
1176 } else {
1177 crate::roxygen::doc_conflict_warnings(attrs, rust_ident.span())
1178 };
1179
1180 let rust_inputs: Vec<proc_macro2::TokenStream> = all_inputs
1185 .iter()
1186 .filter_map(|arg| {
1187 if let syn::FnArg::Typed(pt) = arg
1188 && let syn::Pat::Ident(p) = pt.pat.as_ref()
1189 {
1190 let ident = &p.ident;
1191 if crate::type_inspect::is_rng_guard_param(&pt.ty) {
1192 return Some(crate::type_inspect::rng_guard_arg());
1193 }
1194 return Some(match crate::type_inspect::call_marker(&pt.ty) {
1195 Some(r_wrapper_builder::CallAttribution::Caller) => {
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "CallerCall");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "from_sexp");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "__miniextendr_call");
_s
});
_s
}quote::quote! {
1196 ::miniextendr_api::CallerCall::from_sexp(__miniextendr_call)
1197 },
1198 Some(_) => {
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "Call");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "from_sexp");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "__miniextendr_call");
_s
});
_s
}quote::quote! {
1199 ::miniextendr_api::Call::from_sexp(__miniextendr_call)
1200 },
1201 None => {
let mut _s = ::quote::__private::TokenStream::new();
::quote::ToTokens::to_tokens(&ident, &mut _s);
_s
}quote::quote! { #ident },
1202 });
1203 }
1204 None
1205 })
1206 .collect();
1207
1208 if dots_spec.is_some() && !has_dots {
1210 let err = syn::Error::new(
1211 dots_span.unwrap_or_else(proc_macro2::Span::call_site),
1212 "#[miniextendr(dots = typed_list!(...))] requires a `...` or `&Dots` parameter in the function signature",
1213 );
1214 return err.into_compile_error().into();
1215 }
1216 if dots_spec.is_some()
1217 && let Some(err) = miniextendr_fn::typed_list_on_lazy_dots(all_inputs, dots_span)
1218 {
1219 return err.into_compile_error().into();
1220 }
1221 if let Some(policy) = &dots_policy
1224 && let Err(err) = policy.check_signature(has_dots, has_dots)
1225 {
1226 return err.into_compile_error().into();
1227 }
1228
1229 if serde_error.is_some() && !return_type_analysis::output_is_result(output) {
1231 return syn::Error::new_spanned(
1232 output,
1233 "`#[miniextendr(serde_error(..))]` requires a `Result<T, E>` return type: it classes \
1234 the condition raised from the `Err` arm",
1235 )
1236 .into_compile_error()
1237 .into();
1238 }
1239 let err_parts = c_wrapper_builder::ErrPartsMode::from_spec(serde_error.as_ref());
1240
1241 let crate_config = match crate::crate_config::crate_config() {
1246 Ok(config) => config,
1247 Err(err) => {
1248 return syn::Error::new(proc_macro2::Span::call_site(), err.to_string())
1249 .into_compile_error()
1250 .into();
1251 }
1252 };
1253
1254 let is_s3_method = s3_generic.is_some() || s3_class.is_some();
1256 let effective_postfix = match &fn_postfix {
1263 Some(postfix) => Some(postfix.clone()),
1264 None if (noexport || internal) && fn_r_name.is_none() && !is_s3_method => {
1265 crate_config.noexport_postfix.clone()
1266 }
1267 None => None,
1268 };
1269 let r_wrapper_ident_str: String;
1270 let s3_method_comment: String;
1271 let mut s3_qualified_registration: Option<String> = None;
1273
1274 if is_s3_method {
1275 let generic = s3_generic
1278 .clone()
1279 .unwrap_or_else(|| crate::naming::ident_name(rust_ident));
1280 let (package, generic) = crate::naming::split_generic(&generic);
1281 let class = s3_class.as_ref().expect("s3_class validated at parse time");
1284 r_wrapper_ident_str = ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("{0}.{1}", generic, class))
})format!("{}.{}", generic, class);
1285 let import_comment =
1289 if package.is_none() && crate::vctrs_generics::is_vctrs_generic(generic) {
1290 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("#\' @importFrom vctrs {0}\n",
generic))
})format!("#' @importFrom vctrs {}\n", generic)
1291 } else {
1292 String::new()
1293 };
1294 s3_method_comment = ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("{0}#\' @method {1} {2}\n",
import_comment, generic, class))
})format!("{}#' @method {} {}\n", import_comment, generic, class);
1295 s3_qualified_registration =
1296 package.map(|package| ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("#\' @exportS3Method {0}::{1} {2}\n",
package, generic, class))
})format!("#' @exportS3Method {package}::{generic} {class}\n"));
1297 } else if let Some(ref custom_name) = fn_r_name {
1298 r_wrapper_ident_str = custom_name.clone();
1299 s3_method_comment = String::new();
1300 } else if let Some(ref postfix) = effective_postfix {
1301 r_wrapper_ident_str = ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("{0}{1}",
crate::naming::ident_name(rust_ident), postfix))
})format!("{}{postfix}", crate::naming::ident_name(rust_ident));
1304 s3_method_comment = String::new();
1305 } else if abi.is_some() {
1306 r_wrapper_ident_str = ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("unsafe_{0}",
crate::naming::ident_name(rust_ident)))
})format!("unsafe_{}", crate::naming::ident_name(rust_ident));
1307 s3_method_comment = String::new();
1308 } else {
1309 r_wrapper_ident_str = crate::naming::ident_name(rust_ident);
1310 s3_method_comment = String::new();
1311 };
1312
1313 let is_invisible_return_type = match crate::type_inspect::resolve_visibility(
1316 visibility_marker,
1317 force_invisible,
1318 return_type_analysis::returns_invisibly(output, unwrap_in_r),
1319 syn::spanned::Spanned::span(parsed.output()),
1320 ) {
1321 Ok(v) => v,
1322 Err(err) => return err.into_compile_error().into(),
1323 };
1324
1325 let cfg_attrs = extract_cfg_attrs(parsed.attrs());
1327
1328 let source_loc_doc = source_location_doc(rust_ident.span());
1329
1330 let mut coerce_params_list: Vec<String> = Vec::new();
1334 let mut match_arg_several_ok_params_list: Vec<String> = Vec::new();
1335 let mut layered_choice_params_list: Vec<(String, rust_conversion_builder::ChoiceLeaf)> =
1336 Vec::new();
1337 let mut no_na_params_list: Vec<(String, Option<String>)> = Vec::new();
1338 for input in inputs.iter() {
1339 if let syn::FnArg::Typed(pt) = input
1340 && let syn::Pat::Ident(pat_ident) = pt.pat.as_ref()
1341 {
1342 let param_name = crate::naming::ident_name(&pat_ident.ident);
1343 if parsed.has_coerce_attr(¶m_name) {
1344 if miniextendr_fn::CoercionMapping::from_type(&pt.ty).is_none() {
1349 return miniextendr_fn::unmapped_coerce_error(pt, ¶m_name)
1350 .into_compile_error()
1351 .into();
1352 }
1353 coerce_params_list.push(param_name.clone());
1354 }
1355 if let Some(attrs) = parsed.param_attrs(¶m_name)
1356 && attrs.checks.no_na
1357 {
1358 no_na_params_list.push((param_name.clone(), attrs.checks.no_na_message.clone()));
1359 }
1360 if let Some(leaf) = parsed
1361 .param_attrs(¶m_name)
1362 .and_then(miniextendr_fn::ParamAttrs::layered_leaf)
1363 {
1364 layered_choice_params_list.push((param_name, leaf));
1365 } else if parsed.has_match_arg_attr(¶m_name) && parsed.has_several_ok(¶m_name) {
1366 match_arg_several_ok_params_list.push(param_name);
1367 }
1368 }
1369 }
1370
1371 let fn_call_expr = crate::type_inspect::prepare_return_value(
1375 {
let mut _s = ::quote::__private::TokenStream::new();
::quote::ToTokens::to_tokens(&rust_ident, &mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
{
use ::quote::__private::ext::*;
let mut _first = true;
let has_iter = ::quote::__private::HasIterator::<false>;
#[allow(unused_mut)]
let (mut rust_inputs, i) = rust_inputs.quote_into_iter();
let has_iter = has_iter | i;
<_ as
::quote::__private::CheckHasIterator<true>>::check(has_iter);
while true {
let rust_inputs =
match rust_inputs.next() {
Some(_x) => ::quote::__private::RepInterp(_x),
None => break,
};
if !_first { ::quote::__private::push_comma(&mut _s); }
_first = false;
::quote::ToTokens::to_tokens(&rust_inputs, &mut _s);
}
}
_s
});
_s
}quote::quote! { #rust_ident(#(#rust_inputs),*) },
1376 visibility_marker,
1377 serialize,
1378 );
1379 let fn_call_expr = match &return_wrap {
1380 Some(wrap) => wrap.prepare_value(fn_call_expr),
1381 None => fn_call_expr,
1382 };
1383
1384 let return_pref_is_set = !#[allow(non_exhaustive_omitted_patterns)] match return_pref {
crate::miniextendr_fn::ReturnPref::Auto => true,
_ => false,
}matches!(return_pref, crate::miniextendr_fn::ReturnPref::Auto);
1387 let fn_return_handling = if unwrap_in_r && crate::return_type_analysis::output_is_result(output)
1388 {
1389 if return_pref_is_set {
1395 let span = return_pref_span.unwrap_or_else(proc_macro2::Span::call_site);
1396 return syn::Error::new(
1397 span,
1398 "`prefer = ...` cannot be combined with `unwrap_in_r` on a function returning \
1399 `Result<T, E>`: `unwrap_in_r` converts the whole `Result<T, E>` via a single \
1400 `IntoR` impl (a tagged list for R to decode), not the inner `T` alone, so \
1401 there is no plain `T` for `prefer=` to wrap. Remove `prefer=`.",
1402 )
1403 .into_compile_error()
1404 .into();
1405 }
1406 c_wrapper_builder::ReturnHandling::IntoR
1407 } else {
1408 let auto = c_wrapper_builder::detect_return_handling(output, return_wrap.as_ref());
1409 match apply_return_pref(auto, return_pref, return_pref_span) {
1414 Ok(handling) => handling,
1415 Err(err) => return err.into_compile_error().into(),
1416 }
1417 };
1418
1419 let rng_seed_formal = match &rng_seed {
1422 Some(seed) => {
1423 use c_wrapper_builder::ReturnHandling;
1424 let unit_return = #[allow(non_exhaustive_omitted_patterns)] match fn_return_handling {
ReturnHandling::Unit | ReturnHandling::ResultUnit |
ReturnHandling::OptionUnit => true,
_ => false,
}matches!(
1425 fn_return_handling,
1426 ReturnHandling::Unit | ReturnHandling::ResultUnit | ReturnHandling::OptionUnit
1427 );
1428 match miniextendr_fn::check_rng_seed(
1429 seed,
1430 all_inputs,
1431 inputs,
1432 &formals,
1433 &unevaluated_r_names,
1434 unit_return,
1435 ) {
1436 Ok(formal) => Some(formal),
1437 Err(err) => return err.into_compile_error().into(),
1438 }
1439 }
1440 None => None,
1441 };
1442
1443 let mut c_wrapper_builder =
1445 c_wrapper_builder::CWrapperContext::builder(rust_ident.clone(), c_ident.clone())
1446 .r_name(r_wrapper_ident_str.clone())
1447 .r_wrapper_const(r_wrapper_generator.clone())
1448 .inputs(inputs.iter().cloned().collect())
1449 .output(output.clone())
1450 .call_expr(fn_call_expr)
1451 .return_handling(fn_return_handling)
1452 .err_parts(err_parts)
1453 .cfg_attrs(cfg_attrs.clone())
1454 .vis(vis.clone())
1455 .generics(generics.clone())
1456 .formals(formals.clone())
1457 .preserve_param_names();
1458
1459 if uses_internal_c_wrapper {
1460 } else {
1462 c_wrapper_builder = c_wrapper_builder.skip_wrapper();
1464 }
1465
1466 if coerce_all {
1467 c_wrapper_builder = c_wrapper_builder.coerce_all();
1468 }
1469 for param in &coerce_params_list {
1470 c_wrapper_builder = c_wrapper_builder.with_coerce_param(param.clone());
1471 }
1472 for param in match_arg_several_ok_params_list {
1473 c_wrapper_builder = c_wrapper_builder.match_arg_several_ok(param);
1474 }
1475 for (param, leaf) in layered_choice_params_list {
1476 c_wrapper_builder = c_wrapper_builder.layered_choice(param, leaf);
1477 }
1478 for (param, message) in no_na_params_list {
1479 c_wrapper_builder = c_wrapper_builder.no_na(param, message);
1480 }
1481 for input in inputs.iter() {
1482 if let syn::FnArg::Typed(pt) = input
1483 && let syn::Pat::Ident(p) = pt.pat.as_ref()
1484 {
1485 let name = crate::naming::ident_name(&p.ident);
1486 if parsed.param_attrs(&name).is_some_and(|a| a.convert) {
1487 c_wrapper_builder = c_wrapper_builder.with_convert_param(name);
1488 }
1489 }
1490 }
1491 for (param, markers) in parsed.param_markers() {
1492 c_wrapper_builder = c_wrapper_builder.param_markers(param.clone(), markers.clone());
1493 }
1494 if check_interrupt {
1495 c_wrapper_builder = c_wrapper_builder.check_interrupt();
1496 }
1497 if rng {
1498 c_wrapper_builder = c_wrapper_builder.rng();
1499 }
1500 if strict {
1501 c_wrapper_builder = c_wrapper_builder.strict();
1502 }
1503
1504 let c_wrapper = c_wrapper_builder.build().generate();
1505
1506 let mut arg_builder = RArgumentBuilder::new(inputs).with_formals(formals.clone());
1509 let mut merged_defaults = formals.rekey(parsed.param_defaults());
1513 let mut match_arg_placeholders: Vec<(String, String, String, String)> = Vec::new();
1523 for match_arg_param in parsed.match_arg_params() {
1524 let r_name = formals.of(match_arg_param);
1525 let preferred = match merged_defaults.get(&r_name) {
1526 Some(raw) => crate::match_arg_keys::extract_match_arg_default(raw),
1527 None => String::new(),
1528 };
1529 let key = crate::match_arg_keys::param_key(match_arg_param);
1532 let placeholder = crate::match_arg_keys::choices_placeholder(&c_ident.to_string(), &key);
1533 let formal = match parsed.param_attrs(match_arg_param) {
1538 Some(attrs) => attrs.choice_formal(&placeholder),
1539 None => Some(placeholder.clone()),
1540 };
1541 if let Some(formal) = formal {
1542 merged_defaults.insert(r_name.clone(), formal);
1543 }
1544 let aliases_placeholder =
1545 crate::match_arg_keys::aliases_placeholder(&c_ident.to_string(), &key);
1546 match_arg_placeholders.push((
1547 placeholder,
1548 aliases_placeholder,
1549 match_arg_param.clone(),
1550 preferred,
1551 ));
1552 }
1553 for (param_name, choices) in parsed.choices_params() {
1557 let r_name = formals.of(param_name);
1558 let quoted: Vec<String> = choices.iter().map(|c| ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("\"{0}\"", c))
})format!("\"{}\"", c)).collect();
1559 let choices_expr = ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("c({0})", quoted.join(", ")))
})format!("c({})", quoted.join(", "));
1560 let formal = match parsed.param_attrs(param_name) {
1561 Some(attrs) => attrs.choice_formal(&choices_expr),
1562 None => Some(choices_expr),
1563 };
1564 if let Some(formal) = formal {
1565 merged_defaults.entry(r_name).or_insert(formal);
1566 }
1567 }
1568 arg_builder = arg_builder
1569 .with_defaults(merged_defaults)
1570 .with_absent_formals(parsed.absent_formals());
1571
1572 let r_formals = arg_builder.build_formals();
1573 let mut r_call_args_strs = arg_builder.build_call_args_vec();
1574
1575 let call_attribution = r_wrapper_builder::CallAttribution::resolve(
1598 call_marker.as_ref().map(|(_, kind)| *kind),
1599 call_attribution_attr,
1600 crate_config.call_attribution.filter(|_| !call_arg),
1601 noexport || internal,
1602 )
1603 .with_call_arg(call_arg);
1604 let call_attribution = if is_s3_method {
1605 call_attribution.for_s3_method(call_marker.is_some())
1606 } else {
1607 call_attribution
1608 };
1609 if uses_internal_c_wrapper {
1610 r_call_args_strs.insert(0, call_attribution.dot_call_arg().to_string());
1611 } else if #[allow(non_exhaustive_omitted_patterns)] match call_attribution_attr {
Some(r_wrapper_builder::CallAttribution::Caller |
r_wrapper_builder::CallAttribution::NoCall) => true,
_ => false,
}matches!(
1612 call_attribution_attr,
1613 Some(
1614 r_wrapper_builder::CallAttribution::Caller | r_wrapper_builder::CallAttribution::NoCall
1615 )
1616 ) || call_arg
1617 {
1618 let option = if call_arg {
1621 "`call_arg`"
1622 } else if call_attribution_attr == Some(r_wrapper_builder::CallAttribution::NoCall) {
1623 "`call = none`"
1624 } else {
1625 "`call = caller`"
1626 };
1627 return syn::Error::new_spanned(
1628 &parsed.item().sig.ident,
1629 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("{0} needs the generated call slot; an `extern \"C-unwind\"` function has no `.call` argument to attribute",
option))
})format!(
1630 "{option} needs the generated call slot; an `extern \"C-unwind\"` function \
1631 has no `.call` argument to attribute"
1632 ),
1633 )
1634 .into_compile_error()
1635 .into();
1636 }
1637
1638 let c_ident_str = c_ident.to_string();
1640 let call_args_joined = r_call_args_strs.join(", ");
1641 let call_expr = if r_call_args_strs.is_empty() {
1642 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!(".Call({0})", c_ident_str))
})format!(".Call({})", c_ident_str)
1643 } else {
1644 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!(".Call({0}, {1})", c_ident_str,
call_args_joined))
})format!(".Call({}, {})", c_ident_str, call_args_joined)
1645 };
1646 let r_wrapper_return_str = {
1647 let final_return = return_wrap
1649 .as_ref()
1650 .map_or_else(|| ".val".to_owned(), |wrap| wrap.r_expression(".val", None));
1651 let final_return = if is_invisible_return_type {
1652 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("invisible({0})", final_return))
})format!("invisible({final_return})")
1653 } else {
1654 final_return
1655 };
1656 let final_return = if rng_seed_formal.is_some() {
1659 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("{0}\n {1}",
r_wrapper_builder::RngSeedContract::ATTRIBUTE, final_return))
})format!(
1660 "{}\n {final_return}",
1661 r_wrapper_builder::RngSeedContract::ATTRIBUTE
1662 )
1663 } else {
1664 final_return
1665 };
1666 crate::method_return_builder::standalone_body_with_call_default(
1669 &call_expr,
1670 &final_return,
1671 " ",
1672 call_attribution.raise_default(),
1673 )
1674 };
1675 let call_formal = call_attribution.formal().filter(|_| !is_s3_method);
1685 let formals_joined = r_wrapper_builder::with_call_formal(&r_formals, call_formal);
1688 let mut roxygen_tags = if let Some(ref doc_text) = doc {
1689 doc_text.lines().map(|l| l.to_string()).collect()
1691 } else {
1692 crate::roxygen::roxygen_tags_from_attrs(
1695 attrs,
1696 crate::roxygen::RdPage::suppressed_if(noexport),
1697 )
1698 };
1699
1700 let lifecycle_spec = lifecycle.or_else(|| {
1702 attrs
1703 .iter()
1704 .find_map(crate::lifecycle::parse_rust_deprecated)
1705 });
1706
1707 if let Some(ref spec) = lifecycle_spec {
1709 crate::lifecycle::inject_lifecycle_badge(&mut roxygen_tags, spec);
1710 }
1711
1712 let renders_no_page = noexport || crate::roxygen::has_roxygen_tag(&roxygen_tags, "noRd");
1721 let call_param_doc = call_formal
1722 .and(call_attribution.param_doc())
1723 .filter(|_| !renders_no_page);
1724 let match_arg_param_doc_placeholders = crate::roxygen::push_fn_param_tags(
1725 &mut roxygen_tags,
1726 inputs,
1727 &parsed,
1728 &c_ident_str,
1729 call_param_doc,
1730 );
1731
1732 let has_no_rd_tag = crate::roxygen::has_roxygen_tag(&roxygen_tags, "noRd");
1740 if !roxygen_tags.is_empty()
1741 && !has_no_rd_tag
1742 && !noexport
1743 && !crate::roxygen::has_roxygen_tag(&roxygen_tags, "title")
1744 {
1745 roxygen_tags.insert(0, ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("@title {0}", r_wrapper_ident_str))
})format!("@title {}", r_wrapper_ident_str));
1746 }
1747
1748 let roxygen_tags_str = crate::roxygen::format_roxygen_tags(&roxygen_tags);
1749 let has_export_tag = crate::roxygen::has_export_tag(&roxygen_tags);
1750 let has_internal_tag = crate::roxygen::has_roxygen_tag(&roxygen_tags, "keywords internal");
1751 let source_comment = crate::roxygen::source_tag_with(
1754 crate_config.source_tags,
1755 &::alloc::__export::must_use({
::alloc::fmt::format(format_args!("Generated by miniextendr from Rust fn `{0}`",
rust_ident))
})format!("Generated by miniextendr from Rust fn `{rust_ident}`"),
1756 )
1757 .map(|line| ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("{0}\n", line))
})format!("{line}\n"))
1758 .unwrap_or_default();
1759 let internal_comment = if internal && !has_internal_tag {
1761 "#' @keywords internal\n"
1762 } else {
1763 ""
1764 };
1765 let export_comment = if (#[allow(non_exhaustive_omitted_patterns)] match vis {
syn::Visibility::Public(_) => true,
_ => false,
}matches!(vis, syn::Visibility::Public(_)) || export)
1769 && !has_export_tag
1770 && !has_no_rd_tag
1771 && !has_internal_tag
1772 && !internal
1773 && !noexport
1774 {
1775 s3_qualified_registration.unwrap_or_else(|| "#' @export\n".to_string())
1780 } else {
1781 String::new()
1782 };
1783 let no_rd_comment = if noexport && !has_no_rd_tag {
1789 "#' @noRd\n"
1790 } else {
1791 ""
1792 };
1793 let match_arg_param_info: Vec<(String, String, &syn::Type)> = inputs
1796 .iter()
1797 .filter_map(|arg| {
1798 if let syn::FnArg::Typed(pt) = arg
1799 && let syn::Pat::Ident(pat_ident) = pt.pat.as_ref()
1800 {
1801 let rust_name = crate::naming::ident_name(&pat_ident.ident);
1802 if parsed.has_match_arg_attr(&rust_name) {
1803 let r_name = formals.of(&rust_name);
1804 return Some((r_name, rust_name, pt.ty.as_ref()));
1805 }
1806 }
1807 None
1808 })
1809 .collect();
1810
1811 let match_arg_prelude = if match_arg_param_info.is_empty() {
1812 String::new()
1813 } else {
1814 let mut lines = Vec::new();
1815 for (r_param, rust_name, _) in &match_arg_param_info {
1816 let key = crate::match_arg_keys::param_key(rust_name);
1827 let placeholder =
1828 crate::match_arg_keys::choices_placeholder(&c_ident.to_string(), &key);
1829 let aliases = crate::match_arg_keys::aliases_placeholder(&c_ident.to_string(), &key);
1830 if let Some(attrs) = parsed.param_attrs(rust_name) {
1831 lines.extend(call_attribution.match_arg_lines(
1832 r_param,
1833 &placeholder,
1834 Some(&aliases),
1835 attrs,
1836 ));
1837 }
1838 }
1839 lines.join("\n ")
1840 };
1841
1842 let choices_prelude = {
1845 let mut lines = Vec::new();
1846 for arg in inputs.iter() {
1847 if let syn::FnArg::Typed(pt) = arg
1848 && let syn::Pat::Ident(pat_ident) = pt.pat.as_ref()
1849 {
1850 let rust_name = crate::naming::ident_name(&pat_ident.ident);
1851 if let Some(attrs) = parsed.param_attrs(&rust_name)
1852 && let Some(choices) = attrs.choices.as_ref()
1853 {
1854 let r_name = formals.of(&rust_name);
1855 let quoted: Vec<String> =
1856 choices.iter().map(|c| ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("\"{0}\"", c))
})format!("\"{}\"", c)).collect();
1857 let choices_expr = ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("c({0})", quoted.join(", ")))
})format!("c({})", quoted.join(", "));
1858 lines.extend(call_attribution.match_arg_lines(
1859 &r_name,
1860 &choices_expr,
1861 None,
1862 attrs,
1863 ));
1864 }
1865 }
1866 }
1867 if lines.is_empty() {
1868 String::new()
1869 } else {
1870 lines.join("\n ")
1871 }
1872 };
1873
1874 let lifecycle_prelude = lifecycle_spec
1876 .as_ref()
1877 .and_then(|spec| spec.r_prelude(&r_wrapper_ident_str));
1878
1879 let mut skip_params = parsed.precondition_skip_params();
1883 skip_params.extend(unevaluated_r_names.iter().cloned());
1884 let precondition_prelude = {
1898 let mut unchecked = r_preconditions::unchecked_params(
1901 inputs,
1902 &formals,
1903 |name| parsed.param_attrs(name).and_then(|a| a.preconditions),
1904 preconditions,
1905 None,
1906 crate_config.preconditions,
1907 );
1908 unchecked.extend(rng_seed_formal.iter().cloned());
1909 let precondition_opts = r_preconditions::PreconditionOptions {
1913 coerce_all,
1914 coerce_params: coerce_params_list.iter().map(|p| formals.of(p)).collect(),
1915 explicit: parsed.explicit_checks(),
1916 unchecked,
1917 formals: formals.clone(),
1918 };
1919 let precondition_output =
1920 r_preconditions::build_precondition_checks(inputs, &skip_params, &precondition_opts);
1921 precondition_output
1925 .guards(call_attribution.r_check_call())
1926 .join("\n ")
1927 };
1928
1929 let dots_check = dots_policy
1933 .as_ref()
1934 .and_then(|policy| policy.r_check(&formals_joined, call_attribution.r_check_call()));
1935
1936 let on_exit_str = r_on_exit.as_ref().map(|oe| oe.to_r_code());
1946 let rng_seed_prelude = rng_seed_formal
1947 .as_deref()
1948 .map(|formal| r_wrapper_builder::RngSeedContract { formal }.prelude(" "));
1949 let attribution_prelude = call_attribution.prelude(call_formal.is_some());
1950 let combined_prelude = {
1951 let mut parts = Vec::new();
1952 if !attribution_prelude.is_empty() {
1953 parts.push(attribution_prelude.as_str());
1954 }
1955 if let Some(ref entry) = r_entry {
1956 parts.push(entry.as_str());
1957 }
1958 if let Some(ref s) = on_exit_str {
1959 parts.push(s.as_str());
1960 }
1961 if let Some(ref lc) = lifecycle_prelude {
1962 parts.push(lc.as_str());
1963 }
1964 if let Some(ref check) = dots_check {
1965 parts.push(check.as_str());
1966 }
1967 if !precondition_prelude.is_empty() {
1968 parts.push(&precondition_prelude);
1969 }
1970 if !match_arg_prelude.is_empty() {
1971 parts.push(&match_arg_prelude);
1972 }
1973 if !choices_prelude.is_empty() {
1974 parts.push(&choices_prelude);
1975 }
1976 if let Some(ref post) = r_post_checks {
1977 parts.push(post.as_str());
1978 }
1979 if let Some(ref seed) = rng_seed_prelude {
1980 parts.push(seed.as_str());
1981 }
1982 if parts.is_empty() {
1983 None
1984 } else {
1985 Some(parts.join("\n "))
1986 }
1987 };
1988
1989 let r_wrapper_string = if let Some(prelude) = combined_prelude {
1990 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("{0}{1}{2}{3}{4}{5}{6} <- function({7}) {{\n {8}\n {9}\n}}",
roxygen_tags_str, source_comment, s3_method_comment,
internal_comment, no_rd_comment, export_comment,
crate::naming::r_def_name(&r_wrapper_ident_str),
formals_joined, prelude, r_wrapper_return_str))
})format!(
1991 "{}{}{}{}{}{}{} <- function({}) {{\n {}\n {}\n}}",
1992 roxygen_tags_str,
1993 source_comment,
1994 s3_method_comment,
1995 internal_comment,
1996 no_rd_comment,
1997 export_comment,
1998 crate::naming::r_def_name(&r_wrapper_ident_str),
1999 formals_joined,
2000 prelude,
2001 r_wrapper_return_str
2002 )
2003 } else {
2004 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("{0}{1}{2}{3}{4}{5}{6} <- function({7}) {{\n {8}\n}}",
roxygen_tags_str, source_comment, s3_method_comment,
internal_comment, no_rd_comment, export_comment,
crate::naming::r_def_name(&r_wrapper_ident_str),
formals_joined, r_wrapper_return_str))
})format!(
2005 "{}{}{}{}{}{}{} <- function({}) {{\n {}\n}}",
2006 roxygen_tags_str,
2007 source_comment,
2008 s3_method_comment,
2009 internal_comment,
2010 no_rd_comment,
2011 export_comment,
2012 crate::naming::r_def_name(&r_wrapper_ident_str),
2013 formals_joined,
2014 r_wrapper_return_str
2015 )
2016 };
2017 let r_wrapper_str = r_wrapper_raw_literal(
2019 &r_wrapper_string,
2020 &r_shadowing::formal_names([(inputs, formals.clone())]),
2021 );
2022
2023 let r_wrapper_doc = ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("R wrapper code for [`{0}`], calls [`{1}`].",
rust_ident, c_ident))
})format!(
2027 "R wrapper code for [`{}`], calls [`{}`].",
2028 rust_ident, c_ident
2029 );
2030 let source_start = rust_ident.span().start();
2031 let source_line_lit = syn::LitInt::new(&source_start.line.to_string(), rust_ident.span());
2032 let source_col_lit =
2033 syn::LitInt::new(&(source_start.column + 1).to_string(), rust_ident.span());
2034
2035 let mut original_item = parsed.item_without_roxygen();
2038 original_item
2040 .attrs
2041 .retain(|attr| !attr.path().is_ident("miniextendr"));
2042
2043 if let (Some(spec_tokens), Some(dots_param)) = (&dots_spec, &dots_ident) {
2046 let validation_stmt = build_dots_validation_stmt(dots_param, spec_tokens);
2047 original_item.block.stmts.insert(0, validation_stmt);
2048 }
2049
2050 let original_item = original_item;
2051
2052 let choices_ty_for = |rust_param: &str| -> Option<&syn::Type> {
2057 let (_, _, param_ty) = match_arg_param_info
2058 .iter()
2059 .find(|(_, rn, _)| rn == rust_param)?;
2060 Some(match_arg_choices_ty(
2061 param_ty,
2062 parsed.has_several_ok(rust_param),
2063 ))
2064 };
2065
2066 let match_arg_choices_entries: Vec<proc_macro2::TokenStream> = match_arg_placeholders
2067 .iter()
2068 .filter_map(
2069 |(placeholder, aliases_placeholder, rust_param, preferred_default)| {
2070 let choices_ty = choices_ty_for(rust_param)?;
2071 let entry_ident = syn::Ident::new(
2072 &::alloc::__export::must_use({
::alloc::fmt::format(format_args!("match_arg_choices_entry_{0}",
crate::match_arg_keys::placeholder_ident_suffix(placeholder)))
})format!(
2073 "match_arg_choices_entry_{}",
2074 crate::match_arg_keys::placeholder_ident_suffix(placeholder)
2075 ),
2076 proc_macro2::Span::call_site(),
2077 );
2078 Some(crate::match_arg_keys::choices_entry_tokens(
2079 &cfg_attrs,
2080 &entry_ident,
2081 placeholder,
2082 aliases_placeholder,
2083 choices_ty,
2084 preferred_default,
2085 ))
2086 },
2087 )
2088 .collect();
2089
2090 let match_arg_param_doc_entries: Vec<proc_macro2::TokenStream> =
2092 match_arg_param_doc_placeholders
2093 .iter()
2094 .filter_map(|(doc_placeholder, rust_param)| {
2095 let choices_ty = choices_ty_for(rust_param)?;
2096 let attrs = parsed.param_attrs(rust_param)?;
2097 let entry_ident = syn::Ident::new(
2098 &::alloc::__export::must_use({
::alloc::fmt::format(format_args!("match_arg_param_doc_entry_{0}",
crate::match_arg_keys::placeholder_ident_suffix(doc_placeholder)))
})format!(
2099 "match_arg_param_doc_entry_{}",
2100 crate::match_arg_keys::placeholder_ident_suffix(doc_placeholder)
2101 ),
2102 proc_macro2::Span::call_site(),
2103 );
2104 Some(crate::match_arg_keys::param_doc_entry_tokens(
2105 &cfg_attrs,
2106 &entry_ident,
2107 doc_placeholder,
2108 attrs.several_ok,
2109 &attrs.choice_doc_suffix(),
2110 choices_ty,
2111 ))
2112 })
2113 .collect();
2114
2115 let fn_r_wrapper_doc = ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("See [`{0}`] for C wrapper, [`{1}`] for R wrapper.",
c_ident, r_wrapper_generator))
})format!(
2117 "See [`{}`] for C wrapper, [`{}`] for R wrapper.",
2118 c_ident, r_wrapper_generator
2119 );
2120
2121 let expanded: T = {
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::ToTokens::to_tokens(&fn_r_wrapper_doc, &mut _s);
_s
});
::quote::ToTokens::to_tokens(&original_item, &mut _s);
{
use ::quote::__private::ext::*;
let has_iter = ::quote::__private::HasIterator::<false>;
#[allow(unused_mut)]
let (mut cfg_attrs, i) = cfg_attrs.quote_into_iter();
let has_iter = has_iter | i;
<_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
while true {
let cfg_attrs =
match cfg_attrs.next() {
Some(_x) => ::quote::__private::RepInterp(_x),
None => break,
};
::quote::ToTokens::to_tokens(&cfg_attrs, &mut _s);
}
}
::quote::ToTokens::to_tokens(&c_wrapper, &mut _s);
{
use ::quote::__private::ext::*;
let has_iter = ::quote::__private::HasIterator::<false>;
#[allow(unused_mut)]
let (mut cfg_attrs, i) = cfg_attrs.quote_into_iter();
let has_iter = has_iter | i;
<_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
while true {
let cfg_attrs =
match cfg_attrs.next() {
Some(_x) => ::quote::__private::RepInterp(_x),
None => break,
};
::quote::ToTokens::to_tokens(&cfg_attrs, &mut _s);
}
}
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::ToTokens::to_tokens(&r_wrapper_doc, &mut _s);
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "concat");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::parse(&mut _s,
"\"Wraps Rust function `\"");
::quote::__private::push_comma(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "stringify");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::ToTokens::to_tokens(&rust_ident, &mut _s);
_s
});
::quote::__private::push_comma(&mut _s);
::quote::__private::parse(&mut _s, "\"`.\"");
_s
});
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::ToTokens::to_tokens(&source_loc_doc, &mut _s);
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "concat");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::parse(&mut _s,
"\"Generated from source file `\"");
::quote::__private::push_comma(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "file");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
::quote::__private::TokenStream::new());
::quote::__private::push_comma(&mut _s);
::quote::__private::parse(&mut _s, "\"`.\"");
_s
});
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "cfg_attr");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "not");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "target_arch");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s, "\"wasm32\"");
_s
});
::quote::__private::push_comma(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "linkme");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s,
"distributed_slice");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "registry");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "MX_R_WRAPPERS");
_s
});
::quote::__private::push_comma(&mut _s);
::quote::__private::push_ident(&mut _s, "linkme");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "crate");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "linkme");
_s
});
_s
});
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "allow");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s,
"non_upper_case_globals");
_s
});
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "allow");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "non_snake_case");
_s
});
_s
});
::quote::__private::push_ident(&mut _s, "static");
::quote::ToTokens::to_tokens(&r_wrapper_generator, &mut _s);
::quote::__private::push_colon(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "registry");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "RWrapperEntry");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "registry");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "RWrapperEntry");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "priority");
::quote::__private::push_colon(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "registry");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "RWrapperPriority");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "Function");
::quote::__private::push_comma(&mut _s);
::quote::__private::push_ident(&mut _s, "source_file");
::quote::__private::push_colon(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "file");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
::quote::__private::TokenStream::new());
::quote::__private::push_comma(&mut _s);
::quote::__private::push_ident(&mut _s, "source_line");
::quote::__private::push_colon(&mut _s);
::quote::ToTokens::to_tokens(&source_line_lit, &mut _s);
::quote::__private::push_comma(&mut _s);
::quote::__private::push_ident(&mut _s, "content");
::quote::__private::push_colon(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "concat");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::parse(&mut _s,
"\"# Generated from Rust fn `\"");
::quote::__private::push_comma(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "stringify");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::ToTokens::to_tokens(&rust_ident, &mut _s);
_s
});
::quote::__private::push_comma(&mut _s);
::quote::__private::parse(&mut _s, "\"` (\"");
::quote::__private::push_comma(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "file");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
::quote::__private::TokenStream::new());
::quote::__private::push_comma(&mut _s);
::quote::__private::parse(&mut _s, "\":\"");
::quote::__private::push_comma(&mut _s);
::quote::ToTokens::to_tokens(&source_line_lit, &mut _s);
::quote::__private::push_comma(&mut _s);
::quote::__private::parse(&mut _s, "\":\"");
::quote::__private::push_comma(&mut _s);
::quote::ToTokens::to_tokens(&source_col_lit, &mut _s);
::quote::__private::push_comma(&mut _s);
::quote::__private::parse(&mut _s, "\")\"");
::quote::__private::push_comma(&mut _s);
::quote::ToTokens::to_tokens(&r_wrapper_str, &mut _s);
_s
});
::quote::__private::push_comma(&mut _s);
_s
});
::quote::__private::push_semi(&mut _s);
{
use ::quote::__private::ext::*;
let has_iter = ::quote::__private::HasIterator::<false>;
#[allow(unused_mut)]
let (mut match_arg_choices_entries, i) =
match_arg_choices_entries.quote_into_iter();
let has_iter = has_iter | i;
<_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
while true {
let match_arg_choices_entries =
match match_arg_choices_entries.next() {
Some(_x) => ::quote::__private::RepInterp(_x),
None => break,
};
::quote::ToTokens::to_tokens(&match_arg_choices_entries, &mut _s);
}
}
{
use ::quote::__private::ext::*;
let has_iter = ::quote::__private::HasIterator::<false>;
#[allow(unused_mut)]
let (mut match_arg_param_doc_entries, i) =
match_arg_param_doc_entries.quote_into_iter();
let has_iter = has_iter | i;
<_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
while true {
let match_arg_param_doc_entries =
match match_arg_param_doc_entries.next() {
Some(_x) => ::quote::__private::RepInterp(_x),
None => break,
};
::quote::ToTokens::to_tokens(&match_arg_param_doc_entries,
&mut _s);
}
}
::quote::ToTokens::to_tokens(&doc_lint_warnings, &mut _s);
_s
}quote::quote! {
2122 #[doc = #fn_r_wrapper_doc]
2124 #original_item
2125
2126 #(#cfg_attrs)*
2128 #c_wrapper
2129
2130 #(#cfg_attrs)*
2132 #[doc = #r_wrapper_doc]
2133 #[doc = ::core::concat!("Wraps Rust function `", ::core::stringify!(#rust_ident), "`.")]
2134 #[doc = #source_loc_doc]
2135 #[doc = ::core::concat!("Generated from source file `", ::core::file!(), "`.")]
2136 #[cfg_attr(not(target_arch = "wasm32"), ::miniextendr_api::linkme::distributed_slice(::miniextendr_api::registry::MX_R_WRAPPERS), linkme(crate = ::miniextendr_api::linkme))]
2137 #[allow(non_upper_case_globals)]
2138 #[allow(non_snake_case)]
2139 static #r_wrapper_generator: ::miniextendr_api::registry::RWrapperEntry =
2140 ::miniextendr_api::registry::RWrapperEntry {
2141 priority: ::miniextendr_api::registry::RWrapperPriority::Function,
2142 source_file: ::core::file!(),
2143 source_line: #source_line_lit,
2144 content: ::core::concat!(
2145 "# Generated from Rust fn `",
2146 ::core::stringify!(#rust_ident),
2147 "` (",
2148 ::core::file!(),
2149 ":",
2150 #source_line_lit,
2151 ":",
2152 #source_col_lit,
2153 ")",
2154 #r_wrapper_str
2155 ),
2156 };
2157
2158 #(#match_arg_choices_entries)*
2160
2161 #(#match_arg_param_doc_entries)*
2163
2164 #doc_lint_warnings
2166 }
2167 .into();
2168
2169 expanded
2170}
2171
2172fn apply_return_pref(
2182 auto: c_wrapper_builder::ReturnHandling,
2183 pref: crate::miniextendr_fn::ReturnPref,
2184 pref_span: Option<proc_macro2::Span>,
2185) -> syn::Result<c_wrapper_builder::ReturnHandling> {
2186 use crate::miniextendr_fn::ReturnPref;
2187 use c_wrapper_builder::ReturnHandling;
2188
2189 let wrapped = match pref {
2190 ReturnPref::Auto => return Ok(auto),
2191 ReturnPref::List => match auto {
2192 ReturnHandling::IntoR => Some(ReturnHandling::AsListOf),
2193 _ => None,
2194 },
2195 ReturnPref::ExternalPtr => match auto {
2196 ReturnHandling::IntoR => Some(ReturnHandling::AsExternalPtrOf),
2197 _ => None,
2198 },
2199 ReturnPref::Native => match auto {
2200 ReturnHandling::IntoR => Some(ReturnHandling::AsNativeOf),
2201 _ => None,
2202 },
2203 };
2204
2205 wrapped.ok_or_else(|| {
2206 let (pref_name, wrapper_name) = return_pref_names(pref);
2207 let span = pref_span.unwrap_or_else(proc_macro2::Span::call_site);
2208 syn::Error::new(
2209 span,
2210 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("`prefer = \"{1}\"` cannot be honored on this return type. `prefer=` only applies to a function returning a plain `T: IntoR` value, which it wraps in `{2}` before conversion. This function\'s return type falls into a different codegen category ({0}) with its own fixed SEXP-shape rule, so there is no plain `T` for `prefer=` to wrap. Remove `prefer=`, or change the return type to a plain `T`.",
return_handling_category_description(&auto), pref_name,
wrapper_name))
})format!(
2211 "`prefer = \"{pref_name}\"` cannot be honored on this return type. \
2212 `prefer=` only applies to a function returning a plain `T: IntoR` value, \
2213 which it wraps in `{wrapper_name}` before conversion. This function's return \
2214 type falls into a different codegen category ({}) with its own fixed \
2215 SEXP-shape rule, so there is no plain `T` for `prefer=` to wrap. Remove \
2216 `prefer=`, or change the return type to a plain `T`.",
2217 return_handling_category_description(&auto),
2218 ),
2219 )
2220 })
2221}
2222
2223fn return_pref_names(pref: crate::miniextendr_fn::ReturnPref) -> (&'static str, &'static str) {
2226 use crate::miniextendr_fn::ReturnPref;
2227 match pref {
2228 ReturnPref::Auto => ("auto", ""),
2229 ReturnPref::List => ("list", "AsList"),
2230 ReturnPref::ExternalPtr => ("externalptr", "AsExternalPtr"),
2231 ReturnPref::Native => ("native", "AsRNative"),
2232 }
2233}
2234
2235fn return_handling_category_description(rh: &c_wrapper_builder::ReturnHandling) -> &'static str {
2242 use c_wrapper_builder::ReturnHandling;
2243 match rh {
2244 ReturnHandling::Unit => "the unit return type `()`",
2245 ReturnHandling::RawSexp => "a raw `SEXP` return type",
2246 ReturnHandling::ExternalPtr => {
2247 "a `Self`-returning constructor, already converted via `ExternalPtr::new`"
2248 }
2249 ReturnHandling::OptionUnit => "`Option<()>`",
2250 ReturnHandling::OptionSexp => "`Option<SEXP>`",
2251 ReturnHandling::OptionIntoR | ReturnHandling::OptionClassPayload => "`Option<T>`",
2252 ReturnHandling::ResultUnit => "`Result<(), E>`",
2253 ReturnHandling::ResultSexp => "`Result<SEXP, E>`",
2254 ReturnHandling::ResultIntoR => "`Result<T, E>`",
2255 ReturnHandling::ResultNullOnErr => "`Result<T, ()>`",
2256 _ => "this return type",
2257 }
2258}
2259
2260#[proc_macro_attribute]
2321pub fn r_ffi_checked(
2322 _attr: proc_macro::TokenStream,
2323 item: proc_macro::TokenStream,
2324) -> proc_macro::TokenStream {
2325 let foreign_mod = match ::syn::parse::<syn::ItemForeignMod>(item) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(item as syn::ItemForeignMod);
2326
2327 let foreign_mod_attrs = &foreign_mod.attrs;
2328 let abi = &foreign_mod.abi;
2329 let mut unchecked_items = Vec::new();
2330 let mut checked_wrappers = Vec::new();
2331
2332 for item in &foreign_mod.items {
2333 match item {
2334 syn::ForeignItem::Fn(fn_item) => {
2335 let is_variadic = fn_item.sig.variadic.is_some();
2336
2337 let has_link_name = fn_item
2339 .attrs
2340 .iter()
2341 .any(|attr| attr.path().is_ident("link_name"));
2342
2343 if is_variadic || has_link_name {
2344 unchecked_items.push(item.clone());
2346 } else {
2347 let vis = &fn_item.vis;
2349 let fn_name = &fn_item.sig.ident;
2350 let fn_name_str = fn_name.to_string();
2351 let unchecked_name = match ::quote::__private::IdentFragmentAdapter(&fn_name) {
arg =>
::quote::__private::mk_ident(&::alloc::__export::must_use({
::alloc::fmt::format(format_args!("{0}_unchecked", arg))
}), ::quote::__private::Option::None.or(arg.span())),
}quote::format_ident!("{}_unchecked", fn_name);
2352 let unchecked_name_str = unchecked_name.to_string();
2353 let inputs = &fn_item.sig.inputs;
2354 let output = &fn_item.sig.output;
2355 let attrs: Vec<_> = fn_item
2357 .attrs
2358 .iter()
2359 .filter(|attr| !attr.path().is_ident("link_name"))
2360 .collect();
2361 let checked_doc = ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("Checked wrapper for `{0}`. Calls `{1}` inside `with_r_thread`, which panics off R\'s main thread.",
fn_name_str, unchecked_name_str))
})format!(
2362 "Checked wrapper for `{}`. Calls `{}` inside `with_r_thread`, which panics off R's main thread.",
2363 fn_name_str, unchecked_name_str
2364 );
2365 let checked_doc_lit = syn::LitStr::new(&checked_doc, fn_name.span());
2366 let source_loc_doc = crate::source_location_doc(fn_name.span());
2367 let source_loc_doc_lit = syn::LitStr::new(&source_loc_doc, fn_name.span());
2368
2369 let link_name = syn::LitStr::new(&fn_name_str, fn_name.span());
2372 let unchecked_fn: syn::ForeignItem = ::syn::__private::parse_quote({
let mut _s = ::quote::__private::TokenStream::new();
{
use ::quote::__private::ext::*;
let has_iter = ::quote::__private::HasIterator::<false>;
#[allow(unused_mut)]
let (mut attrs, i) = attrs.quote_into_iter();
let has_iter = has_iter | i;
<_ as
::quote::__private::CheckHasIterator<true>>::check(has_iter);
while true {
let attrs =
match attrs.next() {
Some(_x) => ::quote::__private::RepInterp(_x),
None => break,
};
::quote::ToTokens::to_tokens(&attrs, &mut _s);
}
}
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "concat");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::parse(&mut _s,
"\"Unchecked FFI binding for `\"");
::quote::__private::push_comma(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "stringify");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::ToTokens::to_tokens(&fn_name, &mut _s);
_s
});
::quote::__private::push_comma(&mut _s);
::quote::__private::parse(&mut _s, "\"`.\"");
_s
});
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::ToTokens::to_tokens(&source_loc_doc_lit, &mut _s);
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "concat");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::parse(&mut _s,
"\"Generated from source file `\"");
::quote::__private::push_comma(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "file");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
::quote::__private::TokenStream::new());
::quote::__private::push_comma(&mut _s);
::quote::__private::parse(&mut _s, "\"`.\"");
_s
});
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "link_name");
::quote::__private::push_eq(&mut _s);
::quote::ToTokens::to_tokens(&link_name, &mut _s);
_s
});
::quote::ToTokens::to_tokens(&vis, &mut _s);
::quote::__private::push_ident(&mut _s, "fn");
::quote::ToTokens::to_tokens(&unchecked_name, &mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::ToTokens::to_tokens(&inputs, &mut _s);
_s
});
::quote::ToTokens::to_tokens(&output, &mut _s);
::quote::__private::push_semi(&mut _s);
_s
})syn::parse_quote! {
2373 #(#attrs)*
2374 #[doc = ::core::concat!("Unchecked FFI binding for `", ::core::stringify!(#fn_name), "`.")]
2375 #[doc = #source_loc_doc_lit]
2376 #[doc = ::core::concat!("Generated from source file `", ::core::file!(), "`.")]
2377 #[link_name = #link_name]
2378 #vis fn #unchecked_name(#inputs) #output;
2379 };
2380 unchecked_items.push(unchecked_fn);
2381
2382 let arg_names: Vec<_> = inputs
2384 .iter()
2385 .filter_map(|arg| {
2386 if let syn::FnArg::Typed(pat_type) = arg
2387 && let syn::Pat::Ident(pat_ident) = pat_type.pat.as_ref()
2388 {
2389 Some(pat_ident.ident.clone())
2390 } else {
2391 None
2392 }
2393 })
2394 .collect();
2395
2396 let wrapper = {
let mut _s = ::quote::__private::TokenStream::new();
{
use ::quote::__private::ext::*;
let has_iter = ::quote::__private::HasIterator::<false>;
#[allow(unused_mut)]
let (mut attrs, i) = attrs.quote_into_iter();
let has_iter = has_iter | i;
<_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
while true {
let attrs =
match attrs.next() {
Some(_x) => ::quote::__private::RepInterp(_x),
None => break,
};
::quote::ToTokens::to_tokens(&attrs, &mut _s);
}
}
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::ToTokens::to_tokens(&checked_doc_lit, &mut _s);
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::ToTokens::to_tokens(&source_loc_doc_lit, &mut _s);
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "concat");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::parse(&mut _s,
"\"Generated from source file `\"");
::quote::__private::push_comma(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "file");
::quote::__private::push_bang(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
::quote::__private::TokenStream::new());
::quote::__private::push_comma(&mut _s);
::quote::__private::parse(&mut _s, "\"`.\"");
_s
});
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "inline");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "always");
_s
});
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "allow");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "non_snake_case");
_s
});
_s
});
::quote::ToTokens::to_tokens(&vis, &mut _s);
::quote::__private::push_ident(&mut _s, "unsafe");
::quote::__private::push_ident(&mut _s, "fn");
::quote::ToTokens::to_tokens(&fn_name, &mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::ToTokens::to_tokens(&inputs, &mut _s);
_s
});
::quote::ToTokens::to_tokens(&output, &mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "with_r_thread");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "move");
::quote::__private::push_or_or(&mut _s);
::quote::__private::push_ident(&mut _s, "unsafe");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::ToTokens::to_tokens(&unchecked_name, &mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
{
use ::quote::__private::ext::*;
let mut _first = true;
let has_iter = ::quote::__private::HasIterator::<false>;
#[allow(unused_mut)]
let (mut arg_names, i) = arg_names.quote_into_iter();
let has_iter = has_iter | i;
<_ as
::quote::__private::CheckHasIterator<true>>::check(has_iter);
while true {
let arg_names =
match arg_names.next() {
Some(_x) => ::quote::__private::RepInterp(_x),
None => break,
};
if !_first { ::quote::__private::push_comma(&mut _s); }
_first = false;
::quote::ToTokens::to_tokens(&arg_names, &mut _s);
}
}
_s
});
_s
});
_s
});
_s
});
_s
}quote::quote! {
2397 #(#attrs)*
2398 #[doc = #checked_doc_lit]
2399 #[doc = #source_loc_doc_lit]
2400 #[doc = ::core::concat!("Generated from source file `", ::core::file!(), "`.")]
2401 #[inline(always)]
2402 #[allow(non_snake_case)]
2403 #vis unsafe fn #fn_name(#inputs) #output {
2404 ::miniextendr_api::with_r_thread(move || unsafe {
2405 #unchecked_name(#(#arg_names),*)
2406 })
2407 }
2408 };
2409 checked_wrappers.push(wrapper);
2410 }
2411 }
2412 _ => {
2413 unchecked_items.push(item.clone());
2415 }
2416 }
2417 }
2418
2419 let expanded = {
let mut _s = ::quote::__private::TokenStream::new();
{
use ::quote::__private::ext::*;
let has_iter = ::quote::__private::HasIterator::<false>;
#[allow(unused_mut)]
let (mut foreign_mod_attrs, i) = foreign_mod_attrs.quote_into_iter();
let has_iter = has_iter | i;
<_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
while true {
let foreign_mod_attrs =
match foreign_mod_attrs.next() {
Some(_x) => ::quote::__private::RepInterp(_x),
None => break,
};
::quote::ToTokens::to_tokens(&foreign_mod_attrs, &mut _s);
}
}
::quote::__private::push_ident(&mut _s, "unsafe");
::quote::ToTokens::to_tokens(&abi, &mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
{
use ::quote::__private::ext::*;
let has_iter = ::quote::__private::HasIterator::<false>;
#[allow(unused_mut)]
let (mut unchecked_items, i) =
unchecked_items.quote_into_iter();
let has_iter = has_iter | i;
<_ as
::quote::__private::CheckHasIterator<true>>::check(has_iter);
while true {
let unchecked_items =
match unchecked_items.next() {
Some(_x) => ::quote::__private::RepInterp(_x),
None => break,
};
::quote::ToTokens::to_tokens(&unchecked_items, &mut _s);
}
}
_s
});
{
use ::quote::__private::ext::*;
let has_iter = ::quote::__private::HasIterator::<false>;
#[allow(unused_mut)]
let (mut checked_wrappers, i) = checked_wrappers.quote_into_iter();
let has_iter = has_iter | i;
<_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
while true {
let checked_wrappers =
match checked_wrappers.next() {
Some(_x) => ::quote::__private::RepInterp(_x),
None => break,
};
::quote::ToTokens::to_tokens(&checked_wrappers, &mut _s);
}
}
_s
}quote::quote! {
2420 #(#foreign_mod_attrs)*
2421 unsafe #abi {
2422 #(#unchecked_items)*
2423 }
2424
2425 #(#checked_wrappers)*
2426 };
2427
2428 expanded.into()
2429}
2430
2431#[proc_macro_derive(RNativeType)]
2493pub fn derive_rnative_type(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
2494 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
2495 let name = &input.ident;
2496 let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
2497
2498 let (inner_ty, elt_ctor): (syn::Type, proc_macro2::TokenStream) = match &input.data {
2500 syn::Data::Struct(data) => match &data.fields {
2501 syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
2502 let ty = fields.unnamed.first().unwrap().ty.clone();
2503 let ctor = {
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "Self");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "val");
_s
});
_s
}quote::quote! { Self(val) };
2504 (ty, ctor)
2505 }
2506 syn::Fields::Named(fields) if fields.named.len() == 1 => {
2507 let field = fields.named.first().unwrap();
2508 let ty = field.ty.clone();
2509 let field_name = field.ident.as_ref().unwrap();
2510 let ctor = {
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "Self");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::ToTokens::to_tokens(&field_name, &mut _s);
::quote::__private::push_colon(&mut _s);
::quote::__private::push_ident(&mut _s, "val");
_s
});
_s
}quote::quote! { Self { #field_name: val } };
2511 (ty, ctor)
2512 }
2513 _ => {
2514 return syn::Error::new_spanned(
2515 name,
2516 "#[derive(RNativeType)] requires a newtype struct with exactly one field",
2517 )
2518 .into_compile_error()
2519 .into();
2520 }
2521 },
2522 _ => {
2523 return syn::Error::new_spanned(name, "#[derive(RNativeType)] only works on structs")
2524 .into_compile_error()
2525 .into();
2526 }
2527 };
2528
2529 let transparent = input
2532 .attrs
2533 .iter()
2534 .filter(|attr| attr.path().is_ident("repr"))
2535 .any(|attr| {
2536 attr.parse_args_with(
2537 syn::punctuated::Punctuated::<syn::Meta, ::syn::token::Commasyn::Token![,]>::parse_terminated,
2538 )
2539 .is_ok_and(|reprs| reprs.iter().any(|repr| repr.path().is_ident("transparent")))
2540 });
2541 if !transparent {
2542 return syn::Error::new_spanned(
2543 name,
2544 "#[derive(RNativeType)] requires #[repr(transparent)] for native R buffer access",
2545 )
2546 .into_compile_error()
2547 .into();
2548 }
2549
2550 let expanded = {
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "impl");
::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "RNativeType");
::quote::__private::push_ident(&mut _s, "for");
::quote::ToTokens::to_tokens(&name, &mut _s);
::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
::quote::ToTokens::to_tokens(&where_clause, &mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "const");
::quote::__private::push_ident(&mut _s, "SEXP_TYPE");
::quote::__private::push_colon(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "SEXPTYPE");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_lt(&mut _s);
::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
::quote::__private::push_ident(&mut _s, "as");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "RNativeType");
::quote::__private::push_gt(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "SEXP_TYPE");
::quote::__private::push_semi(&mut _s);
::quote::__private::push_ident(&mut _s, "const");
::quote::__private::push_ident(&mut _s, "R_NA");
::quote::__private::push_colon(&mut _s);
::quote::__private::push_ident(&mut _s, "Self");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "let");
::quote::__private::push_ident(&mut _s, "val");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_lt(&mut _s);
::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
::quote::__private::push_ident(&mut _s, "as");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "RNativeType");
::quote::__private::push_gt(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "R_NA");
::quote::__private::push_semi(&mut _s);
::quote::ToTokens::to_tokens(&elt_ctor, &mut _s);
_s
});
::quote::__private::push_semi(&mut _s);
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "inline");
_s
});
::quote::__private::push_ident(&mut _s, "unsafe");
::quote::__private::push_ident(&mut _s, "fn");
::quote::__private::push_ident(&mut _s, "dataptr_mut");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "sexp");
::quote::__private::push_colon(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "SEXP");
_s
});
::quote::__private::push_rarrow(&mut _s);
::quote::__private::push_star(&mut _s);
::quote::__private::push_ident(&mut _s, "mut");
::quote::__private::push_ident(&mut _s, "Self");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "unsafe");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_lt(&mut _s);
::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
::quote::__private::push_ident(&mut _s, "as");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "RNativeType");
::quote::__private::push_gt(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "dataptr_mut");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "sexp");
_s
});
::quote::__private::push_dot(&mut _s);
::quote::__private::push_ident(&mut _s, "cast");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
::quote::__private::TokenStream::new());
_s
});
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "inline");
_s
});
::quote::__private::push_ident(&mut _s, "fn");
::quote::__private::push_ident(&mut _s, "elt");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "sexp");
::quote::__private::push_colon(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "SEXP");
::quote::__private::push_comma(&mut _s);
::quote::__private::push_ident(&mut _s, "i");
::quote::__private::push_colon(&mut _s);
::quote::__private::push_ident(&mut _s, "isize");
_s
});
::quote::__private::push_rarrow(&mut _s);
::quote::__private::push_ident(&mut _s, "Self");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "let");
::quote::__private::push_ident(&mut _s, "val");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_lt(&mut _s);
::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
::quote::__private::push_ident(&mut _s, "as");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "RNativeType");
::quote::__private::push_gt(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "elt");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "sexp");
::quote::__private::push_comma(&mut _s);
::quote::__private::push_ident(&mut _s, "i");
_s
});
::quote::__private::push_semi(&mut _s);
::quote::ToTokens::to_tokens(&elt_ctor, &mut _s);
_s
});
_s
});
_s
}quote::quote! {
2551 impl #impl_generics ::miniextendr_api::RNativeType for #name #ty_generics #where_clause {
2552 const SEXP_TYPE: ::miniextendr_api::SEXPTYPE =
2553 <#inner_ty as ::miniextendr_api::RNativeType>::SEXP_TYPE;
2554
2555 const R_NA: Self = {
2556 let val = <#inner_ty as ::miniextendr_api::RNativeType>::R_NA;
2557 #elt_ctor
2558 };
2559
2560 #[inline]
2561 unsafe fn dataptr_mut(sexp: ::miniextendr_api::SEXP) -> *mut Self {
2562 unsafe {
2564 <#inner_ty as ::miniextendr_api::RNativeType>::dataptr_mut(sexp).cast()
2565 }
2566 }
2567
2568 #[inline]
2569 fn elt(sexp: ::miniextendr_api::SEXP, i: isize) -> Self {
2570 let val = <#inner_ty as ::miniextendr_api::RNativeType>::elt(sexp, i);
2571 #elt_ctor
2572 }
2573 }
2574
2575 };
2576
2577 expanded.into()
2578}
2579
2580#[proc_macro_derive(IsNA)]
2612pub fn derive_is_na(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
2613 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
2614 newtype_derive::derive_is_na(input)
2615 .unwrap_or_else(|e| e.into_compile_error())
2616 .into()
2617}
2618
2619#[proc_macro_derive(ExternalPtr, attributes(externalptr, r_data))]
2672pub fn derive_external_ptr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
2673 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
2674
2675 externalptr_derive::derive_external_ptr(input, true)
2679 .unwrap_or_else(|e| e.into_compile_error())
2680 .into()
2681}
2682
2683#[proc_macro_derive(AllEqual, attributes(all_equal))]
2774pub fn derive_all_equal(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
2775 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
2776 all_equal_derive::derive_all_equal(input)
2777 .unwrap_or_else(|e| e.into_compile_error())
2778 .into()
2779}
2780
2781#[proc_macro_derive(AltrepInteger, attributes(altrep, r_data))]
2831pub fn derive_altrep_integer(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
2832 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
2833 altrep_derive::derive_altrep_integer(input)
2834 .unwrap_or_else(|e| e.into_compile_error())
2835 .into()
2836}
2837
2838#[proc_macro_derive(AltrepReal, attributes(altrep, r_data))]
2843pub fn derive_altrep_real(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
2844 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
2845 altrep_derive::derive_altrep_real(input)
2846 .unwrap_or_else(|e| e.into_compile_error())
2847 .into()
2848}
2849
2850#[proc_macro_derive(AltrepLogical, attributes(altrep, r_data))]
2855pub fn derive_altrep_logical(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
2856 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
2857 altrep_derive::derive_altrep_logical(input)
2858 .unwrap_or_else(|e| e.into_compile_error())
2859 .into()
2860}
2861
2862#[proc_macro_derive(AltrepRaw, attributes(altrep, r_data))]
2867pub fn derive_altrep_raw(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
2868 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
2869 altrep_derive::derive_altrep_raw(input)
2870 .unwrap_or_else(|e| e.into_compile_error())
2871 .into()
2872}
2873
2874#[proc_macro_derive(AltrepString, attributes(altrep, r_data))]
2879pub fn derive_altrep_string(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
2880 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
2881 altrep_derive::derive_altrep_string(input)
2882 .unwrap_or_else(|e| e.into_compile_error())
2883 .into()
2884}
2885
2886#[proc_macro_derive(AltrepComplex, attributes(altrep, r_data))]
2891pub fn derive_altrep_complex(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
2892 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
2893 altrep_derive::derive_altrep_complex(input)
2894 .unwrap_or_else(|e| e.into_compile_error())
2895 .into()
2896}
2897
2898#[proc_macro_derive(AltrepList, attributes(altrep, r_data))]
2907pub fn derive_altrep_list(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
2908 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
2909 altrep_derive::derive_altrep_list(input)
2910 .unwrap_or_else(|e| e.into_compile_error())
2911 .into()
2912}
2913
2914#[proc_macro_derive(Altrep, attributes(altrep, r_data))]
2941pub fn derive_altrep(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
2942 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
2943 altrep::derive_altrep(input)
2944 .unwrap_or_else(|e| e.into_compile_error())
2945 .into()
2946}
2947
2948#[proc_macro_derive(IntoList, attributes(into_list))]
2956pub fn derive_into_list(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
2957 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
2958 list_derive::derive_into_list(input)
2959 .unwrap_or_else(|e| e.into_compile_error())
2960 .into()
2961}
2962
2963#[proc_macro_derive(TryFromList, attributes(into_list))]
2974pub fn derive_try_from_list(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
2975 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
2976 list_derive::derive_try_from_list(input)
2977 .unwrap_or_else(|e| e.into_compile_error())
2978 .into()
2979}
2980
2981#[proc_macro_derive(PreferList)]
3000pub fn derive_prefer_list(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3001 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
3002 list_derive::derive_prefer_list(input)
3003 .unwrap_or_else(|e| e.into_compile_error())
3004 .into()
3005}
3006
3007#[proc_macro_derive(PreferExternalPtr)]
3024pub fn derive_prefer_externalptr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3025 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
3026 list_derive::derive_prefer_externalptr(input)
3027 .unwrap_or_else(|e| e.into_compile_error())
3028 .into()
3029}
3030
3031#[proc_macro_derive(PreferRNativeType)]
3044pub fn derive_prefer_rnative(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3045 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
3046 list_derive::derive_prefer_rnative(input)
3047 .unwrap_or_else(|e| e.into_compile_error())
3048 .into()
3049}
3050
3051#[cfg(feature = "vctrs")]
3066#[proc_macro_derive(PreferVctrs)]
3067pub fn derive_prefer_vctrs(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3068 let input = syn::parse_macro_input!(input as syn::DeriveInput);
3069 list_derive::derive_prefer_vctrs(input)
3070 .unwrap_or_else(|e| e.into_compile_error())
3071 .into()
3072}
3073
3074#[proc_macro_derive(DataFrameRow, attributes(dataframe))]
3159pub fn derive_dataframe_row(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3160 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
3161 dataframe_derive::derive_dataframe_row(input)
3162 .unwrap_or_else(|e| e.into_compile_error())
3163 .into()
3164}
3165
3166#[proc_macro_derive(RFactor, attributes(r_factor))]
3189pub fn derive_r_factor(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3190 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
3191 factor_derive::derive_r_factor(input)
3192 .unwrap_or_else(|e| e.into_compile_error())
3193 .into()
3194}
3195
3196#[proc_macro_derive(MatchArg, attributes(match_arg))]
3228pub fn derive_match_arg(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3229 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
3230 match_arg_derive::derive_match_arg(input)
3231 .unwrap_or_else(|e| e.into_compile_error())
3232 .into()
3233}
3234
3235#[proc_macro_derive(RCondition, attributes(condition))]
3262pub fn derive_r_condition(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3263 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
3264 condition_derive::derive_r_condition(input)
3265 .unwrap_or_else(|e| e.into_compile_error())
3266 .into()
3267}
3268
3269#[proc_macro_derive(TryFromSexp, attributes(try_from_sexp))]
3331pub fn derive_try_from_sexp(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3332 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
3333 newtype_derive::derive_try_from_sexp(input)
3334 .unwrap_or_else(|e| e.into_compile_error())
3335 .into()
3336}
3337
3338#[proc_macro_derive(IntoR)]
3349pub fn derive_into_r(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3350 let input = match ::syn::parse::<syn::DeriveInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::DeriveInput);
3351 newtype_derive::derive_into_r(input)
3352 .unwrap_or_else(|e| e.into_compile_error())
3353 .into()
3354}
3355
3356#[cfg(feature = "vctrs")]
3380#[proc_macro_derive(Vctrs, attributes(vctrs))]
3381pub fn derive_vctrs(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3382 let input = syn::parse_macro_input!(input as syn::DeriveInput);
3383 vctrs_derive::derive_vctrs(input)
3384 .unwrap_or_else(|e| e.into_compile_error())
3385 .into()
3386}
3387
3388#[proc_macro]
3504pub fn typed_list(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3505 let parsed = match ::syn::parse::<typed_list::TypedListInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as typed_list::TypedListInput);
3506 typed_list::expand_typed_list(parsed).into()
3507}
3508
3509#[proc_macro]
3599pub fn typed_dataframe(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3600 let parsed = match ::syn::parse::<typed_dataframe::TypedDataframeInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as typed_dataframe::TypedDataframeInput);
3601 typed_dataframe::expand_typed_dataframe(parsed).into()
3602}
3603
3604#[proc_macro]
3647pub fn list(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3648 let parsed = match ::syn::parse::<list_macro::ListInput>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as list_macro::ListInput);
3649 list_macro::expand_list(parsed).into()
3650}
3651
3652#[proc_macro]
3710pub fn r(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3711 r_macro::expand(input)
3712}
3713
3714#[proc_macro]
3756pub fn reexport(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3757 reexport::expand(input.into()).into()
3758}
3759
3760#[proc_macro]
3765#[doc(hidden)]
3766pub fn __mx_trait_impl_expand(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3767 miniextendr_impl_trait::expand_tpie(input)
3768}
3769
3770#[proc_macro]
3785pub fn impl_typed_external(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3786 match typed_external_macro::impl_typed_external(input.into()) {
3787 Ok(tokens) => tokens.into(),
3788 Err(err) => err.into_compile_error().into(),
3789 }
3790}
3791
3792#[proc_macro]
3817pub fn miniextendr_init(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
3818 let pkg_name: syn::Ident = if input.is_empty() {
3819 let name = match std::env::var("CARGO_CRATE_NAME") {
3824 Ok(n) => n,
3825 Err(_) => {
3826 return syn::Error::new(
3827 proc_macro2::Span::call_site(),
3828 "CARGO_CRATE_NAME not set. Either pass the package name explicitly: \
3829 miniextendr_init!(mypkg), or ensure you're building with cargo.",
3830 )
3831 .into_compile_error()
3832 .into();
3833 }
3834 };
3835 match syn::parse_str::<syn::Ident>(&name) {
3836 Ok(id) => id,
3837 Err(_) => {
3838 return syn::Error::new(
3839 proc_macro2::Span::call_site(),
3840 ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("CARGO_CRATE_NAME `{0}` is not a valid C identifier; R_init_<pkg> must match `[A-Za-z_][A-Za-z0-9_]*`. Pass the name explicitly: miniextendr_init!(my_pkg).",
name))
})format!(
3841 "CARGO_CRATE_NAME `{name}` is not a valid C identifier; \
3842 R_init_<pkg> must match `[A-Za-z_][A-Za-z0-9_]*`. \
3843 Pass the name explicitly: miniextendr_init!(my_pkg)."
3844 ),
3845 )
3846 .into_compile_error()
3847 .into();
3848 }
3849 }
3850 } else {
3851 match ::syn::parse::<syn::Ident>(input) {
::syn::__private::Ok(data) => data,
::syn::__private::Err(err) => {
return ::syn::__private::TokenStream::from(err.to_compile_error());
}
}syn::parse_macro_input!(input as syn::Ident)
3852 };
3853 let fn_name = syn::Ident::new(&::alloc::__export::must_use({
::alloc::fmt::format(format_args!("R_init_{0}", pkg_name))
})format!("R_init_{}", pkg_name), pkg_name.span());
3854 let unload_name = syn::Ident::new(&::alloc::__export::must_use({
::alloc::fmt::format(format_args!("R_unload_{0}", pkg_name))
})format!("R_unload_{}", pkg_name), pkg_name.span());
3855
3856 let mut name_bytes = pkg_name.to_string().into_bytes();
3858 name_bytes.push(0);
3859 let byte_lit = syn::LitByteStr::new(&name_bytes, pkg_name.span());
3860
3861 let conversion_error_class = crate::crate_config::conversion_error_class();
3865 let init_marker = crate::miniextendr_fn::init_marker_ident();
3866
3867 let expanded = {
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" The crate\'s marker type. A `serde_error_shape!` declaration is an\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" impl keyed by it, and the generated `Err` arms look the declaration\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" up under it, so the macro must be called at the crate root.\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "hidden");
_s
});
_s
});
::quote::__private::push_ident(&mut _s, "pub");
::quote::__private::push_ident(&mut _s, "enum");
::quote::ToTokens::to_tokens(&init_marker, &mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
::quote::__private::TokenStream::new());
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" The package crate\'s `conversion_error_class`, read by the\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" wrapper-generation pass and the raising guards (host-only; the\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" `wasm_registry.rs` snapshot carries it to wasm32).\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "cfg");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "not");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "target_arch");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s, "\"wasm32\"");
_s
});
_s
});
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "linkme");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "distributed_slice");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "registry");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s,
"MX_CONVERSION_ERROR_CLASS");
_s
});
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "linkme");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "crate");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "linkme");
_s
});
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "hidden");
_s
});
_s
});
::quote::__private::push_ident(&mut _s, "static");
::quote::__private::push_ident(&mut _s, "__MX_CONVERSION_ERROR_CLASS");
::quote::__private::push_colon(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "registry");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "ConversionErrorClassEntry");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "registry");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "ConversionErrorClassEntry");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "classes");
::quote::__private::push_colon(&mut _s);
::quote::__private::push_and(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
{
use ::quote::__private::ext::*;
let mut _first = true;
let has_iter = ::quote::__private::HasIterator::<false>;
#[allow(unused_mut)]
let (mut conversion_error_class, i) =
conversion_error_class.quote_into_iter();
let has_iter = has_iter | i;
<_ as
::quote::__private::CheckHasIterator<true>>::check(has_iter);
while true {
let conversion_error_class =
match conversion_error_class.next() {
Some(_x) => ::quote::__private::RepInterp(_x),
None => break,
};
if !_first { ::quote::__private::push_comma(&mut _s); }
_first = false;
::quote::ToTokens::to_tokens(&conversion_error_class,
&mut _s);
}
}
_s
});
::quote::__private::push_comma(&mut _s);
_s
});
::quote::__private::push_semi(&mut _s);
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "cfg");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "target_arch");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s, "\"wasm32\"");
_s
});
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "path");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s, "\"wasm_registry.rs\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "hidden");
_s
});
_s
});
::quote::__private::push_ident(&mut _s, "mod");
::quote::__private::push_ident(&mut _s, "__miniextendr_wasm_registry");
::quote::__private::push_semi(&mut _s);
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "unsafe");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "no_mangle");
_s
});
_s
});
::quote::__private::push_ident(&mut _s, "pub");
::quote::__private::push_ident(&mut _s, "unsafe");
::quote::__private::push_ident(&mut _s, "extern");
::quote::__private::parse(&mut _s, "\"C-unwind\"");
::quote::__private::push_ident(&mut _s, "fn");
::quote::ToTokens::to_tokens(&fn_name, &mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "dll");
::quote::__private::push_colon(&mut _s);
::quote::__private::push_star(&mut _s);
::quote::__private::push_ident(&mut _s, "mut");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "sys");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "DllInfo");
::quote::__private::push_comma(&mut _s);
_s
});
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "let");
::quote::__private::push_ident(&mut _s,
"__miniextendr_init_result");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "std");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "panic");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "catch_unwind");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "std");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "panic");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "AssertUnwindSafe");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_or_or(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "cfg");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "target_arch");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s, "\"wasm32\"");
_s
});
_s
});
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "registry");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s,
"install_wasm_runtime_slices");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s,
"__miniextendr_wasm_registry");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s,
"MX_CALL_DEFS_WASM");
::quote::__private::push_comma(&mut _s);
::quote::__private::push_ident(&mut _s,
"__miniextendr_wasm_registry");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s,
"MX_ALTREP_REGISTRATIONS_WASM");
::quote::__private::push_comma(&mut _s);
::quote::__private::push_ident(&mut _s,
"__miniextendr_wasm_registry");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s,
"MX_TRAIT_DISPATCH_WASM");
::quote::__private::push_comma(&mut _s);
::quote::__private::push_ident(&mut _s,
"__miniextendr_wasm_registry");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s,
"MX_CONVERSION_ERROR_CLASS_WASM");
::quote::__private::push_comma(&mut _s);
_s
});
::quote::__private::push_semi(&mut _s);
::quote::__private::push_ident(&mut _s, "unsafe");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "let");
::quote::__private::push_ident(&mut _s, "pkg_name");
::quote::__private::push_eq(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "std");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "ffi");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "CStr");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s,
"from_bytes_with_nul_unchecked");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::ToTokens::to_tokens(&byte_lit, &mut _s);
_s
});
::quote::__private::push_semi(&mut _s);
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "init");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "package_init");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "dll");
::quote::__private::push_comma(&mut _s);
::quote::__private::push_ident(&mut _s, "pkg_name");
_s
});
::quote::__private::push_semi(&mut _s);
_s
});
_s
});
_s
});
::quote::__private::push_comma(&mut _s);
_s
});
::quote::__private::push_semi(&mut _s);
::quote::__private::push_ident(&mut _s, "if");
::quote::__private::push_ident(&mut _s, "let");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "result");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "Result");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "Err");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "payload");
_s
});
::quote::__private::push_eq(&mut _s);
::quote::__private::push_ident(&mut _s,
"__miniextendr_init_result");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "core");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "mem");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "drop");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "payload");
_s
});
::quote::__private::push_semi(&mut _s);
::quote::__private::push_ident(&mut _s, "unsafe");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "sys");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s,
"Rf_error_unchecked");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::parse(&mut _s,
"c\"miniextendr package initialization panicked before completing\"");
::quote::__private::push_dot(&mut _s);
::quote::__private::push_ident(&mut _s, "as_ptr");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
::quote::__private::TokenStream::new());
::quote::__private::push_comma(&mut _s);
_s
});
::quote::__private::push_semi(&mut _s);
_s
});
_s
});
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" R_unload_<pkg> entry point \u{2014} R calls this on `detach(unload=TRUE)` /\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" `dyn.unload()`. Uninstalls the miniextendr panic hook before R\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" unmaps the library\'s code.\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "unsafe");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "no_mangle");
_s
});
_s
});
::quote::__private::push_ident(&mut _s, "pub");
::quote::__private::push_ident(&mut _s, "unsafe");
::quote::__private::push_ident(&mut _s, "extern");
::quote::__private::parse(&mut _s, "\"C-unwind\"");
::quote::__private::push_ident(&mut _s, "fn");
::quote::ToTokens::to_tokens(&unload_name, &mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "_dll");
::quote::__private::push_colon(&mut _s);
::quote::__private::push_star(&mut _s);
::quote::__private::push_ident(&mut _s, "mut");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "sys");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "DllInfo");
::quote::__private::push_comma(&mut _s);
_s
});
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "miniextendr_api");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s, "thread");
::quote::__private::push_colon2(&mut _s);
::quote::__private::push_ident(&mut _s,
"miniextendr_runtime_shutdown");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
::quote::__private::TokenStream::new());
::quote::__private::push_semi(&mut _s);
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" Linker anchor: stub.c takes the address of this symbol to force the\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" linker to pull in the user crate\'s archive member from the staticlib.\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" With codegen-units = 1, this single member contains all linkme\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" distributed_slice entries. The name is package-independent so stub.c\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" doesn\'t need configure substitution.\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s, "r\"\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" Defined as a function rather than a static so it stays exported under\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" the webR wasm RUSTFLAG -Zdefault-visibility=hidden, which keeps\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" no_mangle functions exported (like the R_init entry point) but hides\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" no_mangle statics. A hidden anchor breaks wasm side-module dlopen\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "doc");
::quote::__private::push_eq(&mut _s);
::quote::__private::parse(&mut _s,
"r\" (bad export type, undefined). See miniextendr webR notes (#494).\"");
_s
});
::quote::__private::push_pound(&mut _s);
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Bracket,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "unsafe");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
{
let mut _s = ::quote::__private::TokenStream::new();
::quote::__private::push_ident(&mut _s, "no_mangle");
_s
});
_s
});
::quote::__private::push_ident(&mut _s, "pub");
::quote::__private::push_ident(&mut _s, "extern");
::quote::__private::parse(&mut _s, "\"C\"");
::quote::__private::push_ident(&mut _s, "fn");
::quote::__private::push_ident(&mut _s, "miniextendr_force_link");
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Parenthesis,
::quote::__private::TokenStream::new());
::quote::__private::push_group(&mut _s,
::quote::__private::Delimiter::Brace,
::quote::__private::TokenStream::new());
_s
}quote::quote! {
3868 #[doc(hidden)]
3872 pub enum #init_marker {}
3873
3874 #[cfg(not(target_arch = "wasm32"))]
3878 #[::miniextendr_api::linkme::distributed_slice(::miniextendr_api::registry::MX_CONVERSION_ERROR_CLASS)]
3879 #[linkme(crate = ::miniextendr_api::linkme)]
3880 #[doc(hidden)]
3881 static __MX_CONVERSION_ERROR_CLASS: ::miniextendr_api::registry::ConversionErrorClassEntry =
3882 ::miniextendr_api::registry::ConversionErrorClassEntry {
3883 classes: &[#(#conversion_error_class),*],
3884 };
3885
3886 #[cfg(target_arch = "wasm32")]
3895 #[path = "wasm_registry.rs"]
3896 #[doc(hidden)]
3897 mod __miniextendr_wasm_registry;
3898
3899 #[unsafe(no_mangle)]
3900 pub unsafe extern "C-unwind" fn #fn_name(
3901 dll: *mut ::miniextendr_api::sys::DllInfo,
3902 ) {
3903 let __miniextendr_init_result = ::std::panic::catch_unwind(
3904 ::std::panic::AssertUnwindSafe(|| {
3905 #[cfg(target_arch = "wasm32")]
3911 ::miniextendr_api::registry::install_wasm_runtime_slices(
3912 __miniextendr_wasm_registry::MX_CALL_DEFS_WASM,
3913 __miniextendr_wasm_registry::MX_ALTREP_REGISTRATIONS_WASM,
3914 __miniextendr_wasm_registry::MX_TRAIT_DISPATCH_WASM,
3915 __miniextendr_wasm_registry::MX_CONVERSION_ERROR_CLASS_WASM,
3916 );
3917
3918 unsafe {
3919 let pkg_name = ::std::ffi::CStr::from_bytes_with_nul_unchecked(#byte_lit);
3921 ::miniextendr_api::init::package_init(dll, pkg_name);
3922 }
3923 }),
3924 );
3925 if let ::core::result::Result::Err(payload) = __miniextendr_init_result {
3926 ::core::mem::drop(payload);
3930 unsafe {
3931 ::miniextendr_api::sys::Rf_error_unchecked(
3932 c"miniextendr package initialization panicked before completing".as_ptr(),
3933 );
3934 }
3935 }
3936 }
3937
3938 #[unsafe(no_mangle)]
3942 pub unsafe extern "C-unwind" fn #unload_name(
3943 _dll: *mut ::miniextendr_api::sys::DllInfo,
3944 ) {
3945 ::miniextendr_api::thread::miniextendr_runtime_shutdown();
3946 }
3947
3948 #[unsafe(no_mangle)]
3960 pub extern "C" fn miniextendr_force_link() {}
3961 };
3962
3963 expanded.into()
3964}
3965
3966#[cfg(test)]
3967mod tests;