add options to emit

jackdotink · jackdotink · commit aacf9dd5a049 · 2025-07-31T09:04:38.000-05:00
diff --git a/src/hir/build.rs b/src/hir/build.rs
@@ -2,26 +2,33 @@ use crate::{
     api,
     hir::{
         ArrayType, BinaryStringType, BooleanType, EnumType, Event, Item, Length, MapType,
-        NumberType, SetType, StructType, Type, Utf8StringType, VectorType,
+        NumberType, SetType, StructType, Table, Type, Utf8StringType, VectorType,
     },
     shared::Range,
 };
 
 impl From<api::Item> for Item {
     fn from(value: api::Item) -> Self {
         match value {
-            api::Item::Table(table) => Item::Table(
-                table
-                    .into_iter()
-                    .map(|(name, item)| (name, Item::from(item)))
-                    .collect(),
-            ),
-
+            api::Item::Table(table) => Item::Table(table.into()),
             api::Item::Event(event) => Item::Event(event.into()),
         }
     }
 }
 
+impl From<api::Table> for Table {
+    fn from(value: api::Table) -> Self {
+        let options = value.options;
+        let items = value
+            .items
+            .into_iter()
+            .map(|(name, item)| (name, Item::from(item)))
+            .collect();
+
+        Table { options, items }
+    }
+}
+
 impl From<api::Event> for Event {
     fn from(value: api::Event) -> Self {
         let uuid = value.uuid;
diff --git a/src/hir/mod.rs b/src/hir/mod.rs
@@ -1,16 +1,24 @@
+use std::rc::Rc;
+
 use uuid::Uuid;
 
-use crate::shared::{NetworkSide, NumberKind, Range};
+use crate::shared::{NetworkSide, NumberKind, Options, Range};
 
 mod build;
 mod size;
 
 #[derive(Clone)]
 pub enum Item {
-    Table(Vec<(String, Item)>),
+    Table(Table),
     Event(Event),
 }
 
+#[derive(Clone)]
+pub struct Table {
+    pub options: Rc<Options>,
+    pub items: Vec<(String, Item)>,
+}
+
 #[derive(Clone)]
 pub struct Event {
     pub uuid: Uuid,
diff --git a/src/main.rs b/src/main.rs
@@ -30,18 +30,18 @@ fn main() {
     match cli.command {
         Command::Run => {
             let source = std::fs::read("./zap/net.luau").expect("failed to read zap/net.luau");
-            let items = match api::exec(&source) {
+            let table = match api::exec(&source) {
                 Ok(items) => items,
                 Err(e) => {
                     eprintln!("error: {e}");
                     return;
                 }
             };
 
-            let items = hir::Item::from(items);
+            let table = hir::Table::from(table);
 
-            let server = mir::server(&items).unwrap();
-            let client = mir::client(&items).unwrap();
+            let server = mir::server(&table).unwrap();
+            let client = mir::client(&table).unwrap();
 
             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");
diff --git a/src/mir/client/mod.rs b/src/mir/client/mod.rs
@@ -1,11 +1,13 @@
+use std::rc::Rc;
+
 use crate::{
-    hir::{Event, Item, Type},
+    hir::{Event, Item, Table, Type},
     mir::{
         Expr,
         builder::{Builder, InitVar},
         serdes::{Des, Ser, Serdes},
     },
-    shared::{ApiCheck, NetworkSide},
+    shared::{ApiCheck, NetworkSide, Options},
 };
 
 mod iter;
@@ -19,33 +21,37 @@ pub struct Client {
     pub des: Des,
 }
 
-impl Client {
-    pub fn new(apicheck: ApiCheck) -> Self {
+impl Default for Client {
+    fn default() -> Self {
         let location = "result".to_string();
+
         let ser = Ser {
-            apicheck,
+            options: Rc::new(Options::default()),
             native: false,
         };
+
         let des = Des {
-            apicheck,
+            options: Rc::new(Options::default()),
             native: false,
             check: false,
         };
 
         Client { location, ser, des }
     }
+}
 
-    pub fn item(&self, b: &mut Builder, item: &Item) {
+impl Client {
+    fn item(&self, b: &mut Builder, item: &Item) {
         match item {
             Item::Table(table) => self.table(b, table),
             Item::Event(event) => self.event(b, event),
         }
     }
 
-    fn table(&self, b: &mut Builder, table: &[(String, Item)]) {
-        for (name, item) in table {
+    pub fn table(&self, b: &mut Builder, table: &Table) {
+        for (name, item) in table.items.iter() {
             self.export(b, name, Expr::Table(vec![]));
-            self.location(name).item(b, item);
+            self.child(&table.options, name).item(b, item);
         }
     }
 
@@ -56,12 +62,18 @@ impl Client {
         }
     }
 
-    fn location(&self, name: &str) -> Self {
+    fn child(&self, options: &Rc<Options>, name: &str) -> Self {
+        let mut ser = self.ser.clone();
+        ser.options = Rc::clone(options);
+
+        let mut des = self.des.clone();
+        des.options = Rc::clone(options);
+
         Client {
             location: self.location.clone() + "." + name,
 
-            ser: self.ser.clone(),
-            des: self.des.clone(),
+            ser,
+            des,
         }
     }
 
diff --git a/src/mir/mod.rs b/src/mir/mod.rs
@@ -1,22 +1,19 @@
 use std::fmt::Display;
 
-use crate::{
-    hir,
-    shared::{ApiCheck, NumberKind},
-};
+use crate::{hir, shared::NumberKind};
 
 mod builder;
 mod client;
 mod serdes;
 mod server;
 
-pub fn server(items: &hir::Item) -> Result<String, std::fmt::Error> {
+pub fn server(table: &hir::Table) -> Result<String, std::fmt::Error> {
     use std::fmt::Write;
 
     let mut b = builder::Builder::default();
-    let server = server::Server::new(ApiCheck::Full);
+    let server = server::Server::default();
 
-    server.item(&mut b, items);
+    server.table(&mut b, table);
 
     let mut s = String::new();
 
@@ -31,13 +28,13 @@ pub fn server(items: &hir::Item) -> Result<String, std::fmt::Error> {
     Ok(s)
 }
 
-pub fn client(items: &hir::Item) -> Result<String, std::fmt::Error> {
+pub fn client(table: &hir::Table) -> Result<String, std::fmt::Error> {
     use std::fmt::Write;
 
     let mut b = builder::Builder::default();
-    let client = client::Client::new(ApiCheck::Full);
+    let client = client::Client::default();
 
-    client.item(&mut b, items);
+    client.table(&mut b, table);
 
     let mut s = String::new();
 
diff --git a/src/mir/serdes.rs b/src/mir/serdes.rs
@@ -1,10 +1,12 @@
+use std::rc::Rc;
+
 use crate::{
     hir,
     mir::{
         Expr, FuncD, FuncK,
         builder::{Builder, InitVar},
     },
-    shared::{ApiCheck, NumberKind, Range},
+    shared::{ApiCheck, NumberKind, Options, Range},
 };
 
 fn check_type(b: &mut Builder, expr: impl Into<Expr>, ty: &'static str) {
@@ -43,40 +45,40 @@ fn check_utf8(b: &mut Builder, expr: impl Into<Expr>) {
 
 #[derive(Clone)]
 pub struct Ser {
-    pub apicheck: ApiCheck,
+    pub options: Rc<Options>,
     pub native: bool,
 }
 
 #[derive(Clone)]
 pub struct Des {
-    pub apicheck: ApiCheck,
+    pub options: Rc<Options>,
     pub native: bool,
     pub check: bool,
 }
 
 macro_rules! apicheck_some {
     ($serdes:expr, $block:block) => {
-        if matches!($serdes.apicheck, ApiCheck::Some | ApiCheck::Full) {
+        if matches!($serdes.options.apicheck(), ApiCheck::Some | ApiCheck::Full) {
             $block
         }
     };
 
     ($serdes:expr, $stmt:stmt) => {
-        if matches!($serdes.apicheck, ApiCheck::Some | ApiCheck::Full) {
+        if matches!($serdes.options.apicheck(), ApiCheck::Some | ApiCheck::Full) {
             $stmt
         }
     };
 }
 
 macro_rules! apicheck_full {
     ($serdes:expr, $block:block) => {
-        if matches!($serdes.apicheck, ApiCheck::Full) {
+        if matches!($serdes.options.apicheck(), ApiCheck::Full) {
             $block
         }
     };
 
     ($serdes:expr, $stmt:stmt) => {
-        if matches!($serdes.apicheck, ApiCheck::Full) {
+        if matches!($serdes.options.apicheck(), ApiCheck::Full) {
             $stmt
         }
     };
diff --git a/src/mir/server/mod.rs b/src/mir/server/mod.rs
@@ -1,11 +1,13 @@
+use std::rc::Rc;
+
 use crate::{
-    hir::{Event, Item},
+    hir::{Event, Item, Table},
     mir::{
         Expr,
         builder::{Builder, InitVar},
         serdes::{Des, Ser},
     },
-    shared::{ApiCheck, NetworkSide},
+    shared::{ApiCheck, NetworkSide, Options},
 };
 
 mod iter;
@@ -19,33 +21,37 @@ pub struct Server {
     pub des: Des,
 }
 
-impl Server {
-    pub fn new(apicheck: ApiCheck) -> Self {
+impl Default for Server {
+    fn default() -> Self {
         let location = "result".to_string();
+
         let ser = Ser {
-            apicheck,
-            native: false,
+            options: Rc::new(Options::default()),
+            native: true,
         };
+
         let des = Des {
-            apicheck,
-            native: false,
-            check: false,
+            options: Rc::new(Options::default()),
+            native: true,
+            check: true,
         };
 
         Server { location, ser, des }
     }
+}
 
-    pub fn item(&self, b: &mut Builder, item: &Item) {
+impl Server {
+    fn item(&self, b: &mut Builder, item: &Item) {
         match item {
             Item::Table(table) => self.table(b, table),
             Item::Event(event) => self.event(b, event),
         }
     }
 
-    fn table(&self, b: &mut Builder, table: &[(String, Item)]) {
-        for (name, item) in table {
+    pub fn table(&self, b: &mut Builder, table: &Table) {
+        for (name, item) in table.items.iter() {
             self.export(b, name, Expr::Table(vec![]));
-            self.location(name).item(b, item);
+            self.child(&table.options, name).item(b, item);
         }
     }
 
@@ -56,11 +62,17 @@ impl Server {
         }
     }
 
-    fn location(&self, name: &str) -> Self {
+    fn child(&self, options: &Rc<Options>, name: &str) -> Self {
+        let mut ser = self.ser.clone();
+        ser.options = Rc::clone(&options);
+
+        let mut des = self.des.clone();
+        des.options = Rc::clone(&options);
+
         Server {
             location: self.location.clone() + "." + name,
-            ser: self.ser.clone(),
-            des: self.des.clone(),
+            ser,
+            des,
         }
     }
 
