Continued working on syntax for trait implementations

src/ast/file.rs

@@ -1,6 +1,6 @@
 use super::{
     enumeration::Enum, global_variable::GlobalVar, implementation::Impl, structure::Structure,
-    type_alias::TypeAlias, Function, Given, HelperExpr, SettingsId, Trait,
+    type_alias::TypeAlias, Function, HelperExpr, SettingsId, Trait,
 };
 
 #[derive(Clone, Debug)]
@@ -13,7 +13,6 @@ pub struct AstFile {
     pub helper_exprs: Vec<HelperExpr>,
     pub traits: Vec<Trait>,
     pub impls: Vec<Impl>,
-    pub givens: Vec<Given>,
     pub settings: Option<SettingsId>,
 }
 
@@ -28,7 +27,6 @@ impl AstFile {
             helper_exprs: vec![],
             traits: vec![],
             impls: vec![],
-            givens: vec![],
             settings: None,
         }
     }

src/ast/implementation.rs

@@ -3,8 +3,8 @@ use crate::source_files::Source;
 
 #[derive(Clone, Debug)]
 pub struct Impl {
-    pub for_type: Type,
-    pub target_trait: Type,
+    pub name: Option<String>,
+    pub target: Type,
     pub source: Source,
     pub body: Vec<Function>,
 }

src/ast/mod.rs

@@ -5,7 +5,6 @@ mod enumeration;
 mod expr;
 mod file;
 mod function;
-mod given;
 mod global_variable;
 mod helper_expr;
 mod implementation;
@@ -23,7 +22,6 @@ pub use enumeration::*;
 pub use expr::*;
 pub use file::*;
 pub use function::*;
-pub use given::*;
 pub use global_variable::*;
 pub use helper_expr::*;
 pub use implementation::*;

src/lexer/identifier_state.rs

@@ -47,7 +47,6 @@ impl IdentifierState {
             "impl" => TokenKind::ImplKeyword,
             "for" => TokenKind::ForKeyword,
             "is" => TokenKind::IsKeyword,
-            "given" => TokenKind::GivenKeyword,
             _ => TokenKind::Identifier(identifier),
         }
         .at(self.start_source)

src/parser/annotation.rs

@@ -21,11 +21,11 @@ pub enum AnnotationKind {
     AbideAbi,
     Public,
     Template,
-    Using(Using),
+    Given(Given),
 }
 
 #[derive(Clone, Debug)]
-pub struct Using {
+pub struct Given {
     pub name: Option<String>,
     pub ty: ast::Type,
 }
@@ -45,7 +45,7 @@ impl Display for AnnotationKind {
             Self::AbideAbi => "abide_abi",
             Self::Public => "public",
             Self::Template => "template",
-            Self::Using(_) => "using",
+            Self::Given(_) => "given",
         })
     }
 }

src/parser/input.rs

@@ -78,6 +78,13 @@ where
             .then(|| self.advance().kind.unwrap_identifier())
     }
 
+    pub fn eat_polymorph(&mut self) -> Option<String> {
+        self.peek()
+            .kind
+            .is_polymorph()
+            .then(|| self.advance().kind.unwrap_polymorph())
+    }
+
     pub fn ignore_newlines(&mut self) {
         while self.eat(TokenKind::Newline) {}
     }

src/parser/mod.rs

@@ -8,7 +8,6 @@ mod parse_enum;
 mod parse_expr;
 mod parse_function;
 mod parse_function_parameters;
-mod parse_given;
 mod parse_global_variable;
 mod parse_helper_expr;
 mod parse_impl;

src/parser/parse_annotation.rs

@@ -1,5 +1,5 @@
 use super::{
-    annotation::{Annotation, AnnotationKind, Using},
+    annotation::{Annotation, AnnotationKind, Given},
     error::{ParseError, ParseErrorKind},
     Parser,
 };
@@ -28,10 +28,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                 "abide_abi" => AnnotationKind::AbideAbi,
                 "public" => AnnotationKind::Public,
                 "template" => AnnotationKind::Template,
-                "using" => AnnotationKind::Using(Using {
-                    name: self.parse_optional_name(),
-                    ty: self.parse_type(None::<&str>, Some("for context"))?,
-                }),
+                "given" => AnnotationKind::Given(self.parse_given()?),
                 _ => {
                     return Err(ParseErrorKind::UnrecognizedAnnotation {
                         name: annotation_name,
@@ -52,6 +49,15 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
         Ok(annotations)
     }
 
+    fn parse_given(&mut self) -> Result<Given, ParseError> {
+        let name = self.input.eat_polymorph();
+
+        Ok(Given {
+            name,
+            ty: self.parse_type(None::<&str>, Some("for context"))?,
+        })
+    }
+
     pub fn parse_optional_name(&mut self) -> Option<String> {
         (self.input.peek().is_identifier() && self.input.peek_nth(1).is_identifier())
             .then(|| self.input.advance().kind.unwrap_identifier())

src/parser/parse_function.rs

@@ -15,6 +15,16 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
         // func functionName {
         //   ^
 
+        if !self.input.peek().is_func_keyword() {
+            return Err(ParseError::expected(
+                "function",
+                None::<&str>,
+                self.input.peek(),
+            ));
+        }
+
+        let source = self.input.advance().source;
+
         let mut is_foreign = false;
         let mut abide_abi = false;
         let mut privacy = Privacy::Private;
@@ -25,8 +35,8 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                 AnnotationKind::Foreign => is_foreign = true,
                 AnnotationKind::AbideAbi => abide_abi = true,
                 AnnotationKind::Public => privacy = Privacy::Public,
-                AnnotationKind::Using(using) => {
-                    contextual_parameters.push(using);
+                AnnotationKind::Given(given) => {
+                    contextual_parameters.push(given);
                 }
                 _ => return Err(self.unexpected_annotation(&annotation, Some("for function"))),
             }
@@ -37,8 +47,6 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
             abide_abi = true;
         }
 
-        let source = self.input.advance().source;
-
         let name = self.parse_identifier(Some("after 'func' keyword"))?;
         self.ignore_newlines();
 

src/parser/parse_impl.rs

@@ -16,22 +16,14 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
 
         for annotation in annotations {
             match annotation.kind {
-                _ => return Err(self.unexpected_annotation(&annotation, Some("for impl"))),
-            }
-        }
-
-        let target_trait = self.parse_type(None::<&str>, Some("trait"))?;
-
-        if !self.input.eat(TokenKind::ForKeyword) {
-            return Err(ParseErrorKind::Expected {
-                expected: TokenKind::ForKeyword.to_string(),
-                for_reason: Some("after trait to implement".into()),
-                got: self.input.peek().to_string(),
+                _ => {
+                    return Err(self.unexpected_annotation(&annotation, Some("for implementation")))
+                }
             }
-            .at(self.input.peek().source));
         }
 
-        let for_type = self.parse_type(None::<&str>, Some("impl target"))?;
+        let name = self.parse_optional_name();
+        let target = self.parse_type(None::<&str>, Some("trait"))?;
 
         let mut body = vec![];
 
@@ -64,8 +56,8 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
         }
 
         Ok(Impl {
-            for_type,
-            target_trait,
+            name,
+            target,
             source,
             body,
         })

src/parser/parse_top_level.rs

@@ -76,11 +76,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                 ast_file.traits.push(trait_decl);
             }
             TokenKind::ImplKeyword => {
-                let impl_decl = self.parse_impl(annotations)?;
-                ast_file.impls.push(impl_decl);
-            }
-            TokenKind::GivenKeyword => {
-                ast_file.givens.push(self.parse_given(annotations)?);
+                ast_file.impls.push(self.parse_impl(annotations)?);
             }
             TokenKind::EndOfFile => {
                 // End-of-file is only okay if no preceeding annotations