chore(parser): remove modifier issues

ara-lang · Jan 17, 2023 · 04d6c49 · 04d6c49
1 parent b4a6c45
commit 04d6c49
Show file tree

Hide file tree

Showing 55 changed files with 677 additions and 1,570 deletions.
diff --git a/src/parser/internal/definition/class.rs b/src/parser/internal/definition/class.rs
@@ -16,13 +16,11 @@ use crate::tree::definition::class::ClassDefinitionBody;
 use crate::tree::definition::class::ClassDefinitionExtends;
 use crate::tree::definition::class::ClassDefinitionImplements;
 use crate::tree::definition::class::ClassDefinitionMember;
-use crate::tree::identifier::Identifier;
 
 pub fn class_definition(state: &mut State) -> ParseResult<ClassDefinition> {
     let attributes = state.get_attributes();
 
     let modifiers = modifier::collect(state)?;
-    let modifiers = modifier::class_modifier_definition_group(state, modifiers)?;
     let comments = state.iterator.comments();
     let class = utils::skip_keyword(state, TokenKind::Class)?;
     let name = identifier::classname_identifier(state)?;
@@ -64,7 +62,7 @@ pub fn class_definition(state: &mut State) -> ParseResult<ClassDefinition> {
         members: {
             let mut members = Vec::new();
             while state.iterator.current().kind != TokenKind::RightBrace {
-                members.push(class_definition_member(state, &name)?);
+                members.push(class_definition_member(state)?);
             }
 
             members
@@ -85,28 +83,17 @@ pub fn class_definition(state: &mut State) -> ParseResult<ClassDefinition> {
     })
 }
 
-fn class_definition_member(
-    state: &mut State,
-    name: &Identifier,
-) -> ParseResult<ClassDefinitionMember> {
+fn class_definition_member(state: &mut State) -> ParseResult<ClassDefinitionMember> {
     attribute::gather(state)?;
 
     let modifiers = modifier::collect(state)?;
 
     if state.iterator.current().kind == TokenKind::Const {
-        let modifiers = modifier::constant_modifier_definition_group(state, modifiers)?;
         return classish_constant_definition(state, modifiers).map(ClassDefinitionMember::Constant);
     }
 
     if state.iterator.current().kind == TokenKind::Function {
-        let modifiers = modifier::method_modifier_definition_group(state, modifiers)?;
-
-        let method = method_definition(
-            state,
-            MethodDefinitionType::DependingOnModifiers,
-            modifiers,
-            Some(name),
-        )?;
+        let method = method_definition(state, MethodDefinitionType::Either, modifiers)?;
 
         return match method {
             MethodDefinitionReference::Abstract(method) => {
@@ -124,8 +111,5 @@ fn class_definition_member(
         };
     }
 
-    // e.g: public static
-    let modifiers = modifier::property_modifier_definition_group(state, modifiers)?;
-
     property::property_definition(state, modifiers).map(ClassDefinitionMember::Property)
 }
diff --git a/src/parser/internal/definition/constant.rs b/src/parser/internal/definition/constant.rs
@@ -7,7 +7,7 @@ use crate::parser::state::State;
 use crate::tree::definition::constant::ClassishConstantDefinition;
 use crate::tree::definition::constant::ConstantDefinition;
 use crate::tree::definition::constant::ConstantDefinitionEntry;
-use crate::tree::definition::modifier::ConstantModifierDefinitionGroup;
+use crate::tree::definition::modifier::ModifierGroupDefinition;
 
 pub fn constant_definition(state: &mut State) -> ParseResult<ConstantDefinition> {
     Ok(ConstantDefinition {
@@ -30,7 +30,7 @@ pub fn constant_definition(state: &mut State) -> ParseResult<ConstantDefinition>
 
 pub fn classish_constant_definition(
     state: &mut State,
-    modifiers: ConstantModifierDefinitionGroup,
+    modifiers: ModifierGroupDefinition,
 ) -> ParseResult<ClassishConstantDefinition> {
     Ok(ClassishConstantDefinition {
         comments: state.iterator.comments(),

diff --git a/src/parser/internal/definition/enum.rs b/src/parser/internal/definition/enum.rs
@@ -10,6 +10,7 @@ use crate::parser::internal::utils;
 use crate::parser::result::ParseResult;
 use crate::parser::state::State;
 use crate::tree::definition::function::ConcreteMethodDefinition;
+use crate::tree::definition::modifier::ModifierGroupDefinition;
 use crate::tree::definition::r#enum::BackedEnumBodyDefinition;
 use crate::tree::definition::r#enum::BackedEnumCaseDefinition;
 use crate::tree::definition::r#enum::BackedEnumDefinition;
@@ -158,8 +159,6 @@ fn unit_enum_definition_member(
     let modifiers = modifier::collect(state)?;
 
     if state.iterator.current().kind == TokenKind::Const {
-        let modifiers = modifier::constant_modifier_definition_group(state, modifiers)?;
-
         return constant::classish_constant_definition(state, modifiers)
             .map(UnitEnumMemberDefinition::Constant)
             .map(Some);
@@ -210,8 +209,6 @@ fn backed_enum_definition_member(
     let modifiers = modifier::collect(state)?;
 
     if state.iterator.current().kind == TokenKind::Const {
-        let modifiers = modifier::constant_modifier_definition_group(state, modifiers)?;
-
         return constant::classish_constant_definition(state, modifiers)
             .map(BackedEnumMemberDefinition::Constant)
             .map(Some);
@@ -223,16 +220,11 @@ fn backed_enum_definition_member(
 
 fn concrete_method_definition(
     state: &mut State,
-    modifiers: Vec<(usize, TokenKind)>,
+    modifiers: ModifierGroupDefinition,
     enum_name: &Identifier,
 ) -> ParseResult<Option<ConcreteMethodDefinition>> {
-    let modifiers = modifier::enum_method_modifier_definition_group(state, modifiers)?;
-    let method = function::method_definition(
-        state,
-        function::MethodDefinitionType::Concrete,
-        modifiers,
-        Some(enum_name),
-    )?;
+    let method =
+        function::method_definition(state, function::MethodDefinitionType::Concrete, modifiers)?;
 
     match method {
         MethodDefinitionReference::ConcreteConstructor(constructor) => {

diff --git a/src/parser/internal/definition/function.rs b/src/parser/internal/definition/function.rs
@@ -15,13 +15,13 @@ use crate::tree::definition::function::FunctionDefinition;
 use crate::tree::definition::function::FunctionLikeReturnTypeDefinition;
 use crate::tree::definition::function::MethodTypeConstraintDefinition;
 use crate::tree::definition::function::MethodTypeConstraintGroupDefinition;
-use crate::tree::definition::modifier::MethodModifierDefinitionGroup;
-use crate::tree::identifier::Identifier;
+use crate::tree::definition::modifier::ModifierDefinition;
+use crate::tree::definition::modifier::ModifierGroupDefinition;
 
 pub enum MethodDefinitionType {
     Abstract,
     Concrete,
-    DependingOnModifiers,
+    Either,
 }
 
 pub enum MethodDefinitionReference {
@@ -57,8 +57,7 @@ pub fn function_definition(state: &mut State) -> ParseResult<FunctionDefinition>
 pub fn method_definition(
     state: &mut State,
     r#type: MethodDefinitionType,
-    modifiers: MethodModifierDefinitionGroup,
-    class: Option<&Identifier>,
+    modifiers: ModifierGroupDefinition,
 ) -> ParseResult<MethodDefinitionReference> {
     let comments = state.iterator.comments();
     let attributes = state.get_attributes();
@@ -68,12 +67,15 @@ pub fn method_definition(
     let has_body = match r#type {
         MethodDefinitionType::Abstract => false,
         MethodDefinitionType::Concrete => true,
-        MethodDefinitionType::DependingOnModifiers => !modifiers.has_abstract(),
+        MethodDefinitionType::Either => !modifiers
+            .modifiers
+            .iter()
+            .any(|modifier| matches!(modifier, ModifierDefinition::Abstract(_))),
     };
 
     if name.to_string().to_lowercase() == "__construct" {
         return if has_body {
-            let parameters = parameter::constructor_parameter_list_definition(state, class)?;
+            let parameters = parameter::constructor_parameter_list_definition(state)?;
 
             Ok(MethodDefinitionReference::ConcreteConstructor(
                 ConcreteConstructorDefinition {

diff --git a/src/parser/internal/definition/interface.rs b/src/parser/internal/definition/interface.rs
@@ -14,7 +14,6 @@ use crate::tree::definition::interface::InterfaceDefinition;
 use crate::tree::definition::interface::InterfaceDefinitionBody;
 use crate::tree::definition::interface::InterfaceDefinitionExtends;
 use crate::tree::definition::interface::InterfaceDefinitionMember;
-use crate::tree::identifier::Identifier;
 
 pub fn interface_definition(state: &mut State) -> ParseResult<InterfaceDefinition> {
     let comments = state.iterator.comments();
@@ -47,7 +46,7 @@ pub fn interface_definition(state: &mut State) -> ParseResult<InterfaceDefinitio
         members: {
             let mut members = Vec::new();
             while state.iterator.current().kind != TokenKind::RightBrace {
-                members.push(interface_definition_member(state, &name)?);
+                members.push(interface_definition_member(state)?);
             }
 
             members
@@ -66,27 +65,16 @@ pub fn interface_definition(state: &mut State) -> ParseResult<InterfaceDefinitio
     })
 }
 
-fn interface_definition_member(
-    state: &mut State,
-    interface_name: &Identifier,
-) -> ParseResult<InterfaceDefinitionMember> {
+fn interface_definition_member(state: &mut State) -> ParseResult<InterfaceDefinitionMember> {
     attribute::gather(state)?;
 
     let modifiers = modifier::collect(state)?;
 
     if state.iterator.current().kind == TokenKind::Const {
-        let modifiers = modifier::interface_constant_modifier_definition_group(state, modifiers)?;
         constant::classish_constant_definition(state, modifiers)
             .map(InterfaceDefinitionMember::Constant)
     } else {
-        let modifiers = modifier::interface_method_modifier_definition_group(state, modifiers)?;
-
-        let method = method_definition(
-            state,
-            MethodDefinitionType::Abstract,
-            modifiers,
-            Some(interface_name),
-        )?;
+        let method = method_definition(state, MethodDefinitionType::Abstract, modifiers)?;
 
         match method {
             MethodDefinitionReference::Abstract(method) => {