fix multiple parse errors, and error for magic methods on enums (#206)

Signed-off-by: azjezz <azjezz@protonmail.com>

Author: azjezz

src/parser/error.rs

@@ -53,6 +53,7 @@ pub enum ParseError {
  CannotUseReservedKeywordAsATypeName(String, Span),
  CannotUseReservedKeywordAsAGoToLabel(String, Span),
  CannotUseReservedKeywordAsAConstantName(String, Span),
+ EnumMayNotIncludesMagicMethod(String, String, Span),
 }
 
 impl From<SyntaxError> for ParseError {
@@ -134,6 +135,7 @@ impl Display for ParseError {
  Self::CannotUseReservedKeywordAsATypeName(ty, span) => write!(f, "Parse Error: cannot use `{}` as a type name as it is reserved on line {} column {}", ty, span.0, span.1),
  Self::CannotUseReservedKeywordAsAGoToLabel(ty, span) => write!(f, "Parse Error: cannot use `{}` as a goto label as it is reserved on line {} column {}", ty, span.0, span.1),
  Self::CannotUseReservedKeywordAsAConstantName(ty, span) => write!(f, "Parse Error: cannot use `{}` as a constant name as it is reserved on line {} column {}", ty, span.0, span.1),
+ Self::EnumMayNotIncludesMagicMethod(ty, method, span) => write!(f, "Parse Error: Enum `{}` may not include magic method `{}` on line {} column {}", ty, method, span.0, span.1),
  }
  }
 }

src/parser/expressions.rs

@@ -504,7 +504,7 @@ macro_rules! expressions {
  ($(#[before($else:ident), current($(|)? $( $current:pat_param )|+) $(, peek($(|)? $( $peek:pat_param )|+))?] $expr:ident($out:expr))+) => {
  $(
  #[inline(never)]
- fn $expr(state: &mut State) -> ParseResult<Expression> {
+ pub(in crate::parser) fn $expr(state: &mut State) -> ParseResult<Expression> {
  state.skip_comments();
 
  match &state.current.kind {
@@ -587,7 +587,7 @@ expressions! {
 
  #[before(throw), current(TokenKind::New), peek(TokenKind::Class | TokenKind::Attribute)]
  anonymous_class(|state: &mut State| {
- classes::parse_anonymous(state)
+ classes::parse_anonymous(state, None)
  })
 
  #[before(r#yield), current(TokenKind::Throw)]
@@ -802,6 +802,11 @@ expressions! {
  let span = state.current.span;
 
  state.next();
+ state.skip_comments();
+
+ if state.current.kind == TokenKind::Class || state.current.kind == TokenKind::Attribute {
+ return classes::parse_anonymous(state, Some(span));
+ };
 
  let target = match state.current.kind {
  TokenKind::Self_ => {

src/parser/internal/classes.rs

@@ -1,3 +1,4 @@
+use crate::lexer::token::Span;
 use crate::lexer::token::TokenKind;
 use crate::parser::ast::classes::AnonymousClass;
 use crate::parser::ast::classes::Class;
@@ -91,8 +92,11 @@ pub fn parse(state: &mut State) -> ParseResult<Statement> {
  }))
 }
 
-pub fn parse_anonymous(state: &mut State) -> ParseResult<Expression> {
- let span = utils::skip(state, TokenKind::New)?;
+pub fn parse_anonymous(state: &mut State, span: Option<Span>) -> ParseResult<Expression> {
+ let span = match span {
+ Some(span) => span,
+ None => utils::skip(state, TokenKind::New)?,
+ };
 
  attributes::gather_attributes(state)?;
 

src/parser/internal/enums.rs

@@ -1,3 +1,4 @@
+use crate::lexer::token::Span;
 use crate::lexer::token::TokenKind;
 use crate::parser::ast::enums::BackedEnum;
 use crate::parser::ast::enums::BackedEnumCase;
@@ -6,6 +7,7 @@ use crate::parser::ast::enums::BackedEnumType;
 use crate::parser::ast::enums::UnitEnum;
 use crate::parser::ast::enums::UnitEnumCase;
 use crate::parser::ast::enums::UnitEnumMember;
+use crate::parser::ast::functions::Method;
 use crate::parser::ast::Statement;
 use crate::parser::error::ParseError;
 use crate::parser::error::ParseResult;
@@ -138,7 +140,7 @@ fn unit_member(state: &mut State, enum_name: String) -> ParseResult<UnitEnumMemb
  .map(UnitEnumMember::Constant);
  }
 
- functions::method(state, modifiers::enum_method_group(modifiers)?).map(UnitEnumMember::Method)
+ method(state, modifiers, enum_name).map(UnitEnumMember::Method)
 }
 
 fn backed_member(state: &mut State, enum_name: String) -> ParseResult<BackedEnumMember> {
@@ -182,5 +184,27 @@ fn backed_member(state: &mut State, enum_name: String) -> ParseResult<BackedEnum
  .map(BackedEnumMember::Constant);
  }
 
- functions::method(state, modifiers::enum_method_group(modifiers)?).map(BackedEnumMember::Method)
+ method(state, modifiers, enum_name).map(BackedEnumMember::Method)
+}
+
+fn method(
+ state: &mut State,
+ modifiers: Vec<(Span, TokenKind, Span)>,
+ enum_name: String,
+) -> ParseResult<Method> {
+ let method = functions::method(state, modifiers::enum_method_group(modifiers)?)?;
+
+ match method.name.name[..].to_ascii_lowercase().as_slice() {
+ b"__get" | b"__set" | b"__call" | b"__callstatic" | b"__invoke" | b"__serialize"
+ | b"__unserialize" | b"__destruct" | b"__wakeup" | b"__sleep" => {
+ return Err(ParseError::EnumMayNotIncludesMagicMethod(
+ state.named(&enum_name),
+ method.name.to_string(),
+ method.name.span,
+ ))
+ }
+ _ => {}
+ }
+
+ Ok(method)
 }

src/parser/internal/parameters.rs

@@ -68,9 +68,9 @@ pub fn function_parameter_list(state: &mut State) -> Result<FunctionParameterLis
  });
 
  state.skip_comments();
-
  if state.current.kind == TokenKind::Comma {
  state.next();
+ state.skip_comments();
  } else {
  break;
  }
@@ -219,9 +219,9 @@ pub fn method_parameter_list(state: &mut State) -> Result<MethodParameterList, P
  });
 
  state.skip_comments();
-
  if state.current.kind == TokenKind::Comma {
  state.next();
+ state.skip_comments();
  } else {
  break;
  }

src/parser/internal/uses.rs

@@ -9,14 +9,19 @@ use crate::parser::state::State;
 
 pub fn use_statement(state: &mut State) -> ParseResult<Statement> {
  state.next();
+ state.skip_comments();
 
  let kind = match state.current.kind {
  TokenKind::Function => {
  state.next();
+
+ state.skip_comments();
  UseKind::Function
  }
  TokenKind::Const => {
  state.next();
+
+ state.skip_comments();
  UseKind::Const
  }
  _ => UseKind::Normal,
@@ -25,21 +30,26 @@ pub fn use_statement(state: &mut State) -> ParseResult<Statement> {
  if state.peek.kind == TokenKind::LeftBrace {
  let prefix = identifiers::full_name(state)?;
  state.next();
+ state.skip_comments();
 
  let mut uses = Vec::new();
  while state.current.kind != TokenKind::RightBrace {
- let name = identifiers::full_name(state)?;
+ let name = identifiers::full_type_name(state)?;
  let mut alias = None;
+ state.skip_comments();
 
  if state.current.kind == TokenKind::As {
  state.next();
- alias = Some(identifiers::identifier(state)?);
+ alias = Some(identifiers::type_identifier(state)?);
+ state.skip_comments();
  }
 
  uses.push(Use { name, alias });
 
+ state.skip_comments();
  if state.current.kind == TokenKind::Comma {
  state.next();
+ state.skip_comments();
  continue;
  }
  }
@@ -51,12 +61,14 @@ pub fn use_statement(state: &mut State) -> ParseResult<Statement> {
  } else {
  let mut uses = Vec::new();
  while !state.is_eof() {
- let name = identifiers::full_name(state)?;
+ let name = identifiers::full_type_name(state)?;
  let mut alias = None;
+ state.skip_comments();
 
  if state.current.kind == TokenKind::As {
  state.next();
- alias = Some(identifiers::identifier(state)?);
+ alias = Some(identifiers::type_identifier(state)?);
+ state.skip_comments();
  }
 
  uses.push(Use { name, alias });
@@ -66,6 +78,7 @@ pub fn use_statement(state: &mut State) -> ParseResult<Statement> {
  continue;
  }
 
+ state.skip_comments();
  utils::skip_semicolon(state)?;
  break;
  }

src/parser/mod.rs

@@ -5,7 +5,6 @@ use crate::parser::ast::comments::Comment;
 use crate::parser::ast::comments::CommentFormat;
 use crate::parser::ast::variables::Variable;
 use crate::parser::ast::{DeclareItem, Expression, Program, Statement, StaticVar};
-use crate::parser::error::ParseError;
 use crate::parser::error::ParseResult;
 use crate::parser::internal::attributes;
 use crate::parser::internal::blocks;
@@ -151,13 +150,9 @@ fn statement(state: &mut State) -> ParseResult<Statement> {
  functions::function(state)?
  }
  }
- _ => {
- // Note, we can get attributes and know their span, maybe use that in the
- // error in the future?
- return Err(ParseError::ExpectedItemDefinitionAfterAttributes(
- state.current.span,
- ));
- }
+ _ => Statement::Expression {
+ expr: expressions::attributes(state)?,
+ },
  }
  } else {
  match &state.current.kind {

tests/fixtures/0297-enum-serialize/code.php

@@ -0,0 +1,5 @@
+<?php
+
+enum EnumWithSerialize {
+ public function __serialize() {}
+}

tests/fixtures/0297-enum-serialize/parser-error.txt

@@ -0,0 +1 @@
+EnumMayNotIncludesMagicMethod("EnumWithSerialize", "__serialize", (4, 21)) -> Parse Error: Enum `EnumWithSerialize` may not include magic method `__serialize` on line 4 column 21

tests/fixtures/0298-enum-unserialize/code.php

@@ -0,0 +1,5 @@
+<?php
+
+enum EnumWithUnserialize {
+ public function __unserialize(array $data) {}
+}