2652 lines
46 KiB
Go
2652 lines
46 KiB
Go
package printer_test
|
|
|
|
import (
|
|
"bytes"
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/VKCOM/php-parser/internal/php8"
|
|
"github.com/VKCOM/php-parser/internal/tester"
|
|
"github.com/VKCOM/php-parser/pkg/ast"
|
|
"github.com/VKCOM/php-parser/pkg/conf"
|
|
"github.com/VKCOM/php-parser/pkg/version"
|
|
"github.com/VKCOM/php-parser/pkg/visitor/printer"
|
|
"gotest.tools/assert"
|
|
)
|
|
|
|
func ExamplePrinterPHP8() {
|
|
src := `<?php
|
|
|
|
namespace Foo;
|
|
|
|
abstract class Bar extends Baz
|
|
{
|
|
public function greet()
|
|
{
|
|
echo "Hello";
|
|
// some comment
|
|
}
|
|
}
|
|
`
|
|
|
|
// parsePHP8
|
|
|
|
config := conf.Config{
|
|
Version: &version.Version{
|
|
Major: 8,
|
|
Minor: 0,
|
|
},
|
|
}
|
|
lexer := php8.NewLexer([]byte(src), config)
|
|
php8parser := php8.NewParser(lexer, config)
|
|
php8parser.Parse()
|
|
|
|
rootNode := php8parser.GetRootNode()
|
|
|
|
// change namespace
|
|
|
|
parts := &rootNode.(*ast.Root).Stmts[0].(*ast.StmtNamespace).Name.(*ast.Name).Parts
|
|
*parts = append(*parts, &ast.NamePart{Value: []byte("Quuz")})
|
|
|
|
// print
|
|
|
|
p := printer.NewPrinter(os.Stdout)
|
|
rootNode.Accept(p)
|
|
|
|
// Output:
|
|
// <?php
|
|
//
|
|
// namespace Foo\Quuz;
|
|
//
|
|
// abstract class Bar extends Baz
|
|
// {
|
|
// public function greet()
|
|
// {
|
|
// echo "Hello";
|
|
// // some comment
|
|
// }
|
|
// }
|
|
}
|
|
|
|
func parsePHP8(src string) ast.Vertex {
|
|
config := conf.Config{
|
|
Version: &version.Version{
|
|
Major: 8,
|
|
Minor: 1,
|
|
},
|
|
}
|
|
lexer := php8.NewLexer([]byte(src), config)
|
|
php8parser := php8.NewParser(lexer, config)
|
|
php8parser.Parse()
|
|
|
|
return php8parser.GetRootNode()
|
|
}
|
|
|
|
func printPHP8(n ast.Vertex) string {
|
|
o := bytes.NewBufferString("")
|
|
|
|
p := printer.NewPrinter(o)
|
|
n.Accept(p)
|
|
|
|
return o.String()
|
|
}
|
|
|
|
// test node
|
|
|
|
func TestParseAndPrintRootPHP8(t *testing.T) {
|
|
|
|
src := ` <div>Hello</div>
|
|
<?php
|
|
$a;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintIdentifierPHP8(t *testing.T) {
|
|
src := `<? ;
|
|
/* Foo */
|
|
Foo ( ) ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintParameterTMPPHP8(t *testing.T) {
|
|
|
|
src := `<?php
|
|
function foo ( foo & ... $foo = null ) {}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintParameterPHP8(t *testing.T) {
|
|
|
|
src := `<?php
|
|
function & foo (
|
|
? int $a , & $b = null
|
|
, \Foo ...$c
|
|
) : namespace\Bar\baz\quuz{
|
|
;
|
|
}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintNullablePHP8(t *testing.T) {
|
|
|
|
src := `<?php
|
|
function & foo ( ? int $a ) {
|
|
/* do nothing */
|
|
}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintArgumentPHP8(t *testing.T) {
|
|
src := `<?php
|
|
foo ( $a , $b
|
|
, ... $c ,
|
|
) ; `
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
// test name
|
|
|
|
func TestParseAndPrintNamesPHP8(t *testing.T) {
|
|
src := `<?php
|
|
foo ( ) ;
|
|
\foo ( ) ;
|
|
namespace\foo ( ) ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
// test scalar
|
|
|
|
func TestParseAndPrintMagicConstantPHP8(t *testing.T) {
|
|
src := `<?php
|
|
__CLASS__ ;
|
|
__DIR__ ;
|
|
__FILE__ ;
|
|
__FUNCTION__ ;
|
|
__LINE__ ;
|
|
__NAMESPACE__ ;
|
|
__METHOD__ ;
|
|
__TRAIT__ ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintNumberPHP8(t *testing.T) {
|
|
src := `<?php
|
|
// LNumber
|
|
1234567890123456789 ;
|
|
|
|
// DNumber
|
|
12345678901234567890 ;
|
|
0. ;
|
|
.2 ;
|
|
0.2 ;
|
|
|
|
// binary LNumber
|
|
0b0111111111111111111111111111111111111111111111111111111111111111 ;
|
|
|
|
// binary DNumber
|
|
0b1111111111111111111111111111111111111111111111111111111111111111 ;
|
|
|
|
// HLNumber
|
|
0x007111111111111111 ;
|
|
|
|
// HDNumber
|
|
0x8111111111111111 ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintStringPHP8(t *testing.T) {
|
|
src := `<?php
|
|
'Hello' ;
|
|
"Hello {$world } " ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintHeredocPHP8(t *testing.T) {
|
|
src := `<?php
|
|
foo(<<<EAP
|
|
test
|
|
EAP
|
|
, 'test'
|
|
);
|
|
|
|
<<<EAP
|
|
test
|
|
EAP;
|
|
|
|
<<<'EAP'
|
|
test
|
|
EAP;
|
|
|
|
<<<"EAP"
|
|
test
|
|
EAP;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
// test assign
|
|
|
|
func TestParseAndPrintAssignPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a = $b ;
|
|
$a = & $b ;
|
|
$a &= $b ;
|
|
$a |= $b ;
|
|
$a ^= $b ;
|
|
$a ??= $b ;
|
|
$a .= $b ;
|
|
$a /= $b ;
|
|
$a -= $b ;
|
|
$a %= $b ;
|
|
$a *= $b ;
|
|
$a += $b ;
|
|
$a **= $b ;
|
|
$a <<= $b ;
|
|
$a >>= $b ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
// test binary
|
|
|
|
func TestParseAndPrintBinaryPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a & $b ;
|
|
$a | $b ;
|
|
$a ^ $b ;
|
|
$a && $b ;
|
|
$a || $b ;
|
|
$a ?? $b ;
|
|
$a . $b ;
|
|
$a / $b ;
|
|
$a == $b ;
|
|
$a >= $b ;
|
|
$a > $b ;
|
|
$a === $b ;
|
|
$a and $b ;
|
|
$a or $b ;
|
|
$a xor $b ;
|
|
$a - $b ;
|
|
$a % $b ;
|
|
$a * $b ;
|
|
$a != $b ;
|
|
$a <> $b ;
|
|
$a !== $b ;
|
|
$a + $b ;
|
|
$a ** $b ;
|
|
$a << $b ;
|
|
$a >> $b ;
|
|
$a <= $b ;
|
|
$a < $b ;
|
|
$a <=> $b ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
// test cast
|
|
|
|
func TestParseAndPrintCastPHP8(t *testing.T) {
|
|
src := `<?php
|
|
( array ) $a ;
|
|
( bool ) $a ;
|
|
( boolean ) $a ;
|
|
// ( real ) $a ; real cast was removed in PHP 8
|
|
( double ) $a ;
|
|
( float ) $a ;
|
|
( int ) $a ;
|
|
( integer ) $a ;
|
|
( object ) $a ;
|
|
( string ) $a ;
|
|
( binary ) $a ;
|
|
// ( unset ) $a ; unset cast was removed in PHP 8
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
// test expr
|
|
|
|
func TestParseAndPrintArrayDimFetchPHP8(t *testing.T) {
|
|
src := `<?php
|
|
FOO [ ] ;
|
|
FOO [ 1 ] ;
|
|
$a [ ] ;
|
|
$a [ 1 ] ;
|
|
$a { 1 } ;
|
|
new $a [ ] ;
|
|
new $a [ 1 ] ;
|
|
new $a { 1 } ;
|
|
"$a[1]test" ;
|
|
"${ a [ 1 ] }test" ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintArrayItemPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$foo = [
|
|
$world ,
|
|
& $world ,
|
|
'Hello' => $world ,
|
|
... $unpack
|
|
] ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintArrayPHP8(t *testing.T) {
|
|
src := `<?php
|
|
array ( /* empty array */ ) ;
|
|
array ( 0 , 2 => 2 ) ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintBitwiseNotPHP8(t *testing.T) {
|
|
src := `<?php
|
|
~ $var ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintBooleanNotPHP8(t *testing.T) {
|
|
src := `<?php
|
|
! $var ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintClassConstFetchPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$var :: CONST ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintClonePHP8(t *testing.T) {
|
|
src := `<?php
|
|
clone $var ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintClosureUsePHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a = function ( ) use ( $a , & $b ) {
|
|
// do nothing
|
|
} ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintClosurePHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a = static function & ( ) : void {
|
|
// do nothing
|
|
} ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintArrowFunctionPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a = static fn & ( $b ) : void => $c ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintConstFetchPHP8(t *testing.T) {
|
|
src := `<?php
|
|
null ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintEmptyPHP8(t *testing.T) {
|
|
src := `<?php
|
|
empty ( $a ) ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintErrorSuppressPHP8(t *testing.T) {
|
|
src := `<?php
|
|
@ foo ( ) ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintEvalPHP8(t *testing.T) {
|
|
src := `<?php
|
|
eval ( " " ) ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintExitPHP8(t *testing.T) {
|
|
src := `<?php
|
|
exit ;
|
|
exit ( ) ;
|
|
exit (1) ;
|
|
exit ( 1 );
|
|
die ;
|
|
die ( ) ;
|
|
die (1) ;
|
|
die ( 1 );
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintFunctionCallPHP8(t *testing.T) {
|
|
src := `<?php
|
|
foo ( ) ;
|
|
$var ( $a , ... $b , $c ) ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintIncludePHP8(t *testing.T) {
|
|
|
|
src := `<?php
|
|
include 'foo' ;
|
|
include_once 'bar' ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintInstanceOfPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a instanceof Foo ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintIssetPHP8(t *testing.T) {
|
|
src := `<?php
|
|
isset ( $a , $b [ 2 ] , ) ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintListPHP8(t *testing.T) {
|
|
src := `<?php
|
|
list( , $var , ) = $b ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintMethodCallPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a -> bar ( $arg , ) ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintNewPHP8(t *testing.T) {
|
|
src := `<?php
|
|
|
|
new Foo ;
|
|
|
|
new Foo ( $a, $b ) ;
|
|
|
|
new class ( $c ) extends Foo implements Bar , Baz {
|
|
|
|
} ; `
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintIncDecPHP8(t *testing.T) {
|
|
src := `<?php
|
|
++ $a ;
|
|
-- $a ;
|
|
$a ++ ;
|
|
$a -- ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintPrintPHP8(t *testing.T) {
|
|
src := `<?php
|
|
print $a ;
|
|
print ( $a ) ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintPropertyFetchPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a -> b ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintReferencePHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a = & $b ;
|
|
$a = [ & $b ] ;
|
|
$a = [ $b => & $c ] ;
|
|
|
|
$a = function ( ) use ( & $b ) {
|
|
// do nothing
|
|
} ;
|
|
|
|
foreach ( $a as & $b ) {
|
|
// do nothing
|
|
}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintRequirePHP8(t *testing.T) {
|
|
|
|
src := `<?php
|
|
require __DIR__ . '/folder' ;
|
|
require_once $a ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintShellExecPHP8(t *testing.T) {
|
|
src := "<?php ` {$v} cmd ` ; "
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintShortArrayPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a = [ ] ;
|
|
$a = [ 0 ] ;
|
|
$a = [
|
|
1 => & $b , // one
|
|
$c , /* two */
|
|
] ;
|
|
$a = [0, 1, 2] ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintShortListPHP8(t *testing.T) {
|
|
src := `<?php
|
|
[
|
|
/* skip */,
|
|
$b
|
|
/* skip */,
|
|
] = $a ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintStaticCallPHP8(t *testing.T) {
|
|
src := `<?php
|
|
Foo :: bar ( $a , $b ) ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintStaticPropertyFetchPHP8(t *testing.T) {
|
|
src := `<?php
|
|
Foo :: $bar ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintTernaryPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a ? $b : $c ;
|
|
$a ? : $c ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintUnaryPHP8(t *testing.T) {
|
|
src := `<?php
|
|
- $a ;
|
|
+ $a ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintVariablePHP8(t *testing.T) {
|
|
src := `<?php
|
|
$ /* variable variable comment */ $var ; `
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintYieldPHP8(t *testing.T) {
|
|
src := `<?php
|
|
yield $a ;
|
|
yield $k => $v ;
|
|
yield from $a ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
// test stmt
|
|
|
|
func TestParseAndPrintAltIfPHP8(t *testing.T) {
|
|
src := `<?php
|
|
if ( 1 ) :
|
|
// do nothing
|
|
elseif ( 2 ) :
|
|
elseif ( 3 ) :
|
|
;
|
|
else :
|
|
;
|
|
endif ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintAltForPHP8(t *testing.T) {
|
|
src := `<?php
|
|
for ( $a ; $b ; $c ) :
|
|
endfor ;
|
|
|
|
for ( ; ; ) :
|
|
endfor ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintAltForeachPHP8(t *testing.T) {
|
|
src := `<?php
|
|
foreach ( $a as $k => & $v ) :
|
|
echo $v ;
|
|
endforeach ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintAltSwitchPHP8(t *testing.T) {
|
|
src := `<?php
|
|
|
|
switch ( $a ) :
|
|
case 1 :
|
|
;
|
|
case 2 : ;
|
|
case 3 :
|
|
;
|
|
default :
|
|
;
|
|
endswitch ;
|
|
|
|
|
|
switch ( $a ) : ;
|
|
case 1 ; ;
|
|
default ; ;
|
|
endswitch ;
|
|
|
|
switch ( $a ) :
|
|
endswitch ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintAltWhilePHP8(t *testing.T) {
|
|
src := `<?php
|
|
|
|
while ( $a ) :
|
|
// do nothing
|
|
endwhile ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintBreakPHP8(t *testing.T) {
|
|
src := `<?php
|
|
|
|
break ;
|
|
break 1 ;
|
|
break ( 2 ) ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintClassMethodPHP8(t *testing.T) {
|
|
src := `<?php
|
|
class Foo {
|
|
/**
|
|
* abstract method
|
|
*/
|
|
public static function & greet ( ? Foo $a ) : void ;
|
|
|
|
function greet ( string $a )
|
|
{
|
|
return 'hello' ;
|
|
}
|
|
}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintClassPHP8(t *testing.T) {
|
|
src := `<?php
|
|
abstract final class Foo extends Bar implements Baz , Quuz {
|
|
|
|
}
|
|
|
|
new class ( $c, $a ) extends Foo implements Bar , Baz {
|
|
|
|
} ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintClassConstListPHP8(t *testing.T) {
|
|
src := `<?php
|
|
class Foo {
|
|
public const FOO = 'f' , BAR = 'b' ;
|
|
}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintConstListPHP8(t *testing.T) {
|
|
src := `<?php
|
|
const FOO = 1 , BAR = 2 ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintContinuePHP8(t *testing.T) {
|
|
src := `<?php
|
|
|
|
continue ;
|
|
continue 1 ;
|
|
continue ( 2 ) ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintDeclarePHP8(t *testing.T) {
|
|
src := `<?php
|
|
declare ( FOO = 'bar' , BAR = "foo" ) ;
|
|
declare ( FOO = 'bar' ) $a ;
|
|
declare ( FOO = 'bar' ) { }
|
|
|
|
declare ( FOO = 'bar' ) : enddeclare ;
|
|
declare ( FOO = 'bar' ) :
|
|
;
|
|
enddeclare ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintDoWhilePHP8(t *testing.T) {
|
|
src := `<?php
|
|
do {
|
|
;
|
|
} while ( $a ) ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintEchoPHP8(t *testing.T) {
|
|
src := `<?php
|
|
echo '' ;
|
|
echo $a , ' ' , PHP_EOL;
|
|
|
|
?>
|
|
|
|
<?= $a, $b ?>
|
|
<?= $c ;
|
|
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintIfExpressionPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a ; `
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintForPHP8(t *testing.T) {
|
|
src := `<?php
|
|
for ( $i = 0 ; $i < 3 ; $i ++ )
|
|
echo $i . PHP_EOL;
|
|
|
|
for ( ; ; ) {
|
|
|
|
}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintForeachPHP8(t *testing.T) {
|
|
src := `<?php
|
|
foreach ( $a as $k => & $v ) {
|
|
;
|
|
}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintFunctionPHP8(t *testing.T) {
|
|
|
|
src := `<?php
|
|
function & foo ( ) : void {
|
|
;
|
|
}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintGlobalPHP8(t *testing.T) {
|
|
src := `<?php
|
|
global $a , $b ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintGotoPHP8(t *testing.T) {
|
|
src := `<?php
|
|
goto Foo ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintGroupUsePHP8(t *testing.T) {
|
|
src := `<?php
|
|
use function Foo\{ Bar as Baz , Quuz , } ;
|
|
use Foo\{ function Bar as Baz , const Quuz } ;
|
|
use \Foo\{ function Bar as Baz , const Quuz , } ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintHaltCompilerPHP8(t *testing.T) {
|
|
src := `<?php
|
|
__halt_compiler ( ) ;
|
|
this text is ignored by parser
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintIfElseIfElsePHP8(t *testing.T) {
|
|
src := `<?php
|
|
if ( 1 ) ;
|
|
elseif ( 2 ) {
|
|
;
|
|
}
|
|
else if ( 3 ) $a;
|
|
else { }`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintInlineHtmlPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a;?>test<? `
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintShebangPHP8(t *testing.T) {
|
|
src := `#!/usr/bin/env php
|
|
<?php
|
|
$a;?>test<? `
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintInterfacePHP8(t *testing.T) {
|
|
src := `<?php
|
|
interface Foo extends Bar , Baz {
|
|
|
|
}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintGotoLabelPHP8(t *testing.T) {
|
|
src := `<?php
|
|
Foo : $b ; `
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintNamespacePHP8(t *testing.T) {
|
|
src := `<?php
|
|
namespace Foo\Bar ;
|
|
namespace Baz {
|
|
|
|
}
|
|
namespace {
|
|
|
|
}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintNopPHP8(t *testing.T) {
|
|
src := `<?php `
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintPropertyListPHP8(t *testing.T) {
|
|
src := `<?php
|
|
class Foo {
|
|
var $a = '' , $b = null ;
|
|
private $c ;
|
|
public static Bar $d ;
|
|
|
|
}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintReturnPHP8(t *testing.T) {
|
|
src := `<?php
|
|
class Foo {
|
|
function bar ( )
|
|
{
|
|
return null ;
|
|
}
|
|
}
|
|
|
|
function foo ( )
|
|
{
|
|
return $a ;
|
|
}
|
|
|
|
function bar ( )
|
|
{
|
|
return ;
|
|
}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintStaticVarPHP8(t *testing.T) {
|
|
src := `<?php
|
|
static $a , $b = foo ( ) ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintStmtListPHP8(t *testing.T) {
|
|
src := `<?php
|
|
{
|
|
;
|
|
}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintSwitchPHP8(t *testing.T) {
|
|
src := `<?php
|
|
|
|
switch ( $a ) {
|
|
case 1 : ;
|
|
default : ;
|
|
}
|
|
switch ( $a ) { ;
|
|
case 1 ; ;
|
|
default ; ;
|
|
}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintThrowPHP8(t *testing.T) {
|
|
src := `<?php
|
|
throw new \Exception ( "msg" ) ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintTraitUsePHP8(t *testing.T) {
|
|
src := `<?php
|
|
class foo {
|
|
use \foo , bar ;
|
|
use foo , \bar { }
|
|
use \foo , \bar {
|
|
foo :: a as b ;
|
|
bar :: a insteadof foo ;
|
|
foo :: c as public ;
|
|
foo :: d as public e;
|
|
f as g ;
|
|
}
|
|
}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintTraitPHP8(t *testing.T) {
|
|
src := `<?php
|
|
trait foo {
|
|
function bar ( ) { }
|
|
}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintTryCatchFinallyPHP8(t *testing.T) {
|
|
src := `<?php
|
|
|
|
try {
|
|
|
|
} catch ( \Exception | \Foo\Bar $e) {
|
|
|
|
} finally {
|
|
|
|
}`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintUnsetPHP8(t *testing.T) {
|
|
src := `<?php
|
|
unset ( $a ) ;
|
|
unset ( $a , $b , ) ;`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintUseListPHP8(t *testing.T) {
|
|
src := `<?php
|
|
use Foo ;
|
|
use \Foo as Bar ;
|
|
use function \Foo as Bar ;
|
|
use const Foo as Bar, baz ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintWhilePHP8(t *testing.T) {
|
|
src := `<?php
|
|
while ( $a ) echo '' ;
|
|
while ( $a ) { }
|
|
while ( $a ) ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
// other
|
|
|
|
func TestParseAndPrintParenthesesPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$b = (($a));
|
|
$b = ( ($a) );
|
|
$b = ( ( $a ) );
|
|
$b = ( ($a ));
|
|
$b = (( $a) );
|
|
|
|
( $a + $b ) * 2 ;
|
|
( $ $foo . 'foo' ) :: { $bar . 'bar' } ( ) ;
|
|
( $ $foo ) [ 'bar' ] ;
|
|
$ { $a . 'b' } -> call ( ) ;
|
|
$a -> { $b . 'b' } ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintComplexString1PHP8(t *testing.T) {
|
|
src := `<?php
|
|
// "test $foo" ;
|
|
"test $foo[1]" ;
|
|
"test $foo[-1]" ;
|
|
"test $foo[112345678901234567890] " ;
|
|
"test $foo[-112345678901234567890] " ;
|
|
"test $foo[a]" ;
|
|
"test $foo[$bar]" ;
|
|
"test $foo->bar" ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintComplexString2PHP8(t *testing.T) {
|
|
src := `<?php
|
|
"test ${ foo }" ;
|
|
"test ${ foo . 'bar' }" ;
|
|
"test ${ foo [ ] }" ;
|
|
"test ${ foo [ $b ] }" ;
|
|
"test ${ foo [ 1 ] }" ;
|
|
"test ${ foo [ 'expr' . $bar ] }" ;
|
|
"test ${ $foo }" ;
|
|
"test ${ $foo -> bar }" ;
|
|
"test ${ $foo -> bar ( ) }" ;
|
|
"test ${ $a . '' }" ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintComplexString3PHP8(t *testing.T) {
|
|
src := `<?php
|
|
"test ${foo}" ;
|
|
"test ${foo[0]}";
|
|
"test ${foo::$bar}";
|
|
"test ${foo }" ;
|
|
"test ${foo . 'bar' }" ;
|
|
"test ${foo [ ] }" ;
|
|
"test ${foo [ $b ] }" ;
|
|
"test ${foo [ 1 ] }" ;
|
|
"test ${foo [ 'expr' . $bar ] }" ;
|
|
"test ${$foo }" ;
|
|
"test ${$foo -> bar }" ;
|
|
"test ${$foo -> bar ( ) }" ;
|
|
"test ${$a . '' }" ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintComplexString4PHP8(t *testing.T) {
|
|
src := `<?php
|
|
"test {$foo }" ;
|
|
"test {$foo [ ] }" ;
|
|
"test {$foo [ 1 ] }" ;
|
|
"test {$foo -> bar }" ;
|
|
"test {$foo -> bar ( ) }" ;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintNullsafePHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a?->method();
|
|
$a?->prop;
|
|
"$a?->prop_inside_string";
|
|
(f())?->prop_for_expr;
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintNamedMethods(t *testing.T) {
|
|
src := `<?php
|
|
foo($a, name: $b, ...$b);
|
|
foo(name: $b);
|
|
foo(name: $b, c: 10);
|
|
$foo(a: $a);
|
|
$foo(a: $a, $c, ...$b);
|
|
$foo->bar(some: $a);
|
|
$foo->bar(some: $a, $b, ...$c);
|
|
foo::bar(b: $b);
|
|
foo::bar($a, b: $b, ...$c);
|
|
$foo::bar(c: $a);
|
|
$foo::bar($b, c: $a, ...$b);
|
|
new foo(a: $a);
|
|
new foo(a: $a, $c, ...$b);
|
|
new class (name: $a) {};
|
|
new class (name: $a, $b, ...$c) {};
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintMatchPHP8(t *testing.T) {
|
|
src := `<?php
|
|
echo match($a) {};
|
|
|
|
echo match($a) {
|
|
default => 100,
|
|
};
|
|
echo match($a) {
|
|
default => 100
|
|
};
|
|
echo match($a) {
|
|
default, => 100
|
|
};
|
|
echo match($a) {
|
|
default, => 100,
|
|
};
|
|
|
|
echo match($a) {
|
|
10 => 100
|
|
};
|
|
echo match($a) {
|
|
10 => 100,
|
|
};
|
|
echo match($a) {
|
|
10, => 100
|
|
};
|
|
echo match($a) {
|
|
10, => 100,
|
|
};
|
|
|
|
echo match($a) {
|
|
10, 20 => 100
|
|
};
|
|
echo match($a) {
|
|
10, 20 => 100,
|
|
};
|
|
echo match($a) {
|
|
10, 20, => 100
|
|
};
|
|
echo match($a) {
|
|
10, 20, => 100,
|
|
};
|
|
|
|
echo match($a) {
|
|
10, 20 => 100,
|
|
30, 40 => 101
|
|
};
|
|
echo match($a) {
|
|
10, 20 => 100,
|
|
30, 40 => 101,
|
|
};
|
|
echo match($a) {
|
|
10, 20, => 100,
|
|
30, 40, => 101
|
|
};
|
|
|
|
echo match($a) {
|
|
10, 20 => 100,
|
|
30, 40 => 101,
|
|
default => 102,
|
|
};
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
assert.Equal(t, src, actual)
|
|
}
|
|
|
|
func TestParseAndPrintUnionTypesPHP8(t *testing.T) {
|
|
src := `<?php
|
|
function f(int|string $a) {}
|
|
function f(int|string|float $a) {}
|
|
function f(int|string|float|bool $a) {}
|
|
|
|
function f(int|\Foo $a) {}
|
|
function f(\Foo|int $a) {}
|
|
function f(\Foo|\Boo $a) {}
|
|
function f(\Namespaced\Foo|\Boo $a) {}
|
|
// function f(static|\Boo $a) {} // static cannot be used here.
|
|
|
|
function f(): int|string {}
|
|
function f(): int|\Boo {}
|
|
function f(): \Foo|\Boo {}
|
|
function f(): \Namespaced\Foo|\Boo {}
|
|
|
|
function f(): \Foo|static {}
|
|
function f(): \Foo|void {}
|
|
|
|
function f() {
|
|
$_ = function(int|string $a) {};
|
|
$_ = function(int|string|float $a) {};
|
|
$_ = function(int|string|float|bool $a) {};
|
|
$_ = function(int|\Foo $a) {};
|
|
$_ = function(\Foo|int $a) {};
|
|
$_ = function(\Foo|\Boo $a) {};
|
|
// $_ = function(\Foo|static $a) {}; // static cannot be used here.
|
|
$_ = function(\Namespaced\Foo|\Boo $a) {};
|
|
|
|
$_ = function(): int|string {};
|
|
$_ = function(): int|\Boo {};
|
|
$_ = function(): \Foo|\Boo {};
|
|
$_ = function(): \Namespaced\Foo|\Boo {};
|
|
|
|
$_ = function(): \Foo|static {}; // static can be used here.
|
|
$_ = function(): \Foo|void {};
|
|
|
|
$_ = fn(int|string $a) => $a;
|
|
$_ = fn(int|string|float $a) => $a;
|
|
$_ = fn(int|string|float|bool $a) => $a;
|
|
$_ = fn(int|\Foo $a) => $a;
|
|
$_ = fn(\Foo|int $a) => $a;
|
|
$_ = fn(\Foo|\Boo $a) => $a;
|
|
// $_ = fn(\Foo|static $a) => $a; // static cannot be used here.
|
|
$_ = fn(\Namespaced\Foo|\Boo $a) => $a;
|
|
|
|
$_ = fn(): int|string => null;
|
|
$_ = fn(): int|\Boo => null;
|
|
$_ = fn(): \Foo|\Boo => null;
|
|
$_ = fn(): \Namespaced\Foo|\Boo => null;
|
|
$_ = fn(): \Foo|static => null;
|
|
$_ = fn(): \Foo|void => null;
|
|
}
|
|
|
|
class Foo {
|
|
public int|string $a;
|
|
public int|string|float $a;
|
|
public int|\Foo $a;
|
|
public \Foo|\Boo $a;
|
|
public \Namespaced\Foo|\Boo $a;
|
|
public \Namespaced\Foo|\Boo|int $a;
|
|
// public static $a; // static cannot be used here.
|
|
|
|
public function f(int|\Foo $a) {}
|
|
public function f(\Foo|int $a) {}
|
|
public function f(\Foo|\Boo $a) {}
|
|
public function f(\Namespaced\Foo|\Boo $a) {}
|
|
// public function f(static|\Boo $a) {} // static cannot be used here.
|
|
|
|
public function f(int|\Foo $a = null) {}
|
|
public function f(\Foo|int $a = null) {}
|
|
public function f(\Foo|\Boo $a = null) {}
|
|
public function f(\Namespaced\Foo|\Boo $a = null) {}
|
|
|
|
public function f(): int|string {}
|
|
public function f(): int|\Boo {}
|
|
public function f(): \Foo|\Boo {}
|
|
public function f(): \Namespaced\Foo|\Boo {}
|
|
public function f(): int|static {} // static can be used here.
|
|
}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
assert.Equal(t, src, actual)
|
|
}
|
|
|
|
func TestParseAndPrintTryCatchWithoutVariablePHP8(t *testing.T) {
|
|
src := `<?php
|
|
try {} catch (Exception) {}
|
|
try {} catch (Exception|Exception2) {}
|
|
try {} catch (Exception|Exception2|Exception3) {}
|
|
|
|
try {} catch (Exception) {} catch (Exception2) {}
|
|
try {} catch (Exception|Exception2) {} catch (Exception3|Exception4) {}
|
|
try {} catch (Exception|Exception2|Exception3) {} catch (Exception4) {}
|
|
|
|
// With variable.
|
|
try {} catch (Exception $a) {}
|
|
try {} catch (Exception|Exception2 $a) {}
|
|
try {} catch (Exception|Exception2|Exception3 $ax) {}
|
|
|
|
try {} catch (Exception $a) {} catch (Exception2 $a) {}
|
|
try {} catch (Exception|Exception2 $a) {} catch (Exception3|Exception4 $a) {}
|
|
try {} catch (Exception|Exception2|Exception3 $a) {} catch (Exception4 $a) {}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
assert.Equal(t, src, actual)
|
|
}
|
|
|
|
func TestParseAndPrintParametersWithTrailingCommaPHP8(t *testing.T) {
|
|
src := `<?php
|
|
function f(
|
|
$a,
|
|
$b,
|
|
) {}
|
|
|
|
function f(
|
|
$a,
|
|
) {}
|
|
|
|
|
|
class Foo {
|
|
public function f(
|
|
$a,
|
|
$b,
|
|
) {}
|
|
|
|
public function f(
|
|
$a,
|
|
) {}
|
|
}
|
|
|
|
function f() {
|
|
$_ = function(
|
|
$a,
|
|
$b,
|
|
) {};
|
|
|
|
$_ = function(
|
|
$a,
|
|
) {};
|
|
|
|
$_ = fn(
|
|
$a,
|
|
$b,
|
|
) => 10;
|
|
|
|
$_ = fn(
|
|
$a,
|
|
) => 10;
|
|
}
|
|
|
|
// Without comma.
|
|
function f(
|
|
$a,
|
|
$b
|
|
) {}
|
|
|
|
function f(
|
|
$a
|
|
) {}
|
|
|
|
|
|
class Foo {
|
|
public function f(
|
|
$a,
|
|
$b
|
|
) {}
|
|
|
|
public function f(
|
|
$a
|
|
) {}
|
|
}
|
|
|
|
function f() {
|
|
$_ = function(
|
|
$a,
|
|
$b
|
|
) {};
|
|
|
|
$_ = function(
|
|
$a
|
|
) {};
|
|
|
|
$_ = fn(
|
|
$a,
|
|
$b
|
|
) => 10;
|
|
|
|
$_ = fn(
|
|
$a
|
|
) => 10;
|
|
}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
assert.Equal(t, src, actual)
|
|
}
|
|
|
|
func TestParseAndPrintThrowExprAndStmtPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$a ??= throw new InvalidArgumentException();
|
|
$a && throw new InvalidArgumentException();
|
|
$a || throw new InvalidArgumentException();
|
|
|
|
$a = $b ?: throw new InvalidArgumentException();
|
|
|
|
$a = !empty($b)
|
|
? reset($b)
|
|
: throw new InvalidArgumentException();
|
|
|
|
throw $this->createNotFoundException();
|
|
|
|
throw $exception = new Exception();
|
|
|
|
// As stmt.
|
|
throw new InvalidArgumentException();
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
assert.Equal(t, src, actual)
|
|
}
|
|
|
|
func TestParseAndPrintPropertyInConstructorPHP8(t *testing.T) {
|
|
src := `<?php
|
|
class Point {
|
|
public function __construct(
|
|
protected float $x = 0.0,
|
|
protected float $y = 0.0,
|
|
public float $z = 0.0,
|
|
) {}
|
|
}
|
|
|
|
class Point2 {
|
|
public function __construct(
|
|
private float $x,
|
|
protected float $y,
|
|
public float $z,
|
|
) {}
|
|
}
|
|
|
|
class Point3 {
|
|
public function __construct(
|
|
protected $x,
|
|
private $y,
|
|
public $z,
|
|
) {}
|
|
}
|
|
|
|
class Point4 {
|
|
public function __construct(
|
|
public &$x,
|
|
private &$y,
|
|
protected &$z,
|
|
) {}
|
|
}
|
|
|
|
|
|
class Point4 {
|
|
public function __construct(
|
|
public float &$x = 0.0,
|
|
protected float &$y = 0.0,
|
|
private float &$z = 0.0,
|
|
) {}
|
|
}
|
|
|
|
class Point5 {
|
|
public function __construct(
|
|
public $x,
|
|
public float $y,
|
|
protected float &$z,
|
|
private float $a = 0.0,
|
|
protected float &$b = 0.0,
|
|
) {}
|
|
}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintClass2PHP8(t *testing.T) {
|
|
src := `<?php
|
|
class Foo {}
|
|
abstract class Foo {}
|
|
final class Foo {}
|
|
abstract final class Foo {}
|
|
|
|
abstract final class Foo extends Boo {}
|
|
abstract class Foo extends Boo implements Goo {}
|
|
final class Foo extends Boo implements Goo, Doo {}
|
|
class Foo implements Goo {}
|
|
class Foo implements Goo, Doo {}
|
|
|
|
class Foo {
|
|
public function f() {}
|
|
}
|
|
|
|
abstract final class Foo extends Boo implements Goo, Doo {
|
|
public function f() {}
|
|
}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintTrait2PHP8(t *testing.T) {
|
|
src := `<?php
|
|
trait Foo {}
|
|
|
|
trait Foo {
|
|
public function f() {}
|
|
}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintInterface2PHP8(t *testing.T) {
|
|
src := `<?php
|
|
interface Foo {}
|
|
interface Foo extends Boo {}
|
|
interface Foo extends Boo, Goo {}
|
|
|
|
interface Foo {
|
|
public function f() {}
|
|
}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintClassWithAttributesPHP8(t *testing.T) {
|
|
src := `<?php
|
|
#[SimpleAttribute]
|
|
class Foo {}
|
|
|
|
#[AttributeWithArgs(100, SomeClass::class)]
|
|
class Foo extends Boo {}
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
class Foo implements Goo {}
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
abstract class Foo implements Goo, Doo {}
|
|
|
|
#[
|
|
FirstLineAttribute(100, SomeClass::class),
|
|
SecondLineAttribute()
|
|
]
|
|
class Foo {}
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
#[SecondGroupFirstAttribute(SomeClass::class), SecondGroupSecondAttribute]
|
|
class Foo extends Boo implements Goo {}
|
|
|
|
#[\WithSlash]
|
|
class Foo {}
|
|
|
|
#[\F\Q\N]
|
|
class Foo {}
|
|
|
|
#[\WithSlash]
|
|
final class Foo extends Boo implements Goo, Doo {}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintTraitWithAttributesPHP8(t *testing.T) {
|
|
src := `<?php
|
|
#[SimpleAttribute]
|
|
trait Foo {}
|
|
|
|
#[AttributeWithArgs(100, SomeClass::class)]
|
|
trait Foo {}
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
trait Foo {}
|
|
|
|
#[
|
|
FirstLineAttribute(100, SomeClass::class),
|
|
SecondLineAttribute()
|
|
]
|
|
trait Foo {}
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
#[SecondGroupFirstAttribute(SomeClass::class), SecondGroupSecondAttribute]
|
|
trait Foo {}
|
|
|
|
#[\WithSlash]
|
|
trait Foo {}
|
|
|
|
#[\F\Q\N]
|
|
trait Foo {}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintInterfaceWithAttributesPHP8(t *testing.T) {
|
|
src := `<?php
|
|
#[SimpleAttribute]
|
|
interface Foo {}
|
|
|
|
#[AttributeWithArgs(100, SomeClass::class)]
|
|
interface Foo extends Boo {}
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
interface Foo {}
|
|
|
|
#[
|
|
FirstLineAttribute(100, SomeClass::class),
|
|
SecondLineAttribute()
|
|
]
|
|
interface Foo {}
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
#[SecondGroupFirstAttribute(SomeClass::class), SecondGroupSecondAttribute]
|
|
interface Foo extends Boo, Goo {}
|
|
|
|
#[\WithSlash]
|
|
interface Foo {}
|
|
|
|
#[\F\Q\N]
|
|
interface Foo {}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintParamsWithAttributesPHP8(t *testing.T) {
|
|
src := `<?php
|
|
class Foo {
|
|
public function __construct(#[SimpleAttribute] public string|int $a) {}
|
|
public function __construct(
|
|
#[SimpleAttribute] public string|int $a,
|
|
#[AttributeWithArgs(100, SomeClass::class)] public string|int $b,
|
|
#[
|
|
FirstLineAttribute(100, SomeClass::class),
|
|
SecondLineAttribute()
|
|
]
|
|
$c,
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
#[SecondGroupFirstAttribute(SomeClass::class), SecondGroupSecondAttribute]
|
|
private \Foo|string $d = 100,
|
|
|
|
#[
|
|
FirstAttribute(100, SomeClass::class),
|
|
SecondAttribute(),
|
|
]
|
|
#[
|
|
SecondGroupFirstAttribute(SomeClass::class),
|
|
SecondGroupSecondAttribute
|
|
]
|
|
$e = 100,
|
|
|
|
#[\F\Q\N] string|int $f = 100,
|
|
) {}
|
|
}
|
|
|
|
function f(#[SimpleAttribute] $a) {}
|
|
|
|
function f(
|
|
#[SimpleAttribute] string|int $a,
|
|
#[AttributeWithArgs(100, SomeClass::class)] string|int $b,
|
|
#[
|
|
FirstLineAttribute(100, SomeClass::class),
|
|
SecondLineAttribute()
|
|
]
|
|
$c,
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
#[SecondGroupFirstAttribute(SomeClass::class), SecondGroupSecondAttribute]
|
|
\Foo|string $d = 100,
|
|
|
|
#[
|
|
FirstAttribute(100, SomeClass::class),
|
|
SecondAttribute(),
|
|
]
|
|
#[
|
|
SecondGroupFirstAttribute(SomeClass::class),
|
|
SecondGroupSecondAttribute
|
|
]
|
|
$e = 100,
|
|
|
|
#[\F\Q\N] string|int $f = 100,
|
|
) {}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintFunctionWithAttributesPHP8(t *testing.T) {
|
|
src := `<?php
|
|
#[SimpleAttribute]
|
|
function &f(): void {}
|
|
|
|
#[AttributeWithArgs(100, SomeClass::class)]
|
|
function f() {}
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
function &f(): void {}
|
|
|
|
#[
|
|
FirstLineAttribute(100, SomeClass::class),
|
|
SecondLineAttribute()
|
|
]
|
|
function f() {}
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
#[SecondGroupFirstAttribute(SomeClass::class), SecondGroupSecondAttribute]
|
|
function &f(): int|string {}
|
|
|
|
#[\WithSlash]
|
|
function f() {}
|
|
|
|
#[\F\Q\N]
|
|
function &f(): \Foo|string {}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintClosureWithAttributesPHP8(t *testing.T) {
|
|
src := `<?php
|
|
function f() {
|
|
$_ =
|
|
#[SimpleAttribute]
|
|
function &(): void {};
|
|
|
|
$_ =
|
|
#[AttributeWithArgs(100, SomeClass::class)]
|
|
function () {};
|
|
|
|
$_ =
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
function &(): void {};
|
|
|
|
$_ =
|
|
#[
|
|
FirstLineAttribute(100, SomeClass::class),
|
|
SecondLineAttribute()
|
|
]
|
|
function () {};
|
|
|
|
$_ =
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
#[SecondGroupFirstAttribute(SomeClass::class), SecondGroupSecondAttribute]
|
|
function &(): int|string {};
|
|
|
|
$_ =
|
|
#[\WithSlash]
|
|
function () {};
|
|
|
|
$_ =
|
|
#[\F\Q\N]
|
|
function &(): \Foo|string {};
|
|
}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintArrowFunctionWithAttributesPHP8(t *testing.T) {
|
|
src := `<?php
|
|
function f() {
|
|
$_ =
|
|
#[SimpleAttribute]
|
|
fn &(): void => 1;
|
|
|
|
$_ =
|
|
#[AttributeWithArgs(100, SomeClass::class)]
|
|
fn () => 1;
|
|
|
|
$_ =
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
fn &(): void => 1;
|
|
|
|
$_ =
|
|
#[
|
|
FirstLineAttribute(100, SomeClass::class),
|
|
SecondLineAttribute()
|
|
]
|
|
fn () => 1;
|
|
|
|
$_ =
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
#[SecondGroupFirstAttribute(SomeClass::class), SecondGroupSecondAttribute]
|
|
fn &(): int|string => 1;
|
|
|
|
$_ =
|
|
#[\WithSlash]
|
|
fn () => 1;
|
|
|
|
$_ =
|
|
#[\F\Q\N]
|
|
fn &(): \Foo|string => 1;
|
|
}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintAnonClassWithAttributesPHP8(t *testing.T) {
|
|
src := `<?php
|
|
$_ = new
|
|
#[SimpleAttribute]
|
|
class {};
|
|
|
|
$_ = new
|
|
#[AttributeWithArgs(100, SomeClass::class)]
|
|
class extends Boo {};
|
|
|
|
$_ = new
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
class implements Goo {};
|
|
|
|
$_ = new
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
class implements Goo, Doo {};
|
|
|
|
$_ = new
|
|
#[
|
|
FirstLineAttribute(100, SomeClass::class),
|
|
SecondLineAttribute()
|
|
]
|
|
class {};
|
|
|
|
$_ = new
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
#[SecondGroupFirstAttribute(SomeClass::class), SecondGroupSecondAttribute]
|
|
class extends Boo implements Goo {};
|
|
|
|
$_ = new
|
|
#[\WithSlash]
|
|
class {};
|
|
|
|
$_ = new
|
|
#[\F\Q\N]
|
|
class {};
|
|
|
|
$_ = new
|
|
#[\WithSlash]
|
|
class extends Boo implements Goo, Doo {};
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintClassPropertyWithAttributesPHP8(t *testing.T) {
|
|
src := `<?php
|
|
class Foo {
|
|
#[SimpleAttribute]
|
|
public $a;
|
|
|
|
#[AttributeWithArgs(100, SomeClass::class)]
|
|
protected $a = null;
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
var $a = null, $b;
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
private ?Foo $a = null;
|
|
|
|
#[
|
|
FirstLineAttribute(100, SomeClass::class),
|
|
SecondLineAttribute()
|
|
]
|
|
public int|string $a = 10, $b, $c, $d;
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
#[SecondGroupFirstAttribute(SomeClass::class), SecondGroupSecondAttribute]
|
|
var $a = 100;
|
|
|
|
#[\WithSlash]
|
|
public $a = null;
|
|
|
|
#[\F\Q\N]
|
|
protected $a = null;
|
|
}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintClassConstWithAttributesPHP8(t *testing.T) {
|
|
src := `<?php
|
|
class Foo {
|
|
#[SimpleAttribute]
|
|
public const A = 100;
|
|
|
|
#[AttributeWithArgs(100, SomeClass::class)]
|
|
private const A = 10, B = 10, C = 10;
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
protected const A = "a";
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
public const A = 100;
|
|
|
|
#[
|
|
FirstLineAttribute(100, SomeClass::class),
|
|
SecondLineAttribute()
|
|
]
|
|
public const A = 100;
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
#[SecondGroupFirstAttribute(SomeClass::class), SecondGroupSecondAttribute]
|
|
public const A = 100;
|
|
|
|
#[\WithSlash]
|
|
protected const A = 100;
|
|
|
|
#[\F\Q\N]
|
|
public const A = 100;
|
|
}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
|
|
func TestParseAndPrintClassMethodWithAttributesPHP8(t *testing.T) {
|
|
src := `<?php
|
|
class Foo {
|
|
#[SimpleAttribute]
|
|
function &f(): void {}
|
|
|
|
#[AttributeWithArgs(100, SomeClass::class)]
|
|
public function f() {}
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
protected function &f(): void {}
|
|
|
|
#[
|
|
FirstLineAttribute(100, SomeClass::class),
|
|
SecondLineAttribute()
|
|
]
|
|
public function f() {}
|
|
|
|
#[FirstAttribute(100, SomeClass::class), SecondAttribute()]
|
|
#[SecondGroupFirstAttribute(SomeClass::class), SecondGroupSecondAttribute]
|
|
protected function &f(): int|string {}
|
|
|
|
#[\WithSlash]
|
|
public function f() {}
|
|
|
|
#[\F\Q\N]
|
|
protected function &f(): \Foo|string {}
|
|
}
|
|
`
|
|
|
|
actual := printPHP8(parsePHP8(src))
|
|
|
|
if src != actual {
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
|
|
}
|
|
}
|
|
func TestParseAndPrintNamespaceWithKeywordsPHP8(t *testing.T) {
|
|
tester.NewParserPrintTestSuite(t).UsePHP8().Run(`<?php
|
|
namespace fn;
|
|
namespace Foo\fn;
|
|
namespace Foo\fn\match;
|
|
namespace Foo\abstract\match;
|
|
`)
|
|
}
|
|
|
|
func TestParseAndPrintUsePHP8(t *testing.T) {
|
|
tester.NewParserPrintTestSuite(t).UsePHP8().Run(`<?php
|
|
use Foo, \Foo, Boo as Foo, \Boo as Foo;
|
|
use function Foo, \Foo, Boo as Foo, \Boo as Foo;
|
|
use const Foo, \Foo, Boo as Foo, \Boo as Foo;
|
|
|
|
use Foo\{Boo};
|
|
use Foo\Boo\{Boo};
|
|
use Foo\Boo\{Boo\Match};
|
|
|
|
use Foo\{
|
|
Boo\Foo
|
|
};
|
|
|
|
use Foo\{
|
|
Boo as Name
|
|
};
|
|
|
|
use Foo\{
|
|
Boo,
|
|
};
|
|
|
|
use Foo\Abstract\{
|
|
Boo as Name,
|
|
Boo\Foo as Name,
|
|
Foo\Abstract,
|
|
};
|
|
|
|
use Foo\{
|
|
function Boo as Name,
|
|
const Boo as Name,
|
|
};
|
|
|
|
use Foo\{
|
|
function Boo as Name,
|
|
Boo,
|
|
Boo\Foo,
|
|
const Boo,
|
|
function Boo,
|
|
};
|
|
|
|
use function Foo\{
|
|
// function Boo, // 'function' is not allowed here
|
|
Boo,
|
|
Boo as Foo,
|
|
Boo\Foo as Foo,
|
|
};
|
|
|
|
use const Foo\{
|
|
// const Boo, // 'const' is not allowed here
|
|
Boo,
|
|
Boo as Foo,
|
|
Boo\Foo as Foo,
|
|
};
|
|
`)
|
|
}
|
|
|
|
func TestParseAndPrintClosureUseWithTrailingCommaPHP8(t *testing.T) {
|
|
tester.NewParserPrintTestSuite(t).UsePHP8().Run(`<?php
|
|
$_ = function () use (
|
|
$a
|
|
) {};
|
|
|
|
$_ = function () use (
|
|
$a,
|
|
) {};
|
|
|
|
$_ = function () use (
|
|
$a,
|
|
$a,
|
|
) {};
|
|
|
|
$_ = function () use (
|
|
$a,
|
|
$a,
|
|
$a,
|
|
) {};
|
|
`)
|
|
}
|
|
|
|
func TestParseAndPrintConstFetchClassConstantWithObjectPHP8(t *testing.T) {
|
|
tester.NewParserPrintTestSuite(t).UsePHP8().Run(`<?php
|
|
$a::B;
|
|
$a::class;
|
|
`)
|
|
}
|
|
|
|
func TestParseAndPrintEncapsedStringDerefencablePHP8(t *testing.T) {
|
|
tester.NewParserPrintTestSuite(t).UsePHP8().Run(`<?php
|
|
"string"->length();
|
|
"foo$bar"[0];
|
|
"foo$bar"->length();
|
|
`)
|
|
}
|
|
|
|
func TestParseAndPrintConstantDerefencablePHP8(t *testing.T) {
|
|
tester.NewParserPrintTestSuite(t).UsePHP8().Run(`<?php
|
|
A->length;
|
|
A->length();
|
|
A[0];
|
|
A[0][1][2];
|
|
A{0};
|
|
|
|
A::B[0];
|
|
A::B[0][1][2];
|
|
A::B{0};
|
|
A::B->length;
|
|
A::B->length();
|
|
A::B::C;
|
|
A::B::$c;
|
|
A::B::c();
|
|
`)
|
|
}
|
|
|
|
func TestParseAndPrintArbitraryExpressionsInNewAndInstanceOfPHP8(t *testing.T) {
|
|
tester.NewParserPrintTestSuite(t).UsePHP8().Run(`<?php
|
|
new ('Foo' . $bar);
|
|
new ('Foo' . $bar)($arg);
|
|
$obj instanceof ('Foo' . $bar);
|
|
`)
|
|
}
|
|
|
|
func TestParseAndPrintMagicConstantDerefencablePHP8(t *testing.T) {
|
|
tester.NewParserPrintTestSuite(t).UsePHP8().Run(`<?php
|
|
__FUNCTION__[0];
|
|
__FUNCTION__->length;
|
|
__FUNCTION__->length();
|
|
`)
|
|
}
|