Fixed constructor args

crates/codegen/src/lib.rs

@@ -248,8 +248,12 @@ impl GenRust for Pattern {
             Self::Struct(path, inner) => {
                 cg.add(&path.get_rust());
                 cg.add(" {");
-                for pat in inner {
+                for (name, pat) in inner {
-                    pat.gen_rust(ctx, cg);
+                    cg.add(&name.get_rust());
+                    if let Some(pat) = pat {
+                        cg.add(": ");
+                        pat.gen_rust(ctx, cg);
+                    }
                     cg.add(",");
                 }
                 cg.add("}");

crates/codegen/src/top_level.rs

@@ -175,7 +175,27 @@ impl GenRust for (&Vec<Spanned<FieldDeclStmt>>, &Spanned<ClassConstructor>) {
             self.1.item.generics.get_rust()
         ));
 
-        self.1.item.params.gen_rust(ctx, cg);
+        let params = self
+            .1
+            .item
+            .params
+            .0
+            .clone()
+            .into_iter()
+            .enumerate()
+            .map(|(idx, mut v)| {
+                v.name = construct_pattern(&v.name, idx);
+                (idx, v)
+            })
+            .collect::<Vec<_>>();
+
+        for (i, param) in &params {
+            if *i > 0 {
+                cg.add(", ");
+            }
+
+            param.gen_rust(ctx, cg);
+        }
 
         cg.addln(") -> Self {");
         cg.indent += 1;
@@ -196,21 +216,13 @@ impl GenRust for (&Vec<Spanned<FieldDeclStmt>>, &Spanned<ClassConstructor>) {
 
         cg.add_indented(&format!("this.constructor("));
 
-        for (i, param) in self
+        for (i, param) in params {
-            .1
-            .item
-            .params
-            .0
-            .iter()
-            .map(|v| expr_pattern(&v.name))
-            .enumerate()
-        {
             if i > 0 {
                 cg.add(", ");
             }
 
             ctx.expr_ensure_semicolon = false;
-            param.gen_rust(ctx, cg);
+            param.name.gen_rust(ctx, cg);
         }
 
         cg.addln(");");
@@ -246,21 +258,11 @@ impl GenRust for (&Vec<Spanned<FieldDeclStmt>>, &Spanned<ClassConstructor>) {
     }
 }
 
-pub fn expr_pattern(pat: &Pattern) -> Expression {
+fn construct_pattern(pat: &Pattern, idx: usize) -> Pattern {
     match pat {
-        Pattern::Literal(v) => Expression::Literal(v.clone()),
+        Pattern::Literal(v) => Pattern::Literal(v.clone()),
-        Pattern::Path(_, v) => Expression::Path(v.clone().into()),
+        Pattern::Path(is_mut, v) => Pattern::Path(*is_mut, v.clone().into()),
-        Pattern::Tuple(items) => Expression::Literal(Literal::Tuple(
+        _ => Pattern::Path(false, Path(vec![Identifier(format!("_{idx}"))])),
-            items.iter().map(|v| expr_pattern(&v)).collect(),
-        )),
-        Pattern::NamedTuple(path, items) => Expression::Fix {
-            initial: Box::new(Expression::Path(path.clone().into())),
-            prefixes: Vec::new(),
-            postfixes: vec![Postfix::Call(
-                items.iter().map(|v| expr_pattern(&v)).collect(),
-            )],
-        },
-        Pattern::Struct(_, _) => unimplemented!(),
     }
 }
 

crates/parser/src/ast/expr.rs

@@ -33,7 +33,7 @@ pub enum Literal {
 #[derive(Debug, Clone, Serialize)]
 pub enum Pattern {
     NamedTuple(Path, Vec<Box<Pattern>>),
-    Struct(Path, Vec<Box<Pattern>>),
+    Struct(Path, Vec<(Identifier, Option<Box<Pattern>>)>),
     Tuple(Vec<Box<Pattern>>),
     Literal(Literal),
     Path(bool, Path),

crates/parser/src/grammar.pest

@@ -146,8 +146,12 @@ named_tuple_pattern = {
     static_path ~ "[" ~ multi_pat_template ~ "]"
 }
 
+struct_destruct = {
+    identifier ~ (":" ~ pattern)?
+}
+
 struct_pattern = {
-    static_path ~ "{" ~ multi_pat_template ~ "}"
+    static_path ~ "{" ~ (struct_destruct ~ ("," ~ struct_destruct)*)? ~ "}"
 }
 
 path_pattern = {

crates/parser/src/lib.rs

@@ -77,6 +77,14 @@ macro_rules! ast_expr {
         analyzer.build(v)
     }};
 
+    (( $($v:expr),* $(,)? )) => {{
+        let mut analyzer = $crate::error::AstErrorAnalyzer(None);
+
+        let v = ( $(analyzer.get($v).get()?),* );
+
+        analyzer.build(v)
+    }};
+
     ($($item:ident)::+) => {
         $($item)::+
     };

crates/parser/src/parser/common/mod.rs

@@ -71,7 +71,16 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Pattern {
 
             Rule::struct_pattern => ast_expr!(Pattern::Struct(
                 Path::try_from(inner.next().unwrap()),
-                collect_recovered_map(inner, |v| Self::try_from(v).map(Box::new)),
+                collect_recovered_map(inner, |v| {
+                    let mut inner = v.into_inner();
+                    ast_expr!((
+                        Identifier::try_from(inner.next().unwrap()),
+                        inner
+                            .next()
+                            .map(|v| Self::try_from(v).map(Box::new).get_map(Box::new))
+                            .transpose()
+                    ))
+                }),
             )),
 
             Rule::literal => ast_expr!(Pattern::Literal(pair.try_into())),