Fix: Generics

parser/src/ast/expr.rs

@@ -65,7 +65,7 @@ pub enum Pattern {
 
 #[derive(Debug, Clone, Serialize)]
 pub enum Postfix {
-    FieldAccess(Identifier, Option<GenericsDecl>),
+    FieldAccess(Identifier, Option<Generics>),
     Call(Vec<Expression>),
     MacroCall(String),
     StructCall(Vec<(Identifier, Expression)>),
@@ -79,7 +79,7 @@ pub enum Prefix {
     Ref,
     RefMut,
     Deref,
-    New(Option<GenericsDecl>),
+    New(Option<Generics>),
     Not,
     Neg,
 }
@@ -87,8 +87,17 @@ pub enum Prefix {
 #[derive(Debug, Clone, Serialize)]
 pub struct ExprPathSegment {
     pub ident: Identifier,
-    pub generics: Option<GenericsDecl>,
+    pub generics: Option<Generics>,
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub struct ExprPath(pub Vec<ExprPathSegment>);
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Generics(pub Vec<Generic>);
+
+#[derive(Debug, Clone, Serialize)]
+pub enum Generic {
+    Lifetime(Identifier),
+    Type(TypeExpr),
+}

parser/src/ast/top_level.rs

@@ -74,6 +74,7 @@ pub enum GenericDecl {
     Lifetime(Identifier),
     Type(Identifier, Vec<TypeExpr>),
 }
+
 #[derive(Debug, Clone, Serialize)]
 pub enum EnumItem {
     Named(Identifier),

parser/src/parser/common/expr.rs

@@ -159,7 +159,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Postfix {
             Rule::field_px => {
                 ast_expr!(Postfix::FieldAccess(
                     inner.next().unwrap().try_into(),
-                    inner.next().map(GenericsDecl::try_from).transpose()
+                    inner.next().map(Generics::try_from).transpose()
                 ))
             }
 
@@ -209,7 +209,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for ExprPathSegment {
         ast_ensure!(pair, Rule::expr_path_segment => {
             ast_expr!(ExprPathSegment {
                 ident: Identifier::try_from(inner.next().unwrap()),
-                generics: inner.next().map(GenericsDecl::try_from).transpose(),
+                generics: inner.next().map(Generics::try_from).transpose(),
             })
         })
     }

parser/src/parser/common/types.rs

@@ -119,3 +119,35 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for GenericDecl {
         })
     }
 }
+
+impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Generics {
+    type Error = AstError<'a, Self>;
+
+    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
+        let inner = pair.clone().into_inner();
+
+        ast_ensure!(pair, Rule::generics => {
+            ast_expr!(Generics(collect_recovered(inner)))
+        })
+    }
+}
+
+impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Generic {
+    type Error = AstError<'a, Self>;
+
+    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
+        let mut inner = pair.clone().into_inner();
+
+        ast_ensure!(pair, Rule::generic => {
+            if let Some(pair) = consume_rule(&mut inner, Rule::lifetime) {
+                ast_expr!(Generic::Lifetime(
+                    pair.into_inner().next().unwrap().try_into(),
+                ))
+            } else {
+                ast_expr!(Generic::Type(
+                    inner.next().unwrap().try_into()
+                ))
+            }
+        })
+    }
+}

src/codegen.rs

@@ -1,8 +1,8 @@
 use mist_parser::ast::{
     Attribute, BinaryOp, Block, ClassItem, EnumItem, ExprPath, ExprPathSegment, Expression,
-    FieldDecl, FunctionDecl, GenericDecl, GenericsDecl, Identifier, ImplDecl, Literal, Path,
+    FieldDecl, FunctionDecl, Generic, GenericDecl, Generics, GenericsDecl, Identifier, ImplDecl,
-    Pattern, Postfix, Prefix, Statement, StatementBranch, TopLevel, TopLevelKind, TypeExpr,
+    Literal, Path, Pattern, Postfix, Prefix, Statement, StatementBranch, TopLevel, TopLevelKind,
-    TypeExprKind, TypePostfix, VarDecl, VarDeclStmt, Visibility,
+    TypeExpr, TypeExprKind, TypePostfix, VarDecl, VarDeclStmt, Visibility,
 };
 
 // ---------------------------------------------------------------------------
@@ -923,6 +923,32 @@ impl GetRust for (bool, &GenericDecl) {
     }
 }
 
+impl GetRust for Generics {
+    fn get_rust(&self) -> String {
+        if self.0.len() == 0 {
+            String::new()
+        } else {
+            format!(
+                "<{}>",
+                self.0
+                    .iter()
+                    .map(Generic::get_rust)
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            )
+        }
+    }
+}
+
+impl GetRust for Generic {
+    fn get_rust(&self) -> String {
+        match &self {
+            Self::Lifetime(name) => format!("'{}", name.get_rust()),
+            Self::Type(ty) => ty.get_rust(),
+        }
+    }
+}
+
 impl GetRust for FieldDecl {
     fn get_rust(&self) -> String {
         format!(