export correct types

Author: jackdotink

src/hir/buckets.rs

@@ -0,0 +1,35 @@
+use std::collections::HashMap;
+
+use crate::{
+    hir::{Hir, Item, Table},
+    shared::Remote,
+};
+
+pub type Buckets<'hir> = HashMap<Remote, Vec<(String, &'hir Item)>>;
+
+impl Hir {
+    pub fn buckets(&self) -> Buckets {
+        fn visit<'hir>(
+            buckets: &mut HashMap<Remote, Vec<(String, &'hir Item)>>,
+            table: &'hir Table,
+            path: String,
+        ) {
+            for (name, item) in table.items.iter() {
+                let path = format!("{path}.{name}");
+
+                match item {
+                    Item::Table(table) => visit(buckets, table, path),
+                    Item::Event(event) => buckets
+                        .entry(event.thru.clone())
+                        .or_default()
+                        .push((path, item)),
+                }
+            }
+        }
+
+        let mut buckets = HashMap::new();
+        visit(&mut buckets, &self.table, String::new());
+
+        buckets
+    }
+}

src/hir/build.rs

@@ -1,47 +1,39 @@
-use std::collections::HashMap;
-
 use crate::{
     api,
     hir::{
         ArrayType, BinaryStringType, BooleanType, EnumType, Event, Hir, Item, Length, MapType,
-        NumberType, SetType, StructType, Type, Utf8StringType, VectorType,
+        NumberType, SetType, StructType, Table, Type, Utf8StringType, VectorType,
     },
-    shared::{Range, Remote},
+    shared::Range,
 };
 
 pub fn build(table: api::Table) -> Hir {
-    fn build(buckets: &mut HashMap<Remote, Vec<Item>>, path: String, table: api::Table) {
-        let opts = table.opts.resolved();
-
-        for (name, item) in table.items {
-            let path = format!("{path}.{name}");
-
-            match item {
-                api::Item::Table(table) => build(buckets, path, table),
-
-                api::Item::Event(api::Event { thru, from, data }) => {
-                    let data = data.into_iter().map(Type::from).collect();
-
-                    let event = Event {
-                        opts: opts.clone(),
-                        path,
-                        from,
-                        data,
-                    };
-
-                    buckets
-                        .entry(thru.clone())
-                        .or_default()
-                        .push(Item::Event(event));
-                }
-            }
-        }
+    Hir {
+        table: table.into(),
     }
+}
 
-    let mut buckets = HashMap::new();
-    build(&mut buckets, String::new(), table);
+impl From<api::Table> for Table {
+    fn from(value: api::Table) -> Self {
+        let opts = value.opts.resolved();
+        let mut items = Vec::new();
+
+        for (name, item) in value.items {
+            let item = match item {
+                api::Item::Table(table) => Item::Table(table.into()),
+                api::Item::Event(event) => Item::Event(Event {
+                    opts: opts.clone(),
+                    thru: event.thru,
+                    from: event.from,
+                    data: event.data.into_iter().map(|ty| Type::from(ty)).collect(),
+                }),
+            };
+
+            items.push((name, item))
+        }
 
-    Hir { buckets }
+        Table { items }
+    }
 }
 
 impl From<api::Type> for Type {

src/hir/display.rs

@@ -0,0 +1,91 @@
+use std::fmt::Display;
+
+use crate::hir::{
+    ArrayType, BinaryStringType, BooleanType, EnumType, MapType, NumberType, SetType, StructType,
+    Type, Utf8StringType, VectorType,
+};
+
+impl Display for Type {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Boolean(ty) => write!(f, "{ty}"),
+            Self::Number(ty) => write!(f, "{ty}"),
+            Self::Vector(ty) => write!(f, "{ty}"),
+            Self::BinaryString(ty) => write!(f, "{ty}"),
+            Self::Utf8String(ty) => write!(f, "{ty}"),
+            Self::Array(ty) => write!(f, "{ty}"),
+            Self::Set(ty) => write!(f, "{ty}"),
+            Self::Map(ty) => write!(f, "{ty}"),
+            Self::Enum(ty) => write!(f, "{ty}"),
+            Self::Struct(ty) => write!(f, "{ty}"),
+        }
+    }
+}
+
+impl Display for BooleanType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "boolean")
+    }
+}
+
+impl Display for NumberType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "number")
+    }
+}
+
+impl Display for VectorType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "vector")
+    }
+}
+
+impl Display for BinaryStringType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "string")
+    }
+}
+
+impl Display for Utf8StringType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "string")
+    }
+}
+
+impl Display for ArrayType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{{ {} }}", self.item)
+    }
+}
+
+impl Display for SetType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{{ [{}]: boolean }}", self.item)
+    }
+}
+
+impl Display for MapType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{{ [{}]: {} }}", self.index, self.value)
+    }
+}
+
+impl Display for EnumType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "(")?;
+        for variant in &self.variants {
+            write!(f, "| {variant}")?;
+        }
+        write!(f, ")")
+    }
+}
+
+impl Display for StructType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{{")?;
+        for (name, ty) in &self.fields {
+            write!(f, "[\"{name}\"]: {ty},")?;
+        }
+        write!(f, "}}")
+    }
+}

src/hir/mod.rs

@@ -1,28 +1,35 @@
-use std::collections::HashMap;
-
 use crate::{
     options::Options,
     shared::{NetworkSide, NumberKind, Range, Remote},
 };
 
+mod buckets;
 mod build;
+mod display;
 mod size;
 
+pub use buckets::Buckets;
 pub use build::build;
 
 pub struct Hir {
-    pub buckets: HashMap<Remote, Vec<Item>>,
+    pub table: Table,
+}
+
+#[derive(Clone)]
+pub struct Table {
+    pub items: Vec<(String, Item)>,
 }
 
 #[derive(Clone)]
 pub enum Item {
+    Table(Table),
     Event(Event),
 }
 
 #[derive(Clone)]
 pub struct Event {
     pub opts: Options,
-    pub path: String,
+    pub thru: Remote,
     pub from: NetworkSide,
     pub data: Vec<Type>,
 }
@@ -125,16 +132,6 @@ impl Length {
             NumberKind::U32
         }
     }
-
-    pub fn number_type(&self) -> NumberType {
-        NumberType {
-            kind: self.kind(),
-            range: Range {
-                min: Some(self.min as f64),
-                max: self.max.map(|max| max as f64),
-            },
-        }
-    }
 }
 
 impl From<Length> for Range {

src/main.rs

@@ -41,8 +41,8 @@ fn main() {
 
             let items = hir::build(table);
 
-            let server = mir::server(&items.buckets);
-            let client = mir::client(&items.buckets);
+            let server = mir::server(&items);
+            let client = mir::client(&items);
 
             std::fs::create_dir_all("./zap/out").expect("failed to create zap/out directory");
             std::fs::write("./zap/out/server.luau", server).expect("failed to write server code");

src/mir/client/iter.rs

@@ -8,15 +8,15 @@ use crate::{
     },
 };
 
-pub fn iter(b: &mut Builder, recvctx: &RecvCtx, event: &Event) {
+pub fn iter(b: &mut Builder, recvctx: &RecvCtx, path: &str, event: &Event) {
     match event.data.len() {
-        0 => self::iter_0data(b, recvctx, event),
-        1 => self::iter_1data(b, recvctx, event),
-        _ => self::iter_ndata(b, recvctx, event),
+        0 => self::iter_0data(b, recvctx, path, event),
+        1 => self::iter_1data(b, recvctx, path, event),
+        _ => self::iter_ndata(b, recvctx, path, event),
     }
 }
 
-fn iter_0data(b: &mut Builder, recvctx: &RecvCtx, event: &Event) {
+fn iter_0data(b: &mut Builder, recvctx: &RecvCtx, path: &str, event: &Event) {
     let counter = b.init(0);
 
     let listener = b.function(|b, []| {
@@ -41,7 +41,7 @@ fn iter_0data(b: &mut Builder, recvctx: &RecvCtx, event: &Event) {
         b.ret(vec![next.expr(), captured.expr(), 0.into()]);
     });
 
-    b.export(&event.path, event.opts.casing.fmt("iter"), &iter)
+    b.export(path, event.opts.casing.fmt("iter"), &iter)
 }
 
 fn queue(b: &mut Builder, recvctx: &RecvCtx, event: &Event) -> TVar {
@@ -72,7 +72,7 @@ fn queue(b: &mut Builder, recvctx: &RecvCtx, event: &Event) -> TVar {
     queue
 }
 
-fn iter_1data(b: &mut Builder, recvctx: &RecvCtx, event: &Event) {
+fn iter_1data(b: &mut Builder, recvctx: &RecvCtx, path: &str, event: &Event) {
     let queue = self::queue(b, recvctx, event);
 
     let iter = b.function(|b, []| {
@@ -81,10 +81,10 @@ fn iter_1data(b: &mut Builder, recvctx: &RecvCtx, event: &Event) {
         b.ret(vec![captured.expr()]);
     });
 
-    b.export(&event.path, event.opts.casing.fmt("iter"), &iter)
+    b.export(path, event.opts.casing.fmt("iter"), &iter)
 }
 
-fn iter_ndata(b: &mut Builder, recvctx: &RecvCtx, event: &Event) {
+fn iter_ndata(b: &mut Builder, recvctx: &RecvCtx, path: &str, event: &Event) {
     let queue = self::queue(b, recvctx, event);
 
     let next = b.function(|b, [captured, i]| {
@@ -109,5 +109,27 @@ fn iter_ndata(b: &mut Builder, recvctx: &RecvCtx, event: &Event) {
         b.ret(vec![next.expr(), captured.expr(), 1.into()]);
     });
 
-    b.export(&event.path, event.opts.casing.fmt("iter"), &iter)
+    b.export(path, event.opts.casing.fmt("iter"), &iter)
+}
+
+pub fn interface(s: &mut String, event: &Event) -> std::fmt::Result {
+    use std::fmt::Write;
+
+    match event.data.len() {
+        0 => write!(s, "{{ iter: () -> (number?) -> number? }}"),
+        1 => write!(s, "{{ iter: () -> {{ {} }} }}", event.data.first().unwrap()),
+        _ => {
+            let args = event
+                .data
+                .iter()
+                .map(|ty| ty.to_string())
+                .collect::<Vec<_>>()
+                .join(", ");
+
+            write!(
+                s,
+                "{{ iter: () -> ((, {{ any }} number?) -> (number?, {args}), {{ any }}) }}"
+            )
+        }
+    }
 }