wip

Author: Brayan-724

Cargo.lock

@@ -1,8 +1,8 @@
 [package]
-name = "probe"
+name = "rosttasse"
 version = "0.1.0"
 edition = "2021"
 
 [dependencies]
 jni = "0.21.1"
-probe_macros = { path = "../macros/" }
+rosttasse_macros = { path = "../macros/" }

rust/api/Cargo.toml

@@ -4,7 +4,7 @@ pub mod primitives;
 
 use class::Instance;
 use conversion::{FromJValue, IntoJValue};
-pub use probe_macros::*;
+pub use rosttasse_macros::*;
 
 pub trait JSignature {
     const CLASS: &'static str;

rust/api/src/lib.rs

@@ -1,5 +1,5 @@
 [package]
-name = "probe_macros"
+name = "rosttasse_macros"
 version = "0.1.0"
 edition = "2021"
 

rust/macros/Cargo.toml

@@ -0,0 +1,20 @@
+mod parse;
+
+pub use parse::{ClassBody, ClassInput};
+use proc_macro2::TokenStream;
+use quote::{quote, quote_spanned};
+
+pub fn main(input: ClassInput, body: ClassBody) -> syn::Result<TokenStream> {
+    let struct_name = &body.ident;
+
+    let signature = input.package.value();
+    let signature = quote_spanned! {input.package.span() =>
+        impl ::probe::JSignature for #struct_name {
+            const CLASS: &str = #signature;
+        }
+    };
+
+    Ok(quote! {
+        #signature
+    })
+}

rust/macros/src/class/mod.rs

@@ -0,0 +1,78 @@
+use syn::{
+    parse::{Parse, ParseStream},
+    punctuated::Punctuated,
+    token, FieldsNamed, Ident, LitStr, Token, Type, Visibility,
+};
+
+mod kw {
+    use syn::custom_keyword;
+
+    custom_keyword!(extends);
+    pub type Extends = extends;
+
+    custom_keyword!(implements);
+    pub type Implements = implements;
+}
+
+pub use kw::{Extends, Implements};
+
+pub struct ClassInput {
+    pub package: LitStr,
+    pub extends: Option<(Extends, Type)>,
+    pub implements_token: Option<Implements>,
+    pub implements: Punctuated<Type, Token![,]>,
+}
+
+impl Parse for ClassInput {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let package = input.parse()?;
+        let extends = if let Ok(extends) = input.parse() {
+            let ty = input.parse()?;
+            Some((extends, ty))
+        } else {
+            None
+        };
+
+        let implements_token = input.parse().ok();
+        let implements = if implements_token.is_some() {
+            input.parse_terminated(Type::parse, Token![,])?
+        } else {
+            Punctuated::new()
+        };
+
+        Ok(Self {
+            package,
+            extends,
+            implements_token,
+            implements,
+        })
+    }
+}
+
+pub struct ClassBody {
+    pub vis: Visibility,
+    pub struct_token: Token![struct],
+    pub ident: Ident,
+    pub fields: Option<FieldsNamed>,
+}
+
+impl Parse for ClassBody {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let vis = input.parse()?;
+        let struct_token = input.parse()?;
+        let ident = input.parse()?;
+        let fields = if input.peek(token::Brace) {
+            Some(input.parse()?)
+        } else {
+            input.parse::<Token![;]>()?;
+            None
+        };
+
+        Ok(Self {
+            vis,
+            struct_token,
+            ident,
+            fields,
+        })
+    }
+}

rust/macros/src/class/parse.rs

@@ -9,7 +9,11 @@ use syn::{Attribute, Error, Expr, ExprLit, Lit, LitStr, Meta, MetaList, MetaName
 pub use enum_::main_enum;
 pub use struct_::main_struct;
 
-pub fn get_string_attr(span: Span, attr_name: &impl AsRef<str>, attrs: &Vec<Attribute>) -> Result<Option<String>, Error> {
+pub fn get_string_attr(
+    span: Span,
+    attr_name: &impl AsRef<str>,
+    attrs: &Vec<Attribute>,
+) -> Result<Option<String>, Error> {
     let attr = get_attribute(attr_name, &attrs).map(|attr| match &attr.meta {
         Meta::List(MetaList { tokens, .. }) => {
             Ok(syn::parse2::<LitStr>(tokens.to_token_stream())?.value())
@@ -20,7 +24,10 @@ pub fn get_string_attr(span: Span, attr_name: &impl AsRef<str>, attrs: &Vec<Attr
             }),
             ..
         }) => Ok(p.value()),
-        _ => Err(Error::new(span, format!("Usage: #[{} = \"OtherName\"]", attr_name.as_ref()))),
+        _ => Err(Error::new(
+            span,
+            format!("Usage: #[{} = \"OtherName\"]", attr_name.as_ref()),
+        )),
     });
 
     if let Some(attr) = attr {

rust/macros/src/java_class.rs

@@ -60,9 +60,7 @@ pub fn main_enum(input: &DeriveInput, data: &DataEnum) -> Result<TokenStream, Er
                 let variant_name = get_string_attr(variant.span(), &"variant", &variant.attrs)?;
 
                 let name = &variant.ident;
-                let name = rename
-                    .map(|n| n)
-                    .unwrap_or(name.to_string());
+                let name = rename.map(|n| n).unwrap_or(name.to_string());
 
                 let variant_sig = if !is_itself {
                     quote!(#struct_class::sig())

rust/macros/src/java_class/enum_.rs

@@ -1,11 +1,16 @@
 extern crate proc_macro;
 
+mod class;
 mod import;
 mod java_class;
 
+use quote::quote;
 use syn::DeriveInput;
 
-#[proc_macro_derive(JavaClass, attributes(package, rename, variant, instance, field, enum_of))]
+#[proc_macro_derive(
+    JavaClass,
+    attributes(package, rename, variant, instance, field, enum_of)
+)]
 pub fn java_class(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input = syn::parse_macro_input!(input as DeriveInput);
 
@@ -32,3 +37,29 @@ pub fn import(
 
     data.unwrap_or_else(|e| e.into_compile_error()).into()
 }
+
+#[proc_macro_attribute]
+pub fn class(
+    input: proc_macro::TokenStream,
+    body: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let input = syn::parse_macro_input!(input as class::ClassInput);
+    let body = syn::parse_macro_input!(body as class::ClassBody);
+
+    let data = class::main(input, body);
+
+    data.unwrap_or_else(|e| e.into_compile_error()).into()
+}
+
+#[proc_macro]
+pub fn test(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = match syn::parse::<syn::LitStr>(input) {
+        Ok(o) => o,
+        Err(e) => return e.to_compile_error().into()
+    };
+    let v = std::env::var("MINE").unwrap_or_default() + &input.value();
+    println!("{}", v);
+    std::env::set_var("MINE", v);
+    quote! {}.into()
+}
+

rust/macros/src/lib.rs

@@ -8,4 +8,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 jni = "0.21.1"
-probe = { path = "../api/" }
+rosttasse = { path = "../api/" }
+
+[build-dependencies]
+rosttasse = { path = "../api/" }