chore: merge all method definitions into one (#42)

ara-lang · Jan 20, 2023 · 9d5a763 · 9d5a763
1 parent 8dc8cd1
commit 9d5a763
Show file tree

Hide file tree

Showing 48 changed files with 2,384 additions and 2,618 deletions.
diff --git a/bin/snapshot.rs b/bin/snapshot.rs
@@ -1,7 +1,6 @@
 use std::env;
 use std::fs::read_dir;
 use std::io;
-use std::ops::Deref;
 use std::path::PathBuf;
 
 use ara_parser::parser;
@@ -56,7 +55,7 @@ fn main() -> io::Result<()> {
                     .with_colors(ColorChoice::Never);
 
                 let error = builder
-                    .as_string(report.deref())
+                    .as_string(report.as_ref())
                     .expect("failed to build the report");
 
                 std::fs::write(error_filename, error)?;

diff --git a/examples/linter.rs b/examples/linter.rs
@@ -1,5 +1,4 @@
 use std::env;
-use std::ops::Deref;
 
 use ara_parser::parser;
 use ara_parser::traverser::visitor::NodeVisitor;
@@ -75,7 +74,7 @@ fn main() -> Result<(), Error> {
             ReportBuilder::new(&source_map)
                 .with_charset(CharSet::Unicode)
                 .with_colors(ColorChoice::Always)
-                .print(report.deref())?;
+                .print(report.as_ref())?;
         }
     }
 

diff --git a/examples/parser.rs b/examples/parser.rs
@@ -1,5 +1,4 @@
 use std::env;
-use std::ops::Deref;
 
 use ara_parser::parser;
 use ara_reporting::builder::CharSet;
@@ -21,7 +20,7 @@ fn main() -> Result<(), Error> {
             ReportBuilder::new(&source_map)
                 .with_charset(CharSet::Unicode)
                 .with_colors(ColorChoice::Always)
-                .print(report.deref())?;
+                .print(report.as_ref())?;
         }
     }
 

diff --git a/src/lexer/byte_string.rs b/src/lexer/byte_string.rs
@@ -1,11 +1,11 @@
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-
 use std::ops::Deref;
 use std::ops::DerefMut;
 use std::str::from_utf8;
 
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde::Serialize;
+
 /// A wrapper for Vec<u8> that provides a human-readable Debug impl and
 /// a few other conveniences.
 ///

diff --git a/src/parser/internal/definition/attribute.rs b/src/parser/internal/definition/attribute.rs
@@ -6,7 +6,6 @@ use crate::parser::result::ParseResult;
 use crate::parser::state::State;
 use crate::tree::definition::attribute::AttributeDefinition;
 use crate::tree::definition::attribute::AttributeGroupDefinition;
-use crate::tree::expression::argument::ArgumentExpression;
 
 pub fn gather(state: &mut State) -> ParseResult<bool> {
     if state.iterator.current().kind != TokenKind::Attribute {
@@ -21,29 +20,7 @@ pub fn gather(state: &mut State) -> ParseResult<bool> {
                 Ok(AttributeDefinition {
                     name: identifier::fully_qualified_type_identifier_including_self(state)?,
                     arguments: if state.iterator.current().kind == TokenKind::LeftParen {
-                        let arguments = argument::argument_list_expression(state)?;
-
-                        for argument in &arguments.arguments.inner {
-                            match argument {
-                                ArgumentExpression::Value { value, .. }
-                                | ArgumentExpression::Named { value, .. } => {
-                                    if !value.is_constant(true) {
-                                        crate::parser_report!(
-                                            state,
-                                            invalid_constant_initialization_expression(value)
-                                        );
-                                    }
-                                }
-                                expression => {
-                                    crate::parser_report!(
-                                        state,
-                                        invalid_constant_initialization_expression(expression)
-                                    );
-                                }
-                            }
-                        }
-
-                        Some(arguments)
+                        Some(argument::argument_list_expression(state)?)
                     } else {
                         None
                     },

diff --git a/src/parser/internal/definition/class.rs b/src/parser/internal/definition/class.rs
@@ -2,8 +2,6 @@ use crate::lexer::token::TokenKind;
 use crate::parser::internal::definition::attribute;
 use crate::parser::internal::definition::constant::classish_constant_definition;
 use crate::parser::internal::definition::function::method_definition;
-use crate::parser::internal::definition::function::MethodDefinitionReference;
-use crate::parser::internal::definition::function::MethodDefinitionType;
 use crate::parser::internal::definition::modifier;
 use crate::parser::internal::definition::property;
 use crate::parser::internal::definition::template;
@@ -83,7 +81,7 @@ pub fn class_definition(state: &mut State) -> ParseResult<ClassDefinition> {
     })
 }
 
-fn class_definition_member(state: &mut State) -> ParseResult<ClassDefinitionMember> {
+pub fn class_definition_member(state: &mut State) -> ParseResult<ClassDefinitionMember> {
     attribute::gather(state)?;
 
     let modifiers = modifier::collect(state)?;
@@ -93,22 +91,7 @@ fn class_definition_member(state: &mut State) -> ParseResult<ClassDefinitionMemb
     }
 
     if state.iterator.current().kind == TokenKind::Function {
-        let method = method_definition(state, MethodDefinitionType::Either, modifiers)?;
-
-        return match method {
-            MethodDefinitionReference::Abstract(method) => {
-                Ok(ClassDefinitionMember::AbstractMethod(method))
-            }
-            MethodDefinitionReference::Concrete(method) => {
-                Ok(ClassDefinitionMember::ConcreteMethod(method))
-            }
-            MethodDefinitionReference::AbstractConstructor(ctor) => {
-                Ok(ClassDefinitionMember::AbstractConstructor(ctor))
-            }
-            MethodDefinitionReference::ConcreteConstructor(ctor) => {
-                Ok(ClassDefinitionMember::ConcreteConstructor(ctor))
-            }
-        };
+        return method_definition(state, modifiers).map(ClassDefinitionMember::Method);
     }
 
     property::property_definition(state, modifiers).map(ClassDefinitionMember::Property)

diff --git a/src/parser/internal/definition/enum.rs b/src/parser/internal/definition/enum.rs
@@ -2,15 +2,12 @@ use crate::lexer::token::TokenKind;
 use crate::parser::internal::definition::attribute;
 use crate::parser::internal::definition::constant;
 use crate::parser::internal::definition::function;
-use crate::parser::internal::definition::function::MethodDefinitionReference;
 use crate::parser::internal::definition::modifier;
 use crate::parser::internal::expression;
 use crate::parser::internal::identifier;
 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;
@@ -164,8 +161,9 @@ fn unit_enum_definition_member(
             .map(Some);
     }
 
-    concrete_method_definition(state, modifiers, enum_name)
-        .map(|method| method.map(UnitEnumMemberDefinition::Method))
+    Ok(Some(UnitEnumMemberDefinition::Method(
+        function::method_definition(state, modifiers)?,
+    )))
 }
 
 fn backed_enum_definition_member(
@@ -214,42 +212,7 @@ fn backed_enum_definition_member(
             .map(Some);
     }
 
-    concrete_method_definition(state, modifiers, enum_name)
-        .map(|method| method.map(BackedEnumMemberDefinition::Method))
-}
-
-fn concrete_method_definition(
-    state: &mut State,
-    modifiers: ModifierGroupDefinition,
-    enum_name: &Identifier,
-) -> ParseResult<Option<ConcreteMethodDefinition>> {
-    let method =
-        function::method_definition(state, function::MethodDefinitionType::Concrete, modifiers)?;
-
-    match method {
-        MethodDefinitionReference::ConcreteConstructor(constructor) => {
-            crate::parser_report!(state, enum_cannot_have_constructor(enum_name, &constructor));
-
-            Ok(None)
-        }
-        MethodDefinitionReference::Concrete(method) => {
-            match method.name.value[..].to_ascii_lowercase().as_slice() {
-                b"__get" | b"__set" | b"__serialize" | b"__unserialize" | b"__destruct"
-                | b"__wakeup" | b"__sleep" | b"__set_state" | b"__unset" | b"__isset"
-                | b"__debuginfo" | b"__clone" | b"__tostring" => {
-                    crate::parser_report!(state, enum_cannot_have_magic_method(enum_name, &method));
-                }
-                _ => {}
-            }
-
-            Ok(Some(method))
-        }
-        MethodDefinitionReference::Abstract(_)
-        | MethodDefinitionReference::AbstractConstructor(_) => {
-            crate::parser_bail!(
-                state,
-                unreachable_code("unexpected abstract method in enum definition")
-            )
-        }
-    }
+    Ok(Some(BackedEnumMemberDefinition::Method(
+        function::method_definition(state, modifiers)?,
+    )))
 }