chore: extract some common logics on class definition

src/parser/internal/definition/class.rs

@@ -28,34 +28,70 @@ pub fn class_definition(state: &mut State) -> ParseResult<ClassDefinition> {
         None
     };
 
+    Ok(ClassDefinition {
+        comments,
+        class,
+        name,
+        templates,
+        modifiers,
+        extends: class_definition_extends(state)?,
+        implements: class_definition_implements(state)?,
+        attributes,
+        body: class_definition_body(state)?,
+    })
+}
+
+pub fn class_definition_member(state: &mut State) -> ParseResult<ClassDefinitionMember> {
+    attribute::gather(state)?;
+
+    let modifiers = modifier::collect(state)?;
+
+    if state.iterator.current().kind == TokenKind::Const {
+        return classish_constant_definition(state, modifiers).map(ClassDefinitionMember::Constant);
+    }
+
+    if state.iterator.current().kind == TokenKind::Function {
+        return method_definition(state, modifiers).map(ClassDefinitionMember::Method);
+    }
+
+    property::property_definition(state, modifiers).map(ClassDefinitionMember::Property)
+}
+
+pub fn class_definition_extends(state: &mut State) -> ParseResult<Option<ClassDefinitionExtends>> {
     let current = state.iterator.current();
-    let extends = if current.kind == TokenKind::Extends {
+    if current.kind == TokenKind::Extends {
         let extends = utils::skip_keyword(state, TokenKind::Extends)?;
         let parent = identifier::fully_qualified_templated_identifier(state)?;
 
-        Some(ClassDefinitionExtends { extends, parent })
+        Ok(Some(ClassDefinitionExtends { extends, parent }))
     } else {
-        None
-    };
+        Ok(None)
+    }
+}
 
+pub fn class_definition_implements(
+    state: &mut State,
+) -> ParseResult<Option<ClassDefinitionImplements>> {
     let current = state.iterator.current();
-    let implements = if current.kind == TokenKind::Implements {
+    if current.kind == TokenKind::Implements {
         let implements = utils::skip_keyword(state, TokenKind::Implements)?;
         let interfaces = utils::at_least_one_comma_separated(
             state,
             &identifier::fully_qualified_templated_identifier,
             TokenKind::LeftBrace,
         )?;
 
-        Some(ClassDefinitionImplements {
+        Ok(Some(ClassDefinitionImplements {
             implements,
             interfaces,
-        })
+        }))
     } else {
-        None
-    };
+        Ok(None)
+    }
+}
 
-    let body = ClassDefinitionBody {
+pub fn class_definition_body(state: &mut State) -> ParseResult<ClassDefinitionBody> {
+    Ok(ClassDefinitionBody {
         left_brace: utils::skip_left_brace(state)?,
         members: {
             let mut members = Vec::new();
@@ -66,33 +102,5 @@ pub fn class_definition(state: &mut State) -> ParseResult<ClassDefinition> {
             members
         },
         right_brace: utils::skip_right_brace(state)?,
-    };
-
-    Ok(ClassDefinition {
-        comments,
-        class,
-        name,
-        templates,
-        modifiers,
-        extends,
-        implements,
-        attributes,
-        body,
     })
 }
-
-pub fn class_definition_member(state: &mut State) -> ParseResult<ClassDefinitionMember> {
-    attribute::gather(state)?;
-
-    let modifiers = modifier::collect(state)?;
-
-    if state.iterator.current().kind == TokenKind::Const {
-        return classish_constant_definition(state, modifiers).map(ClassDefinitionMember::Constant);
-    }
-
-    if state.iterator.current().kind == TokenKind::Function {
-        return method_definition(state, modifiers).map(ClassDefinitionMember::Method);
-    }
-
-    property::property_definition(state, modifiers).map(ClassDefinitionMember::Property)
-}

src/parser/internal/expression/class.rs

@@ -1,14 +1,10 @@
 use crate::lexer::token::TokenKind;
 use crate::parser::internal::definition::attribute;
-use crate::parser::internal::definition::class::class_definition_member;
+use crate::parser::internal::definition::class;
 use crate::parser::internal::expression::argument;
-use crate::parser::internal::identifier;
 use crate::parser::internal::utils;
 use crate::parser::result::ParseResult;
 use crate::parser::state::State;
-use crate::tree::definition::class::ClassDefinitionBody;
-use crate::tree::definition::class::ClassDefinitionExtends;
-use crate::tree::definition::class::ClassDefinitionImplements;
 use crate::tree::expression::class::AnonymousClassExpression;
 use crate::tree::expression::operator::ClassOperationExpression;
 
@@ -29,51 +25,14 @@ pub fn anonymous_class_expression(state: &mut State) -> ParseResult<AnonymousCla
     let class = utils::skip_keyword(state, TokenKind::Class)?;
     let comments = state.iterator.comments();
     let arguments = argument::argument_list_expression(state)?;
-    let current = state.iterator.current();
-    let extends = if current.kind == TokenKind::Extends {
-        let extends = utils::skip_keyword(state, TokenKind::Extends)?;
-        let parent = identifier::fully_qualified_templated_identifier(state)?;
-
-        Some(ClassDefinitionExtends { extends, parent })
-    } else {
-        None
-    };
-
-    let current = state.iterator.current();
-    let implements = if current.kind == TokenKind::Implements {
-        let implements = utils::skip_keyword(state, TokenKind::Implements)?;
-        let interfaces = utils::at_least_one_comma_separated(
-            state,
-            &identifier::fully_qualified_templated_identifier,
-            TokenKind::LeftBrace,
-        )?;
-
-        Some(ClassDefinitionImplements {
-            implements,
-            interfaces,
-        })
-    } else {
-        None
-    };
 
     Ok(AnonymousClassExpression {
         comments,
         attributes,
         class,
         arguments,
-        extends,
-        implements,
-        body: ClassDefinitionBody {
-            left_brace: utils::skip_left_brace(state)?,
-            members: {
-                let mut members = Vec::new();
-                while state.iterator.current().kind != TokenKind::RightBrace {
-                    members.push(class_definition_member(state)?);
-                }
-
-                members
-            },
-            right_brace: utils::skip_right_brace(state)?,
-        },
+        extends: class::class_definition_extends(state)?,
+        implements: class::class_definition_implements(state)?,
+        body: class::class_definition_body(state)?,
     })
 }