feat(bls): aiken level g1 and g2 literals

crates/aiken-lang/src/parser/literal/bytearray.rs

@@ -9,16 +9,70 @@ use crate::{
 };
 
 pub fn parser<A>(
-    into: impl Fn(Vec<u8>, ast::ByteArrayFormatPreference, ast::Span) -> A,
+    into: impl Fn(
+        Vec<u8>,
+        ast::ByteArrayFormatPreference,
+        Option<ast::CurveType>,
+        ast::Span,
+        &mut dyn FnMut(ParseError),
+    ) -> A,
 ) -> impl Parser<Token, A, Error = ParseError> {
-    choice((array_of_bytes(), hex_string(), utf8_string()))
-        .map_with_span(move |(preferred_format, bytes), span| into(bytes, preferred_format, span))
+    choice((
+        array_of_bytes(),
+        hex_string(),
+        utf8_string().map(|(p, b)| (None, p, b)),
+    ))
+    .validate(move |(curve, preferred_format, bytes), span, emit| {
+        into(bytes, preferred_format, curve, span, emit)
+    })
 }
 
-pub fn array_of_bytes(
-) -> impl Parser<Token, (ast::ByteArrayFormatPreference, Vec<u8>), Error = ParseError> {
+fn curve_point() -> impl Parser<Token, ast::CurveType, Error = ParseError> {
+    just(Token::Less)
+        .ignore_then(select! {Token::UpName {name} => name})
+        .then_ignore(just(Token::Comma))
+        .then(select! {Token::UpName {name} => name})
+        .then_ignore(just(Token::Greater))
+        .validate(
+            |(curve_type, point_type), span, emit| match curve_type.as_str() {
+                "Bls12_381" => {
+                    let point = match point_type.as_str() {
+                        "G1" => ast::Bls12_381PointType::G1,
+                        "G2" => ast::Bls12_381PointType::G2,
+                        _ => {
+                            emit(ParseError::unknown_point_curve(
+                                curve_type,
+                                Some(point_type),
+                                span,
+                            ));
+
+                            ast::Bls12_381PointType::G1
+                        }
+                    };
+
+                    ast::CurveType::Bls12_381(point)
+                }
+                _ => {
+                    emit(ParseError::unknown_point_curve(curve_type, None, span));
+
+                    ast::CurveType::Bls12_381(ast::Bls12_381PointType::G1)
+                }
+            },
+        )
+}
+
+pub fn array_of_bytes() -> impl Parser<
+    Token,
+    (
+        Option<ast::CurveType>,
+        ast::ByteArrayFormatPreference,
+        Vec<u8>,
+    ),
+    Error = ParseError,
+> {
     just(Token::Hash)
-        .ignore_then(
+        .ignore_then(curve_point().or_not())
+        .then(
             select! {Token::Int {value, base, ..} => (value, base)}
                 .validate(|(value, base), span, emit| {
                     let byte: u8 = match value.parse() {
@@ -38,7 +92,7 @@ pub fn array_of_bytes(
                 .allow_trailing()
                 .delimited_by(just(Token::LeftSquare), just(Token::RightSquare)),
         )
-        .validate(|bytes, span, emit| {
+        .validate(|(curve, bytes), span, emit| {
             let base = bytes.iter().try_fold(None, |acc, (_, base)| match acc {
                 None => Ok(Some(base)),
                 Some(previous_base) if previous_base == base => Ok(Some(base)),
@@ -58,15 +112,33 @@ pub fn array_of_bytes(
                 Ok(Some(base)) => *base,
             };
 
-            (bytes.into_iter().map(|(b, _)| b).collect::<Vec<u8>>(), base)
+            (
+                curve,
+                bytes.into_iter().map(|(b, _)| b).collect::<Vec<u8>>(),
+                base,
+            )
+        })
+        .map(|(curve, bytes, base)| {
+            (
+                curve,
+                ast::ByteArrayFormatPreference::ArrayOfBytes(base),
+                bytes,
+            )
         })
-        .map(|(bytes, base)| (ast::ByteArrayFormatPreference::ArrayOfBytes(base), bytes))
 }
 
-pub fn hex_string(
-) -> impl Parser<Token, (ast::ByteArrayFormatPreference, Vec<u8>), Error = ParseError> {
+pub fn hex_string() -> impl Parser<
+    Token,
+    (
+        Option<ast::CurveType>,
+        ast::ByteArrayFormatPreference,
+        Vec<u8>,
+    ),
+    Error = ParseError,
+> {
     just(Token::Hash)
-        .ignore_then(
+        .ignore_then(curve_point().or_not())
+        .then(
             select! {Token::ByteString {value} => value}.validate(|value, span, emit| {
                 match hex::decode(value) {
                     Ok(bytes) => bytes,
@@ -77,7 +149,13 @@ pub fn hex_string(
                 }
             }),
         )
-        .map(|token| (ast::ByteArrayFormatPreference::HexadecimalString, token))
+        .map(|(curve, token)| {
+            (
+                curve,
+                ast::ByteArrayFormatPreference::HexadecimalString,
+                token,
+            )
+        })
 }
 
 pub fn utf8_string(