field exporting

semantic/src/lib.rs

@@ -48,12 +48,16 @@ pub fn walk_ast(top_scope: Arc<Scope>, tl: &mut Vec<parser::ast::TopLevel>) {
 }
 
 pub fn walk_param_list(fields: &HashMap<String, Arc<VarRef>>, param_list: &mut ParamList) {
+    let old_param_list = param_list.clone();
     param_list.0.clear();
 
-    for (_, param) in fields {
-        param_list.0.push((
+    for (name, param) in fields {
+        param_list.0.insert(
             param.name.clone(),
-            TypeExpr::Identifier(param.var_type.get_name()),
-        ));
+            (
+                old_param_list.0.get(name).map(|a| a.0).unwrap_or_default(),
+                TypeExpr::Identifier(param.var_type.get_name()),
+            ),
+        );
     }
 }

semantic/src/scope.rs

@@ -151,7 +151,7 @@ impl LocalScope {
     }
 
     pub fn with_params(self: &Arc<Self>, param_list: &ParamList) {
-        for (param_name, type_expr) in &param_list.0 {
+        for (param_name, (_, type_expr)) in &param_list.0 {
             match type_expr {
                 parser::ast::TypeExpr::Identifier(id) => {
                     if let Some(var_type) =

semantic/src/top_level.rs

@@ -47,12 +47,21 @@ impl FunctionSymbol {
         Self {
             export: export,
             name: name.clone(),
-            params: params.to_hashmap(|name, v| VarSymbol {
-                name: name.clone(),
-                var_type: TypeSymbol(match v {
-                    TypeExpr::Identifier(i) => i.to_string(),
-                }),
-            }),
+            params: params
+                .0
+                .iter()
+                .map(|(name, (_, v))| {
+                    (
+                        name.clone(),
+                        VarSymbol {
+                            name: name.clone(),
+                            var_type: TypeSymbol(match v {
+                                TypeExpr::Identifier(i) => i.to_string(),
+                            }),
+                        },
+                    )
+                })
+                .collect(),
             return_type: return_type.map(TypeSymbol::from_ast),
         }
     }
@@ -63,12 +72,21 @@ impl StructSymbol {
         Self {
             export,
             name,
-            fields: fields.to_hashmap(|name, v| VarSymbol {
-                name: name.clone(),
-                var_type: TypeSymbol(match v {
-                    TypeExpr::Identifier(i) => i.to_string(),
-                }),
-            }),
+            fields: fields
+                .0
+                .iter()
+                .map(|(name, (_, v))| {
+                    (
+                        name.clone(),
+                        VarSymbol {
+                            name: name.clone(),
+                            var_type: TypeSymbol(match v {
+                                TypeExpr::Identifier(i) => i.to_string(),
+                            }),
+                        },
+                    )
+                })
+                .collect(),
             // TODO - parse struct methods
             methods: HashMap::new(),
         }