From db9059dfee52863059466ce44ff005c0b98dc9b3 Mon Sep 17 00:00:00 2001 From: azjezz Date: Sat, 3 Dec 2022 02:22:30 +0100 Subject: [PATCH] fix: multiple issues regarding optional comma Signed-off-by: azjezz --- src/parser/internal/classish.rs | 18 +- src/parser/internal/classish_statement.rs | 46 ++++- src/parser/internal/functions.rs | 6 +- src/parser/internal/params.rs | 12 +- src/parser/internal/punc.rs | 12 -- src/parser/mod.rs | 155 ++++++++++----- tests/0179/code.php | 3 + tests/0179/parser-error.txt | 1 + tests/0179/tokens.txt | 84 ++++++++ tests/0180/code.php | 3 + tests/0180/parser-error.txt | 1 + tests/0180/tokens.txt | 84 ++++++++ tests/0181/code.php | 4 + tests/0181/parser-error.txt | 1 + tests/0181/tokens.txt | 75 +++++++ tests/0182/ast.txt | 39 ++++ tests/0182/code.php | 3 + tests/0182/tokens.txt | 105 ++++++++++ tests/0183/ast.txt | 42 ++++ tests/0183/code.php | 3 + tests/0183/tokens.txt | 105 ++++++++++ tests/0184/ast.txt | 42 ++++ tests/0184/code.php | 3 + tests/0184/tokens.txt | 112 +++++++++++ tests/0185/ast.txt | 22 ++ tests/0185/code.php | 4 + tests/0185/tokens.txt | 82 ++++++++ tests/0186/code.php | 6 + tests/0186/parser-error.txt | 1 + tests/0186/tokens.txt | 89 +++++++++ tests/0187/ast.txt | 23 +++ tests/0187/code.php | 6 + tests/0187/tokens.txt | 96 +++++++++ tests/0188/code.php | 5 + tests/0188/parser-error.txt | 1 + tests/0188/tokens.txt | 87 ++++++++ tests/0189/ast.txt | 22 ++ tests/0189/code.php | 5 + tests/0189/tokens.txt | 94 +++++++++ tests/0190/ast.txt | 28 +++ tests/0190/code.php | 5 + tests/0190/tokens.txt | 94 +++++++++ tests/0191/code.php | 5 + tests/0191/parser-error.txt | 1 + tests/0191/tokens.txt | 87 ++++++++ tests/0192/code.php | 5 + tests/0192/parser-error.txt | 1 + tests/0192/tokens.txt | 87 ++++++++ tests/0193/ast.txt | 27 +++ tests/0193/code.php | 7 + tests/0193/tokens.txt | 110 ++++++++++ tests/0194/ast.txt | 47 +++++ tests/0194/code.php | 8 + tests/0194/tokens.txt | 188 ++++++++++++++++++ tests/0195/ast.txt | 47 +++++ tests/0195/code.php | 8 + tests/0195/tokens.txt | 195 ++++++++++++++++++ tests/0196/ast.txt | 47 +++++ tests/0196/code.php | 8 + tests/0196/tokens.txt | 181 +++++++++++++++++ tests/0197/ast.txt | 51 +++++ tests/0197/code.php | 10 + tests/0197/tokens.txt | 232 ++++++++++++++++++++++ tests/0198/code.php | 10 + tests/0198/parser-error.txt | 1 + tests/0198/tokens.txt | 186 +++++++++++++++++ tests/0199/code.php | 10 + tests/0199/parser-error.txt | 1 + tests/0199/tokens.txt | 179 +++++++++++++++++ tests/0200/code.php | 3 + tests/0200/parser-error.txt | 1 + tests/0200/tokens.txt | 66 ++++++ tests/0201/ast.txt | 18 ++ tests/0201/code.php | 3 + tests/0201/tokens.txt | 73 +++++++ tests/0202/code.php | 3 + tests/0202/parser-error.txt | 1 + tests/0202/tokens.txt | 66 ++++++ tests/0203/ast.txt | 16 ++ tests/0203/code.php | 3 + tests/0203/tokens.txt | 73 +++++++ tests/0204/ast.txt | 23 +++ tests/0204/code.php | 5 + tests/0204/tokens.txt | 80 ++++++++ tests/0205/ast.txt | 23 +++ tests/0205/code.php | 5 + tests/0205/tokens.txt | 87 ++++++++ tests/0206/code.php | 7 + tests/0206/parser-error.txt | 1 + tests/0206/tokens.txt | 174 ++++++++++++++++ tests/0207/ast.txt | 45 +++++ tests/0207/code.php | 7 + tests/0207/tokens.txt | 167 ++++++++++++++++ tests/0208/code.php | 7 + tests/0208/parser-error.txt | 1 + tests/0208/tokens.txt | 174 ++++++++++++++++ tests/0209/code.php | 5 + tests/0209/parser-error.txt | 1 + tests/0209/tokens.txt | 103 ++++++++++ 99 files changed, 4528 insertions(+), 81 deletions(-) create mode 100644 tests/0179/code.php create mode 100644 tests/0179/parser-error.txt create mode 100644 tests/0179/tokens.txt create mode 100644 tests/0180/code.php create mode 100644 tests/0180/parser-error.txt create mode 100644 tests/0180/tokens.txt create mode 100644 tests/0181/code.php create mode 100644 tests/0181/parser-error.txt create mode 100644 tests/0181/tokens.txt create mode 100644 tests/0182/ast.txt create mode 100644 tests/0182/code.php create mode 100644 tests/0182/tokens.txt create mode 100644 tests/0183/ast.txt create mode 100644 tests/0183/code.php create mode 100644 tests/0183/tokens.txt create mode 100644 tests/0184/ast.txt create mode 100644 tests/0184/code.php create mode 100644 tests/0184/tokens.txt create mode 100644 tests/0185/ast.txt create mode 100644 tests/0185/code.php create mode 100644 tests/0185/tokens.txt create mode 100644 tests/0186/code.php create mode 100644 tests/0186/parser-error.txt create mode 100644 tests/0186/tokens.txt create mode 100644 tests/0187/ast.txt create mode 100644 tests/0187/code.php create mode 100644 tests/0187/tokens.txt create mode 100644 tests/0188/code.php create mode 100644 tests/0188/parser-error.txt create mode 100644 tests/0188/tokens.txt create mode 100644 tests/0189/ast.txt create mode 100644 tests/0189/code.php create mode 100644 tests/0189/tokens.txt create mode 100644 tests/0190/ast.txt create mode 100644 tests/0190/code.php create mode 100644 tests/0190/tokens.txt create mode 100644 tests/0191/code.php create mode 100644 tests/0191/parser-error.txt create mode 100644 tests/0191/tokens.txt create mode 100644 tests/0192/code.php create mode 100644 tests/0192/parser-error.txt create mode 100644 tests/0192/tokens.txt create mode 100644 tests/0193/ast.txt create mode 100644 tests/0193/code.php create mode 100644 tests/0193/tokens.txt create mode 100644 tests/0194/ast.txt create mode 100644 tests/0194/code.php create mode 100644 tests/0194/tokens.txt create mode 100644 tests/0195/ast.txt create mode 100644 tests/0195/code.php create mode 100644 tests/0195/tokens.txt create mode 100644 tests/0196/ast.txt create mode 100644 tests/0196/code.php create mode 100644 tests/0196/tokens.txt create mode 100644 tests/0197/ast.txt create mode 100644 tests/0197/code.php create mode 100644 tests/0197/tokens.txt create mode 100644 tests/0198/code.php create mode 100644 tests/0198/parser-error.txt create mode 100644 tests/0198/tokens.txt create mode 100644 tests/0199/code.php create mode 100644 tests/0199/parser-error.txt create mode 100644 tests/0199/tokens.txt create mode 100644 tests/0200/code.php create mode 100644 tests/0200/parser-error.txt create mode 100644 tests/0200/tokens.txt create mode 100644 tests/0201/ast.txt create mode 100644 tests/0201/code.php create mode 100644 tests/0201/tokens.txt create mode 100644 tests/0202/code.php create mode 100644 tests/0202/parser-error.txt create mode 100644 tests/0202/tokens.txt create mode 100644 tests/0203/ast.txt create mode 100644 tests/0203/code.php create mode 100644 tests/0203/tokens.txt create mode 100644 tests/0204/ast.txt create mode 100644 tests/0204/code.php create mode 100644 tests/0204/tokens.txt create mode 100644 tests/0205/ast.txt create mode 100644 tests/0205/code.php create mode 100644 tests/0205/tokens.txt create mode 100644 tests/0206/code.php create mode 100644 tests/0206/parser-error.txt create mode 100644 tests/0206/tokens.txt create mode 100644 tests/0207/ast.txt create mode 100644 tests/0207/code.php create mode 100644 tests/0207/tokens.txt create mode 100644 tests/0208/code.php create mode 100644 tests/0208/parser-error.txt create mode 100644 tests/0208/tokens.txt create mode 100644 tests/0209/code.php create mode 100644 tests/0209/parser-error.txt create mode 100644 tests/0209/tokens.txt diff --git a/src/parser/internal/classish.rs b/src/parser/internal/classish.rs index 98402606..bc6143a8 100644 --- a/src/parser/internal/classish.rs +++ b/src/parser/internal/classish.rs @@ -144,11 +144,7 @@ impl Parser { let mut args = vec![]; if state.current.kind == TokenKind::LeftParen { - self.lparen(state)?; - args = self.args_list(state)?; - - self.rparen(state)?; } let mut extends: Option = None; @@ -163,9 +159,13 @@ impl Parser { state.next(); while state.current.kind != TokenKind::LeftBrace { - self.optional_comma(state)?; - implements.push(self.full_name(state)?.into()); + + if state.current.kind == TokenKind::Comma { + state.next(); + } else { + break; + } } } @@ -218,7 +218,11 @@ impl Parser { while state.current.kind != TokenKind::LeftBrace { implements.push(self.full_name(state)?.into()); - self.optional_comma(state)?; + if state.current.kind == TokenKind::Comma { + state.next(); + } else { + break; + } } } diff --git a/src/parser/internal/classish_statement.rs b/src/parser/internal/classish_statement.rs index c8e8ac48..2a27f943 100644 --- a/src/parser/internal/classish_statement.rs +++ b/src/parser/internal/classish_statement.rs @@ -227,10 +227,24 @@ impl Parser { while state.current.kind != TokenKind::SemiColon && state.current.kind != TokenKind::LeftBrace { - self.optional_comma(state)?; - let t = self.full_name(state)?; traits.push(t.into()); + + if state.current.kind == TokenKind::Comma { + if state.peek.kind == TokenKind::SemiColon { + // will fail with unexpected token `,` + // as `use` doesn't allow for trailing commas. + self.semi(state)?; + } else if state.peek.kind == TokenKind::LeftBrace { + // will fail with unexpected token `{` + // as `use` doesn't allow for trailing commas. + self.lbrace(state)?; + } else { + state.next(); + } + } else { + break; + } } let mut adaptations = Vec::new(); @@ -285,9 +299,31 @@ impl Parser { TokenKind::Insteadof => { let mut insteadof = Vec::new(); insteadof.push(self.full_name(state)?.into()); - while state.current.kind != TokenKind::SemiColon { - self.optional_comma(state)?; - insteadof.push(self.full_name(state)?.into()); + + if state.current.kind == TokenKind::Comma { + if state.peek.kind == TokenKind::SemiColon { + // will fail with unexpected token `,` + // as `insteadof` doesn't allow for trailing commas. + self.semi(state)?; + } + + state.next(); + + while state.current.kind != TokenKind::SemiColon { + insteadof.push(self.full_name(state)?.into()); + + if state.current.kind == TokenKind::Comma { + if state.peek.kind == TokenKind::SemiColon { + // will fail with unexpected token `,` + // as `insteadof` doesn't allow for trailing commas. + self.semi(state)?; + } else { + state.next(); + } + } else { + break; + } + } } adaptations.push(TraitAdaptation::Precedence { diff --git a/src/parser/internal/functions.rs b/src/parser/internal/functions.rs index 5900a938..1cc6e766 100644 --- a/src/parser/internal/functions.rs +++ b/src/parser/internal/functions.rs @@ -67,7 +67,11 @@ impl Parser { uses.push(var); - self.optional_comma(state)?; + if state.current.kind == TokenKind::Comma { + state.next(); + } else { + break; + } } self.rparen(state)?; diff --git a/src/parser/internal/params.rs b/src/parser/internal/params.rs index 232adcd7..a639037d 100644 --- a/src/parser/internal/params.rs +++ b/src/parser/internal/params.rs @@ -139,7 +139,7 @@ impl Parser { }); if state.current.kind == TokenKind::Comma { - self.comma(state)?; + state.next(); } else { break; } @@ -151,6 +151,8 @@ impl Parser { } pub(in crate::parser) fn args_list(&self, state: &mut State) -> ParseResult> { + self.lparen(state)?; + let mut args = Vec::new(); while !state.is_eof() && state.current.kind != TokenKind::RightParen { @@ -184,9 +186,15 @@ impl Parser { value, }); - self.optional_comma(state)?; + if state.current.kind == TokenKind::Comma { + state.next(); + } else { + break; + } } + self.rparen(state)?; + Ok(args) } } diff --git a/src/parser/internal/punc.rs b/src/parser/internal/punc.rs index da779596..ecf6b85e 100644 --- a/src/parser/internal/punc.rs +++ b/src/parser/internal/punc.rs @@ -30,18 +30,6 @@ impl Parser { expect_token!([TokenKind::RightBracket => Ok(())], state, "`]`") } - pub(in crate::parser) fn comma(&self, state: &mut State) -> ParseResult<()> { - expect_token!([TokenKind::Comma => Ok(())], state, "`,`") - } - - pub(in crate::parser) fn optional_comma(&self, state: &mut State) -> ParseResult<()> { - if state.current.kind == TokenKind::Comma { - expect_token!([TokenKind::Comma], state, "`,`"); - } - - Ok(()) - } - pub(in crate::parser) fn colon(&self, state: &mut State) -> ParseResult<()> { expect_token!([TokenKind::Colon => Ok(())], state, "`:`") } diff --git a/src/parser/mod.rs b/src/parser/mod.rs index ae0952b5..1aad12a8 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -142,7 +142,7 @@ impl Parser { let mut constants = vec![]; - while state.current.kind != TokenKind::SemiColon { + loop { let name = self.ident(state)?; expect_token!([TokenKind::Equals], state, "`=`"); @@ -154,7 +154,11 @@ impl Parser { value, }); - self.optional_comma(state)?; + if state.current.kind == TokenKind::Comma { + state.next(); + } else { + break; + } } self.semi(state)?; @@ -206,19 +210,23 @@ impl Parser { self.lparen(state)?; let mut declares = Vec::new(); - while state.current.kind != TokenKind::RightParen { + loop { let key = self.ident(state)?; expect_token!([TokenKind::Equals], state, "`=`"); let value = expect_literal!(state); - self.optional_comma(state)?; - declares.push(DeclareItem { key: key.into(), value, }); + + if state.current.kind == TokenKind::Comma { + state.next(); + } else { + break; + } } self.rparen(state)?; @@ -245,10 +253,15 @@ impl Parser { state.next(); let mut vars = vec![]; - while state.current.kind != TokenKind::SemiColon { + // `loop` instead of `while` as we don't allow for extra commas. + loop { vars.push(self.var(state)?.into()); - self.optional_comma(state)?; + if state.current.kind == TokenKind::Comma { + state.next(); + } else { + break; + } } self.semi(state)?; @@ -259,20 +272,26 @@ impl Parser { let mut vars = vec![]; - while state.current.kind != TokenKind::SemiColon { + // `loop` instead of `while` as we don't allow for extra commas. + loop { let var = Expression::Variable { name: self.var(state)?, }; let mut default = None; if state.current.kind == TokenKind::Equals { - expect_token!([TokenKind::Equals], state, "`=`"); + state.next(); + default = Some(self.expression(state, Precedence::Lowest)?); } - self.optional_comma(state)?; + vars.push(StaticVar { var, default }); - vars.push(StaticVar { var, default }) + if state.current.kind == TokenKind::Comma { + state.next(); + } else { + break; + } } self.semi(state)?; @@ -678,11 +697,16 @@ impl Parser { state.next(); let mut values = Vec::new(); - while !state.is_eof() && state.current.kind != TokenKind::SemiColon { + loop { values.push(self.expression(state, Precedence::Lowest)?); - self.optional_comma(state)?; + if state.current.kind == TokenKind::Comma { + state.next(); + } else { + break; + } } + self.semi(state)?; Statement::Echo { values } } @@ -976,33 +1000,43 @@ impl Parser { let mut arms = Vec::new(); while state.current.kind != TokenKind::RightBrace { - let mut conditions = Vec::new(); + state.skip_comments(); - while state.current.kind != TokenKind::DoubleArrow { - if state.current.kind == TokenKind::Default { + let conditions = if state.current.kind == TokenKind::Default { + state.next(); + + // match conditions can have an extra comma at the end, including `default`. + if state.current.kind == TokenKind::Comma { state.next(); - break; } - conditions.push(self.expression(state, Precedence::Lowest)?); + None + } else { + let mut conditions = Vec::new(); + while state.current.kind != TokenKind::DoubleArrow { + conditions.push(self.expression(state, Precedence::Lowest)?); - self.optional_comma(state)?; - } + if state.current.kind == TokenKind::Comma { + state.next(); + } else { + break; + } + } + + Some(conditions) + }; expect_token!([TokenKind::DoubleArrow], state, "`=>`"); let body = self.expression(state, Precedence::Lowest)?; - self.optional_comma(state)?; + arms.push(MatchArm { conditions, body }); - arms.push(MatchArm { - conditions: if conditions.is_empty() { - None - } else { - Some(conditions) - }, - body, - }) + if state.current.kind == TokenKind::Comma { + state.next(); + } else { + break; + } } self.rbrace(state)?; @@ -1027,6 +1061,7 @@ impl Parser { let mut value = self.expression(state, Precedence::Lowest)?; + // TODO: return error for `[...$a => $b]`. if state.current.kind == TokenKind::DoubleArrow { state.next(); @@ -1036,7 +1071,11 @@ impl Parser { items.push(ArrayItem { key, value, unpack }); - self.optional_comma(state)?; + if state.current.kind == TokenKind::Comma { + state.next(); + } else { + break; + } state.skip_comments(); } @@ -1052,6 +1091,9 @@ impl Parser { state.skip_comments(); while state.current.kind != TokenKind::RightBracket { + // TODO: return an error here instead of + // an empty array element + // see: https://3v4l.org/uLTVA if state.current.kind == TokenKind::Comma { items.push(ArrayItem { key: None, @@ -1069,6 +1111,7 @@ impl Parser { } else { false }; + let mut value = self.expression(state, Precedence::Lowest)?; if state.current.kind == TokenKind::DoubleArrow { @@ -1080,11 +1123,16 @@ impl Parser { items.push(ArrayItem { key, value, unpack }); - self.optional_comma(state)?; - state.skip_comments(); + if state.current.kind == TokenKind::Comma { + state.next(); + } else { + break; + } } + state.skip_comments(); + self.rbracket(state)?; Expression::Array { items } @@ -1105,11 +1153,7 @@ impl Parser { let target = self.expression(state, Precedence::CloneOrNew)?; if state.current.kind == TokenKind::LeftParen { - self.lparen(state)?; - args = self.args_list(state)?; - - self.rparen(state)?; } Expression::New { @@ -1165,8 +1209,6 @@ impl Parser { break; } - state.next(); - left = self.postfix(state, left, &kind)?; continue; } @@ -1234,6 +1276,8 @@ impl Parser { ) -> Result { Ok(match op { TokenKind::Coalesce => { + state.next(); + let rhs = self.expression(state, Precedence::NullCoalesce)?; Expression::Coalesce { @@ -1244,14 +1288,14 @@ impl Parser { TokenKind::LeftParen => { let args = self.args_list(state)?; - self.rparen(state)?; - Expression::Call { target: Box::new(lhs), args, } } TokenKind::LeftBracket => { + state.next(); + if state.current.kind == TokenKind::RightBracket { state.next(); @@ -1271,6 +1315,8 @@ impl Parser { } } TokenKind::DoubleColon => { + state.next(); + let mut must_be_method_call = false; let property = match state.current.kind.clone() { @@ -1327,12 +1373,8 @@ impl Parser { // is only valid a method call context, we can assume we're parsing a static // method call. _ if state.current.kind == TokenKind::LeftParen || must_be_method_call => { - self.lparen(state)?; - let args = self.args_list(state)?; - self.rparen(state)?; - Expression::StaticMethodCall { target: lhs, method: Box::new(property), @@ -1348,6 +1390,8 @@ impl Parser { } } TokenKind::Arrow | TokenKind::NullsafeArrow => { + state.next(); + let property = match state.current.kind { TokenKind::LeftBrace => { self.lbrace(state)?; @@ -1367,12 +1411,8 @@ impl Parser { }; if state.current.kind == TokenKind::LeftParen { - state.next(); - let args = self.args_list(state)?; - self.rparen(state)?; - if op == &TokenKind::NullsafeArrow { Expression::NullsafeMethodCall { target: Box::new(lhs), @@ -1398,12 +1438,19 @@ impl Parser { } } } - TokenKind::Increment => Expression::Increment { - value: Box::new(lhs), - }, - TokenKind::Decrement => Expression::Decrement { - value: Box::new(lhs), - }, + TokenKind::Increment => { + state.next(); + Expression::Increment { + value: Box::new(lhs), + } + } + TokenKind::Decrement => { + state.next(); + + Expression::Decrement { + value: Box::new(lhs), + } + } _ => todo!("postfix: {:?}", op), }) } diff --git a/tests/0179/code.php b/tests/0179/code.php new file mode 100644 index 00000000..226b277c --- /dev/null +++ b/tests/0179/code.php @@ -0,0 +1,3 @@ + Parse Error: unexpected token `$b`, expecting `)` on line 3 column 8 diff --git a/tests/0179/tokens.txt b/tests/0179/tokens.txt new file mode 100644 index 00000000..de23afe9 --- /dev/null +++ b/tests/0179/tokens.txt @@ -0,0 +1,84 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Identifier( + "foo", + ), + span: ( + 3, + 1, + ), + }, + Token { + kind: LeftParen, + span: ( + 3, + 4, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 3, + 5, + ), + }, + Token { + kind: Variable( + "b", + ), + span: ( + 3, + 8, + ), + }, + Token { + kind: Variable( + "c", + ), + span: ( + 3, + 11, + ), + }, + Token { + kind: Ellipsis, + span: ( + 3, + 14, + ), + }, + Token { + kind: Variable( + "d", + ), + span: ( + 3, + 17, + ), + }, + Token { + kind: RightParen, + span: ( + 3, + 19, + ), + }, + Token { + kind: SemiColon, + span: ( + 3, + 20, + ), + }, +] diff --git a/tests/0180/code.php b/tests/0180/code.php new file mode 100644 index 00000000..f631f005 --- /dev/null +++ b/tests/0180/code.php @@ -0,0 +1,3 @@ + Parse Error: unexpected token `$b`, expecting `]` on line 3 column 10 diff --git a/tests/0180/tokens.txt b/tests/0180/tokens.txt new file mode 100644 index 00000000..1c4151a5 --- /dev/null +++ b/tests/0180/tokens.txt @@ -0,0 +1,84 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 3, + 1, + ), + }, + Token { + kind: Equals, + span: ( + 3, + 4, + ), + }, + Token { + kind: LeftBracket, + span: ( + 3, + 6, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 3, + 7, + ), + }, + Token { + kind: Variable( + "b", + ), + span: ( + 3, + 10, + ), + }, + Token { + kind: Variable( + "c", + ), + span: ( + 3, + 13, + ), + }, + Token { + kind: Variable( + "d", + ), + span: ( + 3, + 16, + ), + }, + Token { + kind: RightBracket, + span: ( + 3, + 18, + ), + }, + Token { + kind: SemiColon, + span: ( + 3, + 19, + ), + }, +] diff --git a/tests/0181/code.php b/tests/0181/code.php new file mode 100644 index 00000000..31be8725 --- /dev/null +++ b/tests/0181/code.php @@ -0,0 +1,4 @@ + Parse Error: unexpected token `B`, expecting `;` on line 4 column 9 diff --git a/tests/0181/tokens.txt b/tests/0181/tokens.txt new file mode 100644 index 00000000..0d40837f --- /dev/null +++ b/tests/0181/tokens.txt @@ -0,0 +1,75 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Const, + span: ( + 3, + 1, + ), + }, + Token { + kind: Identifier( + "A", + ), + span: ( + 3, + 9, + ), + }, + Token { + kind: Equals, + span: ( + 3, + 11, + ), + }, + Token { + kind: LiteralInteger( + 3, + ), + span: ( + 3, + 13, + ), + }, + Token { + kind: Identifier( + "B", + ), + span: ( + 4, + 9, + ), + }, + Token { + kind: Equals, + span: ( + 4, + 11, + ), + }, + Token { + kind: LiteralInteger( + 3, + ), + span: ( + 4, + 13, + ), + }, + Token { + kind: SemiColon, + span: ( + 4, + 14, + ), + }, +] diff --git a/tests/0182/ast.txt b/tests/0182/ast.txt new file mode 100644 index 00000000..bdc4fcf6 --- /dev/null +++ b/tests/0182/ast.txt @@ -0,0 +1,39 @@ +[ + Expression { + expr: Call { + target: Identifier { + name: "foo", + }, + args: [ + Arg { + name: None, + value: Variable { + name: "a", + }, + unpack: false, + }, + Arg { + name: None, + value: Variable { + name: "b", + }, + unpack: false, + }, + Arg { + name: None, + value: Variable { + name: "c", + }, + unpack: false, + }, + Arg { + name: None, + value: Variable { + name: "d", + }, + unpack: true, + }, + ], + }, + }, +] diff --git a/tests/0182/code.php b/tests/0182/code.php new file mode 100644 index 00000000..d325fe46 --- /dev/null +++ b/tests/0182/code.php @@ -0,0 +1,3 @@ + Parse Error: unexpected token `c`, expecting `)` on line 5 column 5 diff --git a/tests/0186/tokens.txt b/tests/0186/tokens.txt new file mode 100644 index 00000000..9ed9d3d0 --- /dev/null +++ b/tests/0186/tokens.txt @@ -0,0 +1,89 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Declare, + span: ( + 3, + 1, + ), + }, + Token { + kind: LeftParen, + span: ( + 3, + 8, + ), + }, + Token { + kind: Identifier( + "a", + ), + span: ( + 4, + 5, + ), + }, + Token { + kind: Equals, + span: ( + 4, + 7, + ), + }, + Token { + kind: LiteralInteger( + 3, + ), + span: ( + 4, + 9, + ), + }, + Token { + kind: Identifier( + "c", + ), + span: ( + 5, + 5, + ), + }, + Token { + kind: Equals, + span: ( + 5, + 7, + ), + }, + Token { + kind: LiteralString( + "f", + ), + span: ( + 5, + 9, + ), + }, + Token { + kind: RightParen, + span: ( + 6, + 1, + ), + }, + Token { + kind: SemiColon, + span: ( + 6, + 2, + ), + }, +] diff --git a/tests/0187/ast.txt b/tests/0187/ast.txt new file mode 100644 index 00000000..c805e952 --- /dev/null +++ b/tests/0187/ast.txt @@ -0,0 +1,23 @@ +[ + Declare { + declares: [ + DeclareItem { + key: Identifier { + name: "a", + }, + value: LiteralInteger { + i: 3, + }, + }, + DeclareItem { + key: Identifier { + name: "c", + }, + value: LiteralString { + value: "f", + }, + }, + ], + body: [], + }, +] diff --git a/tests/0187/code.php b/tests/0187/code.php new file mode 100644 index 00000000..b83b176c --- /dev/null +++ b/tests/0187/code.php @@ -0,0 +1,6 @@ + Parse Error: unexpected token `$b`, expecting `;` on line 4 column 15 diff --git a/tests/0188/tokens.txt b/tests/0188/tokens.txt new file mode 100644 index 00000000..e9b85415 --- /dev/null +++ b/tests/0188/tokens.txt @@ -0,0 +1,87 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Function, + span: ( + 3, + 1, + ), + }, + Token { + kind: Identifier( + "foo", + ), + span: ( + 3, + 10, + ), + }, + Token { + kind: LeftParen, + span: ( + 3, + 13, + ), + }, + Token { + kind: RightParen, + span: ( + 3, + 14, + ), + }, + Token { + kind: LeftBrace, + span: ( + 3, + 16, + ), + }, + Token { + kind: Global, + span: ( + 4, + 5, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 4, + 12, + ), + }, + Token { + kind: Variable( + "b", + ), + span: ( + 4, + 15, + ), + }, + Token { + kind: SemiColon, + span: ( + 4, + 17, + ), + }, + Token { + kind: RightBrace, + span: ( + 5, + 1, + ), + }, +] diff --git a/tests/0189/ast.txt b/tests/0189/ast.txt new file mode 100644 index 00000000..60c3d406 --- /dev/null +++ b/tests/0189/ast.txt @@ -0,0 +1,22 @@ +[ + Function { + name: Identifier { + name: "foo", + }, + params: [], + body: [ + Global { + vars: [ + Identifier { + name: "a", + }, + Identifier { + name: "b", + }, + ], + }, + ], + return_type: None, + by_ref: false, + }, +] diff --git a/tests/0189/code.php b/tests/0189/code.php new file mode 100644 index 00000000..72eaea62 --- /dev/null +++ b/tests/0189/code.php @@ -0,0 +1,5 @@ + Parse Error: unexpected token `$b`, expecting `;` on line 4 column 15 diff --git a/tests/0191/tokens.txt b/tests/0191/tokens.txt new file mode 100644 index 00000000..58252437 --- /dev/null +++ b/tests/0191/tokens.txt @@ -0,0 +1,87 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Function, + span: ( + 3, + 1, + ), + }, + Token { + kind: Identifier( + "foo", + ), + span: ( + 3, + 10, + ), + }, + Token { + kind: LeftParen, + span: ( + 3, + 13, + ), + }, + Token { + kind: RightParen, + span: ( + 3, + 14, + ), + }, + Token { + kind: LeftBrace, + span: ( + 3, + 16, + ), + }, + Token { + kind: Static, + span: ( + 4, + 5, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 4, + 12, + ), + }, + Token { + kind: Variable( + "b", + ), + span: ( + 4, + 15, + ), + }, + Token { + kind: SemiColon, + span: ( + 4, + 17, + ), + }, + Token { + kind: RightBrace, + span: ( + 5, + 1, + ), + }, +] diff --git a/tests/0192/code.php b/tests/0192/code.php new file mode 100644 index 00000000..c6cf3c68 --- /dev/null +++ b/tests/0192/code.php @@ -0,0 +1,5 @@ + Parse Error: unexpected token `$b`, expecting `;` on line 4 column 15 diff --git a/tests/0192/tokens.txt b/tests/0192/tokens.txt new file mode 100644 index 00000000..58252437 --- /dev/null +++ b/tests/0192/tokens.txt @@ -0,0 +1,87 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Function, + span: ( + 3, + 1, + ), + }, + Token { + kind: Identifier( + "foo", + ), + span: ( + 3, + 10, + ), + }, + Token { + kind: LeftParen, + span: ( + 3, + 13, + ), + }, + Token { + kind: RightParen, + span: ( + 3, + 14, + ), + }, + Token { + kind: LeftBrace, + span: ( + 3, + 16, + ), + }, + Token { + kind: Static, + span: ( + 4, + 5, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 4, + 12, + ), + }, + Token { + kind: Variable( + "b", + ), + span: ( + 4, + 15, + ), + }, + Token { + kind: SemiColon, + span: ( + 4, + 17, + ), + }, + Token { + kind: RightBrace, + span: ( + 5, + 1, + ), + }, +] diff --git a/tests/0193/ast.txt b/tests/0193/ast.txt new file mode 100644 index 00000000..72172f78 --- /dev/null +++ b/tests/0193/ast.txt @@ -0,0 +1,27 @@ +[ + Expression { + expr: Infix { + lhs: Variable { + name: "a", + }, + op: Assign, + rhs: LiteralInteger { + i: 4, + }, + }, + }, + Expression { + expr: Infix { + lhs: Variable { + name: "b", + }, + op: Assign, + rhs: Match { + condition: Variable { + name: "a", + }, + arms: [], + }, + }, + }, +] diff --git a/tests/0193/code.php b/tests/0193/code.php new file mode 100644 index 00000000..109e0689 --- /dev/null +++ b/tests/0193/code.php @@ -0,0 +1,7 @@ + null +}; diff --git a/tests/0194/tokens.txt b/tests/0194/tokens.txt new file mode 100644 index 00000000..41608e26 --- /dev/null +++ b/tests/0194/tokens.txt @@ -0,0 +1,188 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 4, + 1, + ), + }, + Token { + kind: Equals, + span: ( + 4, + 4, + ), + }, + Token { + kind: LiteralInteger( + 4, + ), + span: ( + 4, + 6, + ), + }, + Token { + kind: SemiColon, + span: ( + 4, + 7, + ), + }, + Token { + kind: Variable( + "b", + ), + span: ( + 6, + 1, + ), + }, + Token { + kind: Equals, + span: ( + 6, + 4, + ), + }, + Token { + kind: Match, + span: ( + 6, + 6, + ), + }, + Token { + kind: LeftParen, + span: ( + 6, + 12, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 6, + 13, + ), + }, + Token { + kind: RightParen, + span: ( + 6, + 15, + ), + }, + Token { + kind: LeftBrace, + span: ( + 6, + 17, + ), + }, + Token { + kind: LiteralInteger( + 1, + ), + span: ( + 7, + 5, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 6, + ), + }, + Token { + kind: LiteralInteger( + 2, + ), + span: ( + 7, + 7, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 8, + ), + }, + Token { + kind: LiteralInteger( + 3, + ), + span: ( + 7, + 9, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 10, + ), + }, + Token { + kind: LiteralInteger( + 4, + ), + span: ( + 7, + 11, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 12, + ), + }, + Token { + kind: DoubleArrow, + span: ( + 7, + 14, + ), + }, + Token { + kind: Null, + span: ( + 7, + 17, + ), + }, + Token { + kind: RightBrace, + span: ( + 8, + 1, + ), + }, + Token { + kind: SemiColon, + span: ( + 8, + 2, + ), + }, +] diff --git a/tests/0195/ast.txt b/tests/0195/ast.txt new file mode 100644 index 00000000..f07faedc --- /dev/null +++ b/tests/0195/ast.txt @@ -0,0 +1,47 @@ +[ + Expression { + expr: Infix { + lhs: Variable { + name: "a", + }, + op: Assign, + rhs: LiteralInteger { + i: 4, + }, + }, + }, + Expression { + expr: Infix { + lhs: Variable { + name: "b", + }, + op: Assign, + rhs: Match { + condition: Variable { + name: "a", + }, + arms: [ + MatchArm { + conditions: Some( + [ + LiteralInteger { + i: 1, + }, + LiteralInteger { + i: 2, + }, + LiteralInteger { + i: 3, + }, + LiteralInteger { + i: 4, + }, + ], + ), + body: Null, + }, + ], + }, + }, + }, +] diff --git a/tests/0195/code.php b/tests/0195/code.php new file mode 100644 index 00000000..37ef74de --- /dev/null +++ b/tests/0195/code.php @@ -0,0 +1,8 @@ + null, +}; diff --git a/tests/0195/tokens.txt b/tests/0195/tokens.txt new file mode 100644 index 00000000..10da61dd --- /dev/null +++ b/tests/0195/tokens.txt @@ -0,0 +1,195 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 4, + 1, + ), + }, + Token { + kind: Equals, + span: ( + 4, + 4, + ), + }, + Token { + kind: LiteralInteger( + 4, + ), + span: ( + 4, + 6, + ), + }, + Token { + kind: SemiColon, + span: ( + 4, + 7, + ), + }, + Token { + kind: Variable( + "b", + ), + span: ( + 6, + 1, + ), + }, + Token { + kind: Equals, + span: ( + 6, + 4, + ), + }, + Token { + kind: Match, + span: ( + 6, + 6, + ), + }, + Token { + kind: LeftParen, + span: ( + 6, + 12, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 6, + 13, + ), + }, + Token { + kind: RightParen, + span: ( + 6, + 15, + ), + }, + Token { + kind: LeftBrace, + span: ( + 6, + 17, + ), + }, + Token { + kind: LiteralInteger( + 1, + ), + span: ( + 7, + 5, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 6, + ), + }, + Token { + kind: LiteralInteger( + 2, + ), + span: ( + 7, + 7, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 8, + ), + }, + Token { + kind: LiteralInteger( + 3, + ), + span: ( + 7, + 9, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 10, + ), + }, + Token { + kind: LiteralInteger( + 4, + ), + span: ( + 7, + 11, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 12, + ), + }, + Token { + kind: DoubleArrow, + span: ( + 7, + 14, + ), + }, + Token { + kind: Null, + span: ( + 7, + 17, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 21, + ), + }, + Token { + kind: RightBrace, + span: ( + 8, + 1, + ), + }, + Token { + kind: SemiColon, + span: ( + 8, + 2, + ), + }, +] diff --git a/tests/0196/ast.txt b/tests/0196/ast.txt new file mode 100644 index 00000000..f07faedc --- /dev/null +++ b/tests/0196/ast.txt @@ -0,0 +1,47 @@ +[ + Expression { + expr: Infix { + lhs: Variable { + name: "a", + }, + op: Assign, + rhs: LiteralInteger { + i: 4, + }, + }, + }, + Expression { + expr: Infix { + lhs: Variable { + name: "b", + }, + op: Assign, + rhs: Match { + condition: Variable { + name: "a", + }, + arms: [ + MatchArm { + conditions: Some( + [ + LiteralInteger { + i: 1, + }, + LiteralInteger { + i: 2, + }, + LiteralInteger { + i: 3, + }, + LiteralInteger { + i: 4, + }, + ], + ), + body: Null, + }, + ], + }, + }, + }, +] diff --git a/tests/0196/code.php b/tests/0196/code.php new file mode 100644 index 00000000..4c10b534 --- /dev/null +++ b/tests/0196/code.php @@ -0,0 +1,8 @@ + null +}; diff --git a/tests/0196/tokens.txt b/tests/0196/tokens.txt new file mode 100644 index 00000000..0171e009 --- /dev/null +++ b/tests/0196/tokens.txt @@ -0,0 +1,181 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 4, + 1, + ), + }, + Token { + kind: Equals, + span: ( + 4, + 4, + ), + }, + Token { + kind: LiteralInteger( + 4, + ), + span: ( + 4, + 6, + ), + }, + Token { + kind: SemiColon, + span: ( + 4, + 7, + ), + }, + Token { + kind: Variable( + "b", + ), + span: ( + 6, + 1, + ), + }, + Token { + kind: Equals, + span: ( + 6, + 4, + ), + }, + Token { + kind: Match, + span: ( + 6, + 6, + ), + }, + Token { + kind: LeftParen, + span: ( + 6, + 12, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 6, + 13, + ), + }, + Token { + kind: RightParen, + span: ( + 6, + 15, + ), + }, + Token { + kind: LeftBrace, + span: ( + 6, + 17, + ), + }, + Token { + kind: LiteralInteger( + 1, + ), + span: ( + 7, + 5, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 6, + ), + }, + Token { + kind: LiteralInteger( + 2, + ), + span: ( + 7, + 7, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 8, + ), + }, + Token { + kind: LiteralInteger( + 3, + ), + span: ( + 7, + 9, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 10, + ), + }, + Token { + kind: LiteralInteger( + 4, + ), + span: ( + 7, + 11, + ), + }, + Token { + kind: DoubleArrow, + span: ( + 7, + 13, + ), + }, + Token { + kind: Null, + span: ( + 7, + 16, + ), + }, + Token { + kind: RightBrace, + span: ( + 8, + 1, + ), + }, + Token { + kind: SemiColon, + span: ( + 8, + 2, + ), + }, +] diff --git a/tests/0197/ast.txt b/tests/0197/ast.txt new file mode 100644 index 00000000..12ec3baa --- /dev/null +++ b/tests/0197/ast.txt @@ -0,0 +1,51 @@ +[ + Expression { + expr: Infix { + lhs: Variable { + name: "a", + }, + op: Assign, + rhs: LiteralInteger { + i: 4, + }, + }, + }, + Expression { + expr: Infix { + lhs: Variable { + name: "b", + }, + op: Assign, + rhs: Match { + condition: Variable { + name: "a", + }, + arms: [ + MatchArm { + conditions: Some( + [ + LiteralInteger { + i: 1, + }, + LiteralInteger { + i: 2, + }, + LiteralInteger { + i: 3, + }, + LiteralInteger { + i: 4, + }, + ], + ), + body: Null, + }, + MatchArm { + conditions: None, + body: Null, + }, + ], + }, + }, + }, +] diff --git a/tests/0197/code.php b/tests/0197/code.php new file mode 100644 index 00000000..8fd624ee --- /dev/null +++ b/tests/0197/code.php @@ -0,0 +1,10 @@ + null, + // seems weird, but PHP considers this valid. + default, => null, +}; diff --git a/tests/0197/tokens.txt b/tests/0197/tokens.txt new file mode 100644 index 00000000..daaa2bf2 --- /dev/null +++ b/tests/0197/tokens.txt @@ -0,0 +1,232 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 4, + 1, + ), + }, + Token { + kind: Equals, + span: ( + 4, + 4, + ), + }, + Token { + kind: LiteralInteger( + 4, + ), + span: ( + 4, + 6, + ), + }, + Token { + kind: SemiColon, + span: ( + 4, + 7, + ), + }, + Token { + kind: Variable( + "b", + ), + span: ( + 6, + 1, + ), + }, + Token { + kind: Equals, + span: ( + 6, + 4, + ), + }, + Token { + kind: Match, + span: ( + 6, + 6, + ), + }, + Token { + kind: LeftParen, + span: ( + 6, + 12, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 6, + 13, + ), + }, + Token { + kind: RightParen, + span: ( + 6, + 15, + ), + }, + Token { + kind: LeftBrace, + span: ( + 6, + 17, + ), + }, + Token { + kind: LiteralInteger( + 1, + ), + span: ( + 7, + 5, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 6, + ), + }, + Token { + kind: LiteralInteger( + 2, + ), + span: ( + 7, + 7, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 8, + ), + }, + Token { + kind: LiteralInteger( + 3, + ), + span: ( + 7, + 9, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 10, + ), + }, + Token { + kind: LiteralInteger( + 4, + ), + span: ( + 7, + 11, + ), + }, + Token { + kind: DoubleArrow, + span: ( + 7, + 13, + ), + }, + Token { + kind: Null, + span: ( + 7, + 16, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 20, + ), + }, + Token { + kind: Comment( + "// seems weird, but PHP considers this valid.", + ), + span: ( + 8, + 5, + ), + }, + Token { + kind: Default, + span: ( + 9, + 5, + ), + }, + Token { + kind: Comma, + span: ( + 9, + 12, + ), + }, + Token { + kind: DoubleArrow, + span: ( + 9, + 14, + ), + }, + Token { + kind: Null, + span: ( + 9, + 17, + ), + }, + Token { + kind: Comma, + span: ( + 9, + 21, + ), + }, + Token { + kind: RightBrace, + span: ( + 10, + 1, + ), + }, + Token { + kind: SemiColon, + span: ( + 10, + 2, + ), + }, +] diff --git a/tests/0198/code.php b/tests/0198/code.php new file mode 100644 index 00000000..b96f9f87 --- /dev/null +++ b/tests/0198/code.php @@ -0,0 +1,10 @@ + null + 2 => null +}; + diff --git a/tests/0198/parser-error.txt b/tests/0198/parser-error.txt new file mode 100644 index 00000000..3e2e3605 --- /dev/null +++ b/tests/0198/parser-error.txt @@ -0,0 +1 @@ +ExpectedToken(["`}`"], Some("int"), (8, 5)) -> Parse Error: unexpected token `int`, expecting `}` on line 8 column 5 diff --git a/tests/0198/tokens.txt b/tests/0198/tokens.txt new file mode 100644 index 00000000..f7383b12 --- /dev/null +++ b/tests/0198/tokens.txt @@ -0,0 +1,186 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 4, + 1, + ), + }, + Token { + kind: Equals, + span: ( + 4, + 4, + ), + }, + Token { + kind: LiteralInteger( + 4, + ), + span: ( + 4, + 6, + ), + }, + Token { + kind: SemiColon, + span: ( + 4, + 7, + ), + }, + Token { + kind: Variable( + "b", + ), + span: ( + 6, + 1, + ), + }, + Token { + kind: Equals, + span: ( + 6, + 4, + ), + }, + Token { + kind: Match, + span: ( + 6, + 6, + ), + }, + Token { + kind: LeftParen, + span: ( + 6, + 12, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 6, + 13, + ), + }, + Token { + kind: RightParen, + span: ( + 6, + 15, + ), + }, + Token { + kind: LeftBrace, + span: ( + 6, + 17, + ), + }, + Token { + kind: LeftParen, + span: ( + 7, + 5, + ), + }, + Token { + kind: LiteralInteger( + 34, + ), + span: ( + 7, + 6, + ), + }, + Token { + kind: RightParen, + span: ( + 7, + 8, + ), + }, + Token { + kind: Comma, + span: ( + 7, + 9, + ), + }, + Token { + kind: LiteralInteger( + 21, + ), + span: ( + 7, + 11, + ), + }, + Token { + kind: DoubleArrow, + span: ( + 7, + 14, + ), + }, + Token { + kind: Null, + span: ( + 7, + 17, + ), + }, + Token { + kind: LiteralInteger( + 2, + ), + span: ( + 8, + 5, + ), + }, + Token { + kind: DoubleArrow, + span: ( + 8, + 7, + ), + }, + Token { + kind: Null, + span: ( + 8, + 10, + ), + }, + Token { + kind: RightBrace, + span: ( + 9, + 1, + ), + }, + Token { + kind: SemiColon, + span: ( + 9, + 2, + ), + }, +] diff --git a/tests/0199/code.php b/tests/0199/code.php new file mode 100644 index 00000000..0d73131e --- /dev/null +++ b/tests/0199/code.php @@ -0,0 +1,10 @@ + null + 2 => null +}; + diff --git a/tests/0199/parser-error.txt b/tests/0199/parser-error.txt new file mode 100644 index 00000000..185bb2b3 --- /dev/null +++ b/tests/0199/parser-error.txt @@ -0,0 +1 @@ +ExpectedToken(["`=>`"], Some("int"), (7, 10)) -> Parse Error: unexpected token `int`, expecting `=>` on line 7 column 10 diff --git a/tests/0199/tokens.txt b/tests/0199/tokens.txt new file mode 100644 index 00000000..f0193b52 --- /dev/null +++ b/tests/0199/tokens.txt @@ -0,0 +1,179 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 4, + 1, + ), + }, + Token { + kind: Equals, + span: ( + 4, + 4, + ), + }, + Token { + kind: LiteralInteger( + 4, + ), + span: ( + 4, + 6, + ), + }, + Token { + kind: SemiColon, + span: ( + 4, + 7, + ), + }, + Token { + kind: Variable( + "b", + ), + span: ( + 6, + 1, + ), + }, + Token { + kind: Equals, + span: ( + 6, + 4, + ), + }, + Token { + kind: Match, + span: ( + 6, + 6, + ), + }, + Token { + kind: LeftParen, + span: ( + 6, + 12, + ), + }, + Token { + kind: Variable( + "a", + ), + span: ( + 6, + 13, + ), + }, + Token { + kind: RightParen, + span: ( + 6, + 15, + ), + }, + Token { + kind: LeftBrace, + span: ( + 6, + 17, + ), + }, + Token { + kind: LeftParen, + span: ( + 7, + 5, + ), + }, + Token { + kind: LiteralInteger( + 34, + ), + span: ( + 7, + 6, + ), + }, + Token { + kind: RightParen, + span: ( + 7, + 8, + ), + }, + Token { + kind: LiteralInteger( + 21, + ), + span: ( + 7, + 10, + ), + }, + Token { + kind: DoubleArrow, + span: ( + 7, + 13, + ), + }, + Token { + kind: Null, + span: ( + 7, + 16, + ), + }, + Token { + kind: LiteralInteger( + 2, + ), + span: ( + 8, + 5, + ), + }, + Token { + kind: DoubleArrow, + span: ( + 8, + 7, + ), + }, + Token { + kind: Null, + span: ( + 8, + 10, + ), + }, + Token { + kind: RightBrace, + span: ( + 9, + 1, + ), + }, + Token { + kind: SemiColon, + span: ( + 9, + 2, + ), + }, +] diff --git a/tests/0200/code.php b/tests/0200/code.php new file mode 100644 index 00000000..94791731 --- /dev/null +++ b/tests/0200/code.php @@ -0,0 +1,3 @@ + Parse Error: unexpected token `C`, expecting `{` on line 3 column 22 diff --git a/tests/0200/tokens.txt b/tests/0200/tokens.txt new file mode 100644 index 00000000..676429d9 --- /dev/null +++ b/tests/0200/tokens.txt @@ -0,0 +1,66 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Class, + span: ( + 3, + 1, + ), + }, + Token { + kind: Identifier( + "A", + ), + span: ( + 3, + 7, + ), + }, + Token { + kind: Implements, + span: ( + 3, + 9, + ), + }, + Token { + kind: Identifier( + "B", + ), + span: ( + 3, + 20, + ), + }, + Token { + kind: Identifier( + "C", + ), + span: ( + 3, + 22, + ), + }, + Token { + kind: LeftBrace, + span: ( + 3, + 24, + ), + }, + Token { + kind: RightBrace, + span: ( + 3, + 25, + ), + }, +] diff --git a/tests/0201/ast.txt b/tests/0201/ast.txt new file mode 100644 index 00000000..d57ba24a --- /dev/null +++ b/tests/0201/ast.txt @@ -0,0 +1,18 @@ +[ + Class { + name: Identifier { + name: "A", + }, + extends: None, + implements: [ + Identifier { + name: "B", + }, + Identifier { + name: "C", + }, + ], + body: [], + flags: [], + }, +] diff --git a/tests/0201/code.php b/tests/0201/code.php new file mode 100644 index 00000000..22a148b1 --- /dev/null +++ b/tests/0201/code.php @@ -0,0 +1,3 @@ + Parse Error: unexpected token `C`, expecting `{` on line 3 column 21 diff --git a/tests/0202/tokens.txt b/tests/0202/tokens.txt new file mode 100644 index 00000000..b8be980f --- /dev/null +++ b/tests/0202/tokens.txt @@ -0,0 +1,66 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Enum, + span: ( + 3, + 1, + ), + }, + Token { + kind: Identifier( + "A", + ), + span: ( + 3, + 6, + ), + }, + Token { + kind: Implements, + span: ( + 3, + 8, + ), + }, + Token { + kind: Identifier( + "B", + ), + span: ( + 3, + 19, + ), + }, + Token { + kind: Identifier( + "C", + ), + span: ( + 3, + 21, + ), + }, + Token { + kind: LeftBrace, + span: ( + 3, + 23, + ), + }, + Token { + kind: RightBrace, + span: ( + 3, + 24, + ), + }, +] diff --git a/tests/0203/ast.txt b/tests/0203/ast.txt new file mode 100644 index 00000000..295fdfa9 --- /dev/null +++ b/tests/0203/ast.txt @@ -0,0 +1,16 @@ +[ + UnitEnum { + name: Identifier { + name: "A", + }, + implements: [ + Identifier { + name: "B", + }, + Identifier { + name: "C", + }, + ], + body: [], + }, +] diff --git a/tests/0203/code.php b/tests/0203/code.php new file mode 100644 index 00000000..1f2bdee0 --- /dev/null +++ b/tests/0203/code.php @@ -0,0 +1,3 @@ + Parse Error: unexpected token `,`, expecting `;` on line 5 column 28 diff --git a/tests/0206/tokens.txt b/tests/0206/tokens.txt new file mode 100644 index 00000000..ea5ea16b --- /dev/null +++ b/tests/0206/tokens.txt @@ -0,0 +1,174 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Class, + span: ( + 3, + 1, + ), + }, + Token { + kind: Identifier( + "foo", + ), + span: ( + 3, + 7, + ), + }, + Token { + kind: LeftBrace, + span: ( + 3, + 11, + ), + }, + Token { + kind: Use, + span: ( + 4, + 5, + ), + }, + Token { + kind: Identifier( + "a", + ), + span: ( + 4, + 9, + ), + }, + Token { + kind: Comma, + span: ( + 4, + 10, + ), + }, + Token { + kind: Identifier( + "b", + ), + span: ( + 4, + 12, + ), + }, + Token { + kind: Comma, + span: ( + 4, + 13, + ), + }, + Token { + kind: Identifier( + "c", + ), + span: ( + 4, + 15, + ), + }, + Token { + kind: LeftBrace, + span: ( + 4, + 17, + ), + }, + Token { + kind: Identifier( + "a", + ), + span: ( + 5, + 9, + ), + }, + Token { + kind: DoubleColon, + span: ( + 5, + 10, + ), + }, + Token { + kind: Identifier( + "s", + ), + span: ( + 5, + 12, + ), + }, + Token { + kind: Insteadof, + span: ( + 5, + 14, + ), + }, + Token { + kind: Identifier( + "b", + ), + span: ( + 5, + 24, + ), + }, + Token { + kind: Comma, + span: ( + 5, + 25, + ), + }, + Token { + kind: Identifier( + "c", + ), + span: ( + 5, + 27, + ), + }, + Token { + kind: Comma, + span: ( + 5, + 28, + ), + }, + Token { + kind: SemiColon, + span: ( + 5, + 29, + ), + }, + Token { + kind: RightBrace, + span: ( + 6, + 5, + ), + }, + Token { + kind: RightBrace, + span: ( + 7, + 1, + ), + }, +] diff --git a/tests/0207/ast.txt b/tests/0207/ast.txt new file mode 100644 index 00000000..d1bfd9dc --- /dev/null +++ b/tests/0207/ast.txt @@ -0,0 +1,45 @@ +[ + Class { + name: Identifier { + name: "foo", + }, + extends: None, + implements: [], + body: [ + TraitUse { + traits: [ + Identifier { + name: "a", + }, + Identifier { + name: "b", + }, + Identifier { + name: "c", + }, + ], + adaptations: [ + Precedence { + trait: Some( + Identifier { + name: "a", + }, + ), + method: Identifier { + name: "s", + }, + insteadof: [ + Identifier { + name: "b", + }, + Identifier { + name: "c", + }, + ], + }, + ], + }, + ], + flags: [], + }, +] diff --git a/tests/0207/code.php b/tests/0207/code.php new file mode 100644 index 00000000..84adf6df --- /dev/null +++ b/tests/0207/code.php @@ -0,0 +1,7 @@ + Parse Error: unexpected token `,`, expecting `{` on line 4 column 16 diff --git a/tests/0208/tokens.txt b/tests/0208/tokens.txt new file mode 100644 index 00000000..88b3d964 --- /dev/null +++ b/tests/0208/tokens.txt @@ -0,0 +1,174 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Class, + span: ( + 3, + 1, + ), + }, + Token { + kind: Identifier( + "foo", + ), + span: ( + 3, + 7, + ), + }, + Token { + kind: LeftBrace, + span: ( + 3, + 11, + ), + }, + Token { + kind: Use, + span: ( + 4, + 5, + ), + }, + Token { + kind: Identifier( + "a", + ), + span: ( + 4, + 9, + ), + }, + Token { + kind: Comma, + span: ( + 4, + 10, + ), + }, + Token { + kind: Identifier( + "b", + ), + span: ( + 4, + 12, + ), + }, + Token { + kind: Comma, + span: ( + 4, + 13, + ), + }, + Token { + kind: Identifier( + "c", + ), + span: ( + 4, + 15, + ), + }, + Token { + kind: Comma, + span: ( + 4, + 16, + ), + }, + Token { + kind: LeftBrace, + span: ( + 4, + 18, + ), + }, + Token { + kind: Identifier( + "a", + ), + span: ( + 5, + 9, + ), + }, + Token { + kind: DoubleColon, + span: ( + 5, + 10, + ), + }, + Token { + kind: Identifier( + "s", + ), + span: ( + 5, + 12, + ), + }, + Token { + kind: Insteadof, + span: ( + 5, + 14, + ), + }, + Token { + kind: Identifier( + "b", + ), + span: ( + 5, + 24, + ), + }, + Token { + kind: Comma, + span: ( + 5, + 25, + ), + }, + Token { + kind: Identifier( + "c", + ), + span: ( + 5, + 27, + ), + }, + Token { + kind: SemiColon, + span: ( + 5, + 28, + ), + }, + Token { + kind: RightBrace, + span: ( + 6, + 5, + ), + }, + Token { + kind: RightBrace, + span: ( + 7, + 1, + ), + }, +] diff --git a/tests/0209/code.php b/tests/0209/code.php new file mode 100644 index 00000000..9cb9a8fd --- /dev/null +++ b/tests/0209/code.php @@ -0,0 +1,5 @@ + Parse Error: unexpected token `,`, expecting `;` on line 4 column 16 diff --git a/tests/0209/tokens.txt b/tests/0209/tokens.txt new file mode 100644 index 00000000..6969a6b4 --- /dev/null +++ b/tests/0209/tokens.txt @@ -0,0 +1,103 @@ +[ + Token { + kind: OpenTag( + Full, + ), + span: ( + 1, + 1, + ), + }, + Token { + kind: Class, + span: ( + 3, + 1, + ), + }, + Token { + kind: Identifier( + "foo", + ), + span: ( + 3, + 7, + ), + }, + Token { + kind: LeftBrace, + span: ( + 3, + 11, + ), + }, + Token { + kind: Use, + span: ( + 4, + 5, + ), + }, + Token { + kind: Identifier( + "a", + ), + span: ( + 4, + 9, + ), + }, + Token { + kind: Comma, + span: ( + 4, + 10, + ), + }, + Token { + kind: Identifier( + "b", + ), + span: ( + 4, + 12, + ), + }, + Token { + kind: Comma, + span: ( + 4, + 13, + ), + }, + Token { + kind: Identifier( + "c", + ), + span: ( + 4, + 15, + ), + }, + Token { + kind: Comma, + span: ( + 4, + 16, + ), + }, + Token { + kind: SemiColon, + span: ( + 4, + 17, + ), + }, + Token { + kind: RightBrace, + span: ( + 5, + 1, + ), + }, +]