improve impl grammar [4] (#155)

* Reorder project and add book

* refactor lower type

* Add initial grammar for impl blocks

* optimize grammar

* Add TypeName to AST, allowing type names to have a full path and generics

* remove unused

* remove comment

* improve impl grammar

* clippy

src/ast/expressions.rs

@@ -123,6 +123,7 @@ pub struct MatchVariant {
 pub enum PathSegment {
     FieldAccess(Ident, Span),
     ArrayIndex(ValueExpr, Span),
+    MethodCall(FnCallOp, Span),
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]

src/ast/types.rs

@@ -27,6 +27,11 @@ pub enum TypeDescriptor {
         size: u64,
         span: Span,
     },
+    // Used in impl blocks.
+    SelfType {
+        is_ref: bool,
+        is_mut: bool,
+    },
 }
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]

src/grammar.lalrpop

@@ -32,6 +32,7 @@ extern {
     "import" => Token::KeywordImport,
     "extern" => Token::KeywordExtern,
     "as" => Token::KeywordAs,
+    "self" => Token::KeywordSelf,
 
     // literals
     "identifier" => Token::Identifier(<String>),
@@ -145,6 +146,10 @@ Ident: ast::common::Ident = {
   <lo:@L> <name:"identifier"> <hi:@R> => ast::common::Ident {
     name,
     span: ast::common::Span::new(lo, hi),
+  },
+  <lo:@L> <name:"self"> <hi:@R> => ast::common::Ident {
+    name: name.to_string(),
+    span: ast::common::Span::new(lo, hi),
   }
 }
 
@@ -311,6 +316,16 @@ Param: ast::functions::Param = {
   <name:Ident> ":" <param_type:TypeDescriptor> => ast::functions::Param {
     name,
     r#type: param_type
+  },
+   <lo:@L> <is_ref:"&"?> <is_mut:"mut"?> "self" <hi:@R> => ast::functions::Param {
+    name: ast::common::Ident {
+      name: "self".to_string(),
+      span: Span::new(lo, hi),
+    },
+    r#type: ast::types::TypeDescriptor::SelfType {
+      is_ref: is_ref.is_some(),
+      is_mut: is_mut.is_some(),
+    },
   }
 }
 
@@ -572,6 +587,7 @@ PathOp: ast::expressions::PathOp = {
 
 PathSegment: ast::expressions::PathSegment = {
   <lo:@L> "." <e:Ident> <hi:@R> => ast::expressions::PathSegment::FieldAccess(e, Span::new(lo, hi)),
+  <lo:@L> "." <e:FnCallOp> <hi:@R> => ast::expressions::PathSegment::MethodCall(e, Span::new(lo, hi)),
   <lo:@L> "[" <e:ValueExpr> "]" <hi:@R> => ast::expressions::PathSegment::ArrayIndex(e, Span::new(lo, hi)),
 }
 

src/ir/lowering.rs

@@ -1739,6 +1739,7 @@ pub fn lower_path(
                     ty = *element_type;
                 }
             }
+            PathSegment::MethodCall(_fn_call_op, _span) => todo!(),
         }
     }
 
@@ -1825,5 +1826,9 @@ pub fn lower_type(
                 }),
             ),
         ),
+        TypeDescriptor::SelfType {
+            is_ref: _,
+            is_mut: _,
+        } => todo!(),
     })
 }

src/parser/mod.rs

@@ -297,6 +297,62 @@ mod ModuleName {
         let source = r##"mod MyMod {
     #[intrinsic = "simdsomething"]
     pub extern fn myintrinsic();
+}"##;
+        let lexer = Lexer::new(source);
+        let parser = grammar::ProgramParser::new();
+        parser.parse(lexer).unwrap();
+    }
+
+    #[test]
+    fn parse_impl() {
+        let source = r##"mod MyMod {
+    struct A {
+        a: i32,
+        b: i32,
+    }
+
+    impl A {
+        pub fn hello(&self, other: i32) -> i32 {
+            return self.a * other;
+        }
+    }
+
+    pub fn main() -> i32 {
+        let x: A = A {
+            a: 2,
+            b: 3,
+        };
+
+        return x.hello(4);
+    }
+}"##;
+        let lexer = Lexer::new(source);
+        let parser = grammar::ProgramParser::new();
+        parser.parse(lexer).unwrap();
+    }
+
+    #[test]
+    fn parse_impl_mut() {
+        let source = r##"mod MyMod {
+    struct A {
+        a: i32,
+        b: i32,
+    }
+
+    impl A {
+        pub fn hello(&mut self, other: i32) -> i32 {
+            return self.a * other;
+        }
+    }
+
+    pub fn main() -> i32 {
+        let x: A = A {
+            a: 2,
+            b: 3,
+        };
+
+        return x.hello(4);
+    }
 }"##;
         let lexer = Lexer::new(source);
         let parser = grammar::ProgramParser::new();

src/parser/tokens.rs

@@ -61,6 +61,8 @@ pub enum Token {
     KeywordExtern,
     #[token("as")]
     KeywordAs,
+    #[token("self")]
+    KeywordSelf,
 
     // Modern way of allowing identifiers, read: https://unicode.org/reports/tr31/
     #[regex(r"[\p{XID_Start}_]\p{XID_Continue}*", |lex| lex.slice().to_string())]