implement eager size checking

Author: jackdotink

src/hir/mod.rs

@@ -10,6 +10,7 @@ mod size;
 
 pub use buckets::Buckets;
 pub use build::build;
+pub use size::{Size, SizeOf};
 
 pub struct Hir {
     pub table: Table,

src/hir/size.rs

@@ -2,12 +2,21 @@ use std::ops::{Add, Mul};
 
 use crate::hir;
 
-#[derive(Default, Clone, Copy)]
+#[derive(Clone, Copy, PartialEq)]
 pub struct Size {
     pub min: u32,
     pub max: Option<u32>,
 }
 
+impl Default for Size {
+    fn default() -> Self {
+        Self {
+            min: 0,
+            max: Some(0),
+        }
+    }
+}
+
 impl Add<u32> for Size {
     type Output = Self;
 
@@ -61,6 +70,17 @@ impl Mul<hir::Length> for Size {
     }
 }
 
+impl PartialOrd for Size {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        match (self.max, other.max) {
+            (Some(a), Some(b)) => Some(self.min.cmp(&other.min).then(a.cmp(&b))),
+            (Some(_), None) => Some(std::cmp::Ordering::Less),
+            (None, Some(_)) => Some(std::cmp::Ordering::Greater),
+            (None, None) => Some(std::cmp::Ordering::Equal),
+        }
+    }
+}
+
 impl From<u32> for Size {
     fn from(value: u32) -> Self {
         Self {
@@ -80,85 +100,99 @@ impl Size {
     }
 }
 
-impl hir::Type {
-    pub fn size(&self) -> Size {
+pub trait SizeOf {
+    fn size_of(&self) -> Size;
+}
+
+impl<T: SizeOf> SizeOf for Vec<T> {
+    fn size_of(&self) -> Size {
+        self.iter()
+            .map(|item| item.size_of())
+            .fold(Size::default(), |acc, size| acc + size)
+    }
+}
+
+impl SizeOf for hir::Type {
+    fn size_of(&self) -> Size {
         match self {
-            hir::Type::Boolean(ty) => ty.size(),
-            hir::Type::Number(ty) => ty.size(),
-            hir::Type::Vector(ty) => ty.size(),
-            hir::Type::BinaryString(ty) => ty.size(),
-            hir::Type::Utf8String(ty) => ty.size(),
-            hir::Type::Array(ty) => ty.size(),
-            hir::Type::Set(ty) => ty.size(),
-            hir::Type::Map(ty) => ty.size(),
-            hir::Type::Enum(ty) => ty.size(),
-            hir::Type::Struct(ty) => ty.size(),
+            hir::Type::Boolean(ty) => ty.size_of(),
+            hir::Type::Number(ty) => ty.size_of(),
+            hir::Type::Vector(ty) => ty.size_of(),
+            hir::Type::BinaryString(ty) => ty.size_of(),
+            hir::Type::Utf8String(ty) => ty.size_of(),
+            hir::Type::Array(ty) => ty.size_of(),
+            hir::Type::Set(ty) => ty.size_of(),
+            hir::Type::Map(ty) => ty.size_of(),
+            hir::Type::Enum(ty) => ty.size_of(),
+            hir::Type::Struct(ty) => ty.size_of(),
         }
     }
 }
 
-impl hir::BooleanType {
-    pub fn size(&self) -> Size {
+impl SizeOf for hir::BooleanType {
+    fn size_of(&self) -> Size {
         Size::from(1)
     }
 }
 
-impl hir::NumberType {
-    pub fn size(&self) -> Size {
+impl SizeOf for hir::NumberType {
+    fn size_of(&self) -> Size {
         Size {
             min: self.kind.size(),
             max: Some(self.kind.size()),
         }
     }
 }
 
-impl hir::VectorType {
-    pub fn size(&self) -> Size {
-        self.x.size() + self.y.size() + self.z.as_ref().map_or(Size::default(), |z| z.size())
+impl SizeOf for hir::VectorType {
+    fn size_of(&self) -> Size {
+        self.x.size_of()
+            + self.y.size_of()
+            + self.z.as_ref().map_or(Size::default(), |z| z.size_of())
     }
 }
 
-impl hir::BinaryStringType {
-    pub fn size(&self) -> Size {
+impl SizeOf for hir::BinaryStringType {
+    fn size_of(&self) -> Size {
         Size::from(1) * self.len + self.len.kind().size()
     }
 }
 
-impl hir::Utf8StringType {
-    pub fn size(&self) -> Size {
+impl SizeOf for hir::Utf8StringType {
+    fn size_of(&self) -> Size {
         Size::from(1) * self.len + self.len.kind().size()
     }
 }
 
-impl hir::ArrayType {
-    pub fn size(&self) -> Size {
-        self.item.size() * self.len + self.len.kind().size()
+impl SizeOf for hir::ArrayType {
+    fn size_of(&self) -> Size {
+        self.item.size_of() * self.len + self.len.kind().size()
     }
 }
 
-impl hir::SetType {
-    pub fn size(&self) -> Size {
-        self.item.size() * self.len + self.len.kind().size()
+impl SizeOf for hir::SetType {
+    fn size_of(&self) -> Size {
+        self.item.size_of() * self.len + self.len.kind().size()
     }
 }
 
-impl hir::MapType {
-    pub fn size(&self) -> Size {
-        self.index.size() + self.value.size() * self.len + self.len.kind().size()
+impl SizeOf for hir::MapType {
+    fn size_of(&self) -> Size {
+        self.index.size_of() + self.value.size_of() * self.len + self.len.kind().size()
     }
 }
 
-impl hir::EnumType {
-    pub fn size(&self) -> Size {
-        self.number.size()
+impl SizeOf for hir::EnumType {
+    fn size_of(&self) -> Size {
+        self.number.size_of()
     }
 }
 
-impl hir::StructType {
-    pub fn size(&self) -> Size {
+impl SizeOf for hir::StructType {
+    fn size_of(&self) -> Size {
         self.fields
             .iter()
-            .map(|(_, field_type)| field_type.size())
+            .map(|(_, field_type)| field_type.size_of())
             .fold(Size::default(), |acc, size| acc + size)
     }
 }

src/mir/server/iter.rs

@@ -1,5 +1,5 @@
 use crate::{
-    hir::Event,
+    hir::{Event, Size},
     mir::{
         Expr,
         builder::{Builder, Ctx},

src/mir/server/mod.rs

@@ -1,5 +1,5 @@
 use crate::{
-    hir::{Buckets, Hir, Item, Table},
+    hir::{Buckets, Hir, Item, Size, SizeOf, Table},
     mir::{
         Expr,
         builder::{Builder, Ctx, TVar},
@@ -129,13 +129,24 @@ fn remote(b: &mut Builder, serverctx: &ServerCtx, remote: &Remote, items: &[(Str
         item_idx: 0,
     };
 
+    let mut max_recv_size = Size::default();
+
     for (path, item) in recv {
         recvctx.item_idx += 1;
 
         match item {
             Item::Table(_) => unreachable!(),
             Item::Event(event) => iter::iter(b, &recvctx, path, event),
         }
+
+        let size = match item {
+            Item::Table(_) => unreachable!(),
+            Item::Event(event) => event.data.size_of(),
+        };
+
+        if size > max_recv_size {
+            max_recv_size = size;
+        }
     }
 
     let mut sendctx = SendCtx {
@@ -161,6 +172,10 @@ fn remote(b: &mut Builder, serverctx: &ServerCtx, remote: &Remote, items: &[(Str
             len: b.init(Expr::Global("buffer.len").call(vec![buf.expr()])),
         };
 
+        if let Some(max) = max_recv_size.max {
+            b.assert(ctx.len.expr().le(max), "packet too large");
+        }
+
         let idx = b.read_k(&ctx, recv_item_kind.into());
         b.call(recvctx.jump_tbl.expr().index(&idx).call(vec![
             plr.expr(),