Modify blueprint schema to properly handle pairs

aiken-lang · May 12, 2024 · f350c5b · f350c5b
1 parent 6d7b851
commit f350c5b
Show file tree

Hide file tree

Showing 2 changed files with 68 additions and 11 deletions.
diff --git a/crates/aiken-project/src/blueprint/parameter.rs b/crates/aiken-project/src/blueprint/parameter.rs
@@ -192,6 +192,50 @@ fn validate_data(
             Ok(())
         }
 
+        Data::Pair(fst, snd) => {
+            let fst = fst
+                .schema(definitions)
+                .ok_or_else(|| Error::UnresolvedSchemaReference {
+                    reference: fst.reference().unwrap().clone(),
+                })?;
+
+            let snd = snd
+                .schema(definitions)
+                .ok_or_else(|| Error::UnresolvedSchemaReference {
+                    reference: snd.reference().unwrap().clone(),
+                })?;
+
+            let terms = expect_data_list(term)?;
+
+            if terms.len() != 2 {
+                mismatch(
+                    term,
+                    Schema::Pair(
+                        Declaration::Inline(Box::new(Schema::Data(fst.clone()))),
+                        Declaration::Inline(Box::new(Schema::Data(snd.clone()))),
+                    ),
+                );
+            }
+
+            for item in terms.into_iter().enumerate() {
+                if item.0 == 0 {
+                    validate_data(fst, definitions, &item.1)?;
+                } else if item.0 == 1 {
+                    validate_data(snd, definitions, &item.1)?;
+                } else {
+                    mismatch(
+                        term,
+                        Schema::Pair(
+                            Declaration::Inline(Box::new(Schema::Data(fst.clone()))),
+                            Declaration::Inline(Box::new(Schema::Data(snd.clone()))),
+                        ),
+                    );
+                }
+            }
+
+            Ok(())
+        }
+
         Data::Map(keys, values) => {
             let terms = expect_data_map(term)?;
 

diff --git a/crates/aiken-project/src/blueprint/schema.rs b/crates/aiken-project/src/blueprint/schema.rs
@@ -92,6 +92,7 @@ pub enum Data {
     Integer,
     Bytes,
     List(Items<Data>),
+    Pair(Declaration<Data>, Declaration<Data>),
     Map(Declaration<Data>, Declaration<Data>),
     AnyOf(Vec<Annotated<Constructor>>),
     Opaque,
@@ -297,18 +298,11 @@ impl Annotated<Schema> {
                             // make all types abide by this convention.
                             let data = match definitions.try_lookup(&generic).cloned() {
                                 Some(Annotated {
-                                    annotated: Schema::Data(Data::List(Items::Many(xs))),
+                                    annotated: Schema::Data(Data::Pair(left, right)),
                                     ..
-                                }) if xs.len() == 2 => {
+                                }) => {
                                     definitions.remove(&generic);
-                                    Data::Map(
-                                        xs.first()
-                                            .expect("length (== 2) checked in pattern clause")
-                                            .to_owned(),
-                                        xs.last()
-                                            .expect("length (== 2) checked in pattern clause")
-                                            .to_owned(),
-                                    )
+                                    Data::Map(left, right)
                                 }
 
                                 _ => Data::List(Items::One(Declaration::Referenced(generic))),
@@ -384,7 +378,20 @@ impl Annotated<Schema> {
                 }
             },
             Type::Fn { .. } => unreachable!(),
-            Type::Pair { .. } => unreachable!(),
+            Type::Pair { fst, snd, .. } => {
+                definitions.register(type_info, &type_parameters.clone(), |definitions| {
+                    let fst = Annotated::do_from_type(fst, modules, type_parameters, definitions)
+                        .map(Declaration::Referenced)?;
+                    let snd = Annotated::do_from_type(snd, modules, type_parameters, definitions)
+                        .map(Declaration::Referenced)?;
+
+                    Ok(Annotated {
+                        title: Some("Pair".to_owned()),
+                        description: None,
+                        annotated: Schema::Data(Data::Pair(fst, snd)),
+                    })
+                })
+            }
         }
     }
 }
@@ -791,6 +798,12 @@ impl Serialize for Data {
                 s.serialize_field("items", &items)?;
                 s.end()
             }
+            Data::Pair(left, right) => {
+                let mut s = serializer.serialize_struct("Pair", 2)?;
+                s.serialize_field("dataType", "list")?;
+                s.serialize_field("items", &[left, right])?;
+                s.end()
+            }
             Data::Map(keys, values) => {
                 let mut s = serializer.serialize_struct("Map", 3)?;
                 s.serialize_field("dataType", "map")?;