Add ACI generator, serializer and tests

Make ACI conversion move instead of borrow

Make AST to HIR conversion move instead of borrow

Missing files

Fix Bytes ACI

format

format

Author: radrow

Cargo.toml

@@ -9,6 +9,8 @@ members = [
     "aesophia_backend_fate",
     "aesophia_cli",
     "aesophia_lsp",
-    "aesophia_format",
-    "aesophia_webapp",
+    # "aesophia_format", TODO these need to be updated
+    # "aesophia_webapp",
+
+    "aesophia_dev_qol",
 ]

aesophia_aci/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 [dependencies]
 aesophia_ast = { path = "../aesophia_ast" }
 aesophia_types = { path = "../aesophia_types" }
-aesophia_backend_fate = { path = "../aesophia_backend_fate" } # TODO needed for HIR, should split
+
 log = "0.4"
 env_logger = "~0.11.5"
 pretty = "0.12.3"
@@ -16,3 +16,4 @@ serde = {version = "1.0.0", features = ["derive"]}
 
 [dev-dependencies]
 proptest = "1.0.0"
+pretty_assertions = "1.3"

aesophia_aci/src/aci.rs

@@ -1,4 +1,3 @@
-use aesophia_backend_fate::hir; // TODO move HIR away, we don't need the whole backend
 use serde::{
     de,
     Deserialize,
@@ -14,17 +13,6 @@ pub struct Aci {
     pub decls: Vec<TopDecl>,
 }
 
-impl Aci {
-    pub fn from_hir(ns: Vec<(String, hir::Namespace)>) -> Self {
-        Self {
-            decls: ns
-                .into_iter()
-                .map(|(n, d)| TopDecl::from_hir(n, d))
-                .collect(),
-        }
-    }
-}
-
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -53,57 +41,6 @@ pub enum TopDecl {
 }
 
 
-impl TopDecl {
-    pub fn from_hir(name: String, ns: hir::Namespace) -> Self {
-        match ns {
-            hir::Namespace::Contract {
-                payable,
-                types,
-                funs,
-            } => {
-                let typedefs = types
-                    .into_iter()
-                    .filter_map(|(n, d)| TypeDef::from_hir(n, d))
-                    .collect();
-                let functions = funs.into_iter().filter_map(FunDecl::from_hir_def).collect();
-                Self::Contract {
-                    name,
-                    kind: Default::default(), // TODO child!
-                    payable,
-                    typedefs,
-                    functions,
-                }
-            }
-            hir::Namespace::Interface {
-                payable,
-                // types,
-                funs,
-            } => {
-                let typedefs = vec![]; //TODO types in interfaces: types.into_iter().map(TypeDef::from_hir).collect();
-                let functions = funs
-                    .into_iter()
-                    .filter_map(FunDecl::from_hir_decl)
-                    .collect();
-                Self::Contract {
-                    name,
-                    kind: Kind::Interface,
-                    payable,
-                    typedefs,
-                    functions,
-                }
-            }
-            hir::Namespace::Namespace { types, .. } => {
-                let typedefs = types
-                    .into_iter()
-                    .filter_map(|(n, t)| TypeDef::from_hir(n, t))
-                    .collect();
-                Self::Namespace { name, typedefs }
-            }
-        }
-    }
-}
-
-
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Kind {
     #[serde(rename = "contract_main")]
@@ -132,16 +69,6 @@ pub struct TypeDef {
     pub typedef: Type,
 }
 
-impl TypeDef {
-    pub fn from_hir(name: String, td: hir::TypeDef) -> Option<Self> {
-        Some(Self {
-            name,
-            vars: vec![], // TODO type params in HIR
-            typedef: Type::from_hir_typedef(td)?,
-        })
-    }
-}
-
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -153,56 +80,6 @@ pub struct FunDecl {
     pub returns:   Type,
 }
 
-impl FunDecl {
-    fn from_hir_def(f: hir::Function) -> Option<Self> {
-        if f.private || !f.entrypoint {
-            return None;
-        }
-
-        let argtypes = f
-            .param_types
-            .into_iter()
-            .map(Type::from_hir_type)
-            .collect::<Option<Vec<_>>>()?;
-
-        Some(Self {
-            name:      f.id_str,
-            payable:   f.payable,
-            stateful:  f.stateful,
-            arguments: argtypes
-                .into_iter()
-                .map(|t| FunArg {
-                    name: None,
-                    typ:  t,
-                })
-                .collect(),
-            returns:   Type::from_hir_type(f.output_type)?,
-        })
-    }
-
-    fn from_hir_decl(f: hir::FunctionSignature) -> Option<Self> {
-        let argtypes = f
-            .param_types
-            .into_iter()
-            .map(Type::from_hir_type)
-            .collect::<Option<Vec<_>>>()?;
-
-        Some(Self {
-            name:      f.id_str,
-            payable:   f.payable,
-            stateful:  f.stateful,
-            arguments: argtypes
-                .into_iter()
-                .map(|t| FunArg {
-                    name: None,
-                    typ:  t,
-                })
-                .collect(),
-            returns:   Type::from_hir_type(f.output_type)?,
-        })
-    }
-}
-
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -224,67 +101,6 @@ pub enum Type {
     Variant { constructors: Vec<Constructor> },
 }
 
-impl Type {
-    pub fn from_hir_type(t: hir::Type) -> Option<Self> {
-        let r = match t {
-            hir::Type::Boolean => Self::Var("bool".to_string()),
-            hir::Type::Integer => Self::Var("int".to_string()),
-            hir::Type::Bits => Self::Var("bits".to_string()),
-            hir::Type::String => Self::Var("string".to_string()),
-            hir::Type::Address => Self::Var("address".to_string()),
-            hir::Type::Contract => Self::Var("contract".to_string()),
-            hir::Type::Oracle => Self::App {
-                name:   "oracle".to_string(),
-                params: vec![todo!("oracle poly")],
-            },
-            hir::Type::OracleQuery => Self::App {
-                name:   "oracle_query".to_string(),
-                params: vec![todo!("oracle query poly")],
-            },
-            hir::Type::Channel => Self::Var("channel".to_string()),
-            hir::Type::ContractBytearray => todo!(),
-            hir::Type::TVar(v) => Self::Var(v),
-            hir::Type::Bytes(s) => Self::Bytes(Some(s)),
-            hir::Type::BytesUnsized => Self::Bytes(None),
-            hir::Type::List(t) => Self::App {
-                name:   "list".to_string(),
-                params: vec![Type::from_hir_type(*t)?],
-            },
-            hir::Type::Tuple(elems) => Self::Tuple {
-                elems: elems
-                    .into_iter()
-                    .map(Type::from_hir_type)
-                    .collect::<Option<Vec<Self>>>()?,
-            },
-            hir::Type::Map { key, val } => Self::App {
-                name:   "map".to_string(),
-                params: vec![Type::from_hir_type(*key)?, Type::from_hir_type(*val)?],
-            },
-            hir::Type::Function { .. } => return None, // No functions in the ACI
-        };
-
-        Some(r)
-    }
-
-    pub fn from_hir_typedef(td: hir::TypeDef) -> Option<Self> {
-        match td {
-            hir::TypeDef::Alias { def } => Some(Type::from_hir_type(def)?),
-            hir::TypeDef::Record { fields } => Some(Self::Record {
-                fields: fields
-                    .into_iter()
-                    .map(Field::from_hir)
-                    .collect::<Option<Vec<_>>>()?,
-            }),
-            hir::TypeDef::Variant { constructors } => Some(Self::Variant {
-                constructors: constructors
-                    .into_iter()
-                    .map(Constructor::from_hir)
-                    .collect::<Option<Vec<_>>>()?,
-            }),
-        }
-    }
-}
-
 
 #[derive(Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -293,35 +109,13 @@ pub struct Field {
     pub typedef: Type,
 }
 
-impl Field {
-    pub fn from_hir(f: hir::FieldDecl) -> Option<Self> {
-        Some(Self {
-            name:    f.name,
-            typedef: Type::from_hir_type(f.typ)?,
-        })
-    }
-}
-
 
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Constructor {
     pub name:   String,
     pub params: Vec<Type>,
 }
 
-impl Constructor {
-    pub fn from_hir(f: hir::Constructor) -> Option<Self> {
-        Some(Self {
-            name:   f.name,
-            params: f
-                .members
-                .into_iter()
-                .map(Type::from_hir_type)
-                .collect::<Option<Vec<Type>>>()?,
-        })
-    }
-}
-
 
 impl<'de> Deserialize<'de> for Constructor {
     // This follows the pattern described here: https://serde.rs/deserialize-struct.html
@@ -398,6 +192,13 @@ impl<'de> Deserialize<'de> for Type {
                     Some(k) => k,
                 };
 
+                #[derive(Deserialize)]
+                #[serde(untagged)]
+                enum IntOrStr<'a> {
+                    Int(usize),
+                    Str(&'a str),
+                }
+
                 let x = match key.as_str() {
                     "record" => Type::Record {
                         fields: map.next_value()?,
@@ -408,7 +209,19 @@ impl<'de> Deserialize<'de> for Type {
                     "tuple" => Type::Tuple {
                         elems: map.next_value()?,
                     },
-                    "bytes" => Type::Bytes(map.next_value()?),
+                    "bytes" => {
+                        let s = match map.next_value()? {
+                            IntOrStr::Int(s) => Some(s),
+                            IntOrStr::Str("any") => None,
+                            IntOrStr::Str(_) => {
+                                return Err(de::Error::invalid_value(
+                                    de::Unexpected::Other(r#"Only "any" is allowed"#),
+                                    &self,
+                                ))
+                            }
+                        };
+                        Type::Bytes(s)
+                    }
                     _ => Type::App {
                         name:   key,
                         params: map.next_value()?,
@@ -451,9 +264,25 @@ impl Serialize for Type {
         S: Serializer,
     {
         use serde::ser::SerializeMap;
+
+        #[derive(Serialize)]
+        #[serde(untagged)]
+        enum IntOrStr<'a> {
+            Int(usize),
+            Str(&'a str),
+        }
+
         match self {
             Self::Var(var) => var.serialize(serializer),
-            Self::Bytes(size) => size.serialize(serializer),
+            Self::Bytes(s) => {
+                let mut ser = serializer.serialize_map(Some(1))?;
+                let s = match s {
+                    Some(s) => IntOrStr::Int(*s),
+                    None => IntOrStr::Str("any"),
+                };
+                ser.serialize_entry("bytes", &s)?;
+                ser.end()
+            }
             Self::App { name, params } => {
                 let mut ser = serializer.serialize_map(Some(1))?;
                 ser.serialize_entry(&name, &params)?;
@@ -600,13 +429,13 @@ mod tests {
 
         fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
             let leaf = prop_oneof![
-                // any::<u32>().prop_map(Type::Bytes),
+                any::<Option<usize>>().prop_map(Type::Bytes),
                 ".*".prop_map(Type::Var),
             ];
             leaf.prop_recursive(
-                8,   // 8 levels deep
-                256, // Shoot for maximum size of 256 nodes
-                10,  // We put up to 10 items per collection TODO wtf does this actually do
+                4,   // Depth
+                256, // Shoot for maximum size of nodes nodes
+                10,  // Items per collection
                 |inner| {
                     let field_strat = (".*".prop_map(|name| name), inner.clone())
                         .prop_map(|(name, typedef)| Field { name, typedef })
@@ -666,6 +495,7 @@ mod tests {
         #[test]
         fn aci_serde_roundtrip_json(aci in any::<Aci>()) {
             let serialized = serde_json::to_string(&aci).expect("Serialization failed");
+            eprintln!("SERIALIZED {}", serialized);
             let deserialized: Aci = serde_json::from_str(&serialized).expect("Deserialization failed");
             prop_assert_eq!(aci, deserialized);
         }