tmp

scripts/src/api/types.rs

@@ -8,27 +8,34 @@ use std::{
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-enum Model {
+pub enum Model {
     Struct {
         name: String,
         orig: Type,
-        fields: Vec<(String, Rc<Model>)>
+        fields: Vec<(String, Rc<Model>)>,
+        /// memoization
+        has_reference: bool
     },
     Enum {
         name: String,
         orig: Type,
-        variants: Vec<Variant>
+        variants: Vec<Variant>,
+        has_reference: bool
     },
     Option(Rc<Model>),
     Vec(Rc<Model>),
-    Map(Rc<Model>, Rc<Model>)
+    Map(Rc<Model>, Rc<Model>),
+    Known {
+        name: &'static str,
+        reference: bool
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-struct Variant {
-    label: String,
-    orig: String,
-    data: Option<Rc<Model>>
+pub struct Variant {
+    pub label: String,
+    pub orig: String,
+    pub data: Option<Rc<Model>>
 }
 
 impl Model {
@@ -39,12 +46,17 @@ impl Model {
             _ => None
         }
     }
-}
 
-struct QueueFrame<'a> {
-    scope: Vec<&'a str>,
-    ty: &'a Type,
-    borrow: bool
+    fn has_reference(&self) -> bool {
+        match self {
+            Model::Struct { has_reference, .. } => *has_reference,
+            Model::Enum { has_reference, .. } => *has_reference,
+            Model::Option(x) => x.has_reference(),
+            Model::Vec(x) => x.has_reference(),
+            Model::Map(k, v) => k.has_reference() || v.has_reference(),
+            Model::Known { name, reference } => *reference
+        }
+    }
 }
 
 pub fn is_action_csharp(a: &Arg) -> bool {
@@ -56,7 +68,7 @@ pub fn is_action_csharp(a: &Arg) -> bool {
     a.name == "action" && for_csharp
 }
 
-fn collect_types(x: &Interface) -> Vec<Rc<Model>> {
+pub fn collect_types(x: &Interface) -> Vec<Rc<Model>> {
     let mut top = Vec::new();
     for member in &x.members {
         for arg in &member.args {
@@ -89,6 +101,7 @@ fn collect_types(x: &Interface) -> Vec<Rc<Model>> {
                 que.push_back(k.clone());
                 que.push_back(x.clone());
             }
+            Model::Known { name, reference } => {}
         }
     }
     all.into_iter()
@@ -104,20 +117,24 @@ fn collect_types(x: &Interface) -> Vec<Rc<Model>> {
                     Model::Struct {
                         name: _,
                         orig,
-                        fields
+                        fields,
+                        has_reference
                     } => Rc::new(Model::Struct {
                         name: orig.name.to_string(),
                         orig: orig.clone(),
-                        fields: fields.clone()
+                        fields: fields.clone(),
+                        has_reference: *has_reference
                     }),
                     Model::Enum {
                         name: _,
                         orig,
-                        variants
+                        variants,
+                        has_reference
                     } => Rc::new(Model::Enum {
                         name: orig.name.to_string(),
                         orig: orig.clone(),
-                        variants: variants.clone()
+                        variants: variants.clone(),
+                        has_reference: *has_reference
                     }),
                     _ => unreachable!()
                 }
@@ -129,9 +146,29 @@ fn collect_types(x: &Interface) -> Vec<Rc<Model>> {
 fn declare_ty<'a>(scope: Vec<&'a str>, ty: &'a Type, allow_borrow: bool) -> Rc<Model> {
     if ty.union.is_empty() {
         match (ty.properties.is_empty(), ty.templates.is_empty()) {
-            (true, true) => {
-                todo! {}
-            }
+            (true, true) => Rc::new(match &*ty.name {
+                "binary" => Model::Array {
+                    data: Rc::new(Model::Struct {
+                        name: "u8".to_string(),
+                        has_reference: false,
+                        orig: todo!(),
+                        fields: vec![]
+                    }),
+                    reference: allow_borrow
+                },
+                "number" => quote!(serde_json::Number),
+                "float" => quote!(f64),
+                "json" if allow_borrow => quote!(&'a str),
+                "json" => quote!(String),
+                "string" if allow_borrow => quote!(&'a str),
+                "string" => quote!(String),
+                "boolean" => quote!(bool),
+                "void" => quote!(()),
+                x => {
+                    let ident = format_ident!("{}", utils::loud_to_camel(x));
+                    quote!(#ident)
+                }
+            }),
             (false, true) => {
                 let name = scope
                     .iter()

scripts/src/generate_api.rs

@@ -1,7 +1,10 @@
 use case::CaseExt;
 use proc_macro2::{Ident, TokenStream};
 use quote::{format_ident, quote, ToTokens, TokenStreamExt};
-use scripts::{api::*, utils};
+use scripts::{
+    api::{types::Model, *},
+    utils
+};
 use std::collections::{HashMap, VecDeque};
 
 fn main() {
@@ -56,15 +59,90 @@ fn body(x: &Interface) -> TokenStream {
             event_tokens(xs)
         }
     };
-    let sub = collect_types(x);
+    let sub = types::collect_types(x);
+    let sub = sub.into_iter().map(|m| format_ty(&*m));
     quote! {
         mod #mod_name {
             #extends
             impl #name {
                 #(#methods)*
             }
             #events
-            #sub
+            #(#sub)*
+        }
+    }
+}
+
+fn format_ty(x: &types::Model) -> TokenStream {
+    match x {
+        Model::Struct { name, orig, fields } => {
+            let n = format_ident!("{}", name);
+            let fields = fields.iter().map(|(k, v)| {
+                let n = format_ident!("{}", k);
+                let v = format_use_ty(v);
+                quote! {
+                    #n: #v
+                }
+            });
+            quote! {
+                struct #n {
+                    #(#fields),*
+                }
+            }
+        }
+        Model::Enum {
+            name,
+            orig,
+            variants
+        } => {
+            let n = format_ident!("{}", name);
+            let variants = variants.iter().map(|variant| {
+                let n = format_ident!("{}", variant.label);
+                if let Some(x) = &variant.data {
+                    let v = format_use_ty(x);
+                    quote! {
+                        #n (v)
+                    }
+                } else {
+                    quote! {
+                        #n
+                    }
+                }
+            });
+            quote! {
+                enum #n {
+                    #(#variants),*
+                }
+            }
+        }
+        _ => {
+            quote! {}
+        }
+    }
+}
+
+fn format_use_ty(x: &types::Model) -> TokenStream {
+    match x {
+        Model::Struct { name, .. } => {
+            let n = format_ident!("{}", name);
+            quote!(#n)
+        }
+        Model::Enum { name, .. } => {
+            let n = format_ident!("{}", name);
+            quote!(#n)
+        }
+        Model::Option(y) => {
+            let y = format_use_ty(y);
+            quote!(Option<#y>)
+        }
+        Model::Vec(y) => {
+            let y = format_use_ty(y);
+            quote!(Vec<#y>)
+        }
+        Model::Map(y, z) => {
+            let y = format_use_ty(y);
+            let z = format_use_ty(z);
+            quote!(HashMap<#y, #z>)
         }
     }
 }