chore: improve properties parser (#6)

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

Author: azjezz

src/lexer/token.rs

@@ -282,7 +282,7 @@ impl Display for TokenKind {
  Self::EndSwitch => "endswitch",
  Self::EndWhile => "endwhile",
  Self::Enum => "enum",
- Self::Eof => "",
+ Self::Eof => "[end of file]",
  Self::Equals => "=",
  Self::Extends => "extends",
  Self::False => "false",
@@ -382,8 +382,10 @@ impl Display for TokenKind {
  Self::Interface => "interface",
  Self::NamespaceConstant => "__NAMESPACE__",
  Self::PowEquals => "**=",
+ Self::Variable(v) => {
+ return write!(f, "${}", v);
+ }
  Self::StringPart(v)
- | Self::Variable(v)
  | Self::QualifiedIdentifier(v)
  | Self::Identifier(v)
  | Self::FullyQualifiedIdentifier(v)

src/parser/ast.rs

@@ -32,12 +32,39 @@ pub enum Type {
  Mixed,
  Callable,
  Iterable,
+ StaticReference,
+ SelfReference,
+ ParentReference,
 }
 
 impl Type {
  pub fn standalone(&self) -> bool {
  matches!(self, Type::Mixed | Type::Never | Type::Void)
  }
+
+ pub fn nullable(&self) -> bool {
+ matches!(self, Type::Nullable(_))
+ }
+
+ pub fn includes_callable(&self) -> bool {
+ match &self {
+ Self::Callable => true,
+ Self::Union(types) | Self::Intersection(types) => {
+ types.iter().any(|x| x.includes_callable())
+ }
+ _ => false,
+ }
+ }
+
+ pub fn includes_class_scoped(&self) -> bool {
+ match &self {
+ Self::StaticReference | Self::SelfReference | Self::ParentReference => true,
+ Self::Union(types) | Self::Intersection(types) => {
+ types.iter().any(|x| x.includes_class_scoped())
+ }
+ _ => false,
+ }
+ }
 }
 
 impl Display for Type {
@@ -77,6 +104,9 @@ impl Display for Type {
  Type::Mixed => write!(f, "mixed"),
  Type::Callable => write!(f, "callable"),
  Type::Iterable => write!(f, "iterable"),
+ Type::StaticReference => write!(f, "static"),
+ Type::SelfReference => write!(f, "self"),
+ Type::ParentReference => write!(f, "parent"),
  }
  }
 }

src/parser/error.rs

@@ -15,6 +15,7 @@ pub enum ParseError {
  StandaloneTypeUsedInCombination(Type, Span),
  TryWithoutCatchOrFinally(Span),
  VariadicPromotedProperty(Span),
+ MissingTypeForReadonlyProperty(String, String, Span),
  PromotedPropertyOutsideConstructor(Span),
  PromotedPropertyOnAbstractConstructor(Span),
  AbstractModifierOnNonAbstractClassMethod(Span),
@@ -27,6 +28,8 @@ pub enum ParseError {
  FinalModifierOnPrivateConstant(Span),
  FinalModifierOnAbstractClass(Span),
  UnpredictableState(Span),
+ StaticPropertyUsingReadonlyModifier(String, String, Span),
+ ReadonlyPropertyHasDefaultValue(String, String, Span),
 }
 
 impl Display for ParseError {
@@ -47,11 +50,12 @@ impl Display for ParseError {
  None => write!(f, "Parse Error: unexpected end of file, expecting {} on line {} column {}", expected, span.0, span.1),
  }
  },
+ Self::MissingTypeForReadonlyProperty(class, prop, span) => write!(f, "Parse Error: Readonly property {}::${} must have type on line {} column {}", class, prop, span.0, span.1),
  Self::MultipleModifiers(modifier, span) => write!(f, "Parse Error: Multiple {} modifiers are not allowed on line {} column {}", modifier, span.0, span.1),
  Self::MultipleAccessModifiers( span) => write!(f, "Parse Error: Multiple access type modifiers are not allowed on line {} column {}", span.0, span.1),
  Self::UnexpectedToken(message, span) => write!(f, "Parse Error: Unexpected token {} on line {} column {}", message, span.0, span.1),
  Self::UnexpectedEndOfFile => write!(f, "Parse Error: unexpected end of file."),
- Self::FinalModifierOnAbstractClassMember(span) => write!(f, "Parse Error: Cannot use the final modifier on an abstract class member on line {} column {}", span.0, span.1),
+ Self::FinalModifierOnAbstractClassMember(span) => write!(f, "Parse Error: Cannot use 'final' as an abstract class member modifier on line {} column {}", span.0, span.1),
  Self::StaticModifierOnConstant(span) => write!(f, "Parse Error: Cannot use 'static' as constant modifier on line {} column {}", span.0, span.1),
  Self::ReadonlyModifierOnConstant(span) => write!(f, "Parse Error: Cannot use 'readonly' as constant modifier on line {} column {}", span.0, span.1),
  Self::FinalModifierOnPrivateConstant(span) => write!(f, "Parse Error: Private constant cannot be final as it is not visible to other classes on line {} column {}", span.0, span.1),
@@ -65,7 +69,9 @@ impl Display for ParseError {
  Self::ConstructorInEnum(name, span) => write!(f, "Parse Error: Enum '{}' cannot have a constructor on line {} column {}", name, span.0, span.1),
  Self::MissingCaseValueForBackedEnum(case, name, span) => write!(f, "Parse Error: Case `{}` of backed enum `{}` must have a value on line {} column {}", case, name, span.0, span.1),
  Self::CaseValueForUnitEnum(case, name, span) => write!(f, "Parse Error: Case `{}` of unit enum `{}` must not have a value on line {} column {}", case, name, span.0, span.1),
- Self::UnpredictableState(span) => write!(f, "Parse Error: Reached an unpredictable state on line {} column {}", span.0, span.1)
+ Self::UnpredictableState(span) => write!(f, "Parse Error: Reached an unpredictable state on line {} column {}", span.0, span.1),
+ Self::StaticPropertyUsingReadonlyModifier(class, prop, span) => write!(f, "Parse Error: Static property {}:${} cannot be readonly on line {} column {}", class, prop, span.0, span.1),
+ Self::ReadonlyPropertyHasDefaultValue(class, prop, span) => write!(f, "Parse Error: Readonly property {}:${} cannot have a default value on line {} column {}", class, prop, span.0, span.1),
  }
  }
 }

src/parser/internal/classish_statement.rs

@@ -2,6 +2,7 @@ use crate::expected_scope;
 use crate::lexer::token::TokenKind;
 use crate::parser::ast::Identifier;
 use crate::parser::ast::MethodFlag;
+use crate::parser::ast::PropertyFlag;
 use crate::parser::ast::Statement;
 use crate::parser::ast::TraitAdaptation;
 use crate::parser::error::ParseError;
@@ -12,7 +13,6 @@ use crate::parser::state::State;
 use crate::parser::Parser;
 
 use crate::expect_token;
-use crate::expected_token_err;
 use crate::peek_token;
 
 impl Parser {
@@ -123,15 +123,22 @@ impl Parser {
 
  let member_flags = self.class_members_flags(state)?;
 
- match &state.current.kind {
- TokenKind::Const => self.parse_classish_const(state, member_flags),
- TokenKind::Function => self.method(
+ if state.current.kind == TokenKind::Const {
+ return self.parse_classish_const(state, member_flags);
+ }
+
+ if state.current.kind == TokenKind::Function {
+ return self.method(
  state,
  member_flags.iter().map(|t| t.clone().into()).collect(),
- ),
- // TODO
- TokenKind::Variable(_) => {
- let var = self.var(state)?;
+ );
+ }
+
+ let ty = self.get_optional_type(state)?;
+
+ expect_token!([
+ TokenKind::Variable(var) => {
+ let flags: Vec<PropertyFlag> = member_flags.into_iter().map(|f| f.into()).collect();
  let mut value = None;
 
  if state.current.kind == TokenKind::Equals {
@@ -141,56 +148,42 @@ impl Parser {
 
  self.semi(state)?;
 
- Ok(Statement::Property {
- var,
- value,
- r#type: None,
- flags: member_flags.into_iter().map(|f| f.into()).collect(),
- })
- }
- TokenKind::Question
- | TokenKind::Identifier(_)
- | TokenKind::QualifiedIdentifier(_)
- | TokenKind::FullyQualifiedIdentifier(_)
- | TokenKind::Array
- | TokenKind::Null => {
- let prop_type = self.type_string(state)?;
- let var = self.var(state)?;
- let mut value = None;
+ if flags.contains(&PropertyFlag::Readonly) {
+ if flags.contains(&PropertyFlag::Static) {
+ let class_name: String = expected_scope!([
+ Scope::Class(name, _) => state.named(&name),
+ Scope::Trait(name) => state.named(&name),
+ Scope::AnonymousClass => state.named(&"class@anonymous".into()),
+ ], state);
 
- if state.current.kind == TokenKind::Equals {
- state.next();
- value = Some(self.expression(state, Precedence::Lowest)?);
- }
+ return Err(ParseError::StaticPropertyUsingReadonlyModifier(class_name, var.to_string(), state.current.span));
+ }
 
- // TODO: Support comma-separated property declarations.
- // nikic/php-parser does this with a single Property statement
- // that is capable of holding multiple property declarations.
- self.semi(state)?;
+ if value.is_some() {
+ let class_name: String = expected_scope!([
+ Scope::Class(name, _) => state.named(&name),
+ Scope::Trait(name) => state.named(&name),
+ Scope::AnonymousClass => state.named(&"class@anonymous".into()),
+ ], state);
+
+ return Err(ParseError::ReadonlyPropertyHasDefaultValue(class_name, var.to_string(), state.current.span));
+ }
+ }
 
  Ok(Statement::Property {
  var,
  value,
- r#type: Some(prop_type),
- flags: member_flags.into_iter().map(|f| f.into()).collect(),
+ r#type: ty,
+ flags,
  })
  }
- _ => expected_token_err!(
- ["`const`", "`function`", "an identifier", "a varaible"],
- state
- ),
- }
+ ], state, ["a varaible"])
  }
 
  fn parse_classish_var(&self, state: &mut State) -> ParseResult<Statement> {
  state.next();
 
- let mut var_type = None;
-
- if !matches!(state.current.kind, TokenKind::Variable(_)) {
- var_type = Some(self.type_string(state)?);
- }
-
+ let ty = self.get_optional_type(state)?;
  let var = self.var(state)?;
  let mut value = None;
 
@@ -205,7 +198,7 @@ impl Parser {
  Ok(Statement::Var {
  var,
  value,
- r#type: var_type,
+ r#type: ty,
  })
  }
 
@@ -238,10 +231,8 @@ impl Parser {
  _ => (None, self.ident(state)?.into()),
  };
 
- match state.current.kind {
+ expect_token!([
  TokenKind::As => {
- state.next();
-
  match state.current.kind {
  TokenKind::Public | TokenKind::Protected | TokenKind::Private => {
  let visibility: MethodFlag = state.current.kind.clone().into();
@@ -273,10 +264,8 @@ impl Parser {
  });
  }
  }
- }
+ },
  TokenKind::Insteadof => {
- state.next();
-
  let mut insteadof = Vec::new();
  insteadof.push(self.full_name(state)?.into());
  while state.current.kind != TokenKind::SemiColon {
@@ -290,13 +279,7 @@ impl Parser {
  insteadof,
  });
  }
- _ => {
- return Err(ParseError::UnexpectedToken(
- state.current.kind.to_string(),
- state.current.span,
- ))
- }
- };
+ ], state, ["`as`", "`insteadof`"]);
 
  self.semi(state)?;
  }

src/parser/internal/functions.rs

@@ -79,7 +79,7 @@ impl Parser {
  if state.current.kind == TokenKind::Colon {
  self.colon(state)?;
 
- return_type = Some(self.type_string(state)?);
+ return_type = Some(self.get_type(state)?);
  }
 
  self.lbrace(state)?;
@@ -128,7 +128,7 @@ impl Parser {
  if state.current.kind == TokenKind::Colon {
  self.colon(state)?;
 
- return_type = Some(self.type_string(state)?);
+ return_type = Some(self.get_type(state)?);
  }
 
  expect_token!([TokenKind::DoubleArrow], state, ["`=>`"]);
@@ -169,7 +169,7 @@ impl Parser {
  if state.current.kind == TokenKind::Colon {
  self.colon(state)?;
 
- return_type = Some(self.type_string(state)?);
+ return_type = Some(self.get_type(state)?);
  }
 
  self.lbrace(state)?;
@@ -241,7 +241,7 @@ impl Parser {
  if state.current.kind == TokenKind::Colon {
  self.colon(state)?;
 
- return_type = Some(self.type_string(state)?);
+ return_type = Some(self.get_type(state)?);
  }
 
  if !has_body {

src/parser/internal/ident.rs

@@ -37,31 +37,6 @@ impl Parser {
  ], state, "a variable"))
  }
 
- pub(in crate::parser) fn full_name_maybe_type_keyword(
- &self,
- state: &mut State,
- ) -> ParseResult<ByteString> {
- match state.current.kind {
- TokenKind::Array | TokenKind::Callable => {
- let r = Ok(state.current.kind.to_string().into());
- state.next();
- r
- }
- _ => self.full_name(state),
- }
- }
-
- pub(in crate::parser) fn type_with_static(&self, state: &mut State) -> ParseResult<ByteString> {
- Ok(match state.current.kind {
- TokenKind::Static | TokenKind::Null | TokenKind::True | TokenKind::False => {
- let str = state.current.kind.to_string();
- state.next();
- str.into()
- }
- _ => self.full_name_maybe_type_keyword(state)?,
- })
- }
-
  pub(in crate::parser) fn ident_maybe_reserved(
  &self,
  state: &mut State,