chore: make the parser more lenient with errors

src/parser/internal/definition/class.rs

@@ -59,14 +59,12 @@ pub fn class_definition(state: &mut State) -> ParseResult<ClassDefinition> {
         None
     };
 
-    let has_abstract = modifiers.has_abstract();
-
     let 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, has_abstract, &name)?);
+                members.push(class_definition_member(state, &name)?);
             }
 
             members
@@ -89,7 +87,6 @@ pub fn class_definition(state: &mut State) -> ParseResult<ClassDefinition> {
 
 fn class_definition_member(
     state: &mut State,
-    has_abstract: bool,
     name: &Identifier,
 ) -> ParseResult<ClassDefinitionMember> {
     attribute::gather(state)?;
@@ -113,26 +110,12 @@ fn class_definition_member(
 
         return match method {
             MethodDefinitionReference::Abstract(method) => {
-                if !has_abstract {
-                    crate::parser_report!(
-                        state,
-                        cannot_declare_abstract_method_on_non_abstract_class(name, &method),
-                    );
-                }
-
                 Ok(ClassDefinitionMember::AbstractMethod(method))
             }
             MethodDefinitionReference::Concrete(method) => {
                 Ok(ClassDefinitionMember::ConcreteMethod(method))
             }
             MethodDefinitionReference::AbstractConstructor(ctor) => {
-                if !has_abstract {
-                    crate::parser_report!(
-                        state,
-                        cannot_declare_abstract_ctor_on_non_abstract_class(name, &ctor),
-                    );
-                }
-
                 Ok(ClassDefinitionMember::AbstractConstructor(ctor))
             }
             MethodDefinitionReference::ConcreteConstructor(ctor) => {
@@ -144,5 +127,5 @@ fn class_definition_member(
     // e.g: public static
     let modifiers = modifier::property_modifier_definition_group(state, modifiers)?;
 
-    property::property_definition(state, Some(name), modifiers).map(ClassDefinitionMember::Property)
+    property::property_definition(state, modifiers).map(ClassDefinitionMember::Property)
 }

src/parser/internal/definition/modifier.rs

@@ -51,13 +51,6 @@ pub fn class_modifier_definition_group(
         }
     }
 
-    if let (Some(abstract_modifier), Some(final_modifier)) = (&abstract_modifier, &final_modifier) {
-        crate::parser_report!(
-            state,
-            final_class_cannot_be_abstract(final_modifier, abstract_modifier)
-        );
-    }
-
     Ok(ClassModifierDefinitionGroup { modifiers })
 }
 
@@ -109,13 +102,6 @@ pub fn method_modifier_definition_group(
         }
     }
 
-    if let (Some(abstract_modifier), Some(final_modifier)) = (&abstract_modifier, &final_modifier) {
-        crate::parser_report!(
-            state,
-            final_class_member_cannot_be_abstract(final_modifier, abstract_modifier)
-        );
-    }
-
     Ok(MethodModifierDefinitionGroup { modifiers })
 }
 

src/parser/internal/definition/parameter.rs

@@ -38,13 +38,6 @@ pub fn function_like_parameter_list_definition(
             // 2. Then expect a variable.
             let variable = variable::parse(state)?;
 
-            if type_definition.is_bottom() {
-                crate::parser_report!(
-                    state,
-                    bottom_type_cannot_be_used_for_parameter(&type_definition, &variable)
-                );
-            }
-
             let current = state.iterator.current();
             let default = if current.kind == TokenKind::Equals {
                 state.iterator.next();
@@ -118,13 +111,6 @@ pub fn constructor_parameter_list_definition(
                 (None, variable::parse(state)?)
             };
 
-            if type_definition.is_bottom() {
-                crate::parser_report!(
-                    state,
-                    bottom_type_cannot_be_used_for_parameter(&type_definition, &variable)
-                );
-            }
-
             let current = state.iterator.current();
             let default = if current.kind == TokenKind::Equals {
                 state.iterator.next();

src/parser/internal/definition/property.rs

@@ -8,35 +8,19 @@ use crate::parser::state::State;
 use crate::tree::definition::modifier::PropertyModifierDefinitionGroup;
 use crate::tree::definition::property::PropertyDefinition;
 use crate::tree::definition::property::PropertyEntryDefinition;
-use crate::tree::identifier::Identifier;
 
 pub fn property_definition(
     state: &mut State,
-    class_name: Option<&Identifier>,
     modifiers: PropertyModifierDefinitionGroup,
 ) -> ParseResult<PropertyDefinition> {
     let type_definition = r#type::type_definition(state)?;
     let variable = variable::parse(state)?;
 
-    if type_definition.is_bottom() {
-        crate::parser_report!(
-            state,
-            bottom_type_cannot_be_used_for_property(class_name, &type_definition, &variable)
-        );
-    }
-
-    if let (Some(readonly), Some(r#static)) = (modifiers.get_readonly(), modifiers.get_static()) {
-        crate::parser_report!(
-            state,
-            readonly_property_cannot_be_static(class_name, &variable, readonly, r#static)
-        );
-    }
-
     let attributes = state.get_attributes();
     let current = state.iterator.current();
 
     let entry = if current.kind == TokenKind::Equals {
-        let entry = PropertyEntryDefinition::Initialized {
+        PropertyEntryDefinition::Initialized {
             variable,
             equals: utils::skip(state, TokenKind::Equals)?,
             value: {
@@ -55,16 +39,7 @@ pub fn property_definition(
 
                 expression
             },
-        };
-
-        if let Some(modifier) = modifiers.get_readonly() {
-            crate::parser_report!(
-                state,
-                readonly_property_cannot_have_default_value(class_name, &entry, modifier,)
-            );
         }
-
-        entry
     } else {
         PropertyEntryDefinition::Uninitialized { variable }
     };