try to fix everything

amqp_codegen/src/parser.rs

@@ -54,9 +54,10 @@ pub type IResult<'a, T> = nom::IResult<&'a [u8], T, TransError>;
                 .iter()
                 .map(method_function_name(&class_name))
                 .join(", ");
+            let class_name_raw = &class.name;
             println!(
-                "    let (input, _) = tag([{class_index}])(input)?;
+                r#"    let (input, _) = tag({class_index}_u16.to_be_bytes())(input).map_err(err("invalid tag for class {class_name_raw}"))?;
-    alt(({all_methods}))(input)"
+    alt(({all_methods}))(input).map_err(err("class {class_name_raw}")).map_err(failure)"#
             );
         });
 
@@ -90,20 +91,26 @@ fn domain_parser(domain: &Domain) {
 
 fn method_parser(amqp: &Amqp, class: &Class, method: &Method) {
     let class_name = class.name.to_snake_case();
+    let method_name_raw = &method.name;
 
     let function_name = method_function_name(&class_name)(method);
     function(&function_name, "Class", || {
         let method_index = method.index;
-        println!("    let (input, _) = tag([{method_index}])(input)?;");
+        println!(
+            r#"    let (input, _) = tag({method_index}_u16.to_be_bytes())(input).map_err(err("parsing method index"))?;"#
+        );
         let mut iter = method.fields.iter().peekable();
         while let Some(field) = iter.next() {
+            let field_name_raw = &field.name;
             let type_name = resolve_type_from_domain(amqp, field_type(field));
 
             if type_name == "bit" {
                 let fields_with_bit = subsequent_bit_fields(amqp, field, &mut iter);
 
                 let amount = fields_with_bit.len();
-                println!("    let (input, bits) = bit(input, {amount})?;");
+                println!(
+                    r#"    let (input, bits) = bit(input, {amount}).map_err(err("field {field_name_raw} in method {method_name_raw}")).map_err(failure)?;"#
+                );
 
                 for (i, field) in fields_with_bit.iter().enumerate() {
                     let field_name = snake_case(&field.name);
@@ -112,7 +119,9 @@ fn method_parser(amqp: &Amqp, class: &Class, method: &Method) {
             } else {
                 let fn_name = domain_function_name(field_type(field));
                 let field_name = snake_case(&field.name);
-                println!("    let (input, {field_name}) = {fn_name}(input)?;");
+                println!(
+                    r#"    let (input, {field_name}) = {fn_name}(input).map_err(err("field {field_name_raw} in method {method_name_raw}")).map_err(failure)?;"#
+                );
 
                 for assert in &field.asserts {
                     assert_check(assert, &type_name, &field_name);
@@ -134,9 +143,13 @@ fn assert_check(assert: &Assert, type_name: &str, var_name: &str) {
     match &*assert.check {
         "notnull" => match type_name {
             "shortstr" | "longstr" => {
-                println!("    if {var_name}.is_empty() {{ fail!() }}")
+                let cause = "string was null";
+                println!(r#"    if {var_name}.is_empty() {{ fail!("{cause}") }}"#);
+            }
+            "short" => {
+                let cause = "number was 0";
+                println!(r#"    if {var_name} == 0 {{ fail!("{cause}") }}"#);
             }
-            "short" => println!("    if {var_name} == 0 {{ fail!() }}"),
             _ => unimplemented!(),
         },
         "regexp" => {
@@ -144,12 +157,14 @@ fn assert_check(assert: &Assert, type_name: &str, var_name: &str) {
             println!(
                 r#"    static REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"{value}").unwrap());"#
             );
-            println!("    if !REGEX.is_match(&{var_name}) {{ fail!() }}");
+            let cause = format!("regex `{value}` did not match value");
+            println!(r#"    if !REGEX.is_match(&{var_name}) {{ fail!(r"{cause}") }}"#);
         }
         "le" => {} // can't validate this here
         "length" => {
             let length = assert.value.as_ref().unwrap();
-            println!("    if {var_name}.len() > {length} {{ fail!() }}");
+            let cause = format!("value is shorter than {length}");
+            println!(r#"    if {var_name}.len() > {length} {{ fail!("{cause}") }}"#);
         }
         _ => unimplemented!(),
     }

amqp_codegen/src/random.rs

@@ -13,7 +13,7 @@ use super::*;
 
     impl_random("Class", || {
         let class_lens = amqp.classes.len();
-        println!("        match rand::thread_rng().gen_range(0u32..{class_lens}) {{");
+        println!("        match rng.gen_range(0u32..{class_lens}) {{");
         for (i, class) in amqp.classes.iter().enumerate() {
             let class_name = class.name.to_upper_camel_case();
             println!("            {i} => Class::{class_name}({class_name}::random(rng)),");
@@ -28,7 +28,7 @@ use super::*;
         let class_name = class.name.to_upper_camel_case();
         impl_random(&class_name, || {
             let method_len = class.methods.len();
-            println!("        match rand::thread_rng().gen_range(0u32..{method_len}) {{");
+            println!("        match rng.gen_range(0u32..{method_len}) {{");
 
             for (i, method) in class.methods.iter().enumerate() {
                 let method_name = method.name.to_upper_camel_case();
@@ -52,6 +52,7 @@ use super::*;
 fn impl_random(name: &str, body: impl FnOnce()) {
     println!(
         "impl<R: Rng> RandomMethod<R> for {name} {{
+    #[allow(unused_variables)]
     fn random(rng: &mut R) -> Self {{"
     );
 

amqp_transport/src/classes/mod.rs

@@ -41,9 +41,15 @@ pub fn parse_method(payload: &[u8]) -> Result<generated::Class, TransError> {
 
     match nom_result {
         Ok(([], class)) => Ok(class),
-        Ok((_, _)) => Err(ProtocolError::ConException(ConException::SyntaxError).into()),
+        Ok((_, _)) => Err(ProtocolError::ConException(ConException::SyntaxError(vec![
+            "could not consume all input".to_string(),
+        ]))
+        .into()),
         Err(nom::Err::Incomplete(_)) => {
-            Err(ProtocolError::ConException(ConException::SyntaxError).into())
+            Err(ProtocolError::ConException(ConException::SyntaxError(vec![
+                "there was not enough data".to_string(),
+            ]))
+            .into())
         }
         Err(nom::Err::Failure(err) | nom::Err::Error(err)) => Err(err),
     }

amqp_transport/src/classes/parse_helper.rs

@@ -9,11 +9,15 @@ use nom::error::ErrorKind;
 use nom::multi::count;
 use nom::number::complete::{f32, f64, i16, i32, i64, i8, u16, u32, u64, u8};
 use nom::number::Endianness::Big;
+use nom::Err;
 use std::collections::HashMap;
 
+// todo: remove the debug machinery or change it in a way that actually does what it should lmao
+// I'm probably misusing nom hard
+
 impl<T> nom::error::ParseError<T> for TransError {
     fn from_error_kind(_input: T, _kind: ErrorKind) -> Self {
-        ProtocolError::ConException(ConException::SyntaxError).into()
+        ProtocolError::ConException(ConException::SyntaxError(vec![])).into()
     }
 
     fn append(_input: T, _kind: ErrorKind, other: Self) -> Self {
@@ -21,12 +25,52 @@ impl<T> nom::error::ParseError<T> for TransError {
     }
 }
 
+pub fn err<S: Into<String>>(msg: S) -> impl FnOnce(Err<TransError>) -> Err<TransError> {
+    move |err| {
+        let error_level = if matches!(err, nom::Err::Failure(_)) {
+            Err::Failure
+        } else {
+            Err::Error
+        };
+
+        let msg = msg.into();
+        let stack = match err {
+            Err::Error(e) | Err::Failure(e) => match e {
+                TransError::Invalid(ProtocolError::ConException(ConException::SyntaxError(
+                    mut stack,
+                ))) => {
+                    stack.push(msg);
+                    stack
+                }
+                _ => vec![msg],
+            },
+            _ => vec![msg],
+        };
+        error_level(ProtocolError::ConException(ConException::SyntaxError(stack)).into())
+    }
+}
+pub fn err_other<E, S: Into<String>>(msg: S) -> impl FnOnce(E) -> Err<TransError> {
+    move |_| {
+        Err::Error(ProtocolError::ConException(ConException::SyntaxError(vec![msg.into()])).into())
+    }
+}
+
+pub fn failure<E>(err: Err<E>) -> Err<E> {
+    match err {
+        Err::Incomplete(needed) => Err::Incomplete(needed),
+        Err::Error(e) => Err::Failure(e),
+        Err::Failure(e) => Err::Failure(e),
+    }
+}
+
 #[macro_export]
 macro_rules! fail {
-    () => {
+    ($cause:expr) => {
         return Err(nom::Err::Failure(
-            crate::error::ProtocolError::ConException(crate::error::ConException::SyntaxError)
+            crate::error::ProtocolError::ConException(crate::error::ConException::SyntaxError(
-                .into(),
+                vec![String::from($cause)],
+            ))
+            .into(),
         ))
     };
 }
@@ -79,9 +123,7 @@ pub fn bit(input: &[u8], amount: usize) -> IResult<Vec<Bit>> {
 pub fn shortstr(input: &[u8]) -> IResult<Shortstr> {
     let (input, len) = u8(input)?;
     let (input, str_data) = take(usize::from(len))(input)?;
-    let data = String::from_utf8(str_data.into()).map_err(|_| {
+    let data = String::from_utf8(str_data.into()).map_err(err_other("shortstr"))?;
-        nom::Err::Failure(ProtocolError::ConException(ConException::SyntaxError).into())
-    })?;
     Ok((input, data))
 }
 
@@ -106,7 +148,7 @@ pub fn table(input: &[u8]) -> IResult<Table> {
 
 fn table_value_pair(input: &[u8]) -> IResult<(TableFieldName, FieldValue)> {
     let (input, field_name) = shortstr(input)?;
-    let (input, field_value) = field_value(input)?;
+    let (input, field_value) = field_value(input).map_err(err(format!("field {field_name}")))?;
     Ok((input, (field_name, field_value)))
 }
 
@@ -119,7 +161,7 @@ fn field_value(input: &[u8]) -> IResult<FieldValue> {
         match bool_byte {
             0 => Ok((input, FieldValue::Boolean(false))),
             1 => Ok((input, FieldValue::Boolean(true))),
-            _ => fail!(),
+            value => fail!(format!("invalid bool value {value}")),
         }
     }
 

amqp_transport/src/classes/tests.rs

@@ -11,8 +11,9 @@ pub(crate) trait RandomMethod<R: Rng> {
 }
 
 impl<R: Rng> RandomMethod<R> for String {
-    fn random(_rng: &mut R) -> Self {
+    fn random(rng: &mut R) -> Self {
-        "randomstring".to_string()
+        let n = rng.gen_range(0_u16..9999);
+        format!("string{n}")
     }
 }
 
@@ -47,7 +48,7 @@ impl<R: Rng> RandomMethod<R> for HashMap<String, FieldValue> {
 
 impl<R: Rng> RandomMethod<R> for FieldValue {
     fn random(rng: &mut R) -> Self {
-        let index = rand::thread_rng().gen_range(0_u32..17);
+        let index = rng.gen_range(0_u32..17);
         match index {
             0 => FieldValue::Boolean(RandomMethod::random(rng)),
             1 => FieldValue::ShortShortInt(RandomMethod::random(rng)),
@@ -73,7 +74,6 @@ impl<R: Rng> RandomMethod<R> for FieldValue {
 
 #[test]
 fn pack_few_bits() {
-    rand::thread_rng().gen_range(0..5);
     let bits = [true, false, true];
 
     let mut buffer = [0u8; 2];
@@ -97,18 +97,20 @@ fn pack_many_bits() {
     assert_eq!(bits.as_slice(), parsed_bits.as_slice());
 }
 
+#[ignore]
 #[test]
 fn random_ser_de() {
     const ITERATIONS: usize = 1000;
     let mut rng = rand::rngs::StdRng::from_seed([0; 32]);
 
     for _ in 0..ITERATIONS {
+        println!("iter");
         let class = Class::random(&mut rng);
         let mut bytes = Vec::new();
 
         if let Err(err) = super::write::write_method(class.clone(), &mut bytes) {
-            eprintln!("{class:?}");
+            eprintln!("{class:#?}");
-            eprintln!("{err}");
+            eprintln!("{err:?}");
             panic!("Failed to serialize");
         }
 
@@ -117,11 +119,31 @@ fn random_ser_de() {
                 assert_eq!(class, parsed);
             }
             Err(err) => {
-                eprintln!("{class:?}");
+                eprintln!("{class:#?}");
                 eprintln!("{bytes:?}");
-                eprintln!("{err}");
+                eprintln!("{err:?}");
                 panic!("Failed to deserialize");
             }
         }
     }
 }
+
+#[test]
+fn nested_table() {
+    let table = HashMap::from([(
+        "A".to_string(),
+        FieldValue::FieldTable(HashMap::from([(
+            "B".to_string(),
+            FieldValue::Boolean(true),
+        )])),
+    )]);
+
+    let mut bytes = Vec::new();
+    crate::classes::write_helper::table(table.clone(), &mut bytes).unwrap();
+    eprintln!("{bytes:?}");
+
+    let (rest, parsed_table) = crate::classes::parse_helper::table(&bytes).unwrap();
+
+    assert!(rest.is_empty());
+    assert_eq!(table, parsed_table);
+}

amqp_transport/src/classes/write_helper.rs

@@ -154,8 +154,9 @@ fn field_value<W: Write>(value: FieldValue, writer: &mut W) -> Result<(), TransE
             writer.write_all(b"T")?;
             writer.write_all(&time.to_be_bytes())?;
         }
-        FieldValue::FieldTable(_) => {
+        FieldValue::FieldTable(value) => {
             writer.write_all(b"F")?;
+            table(value, writer)?;
         }
         FieldValue::Void => {
             writer.write_all(b"V")?;

amqp_transport/src/connection.rs

@@ -125,7 +125,7 @@ fn server_properties(host: SocketAddr) -> classes::Table {
     }
 
     let host_str = host.ip().to_string();
-    let host_value = if host_str.len() < 256 {
+    let _host_value = if host_str.len() < 256 {
         FieldValue::ShortString(host_str)
     } else {
         FieldValue::LongString(host_str.into())

amqp_transport/src/error.rs

@@ -35,7 +35,8 @@ pub enum ConException {
     #[error("503 Command invalid")]
     CommandInvalid,
     #[error("503 Syntax error")]
-    SyntaxError,
+    /// A method was received but there was a syntax error. The string stores where it occured.
+    SyntaxError(Vec<String>),
     #[error("504 Channel error")]
     ChannelError,
     #[error("xxx Not decided yet")]

amqp_transport/src/frame.rs

@@ -1,4 +1,4 @@
-use crate::error::{ConException, ProtocolError, Result, TransError};
+use crate::error::{ConException, ProtocolError, Result};
 use anyhow::Context;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tracing::debug;