field exporting

parser/src/ast.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use serde::Serialize;
 
 #[derive(Debug, Clone, Serialize)]
-pub struct ParamList(pub Vec<(String, TypeExpr)>);
+pub struct ParamList(pub HashMap<String, (bool, TypeExpr)>);
 
 #[derive(Debug, Clone, Serialize)]
 pub struct Block(pub Vec<Statement>);
@@ -120,9 +120,3 @@ pub enum VarKind {
     Const,
     Var,
 }
-
-impl ParamList {
-    pub fn to_hashmap<T>(&self, f: impl Fn(&String, &TypeExpr) -> T) -> HashMap<String, T> {
-        self.0.iter().map(|(k, v)| (k.clone(), f(k, v))).collect()
-    }
-}

parser/src/grammar.pest

@@ -20,7 +20,7 @@ export = { "export" }
 import = { "import" ~ string_lit ~ ";" }
 
 param_list = { param ~ ("," ~ param)* ~ ","? }
-param      = { identifier ~ ":" ~ type_expr }
+param      = { export? ~ identifier ~ ":" ~ type_expr }
 
 struct_decl = {
     export? ~ "struct" ~ identifier ~ "{" ~ param_list? ~ "}"

parser/src/lib.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use pest::Parser;
 use pest_derive::Parser;
 
@@ -39,14 +41,21 @@ impl TypeExpr {
 }
 
 impl ParamList {
-    pub fn from_pair(pair: pest::iterators::Pair<Rule>) -> Self {
+    pub fn from_pair(export_allowed: bool, pair: pest::iterators::Pair<Rule>) -> Self {
         let params = pair
             .into_inner()
             .map(|p| {
                 let mut param_inner = p.into_inner();
+                let export =
+                    if export_allowed && param_inner.peek().unwrap().as_rule() == Rule::export {
+                        param_inner.next().unwrap();
+                        true
+                    } else {
+                        false
+                    };
                 let param_name = param_inner.next().unwrap().as_str().to_string();
                 let param_type = TypeExpr::from_pair(param_inner.next().unwrap());
-                (param_name, param_type)
+                (param_name, (export, param_type))
             })
             .collect();
 
@@ -76,9 +85,9 @@ impl TopLevel {
                 };
                 let name = inner.next().unwrap().as_str().to_string();
                 let params = if inner.peek().unwrap().as_rule() == Rule::param_list {
-                    ParamList::from_pair(inner.next().unwrap())
+                    ParamList::from_pair(false, inner.next().unwrap())
                 } else {
-                    ParamList(vec![])
+                    ParamList(HashMap::new())
                 };
                 let return_type = if let Some(next) = inner.peek() {
                     if next.as_rule() == Rule::type_expr {
@@ -115,7 +124,7 @@ impl TopLevel {
                 };
                 let name = inner.next().unwrap().as_str().to_string();
                 let fields_pair = inner.next().unwrap();
-                let fields = ParamList::from_pair(fields_pair);
+                let fields = ParamList::from_pair(true, fields_pair);
 
                 Some(TopLevel::StructDecl {
                     export,