From 93e010b345bca54974124ab248250d1824019935 Mon Sep 17 00:00:00 2001
From: KtorZ <matthias.benkort@gmail.com>
Date: Wed, 5 Jul 2023 13:57:34 +0200
Subject: [PATCH] Replace 'public' utils with a more generic 'optional_flag'

  The 'public' util was arguably not really adding much except a layer of indirection.
  In the end, one useful parsing behavior to abstract is the idea of 'optional flag' that we use for both 'pub' and 'opaque' keywords.
---
 .../src/parser/definition/constant.rs         |  5 +-
 .../src/parser/definition/data_type.rs        | 49 +++++++++----------
 .../src/parser/definition/function.rs         |  7 ++-
 .../src/parser/definition/type_alias.rs       |  7 ++-
 crates/aiken-lang/src/parser/utils.rs         |  4 +-
 5 files changed, 34 insertions(+), 38 deletions(-)

diff --git a/crates/aiken-lang/src/parser/definition/constant.rs b/crates/aiken-lang/src/parser/definition/constant.rs
index 137111ae..093c9d69 100644
--- a/crates/aiken-lang/src/parser/definition/constant.rs
+++ b/crates/aiken-lang/src/parser/definition/constant.rs
@@ -6,8 +6,7 @@ use crate::{
 };
 
 pub fn parser() -> impl Parser<Token, ast::UntypedDefinition, Error = ParseError> {
-    utils::public()
-        .or_not()
+    utils::optional_flag(Token::Pub)
         .then_ignore(just(Token::Const))
         .then(select! {Token::Name{name} => name})
         .then(
@@ -21,7 +20,7 @@ pub fn parser() -> impl Parser<Token, ast::UntypedDefinition, Error = ParseError
             ast::UntypedDefinition::ModuleConstant(ast::ModuleConstant {
                 doc: None,
                 location: span,
-                public: public.is_some(),
+                public,
                 name,
                 annotation,
                 value: Box::new(value),
diff --git a/crates/aiken-lang/src/parser/definition/data_type.rs b/crates/aiken-lang/src/parser/definition/data_type.rs
index cc9ff73e..dfea21d3 100644
--- a/crates/aiken-lang/src/parser/definition/data_type.rs
+++ b/crates/aiken-lang/src/parser/definition/data_type.rs
@@ -46,34 +46,33 @@ pub fn parser() -> impl Parser<Token, ast::UntypedDefinition, Error = ParseError
         }]
     });
 
-    utils::public()
-        .then(just(Token::Opaque).ignored().or_not())
-        .or_not()
+    utils::optional_flag(Token::Pub)
+        .then(utils::optional_flag(Token::Opaque))
         .then(utils::type_name_with_args())
         .then(choice((constructors, record_sugar)))
-        .map_with_span(|((pub_opaque, (name, parameters)), constructors), span| {
-            ast::UntypedDefinition::DataType(ast::DataType {
-                location: span,
-                constructors: constructors
-                    .into_iter()
-                    .map(|mut constructor| {
-                        if constructor.sugar {
-                            constructor.name = name.clone();
-                        }
+        .map_with_span(
+            |(((public, opaque), (name, parameters)), constructors), span| {
+                ast::UntypedDefinition::DataType(ast::DataType {
+                    location: span,
+                    constructors: constructors
+                        .into_iter()
+                        .map(|mut constructor| {
+                            if constructor.sugar {
+                                constructor.name = name.clone();
+                            }
 
-                        constructor
-                    })
-                    .collect(),
-                doc: None,
-                name,
-                opaque: pub_opaque
-                    .map(|(_, opt_opaque)| opt_opaque.is_some())
-                    .unwrap_or(false),
-                parameters: parameters.unwrap_or_default(),
-                public: pub_opaque.is_some(),
-                typed_parameters: vec![],
-            })
-        })
+                            constructor
+                        })
+                        .collect(),
+                    doc: None,
+                    name,
+                    opaque,
+                    parameters: parameters.unwrap_or_default(),
+                    public,
+                    typed_parameters: vec![],
+                })
+            },
+        )
 }
 
 fn labeled_constructor_type_args(
diff --git a/crates/aiken-lang/src/parser/definition/function.rs b/crates/aiken-lang/src/parser/definition/function.rs
index 235e433a..e0a615b3 100644
--- a/crates/aiken-lang/src/parser/definition/function.rs
+++ b/crates/aiken-lang/src/parser/definition/function.rs
@@ -7,8 +7,7 @@ use crate::{
 };
 
 pub fn parser() -> impl Parser<Token, ast::UntypedDefinition, Error = ParseError> {
-    utils::public()
-        .or_not()
+    utils::optional_flag(Token::Pub)
         .then_ignore(just(Token::Fn))
         .then(select! {Token::Name {name} => name})
         .then(
@@ -25,7 +24,7 @@ pub fn parser() -> impl Parser<Token, ast::UntypedDefinition, Error = ParseError
                 .delimited_by(just(Token::LeftBrace), just(Token::RightBrace)),
         )
         .map_with_span(
-            |((((opt_pub, name), (arguments, args_span)), return_annotation), body), span| {
+            |((((public, name), (arguments, args_span)), return_annotation), body), span| {
                 ast::UntypedDefinition::Fn(ast::Function {
                     arguments,
                     body: body.unwrap_or_else(|| UntypedExpr::todo(span, None)),
@@ -39,7 +38,7 @@ pub fn parser() -> impl Parser<Token, ast::UntypedDefinition, Error = ParseError
                     },
                     end_position: span.end - 1,
                     name,
-                    public: opt_pub.is_some(),
+                    public,
                     return_annotation,
                     return_type: (),
                     can_error: true,
diff --git a/crates/aiken-lang/src/parser/definition/type_alias.rs b/crates/aiken-lang/src/parser/definition/type_alias.rs
index 6787f204..b1a6f3c7 100644
--- a/crates/aiken-lang/src/parser/definition/type_alias.rs
+++ b/crates/aiken-lang/src/parser/definition/type_alias.rs
@@ -6,19 +6,18 @@ use crate::{
 };
 
 pub fn parser() -> impl Parser<Token, ast::UntypedDefinition, Error = ParseError> {
-    utils::public()
-        .or_not()
+    utils::optional_flag(Token::Pub)
         .then(utils::type_name_with_args())
         .then_ignore(just(Token::Equal))
         .then(annotation())
-        .map_with_span(|((opt_pub, (alias, parameters)), annotation), span| {
+        .map_with_span(|((public, (alias, parameters)), annotation), span| {
             ast::UntypedDefinition::TypeAlias(ast::TypeAlias {
                 alias,
                 annotation,
                 doc: None,
                 location: span,
                 parameters: parameters.unwrap_or_default(),
-                public: opt_pub.is_some(),
+                public,
                 tipo: (),
             })
         })
diff --git a/crates/aiken-lang/src/parser/utils.rs b/crates/aiken-lang/src/parser/utils.rs
index 0ce3e404..60099769 100644
--- a/crates/aiken-lang/src/parser/utils.rs
+++ b/crates/aiken-lang/src/parser/utils.rs
@@ -7,8 +7,8 @@ use super::{
     token::{Base, Token},
 };
 
-pub fn public() -> impl Parser<Token, (), Error = ParseError> {
-    just(Token::Pub).ignored()
+pub fn optional_flag(token: Token) -> impl Parser<Token, bool, Error = ParseError> {
+    just(token).ignored().or_not().map(|v| v.is_some())
 }
 
 pub fn bytearray(