CS fixes

nicolas-grekas · nicolas-grekas · commit 1e742d559fe5 · 2025-07-10T10:14:14.000+02:00
diff --git a/Exception/ClassNotFoundException.php b/Exception/ClassNotFoundException.php
@@ -15,6 +15,6 @@ class ClassNotFoundException extends \Exception implements ExceptionInterface
 {
     public function __construct(string $class, ?\Throwable $previous = null)
     {
-        parent::__construct(sprintf('Class "%s" not found.', $class), 0, $previous);
+        parent::__construct(\sprintf('Class "%s" not found.', $class), 0, $previous);
     }
 }
diff --git a/Exception/NotInstantiableTypeException.php b/Exception/NotInstantiableTypeException.php
@@ -15,6 +15,6 @@ class NotInstantiableTypeException extends \Exception implements ExceptionInterf
 {
     public function __construct(string $type, ?\Throwable $previous = null)
     {
-        parent::__construct(sprintf('Type "%s" is not instantiable.', $type), 0, $previous);
+        parent::__construct(\sprintf('Type "%s" is not instantiable.', $type), 0, $previous);
     }
 }
diff --git a/Internal/Exporter.php b/Internal/Exporter.php
@@ -79,7 +79,7 @@ public static function prepare($values, $objectsPool, &$refsPool, &$objectsCount
 
             if ($reflector->hasMethod('__serialize')) {
                 if (!$reflector->getMethod('__serialize')->isPublic()) {
-                    throw new \Error(sprintf('Call to %s method "%s::__serialize()".', $reflector->getMethod('__serialize')->isProtected() ? 'protected' : 'private', $class));
+                    throw new \Error(\sprintf('Call to %s method "%s::__serialize()".', $reflector->getMethod('__serialize')->isProtected() ? 'protected' : 'private', $class));
                 }
 
                 if (!\is_array($serializeProperties = $value->__serialize())) {
@@ -173,7 +173,7 @@ public static function prepare($values, $objectsPool, &$refsPool, &$objectsCount
             }
             if ($sleep) {
                 foreach ($sleep as $n => $v) {
-                    trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $n), \E_USER_NOTICE);
+                    trigger_error(\sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $n), \E_USER_NOTICE);
                 }
             }
             if (method_exists($class, '__unserialize')) {
@@ -226,10 +226,10 @@ public static function export($value, $indent = '')
         $subIndent = $indent.'    ';
 
         if (\is_string($value)) {
-            $code = sprintf("'%s'", addcslashes($value, "'\\"));
+            $code = \sprintf("'%s'", addcslashes($value, "'\\"));
 
             $code = preg_replace_callback("/((?:[\\0\\r\\n]|\u{202A}|\u{202B}|\u{202D}|\u{202E}|\u{2066}|\u{2067}|\u{2068}|\u{202C}|\u{2069})++)(.)/", function ($m) use ($subIndent) {
-                $m[1] = sprintf('\'."%s".\'', str_replace(
+                $m[1] = \sprintf('\'."%s".\'', str_replace(
                     ["\0", "\r", "\n", "\u{202A}", "\u{202B}", "\u{202D}", "\u{202E}", "\u{2066}", "\u{2067}", "\u{2068}", "\u{202C}", "\u{2069}", '\n\\'],
                     ['\0', '\r', '\n', '\u{202A}', '\u{202B}', '\u{202D}', '\u{202E}', '\u{2066}', '\u{2067}', '\u{2068}', '\u{202C}', '\u{2069}', '\n"'."\n".$subIndent.'."\\'],
                     $m[1]
@@ -287,7 +287,7 @@ public static function export($value, $indent = '')
             return self::exportHydrator($value, $indent, $subIndent);
         }
 
-        throw new \UnexpectedValueException(sprintf('Cannot export value of type "%s".', get_debug_type($value)));
+        throw new \UnexpectedValueException(\sprintf('Cannot export value of type "%s".', get_debug_type($value)));
     }
 
     private static function exportRegistry(Registry $value, string $indent, string $subIndent): string
diff --git a/Internal/Hydrator.php b/Internal/Hydrator.php
@@ -73,11 +73,11 @@ public static function getHydrator($class)
                 return $baseHydrator;
 
             case 'ErrorException':
-                return $baseHydrator->bindTo(null, new class() extends \ErrorException {
+                return $baseHydrator->bindTo(null, new class extends \ErrorException {
                 });
 
             case 'TypeError':
-                return $baseHydrator->bindTo(null, new class() extends \Error {
+                return $baseHydrator->bindTo(null, new class extends \Error {
                 });
 
             case 'SplObjectStorage':
@@ -178,11 +178,11 @@ public static function getSimpleHydrator($class)
                 return $baseHydrator;
 
             case 'ErrorException':
-                return $baseHydrator->bindTo(new \stdClass(), new class() extends \ErrorException {
+                return $baseHydrator->bindTo(new \stdClass(), new class extends \ErrorException {
                 });
 
             case 'TypeError':
-                return $baseHydrator->bindTo(new \stdClass(), new class() extends \Error {
+                return $baseHydrator->bindTo(new \stdClass(), new class extends \Error {
                 });
 
             case 'SplObjectStorage':
diff --git a/Internal/LazyObjectState.php b/Internal/LazyObjectState.php
@@ -67,7 +67,7 @@ public function initialize($instance, $propertyName, $writeScope)
 
             if ($initializer = $this->initializer["\0"] ?? null) {
                 if (!\is_array($values = $initializer($instance, LazyObjectRegistry::$defaultProperties[$class]))) {
-                    throw new \TypeError(sprintf('The lazy-initializer defined for instance of "%s" must return an array, got "%s".', $class, get_debug_type($values)));
+                    throw new \TypeError(\sprintf('The lazy-initializer defined for instance of "%s" must return an array, got "%s".', $class, get_debug_type($values)));
                 }
                 $properties = (array) $instance;
                 foreach ($values as $key => $value) {
diff --git a/LazyGhostTrait.php b/LazyGhostTrait.php
@@ -120,7 +120,7 @@ public function initializeLazyObject(): static
 
             if (null === $values) {
                 if (!\is_array($values = ($state->initializer["\0"])($this, Registry::$defaultProperties[$class]))) {
-                    throw new \TypeError(sprintf('The lazy-initializer defined for instance of "%s" must return an array, got "%s".', $class, get_debug_type($values)));
+                    throw new \TypeError(\sprintf('The lazy-initializer defined for instance of "%s" must return an array, got "%s".', $class, get_debug_type($values)));
                 }
 
                 if (\array_key_exists($key, $properties = (array) $this)) {
@@ -198,7 +198,7 @@ public function &__get($name): mixed
 
         if (null === $class) {
             $frame = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0];
-            trigger_error(sprintf('Undefined property: %s::$%s in %s on line %s', $this::class, $name, $frame['file'], $frame['line']), \E_USER_NOTICE);
+            trigger_error(\sprintf('Undefined property: %s::$%s in %s on line %s', $this::class, $name, $frame['file'], $frame['line']), \E_USER_NOTICE);
         }
 
         get_in_scope:
@@ -375,7 +375,7 @@ public function __serialize(): array
             $value = $properties[$k = $name] ?? $properties[$k = "\0*\0$name"] ?? $properties[$k = "\0$class\0$name"] ?? $properties[$k = "\0$scope\0$name"] ?? $k = null;
 
             if (null === $k) {
-                trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $name), \E_USER_NOTICE);
+                trigger_error(\sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $name), \E_USER_NOTICE);
             } else {
                 $data[$k] = $value;
             }
diff --git a/LazyProxyTrait.php b/LazyProxyTrait.php
@@ -120,7 +120,7 @@ public function &__get($name): mixed
 
         if (!$parent && null === $class && !\array_key_exists($name, (array) $instance)) {
             $frame = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0];
-            trigger_error(sprintf('Undefined property: %s::$%s in %s on line %s', $instance::class, $name, $frame['file'], $frame['line']), \E_USER_NOTICE);
+            trigger_error(\sprintf('Undefined property: %s::$%s in %s on line %s', $instance::class, $name, $frame['file'], $frame['line']), \E_USER_NOTICE);
         }
 
         get_in_scope:
@@ -306,7 +306,7 @@ public function __serialize(): array
             $value = $properties[$k = $name] ?? $properties[$k = "\0*\0$name"] ?? $properties[$k = "\0$class\0$name"] ?? $properties[$k = "\0$scope\0$name"] ?? $k = null;
 
             if (null === $k) {
-                trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $name), \E_USER_NOTICE);
+                trigger_error(\sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $name), \E_USER_NOTICE);
             } else {
                 $data[$k] = $value;
             }
diff --git a/ProxyHelper.php b/ProxyHelper.php
@@ -28,34 +28,34 @@ final class ProxyHelper
     public static function generateLazyGhost(\ReflectionClass $class): string
     {
         if (\PHP_VERSION_ID >= 80200 && \PHP_VERSION_ID < 80300 && $class->isReadOnly()) {
-            throw new LogicException(sprintf('Cannot generate lazy ghost with PHP < 8.3: class "%s" is readonly.', $class->name));
+            throw new LogicException(\sprintf('Cannot generate lazy ghost with PHP < 8.3: class "%s" is readonly.', $class->name));
         }
         if ($class->isFinal()) {
-            throw new LogicException(sprintf('Cannot generate lazy ghost: class "%s" is final.', $class->name));
+            throw new LogicException(\sprintf('Cannot generate lazy ghost: class "%s" is final.', $class->name));
         }
         if ($class->isInterface() || $class->isAbstract() || $class->isTrait()) {
             throw new LogicException(\sprintf('Cannot generate lazy ghost: "%s" is not a concrete class.', $class->name));
         }
         if (\stdClass::class !== $class->name && $class->isInternal()) {
-            throw new LogicException(sprintf('Cannot generate lazy ghost: class "%s" is internal.', $class->name));
+            throw new LogicException(\sprintf('Cannot generate lazy ghost: class "%s" is internal.', $class->name));
         }
         if ($class->hasMethod('__get') && 'mixed' !== (self::exportType($class->getMethod('__get')) ?? 'mixed')) {
-            throw new LogicException(sprintf('Cannot generate lazy ghost: return type of method "%s::__get()" should be "mixed".', $class->name));
+            throw new LogicException(\sprintf('Cannot generate lazy ghost: return type of method "%s::__get()" should be "mixed".', $class->name));
         }
 
         static $traitMethods;
         $traitMethods ??= (new \ReflectionClass(LazyGhostTrait::class))->getMethods();
 
         foreach ($traitMethods as $method) {
             if ($class->hasMethod($method->name) && $class->getMethod($method->name)->isFinal()) {
-                throw new LogicException(sprintf('Cannot generate lazy ghost: method "%s::%s()" is final.', $class->name, $method->name));
+                throw new LogicException(\sprintf('Cannot generate lazy ghost: method "%s::%s()" is final.', $class->name, $method->name));
             }
         }
 
         $parent = $class;
         while ($parent = $parent->getParentClass()) {
             if (\stdClass::class !== $parent->name && $parent->isInternal()) {
-                throw new LogicException(sprintf('Cannot generate lazy ghost: class "%s" extends "%s" which is internal.', $class->name, $parent->name));
+                throw new LogicException(\sprintf('Cannot generate lazy ghost: class "%s" extends "%s" which is internal.', $class->name, $parent->name));
             }
         }
 
@@ -70,7 +70,7 @@ public static function generateLazyGhost(\ReflectionClass $class): string
             }
 
             if ($flags & (\ReflectionProperty::IS_FINAL | \ReflectionProperty::IS_PRIVATE)) {
-                throw new LogicException(sprintf('Cannot generate lazy ghost: property "%s::$%s" is final or private(set).', $class->name, $name));
+                throw new LogicException(\sprintf('Cannot generate lazy ghost: property "%s::$%s" is final or private(set).', $class->name, $name));
             }
 
             $p = $propertyScopes[$k][4] ?? Hydrator::$propertyScopes[$class->name][$k][4] = new \ReflectionProperty($scope, $name);
@@ -92,7 +92,7 @@ public static function generateLazyGhost(\ReflectionClass $class): string
                     $arg = '$'.$method->getParameters()[0]->name;
                     $hooks .= "        set({$parameters}) { \$this->initializeLazyObject(); parent::\${$name}::set({$arg}); }\n";
                 } else {
-                    throw new LogicException(sprintf('Cannot generate lazy ghost: hook "%s::%s()" is not supported.', $class->name, $method->name));
+                    throw new LogicException(\sprintf('Cannot generate lazy ghost: hook "%s::%s()" is not supported.', $class->name, $method->name));
                 }
             }
 
@@ -127,13 +127,13 @@ class_exists(\Symfony\Component\VarExporter\Internal\LazyObjectState::class);
     public static function generateLazyProxy(?\ReflectionClass $class, array $interfaces = []): string
     {
         if (!class_exists($class?->name ?? \stdClass::class, false)) {
-            throw new LogicException(sprintf('Cannot generate lazy proxy: "%s" is not a class.', $class->name));
+            throw new LogicException(\sprintf('Cannot generate lazy proxy: "%s" is not a class.', $class->name));
         }
         if ($class?->isFinal()) {
-            throw new LogicException(sprintf('Cannot generate lazy proxy: class "%s" is final.', $class->name));
+            throw new LogicException(\sprintf('Cannot generate lazy proxy: class "%s" is final.', $class->name));
         }
         if (\PHP_VERSION_ID >= 80200 && \PHP_VERSION_ID < 80300 && $class?->isReadOnly()) {
-            throw new LogicException(sprintf('Cannot generate lazy proxy with PHP < 8.3: class "%s" is readonly.', $class->name));
+            throw new LogicException(\sprintf('Cannot generate lazy proxy with PHP < 8.3: class "%s" is readonly.', $class->name));
         }
 
         $propertyScopes = $class ? Hydrator::$propertyScopes[$class->name] ??= Hydrator::getPropertyScopes($class->name) : [];
@@ -159,7 +159,7 @@ public static function generateLazyProxy(?\ReflectionClass $class, array $interf
                 }
 
                 if ($flags & (\ReflectionProperty::IS_FINAL | \ReflectionProperty::IS_PRIVATE)) {
-                    throw new LogicException(sprintf('Cannot generate lazy proxy: property "%s::$%s" is final or private(set).', $class->name, $name));
+                    throw new LogicException(\sprintf('Cannot generate lazy proxy: property "%s::$%s" is final or private(set).', $class->name, $name));
                 }
 
                 $p = $propertyScopes[$k][4] ?? Hydrator::$propertyScopes[$class->name][$k][4] = new \ReflectionProperty($scope, $name);
@@ -170,7 +170,7 @@ public static function generateLazyProxy(?\ReflectionClass $class, array $interf
         $methodReflectors = [$class?->getMethods(\ReflectionMethod::IS_PUBLIC | \ReflectionMethod::IS_PROTECTED) ?? []];
         foreach ($interfaces as $interface) {
             if (!$interface->isInterface()) {
-                throw new LogicException(sprintf('Cannot generate lazy proxy: "%s" is not an interface.', $interface->name));
+                throw new LogicException(\sprintf('Cannot generate lazy proxy: "%s" is not an interface.', $interface->name));
             }
             $methodReflectors[] = $interface->getMethods();
 
@@ -228,7 +228,7 @@ public static function generateLazyProxy(?\ReflectionClass $class, array $interf
 
                     EOPHP;
                 } else {
-                    throw new LogicException(sprintf('Cannot generate lazy proxy: hook "%s::%s()" is not supported.', $class->name, $method->name));
+                    throw new LogicException(\sprintf('Cannot generate lazy proxy: hook "%s::%s()" is not supported.', $class->name, $method->name));
                 }
             }
 
@@ -266,7 +266,7 @@ public static function generateLazyProxy(?\ReflectionClass $class, array $interf
             }
             if ($method->isFinal()) {
                 if ($extendsInternalClass || $methodsHaveToBeProxied || method_exists(LazyProxyTrait::class, $method->name)) {
-                    throw new LogicException(sprintf('Cannot generate lazy proxy: method "%s::%s()" is final.', $class->name, $method->name));
+                    throw new LogicException(\sprintf('Cannot generate lazy proxy: method "%s::%s()" is final.', $class->name, $method->name));
                 }
                 continue;
             }
@@ -396,7 +396,7 @@ public static function exportParameters(\ReflectionFunctionAbstract $function, b
             $args = substr($args, 0, -2);
         } else {
             $args = explode(', ', $args, 1 + $byRefIndex);
-            $args[$byRefIndex] = sprintf('...\array_slice(\func_get_args(), %d)', $byRefIndex);
+            $args[$byRefIndex] = \sprintf('...\array_slice(\func_get_args(), %d)', $byRefIndex);
             $args = implode(', ', $args);
         }
 
diff --git a/Tests/LazyGhostTraitTest.php b/Tests/LazyGhostTraitTest.php
@@ -426,7 +426,7 @@ public function testFullInitializationAfterPartialInitialization()
 
     public function testIndirectModification()
     {
-        $obj = new class() {
+        $obj = new class {
             public array $foo;
         };
         $proxy = $this->createLazyGhost($obj::class, fn () => null);
@@ -518,7 +518,7 @@ public function testPropertyHooksWithDefaultValue()
 
         $this->assertSame(321, $object->backedIntWithDefault);
         $this->assertSame('321', $object->backedStringWithDefault);
-        $this->assertSame(false, $object->backedBoolWithDefault);
+        $this->assertFalse($object->backedBoolWithDefault);
         $this->assertTrue($initialized);
 
         $initialized = false;
@@ -531,7 +531,7 @@ public function testPropertyHooksWithDefaultValue()
         $this->assertTrue($initialized);
         $this->assertSame(654, $object->backedIntWithDefault);
         $this->assertSame('654', $object->backedStringWithDefault);
-        $this->assertSame(true, $object->backedBoolWithDefault);
+        $this->assertTrue($object->backedBoolWithDefault);
     }
 
     /**
diff --git a/Tests/LazyProxyTraitTest.php b/Tests/LazyProxyTraitTest.php
@@ -208,7 +208,7 @@ public function testOverwritePropClass()
 
     public function testWither()
     {
-        $obj = new class() {
+        $obj = new class {
             public $foo = 123;
 
             public function withFoo($foo): static
@@ -229,7 +229,7 @@ public function withFoo($foo): static
 
     public function testFluent()
     {
-        $obj = new class() {
+        $obj = new class {
             public $foo = 123;
 
             public function setFoo($foo): static
@@ -247,7 +247,7 @@ public function setFoo($foo): static
 
     public function testIndirectModification()
     {
-        $obj = new class() {
+        $obj = new class {
             public array $foo;
         };
         $proxy = $this->createLazyProxy($obj::class, fn () => $obj);
@@ -274,7 +274,7 @@ public function testReadOnlyClass()
 
     public function testLazyDecoratorClass()
     {
-        $obj = new class() extends TestClass {
+        $obj = new class extends TestClass {
             use LazyProxyTrait {
                 createLazyProxy as private;
             }
diff --git a/Tests/ProxyHelperTest.php b/Tests/ProxyHelperTest.php
@@ -171,7 +171,7 @@ public function testGenerateLazyProxyForClassWithUnserializeMagicMethod(object $
 
     public static function classWithUnserializeMagicMethodProvider(): iterable
     {
-        yield 'not type hinted __unserialize method' => [new class() {
+        yield 'not type hinted __unserialize method' => [new class {
             public function __unserialize($array)
             {
             }
@@ -191,7 +191,7 @@ public function __unserialize($data): void
         }
         EOPHP];
 
-        yield 'type hinted __unserialize method' => [new class() {
+        yield 'type hinted __unserialize method' => [new class {
             public function __unserialize(array $array)
             {
             }
@@ -221,7 +221,7 @@ public function foo(#[\SensitiveParameter] $a): int
 
         EOPHP;
 
-        $class = new \ReflectionClass(new class() {
+        $class = new \ReflectionClass(new class {
             #[SomeAttribute]
             public function foo(#[\SensitiveParameter, AnotherAttribute] $a): int
             {
diff --git a/Tests/VarExporterTest.php b/Tests/VarExporterTest.php
@@ -66,7 +66,7 @@ public static function provideFailingSerialization()
         yield [$h = fopen(__FILE__, 'r')];
         yield [[$h]];
 
-        $a = new class() {
+        $a = new class {
         };
 
         yield [$a];

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,6 @@ class ClassNotFoundException extends \Exception implements ExceptionInterface`
`15`	`15`	`{`
`16`	`16`	`public function __construct(string $class, ?\Throwable $previous = null)`
`17`	`17`	`{`
`18`		`- parent::__construct(sprintf('Class "%s" not found.', $class), 0, $previous);`
	`18`	`+ parent::__construct(\sprintf('Class "%s" not found.', $class), 0, $previous);`
`19`	`19`	`}`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,6 @@ class NotInstantiableTypeException extends \Exception implements ExceptionInterf`
`15`	`15`	`{`
`16`	`16`	`public function __construct(string $type, ?\Throwable $previous = null)`
`17`	`17`	`{`
`18`		`- parent::__construct(sprintf('Type "%s" is not instantiable.', $type), 0, $previous);`
	`18`	`+ parent::__construct(\sprintf('Type "%s" is not instantiable.', $type), 0, $previous);`
`19`	`19`	`}`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ public static function prepare($values, $objectsPool, &$refsPool, &$objectsCount`
`79`	`79`
`80`	`80`	`if ($reflector->hasMethod('__serialize')) {`
`81`	`81`	`if (!$reflector->getMethod('__serialize')->isPublic()) {`
`82`		`- throw new \Error(sprintf('Call to %s method "%s::__serialize()".', $reflector->getMethod('__serialize')->isProtected() ? 'protected' : 'private', $class));`
	`82`	`+ throw new \Error(\sprintf('Call to %s method "%s::__serialize()".', $reflector->getMethod('__serialize')->isProtected() ? 'protected' : 'private', $class));`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`if (!\is_array($serializeProperties = $value->__serialize())) {`
`@@ -173,7 +173,7 @@ public static function prepare($values, $objectsPool, &$refsPool, &$objectsCount`
`173`	`173`	`}`
`174`	`174`	`if ($sleep) {`
`175`	`175`	`foreach ($sleep as $n => $v) {`
`176`		`- trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $n), \E_USER_NOTICE);`
	`176`	`+ trigger_error(\sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $n), \E_USER_NOTICE);`
`177`	`177`	`}`
`178`	`178`	`}`
`179`	`179`	`if (method_exists($class, '__unserialize')) {`
`@@ -226,10 +226,10 @@ public static function export($value, $indent = '')`
`226`	`226`	`$subIndent = $indent.' ';`
`227`	`227`
`228`	`228`	`if (\is_string($value)) {`
`229`		`- $code = sprintf("'%s'", addcslashes($value, "'\\"));`
	`229`	`+ $code = \sprintf("'%s'", addcslashes($value, "'\\"));`
`230`	`230`
`231`	`231`	`$code = preg_replace_callback("/((?:[\\0\\r\\n]\|\u{202A}\|\u{202B}\|\u{202D}\|\u{202E}\|\u{2066}\|\u{2067}\|\u{2068}\|\u{202C}\|\u{2069})++)(.)/", function ($m) use ($subIndent) {`
`232`		`- $m[1] = sprintf('\'."%s".\'', str_replace(`
	`232`	`+ $m[1] = \sprintf('\'."%s".\'', str_replace(`
`233`	`233`	`["\0", "\r", "\n", "\u{202A}", "\u{202B}", "\u{202D}", "\u{202E}", "\u{2066}", "\u{2067}", "\u{2068}", "\u{202C}", "\u{2069}", '\n\\'],`
`234`	`234`	`['\0', '\r', '\n', '\u{202A}', '\u{202B}', '\u{202D}', '\u{202E}', '\u{2066}', '\u{2067}', '\u{2068}', '\u{202C}', '\u{2069}', '\n"'."\n".$subIndent.'."\\'],`
`235`	`235`	`$m[1]`
`@@ -287,7 +287,7 @@ public static function export($value, $indent = '')`
`287`	`287`	`return self::exportHydrator($value, $indent, $subIndent);`
`288`	`288`	`}`
`289`	`289`
`290`		`- throw new \UnexpectedValueException(sprintf('Cannot export value of type "%s".', get_debug_type($value)));`
	`290`	`+ throw new \UnexpectedValueException(\sprintf('Cannot export value of type "%s".', get_debug_type($value)));`
`291`	`291`	`}`
`292`	`292`
`293`	`293`	`private static function exportRegistry(Registry $value, string $indent, string $subIndent): string`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ public function initialize($instance, $propertyName, $writeScope)`
`67`	`67`
`68`	`68`	`if ($initializer = $this->initializer["\0"] ?? null) {`
`69`	`69`	`if (!\is_array($values = $initializer($instance, LazyObjectRegistry::$defaultProperties[$class]))) {`
`70`		`- throw new \TypeError(sprintf('The lazy-initializer defined for instance of "%s" must return an array, got "%s".', $class, get_debug_type($values)));`
	`70`	`+ throw new \TypeError(\sprintf('The lazy-initializer defined for instance of "%s" must return an array, got "%s".', $class, get_debug_type($values)));`
`71`	`71`	`}`
`72`	`72`	`$properties = (array) $instance;`
`73`	`73`	`foreach ($values as $key => $value) {`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ public function &__get($name): mixed`
`120`	`120`
`121`	`121`	`if (!$parent && null === $class && !\array_key_exists($name, (array) $instance)) {`
`122`	`122`	`$frame = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0];`
`123`		`- trigger_error(sprintf('Undefined property: %s::$%s in %s on line %s', $instance::class, $name, $frame['file'], $frame['line']), \E_USER_NOTICE);`
	`123`	`+ trigger_error(\sprintf('Undefined property: %s::$%s in %s on line %s', $instance::class, $name, $frame['file'], $frame['line']), \E_USER_NOTICE);`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`get_in_scope:`
`@@ -306,7 +306,7 @@ public function __serialize(): array`
`306`	`306`	`$value = $properties[$k = $name] ?? $properties[$k = "\0*\0$name"] ?? $properties[$k = "\0$class\0$name"] ?? $properties[$k = "\0$scope\0$name"] ?? $k = null;`
`307`	`307`
`308`	`308`	`if (null === $k) {`
`309`		`- trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $name), \E_USER_NOTICE);`
	`309`	`+ trigger_error(\sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $name), \E_USER_NOTICE);`
`310`	`310`	`} else {`
`311`	`311`	`$data[$k] = $value;`
`312`	`312`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,34 +28,34 @@ final class ProxyHelper`
`28`	`28`	`public static function generateLazyGhost(\ReflectionClass $class): string`
`29`	`29`	`{`
`30`	`30`	`if (\PHP_VERSION_ID >= 80200 && \PHP_VERSION_ID < 80300 && $class->isReadOnly()) {`
`31`		`- throw new LogicException(sprintf('Cannot generate lazy ghost with PHP < 8.3: class "%s" is readonly.', $class->name));`
	`31`	`+ throw new LogicException(\sprintf('Cannot generate lazy ghost with PHP < 8.3: class "%s" is readonly.', $class->name));`
`32`	`32`	`}`
`33`	`33`	`if ($class->isFinal()) {`
`34`		`- throw new LogicException(sprintf('Cannot generate lazy ghost: class "%s" is final.', $class->name));`
	`34`	`+ throw new LogicException(\sprintf('Cannot generate lazy ghost: class "%s" is final.', $class->name));`
`35`	`35`	`}`
`36`	`36`	`if ($class->isInterface() \|\| $class->isAbstract() \|\| $class->isTrait()) {`
`37`	`37`	`throw new LogicException(\sprintf('Cannot generate lazy ghost: "%s" is not a concrete class.', $class->name));`
`38`	`38`	`}`
`39`	`39`	`if (\stdClass::class !== $class->name && $class->isInternal()) {`
`40`		`- throw new LogicException(sprintf('Cannot generate lazy ghost: class "%s" is internal.', $class->name));`
	`40`	`+ throw new LogicException(\sprintf('Cannot generate lazy ghost: class "%s" is internal.', $class->name));`
`41`	`41`	`}`
`42`	`42`	`if ($class->hasMethod('__get') && 'mixed' !== (self::exportType($class->getMethod('__get')) ?? 'mixed')) {`
`43`		`- throw new LogicException(sprintf('Cannot generate lazy ghost: return type of method "%s::__get()" should be "mixed".', $class->name));`
	`43`	`+ throw new LogicException(\sprintf('Cannot generate lazy ghost: return type of method "%s::__get()" should be "mixed".', $class->name));`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`static $traitMethods;`
`47`	`47`	`$traitMethods ??= (new \ReflectionClass(LazyGhostTrait::class))->getMethods();`
`48`	`48`
`49`	`49`	`foreach ($traitMethods as $method) {`
`50`	`50`	`if ($class->hasMethod($method->name) && $class->getMethod($method->name)->isFinal()) {`
`51`		`- throw new LogicException(sprintf('Cannot generate lazy ghost: method "%s::%s()" is final.', $class->name, $method->name));`
	`51`	`+ throw new LogicException(\sprintf('Cannot generate lazy ghost: method "%s::%s()" is final.', $class->name, $method->name));`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`$parent = $class;`
`56`	`56`	`while ($parent = $parent->getParentClass()) {`
`57`	`57`	`if (\stdClass::class !== $parent->name && $parent->isInternal()) {`
`58`		`- throw new LogicException(sprintf('Cannot generate lazy ghost: class "%s" extends "%s" which is internal.', $class->name, $parent->name));`
	`58`	`+ throw new LogicException(\sprintf('Cannot generate lazy ghost: class "%s" extends "%s" which is internal.', $class->name, $parent->name));`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
`@@ -70,7 +70,7 @@ public static function generateLazyGhost(\ReflectionClass $class): string`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`if ($flags & (\ReflectionProperty::IS_FINAL \| \ReflectionProperty::IS_PRIVATE)) {`
`73`		`- throw new LogicException(sprintf('Cannot generate lazy ghost: property "%s::$%s" is final or private(set).', $class->name, $name));`
	`73`	`+ throw new LogicException(\sprintf('Cannot generate lazy ghost: property "%s::$%s" is final or private(set).', $class->name, $name));`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`$p = $propertyScopes[$k][4] ?? Hydrator::$propertyScopes[$class->name][$k][4] = new \ReflectionProperty($scope, $name);`
`@@ -92,7 +92,7 @@ public static function generateLazyGhost(\ReflectionClass $class): string`
`92`	`92`	`$arg = '$'.$method->getParameters()[0]->name;`
`93`	`93`	`$hooks .= " set({$parameters}) { \$this->initializeLazyObject(); parent::\${$name}::set({$arg}); }\n";`
`94`	`94`	`} else {`
`95`		`- throw new LogicException(sprintf('Cannot generate lazy ghost: hook "%s::%s()" is not supported.', $class->name, $method->name));`
	`95`	`+ throw new LogicException(\sprintf('Cannot generate lazy ghost: hook "%s::%s()" is not supported.', $class->name, $method->name));`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`
`@@ -127,13 +127,13 @@ class_exists(\Symfony\Component\VarExporter\Internal\LazyObjectState::class);`
`127`	`127`	`public static function generateLazyProxy(?\ReflectionClass $class, array $interfaces = []): string`
`128`	`128`	`{`
`129`	`129`	`if (!class_exists($class?->name ?? \stdClass::class, false)) {`
`130`		`- throw new LogicException(sprintf('Cannot generate lazy proxy: "%s" is not a class.', $class->name));`
	`130`	`+ throw new LogicException(\sprintf('Cannot generate lazy proxy: "%s" is not a class.', $class->name));`
`131`	`131`	`}`
`132`	`132`	`if ($class?->isFinal()) {`
`133`		`- throw new LogicException(sprintf('Cannot generate lazy proxy: class "%s" is final.', $class->name));`
	`133`	`+ throw new LogicException(\sprintf('Cannot generate lazy proxy: class "%s" is final.', $class->name));`
`134`	`134`	`}`
`135`	`135`	`if (\PHP_VERSION_ID >= 80200 && \PHP_VERSION_ID < 80300 && $class?->isReadOnly()) {`
`136`		`- throw new LogicException(sprintf('Cannot generate lazy proxy with PHP < 8.3: class "%s" is readonly.', $class->name));`
	`136`	`+ throw new LogicException(\sprintf('Cannot generate lazy proxy with PHP < 8.3: class "%s" is readonly.', $class->name));`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`$propertyScopes = $class ? Hydrator::$propertyScopes[$class->name] ??= Hydrator::getPropertyScopes($class->name) : [];`
`@@ -159,7 +159,7 @@ public static function generateLazyProxy(?\ReflectionClass $class, array $interf`
`159`	`159`	`}`
`160`	`160`
`161`	`161`	`if ($flags & (\ReflectionProperty::IS_FINAL \| \ReflectionProperty::IS_PRIVATE)) {`
`162`		`- throw new LogicException(sprintf('Cannot generate lazy proxy: property "%s::$%s" is final or private(set).', $class->name, $name));`
	`162`	`+ throw new LogicException(\sprintf('Cannot generate lazy proxy: property "%s::$%s" is final or private(set).', $class->name, $name));`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`$p = $propertyScopes[$k][4] ?? Hydrator::$propertyScopes[$class->name][$k][4] = new \ReflectionProperty($scope, $name);`
`@@ -170,7 +170,7 @@ public static function generateLazyProxy(?\ReflectionClass $class, array $interf`
`170`	`170`	`$methodReflectors = [$class?->getMethods(\ReflectionMethod::IS_PUBLIC \| \ReflectionMethod::IS_PROTECTED) ?? []];`
`171`	`171`	`foreach ($interfaces as $interface) {`
`172`	`172`	`if (!$interface->isInterface()) {`
`173`		`- throw new LogicException(sprintf('Cannot generate lazy proxy: "%s" is not an interface.', $interface->name));`
	`173`	`+ throw new LogicException(\sprintf('Cannot generate lazy proxy: "%s" is not an interface.', $interface->name));`
`174`	`174`	`}`
`175`	`175`	`$methodReflectors[] = $interface->getMethods();`
`176`	`176`
`@@ -228,7 +228,7 @@ public static function generateLazyProxy(?\ReflectionClass $class, array $interf`
`228`	`228`
`229`	`229`	`EOPHP;`
`230`	`230`	`} else {`
`231`		`- throw new LogicException(sprintf('Cannot generate lazy proxy: hook "%s::%s()" is not supported.', $class->name, $method->name));`
	`231`	`+ throw new LogicException(\sprintf('Cannot generate lazy proxy: hook "%s::%s()" is not supported.', $class->name, $method->name));`
`232`	`232`	`}`
`233`	`233`	`}`
`234`	`234`
`@@ -266,7 +266,7 @@ public static function generateLazyProxy(?\ReflectionClass $class, array $interf`
`266`	`266`	`}`
`267`	`267`	`if ($method->isFinal()) {`
`268`	`268`	`if ($extendsInternalClass \|\| $methodsHaveToBeProxied \|\| method_exists(LazyProxyTrait::class, $method->name)) {`
`269`		`- throw new LogicException(sprintf('Cannot generate lazy proxy: method "%s::%s()" is final.', $class->name, $method->name));`
	`269`	`+ throw new LogicException(\sprintf('Cannot generate lazy proxy: method "%s::%s()" is final.', $class->name, $method->name));`
`270`	`270`	`}`
`271`	`271`	`continue;`
`272`	`272`	`}`
`@@ -396,7 +396,7 @@ public static function exportParameters(\ReflectionFunctionAbstract $function, b`
`396`	`396`	`$args = substr($args, 0, -2);`
`397`	`397`	`} else {`
`398`	`398`	`$args = explode(', ', $args, 1 + $byRefIndex);`
`399`		`- $args[$byRefIndex] = sprintf('...\array_slice(\func_get_args(), %d)', $byRefIndex);`
	`399`	`+ $args[$byRefIndex] = \sprintf('...\array_slice(\func_get_args(), %d)', $byRefIndex);`
`400`	`400`	`$args = implode(', ', $args);`
`401`	`401`	`}`
`402`	`402`
Original file line number	Diff line number	Diff line change
`@@ -208,7 +208,7 @@ public function testOverwritePropClass()`
`208`	`208`
`209`	`209`	`public function testWither()`
`210`	`210`	`{`
`211`		`- $obj = new class() {`
	`211`	`+ $obj = new class {`
`212`	`212`	`public $foo = 123;`
`213`	`213`
`214`	`214`	`public function withFoo($foo): static`
`@@ -229,7 +229,7 @@ public function withFoo($foo): static`
`229`	`229`
`230`	`230`	`public function testFluent()`
`231`	`231`	`{`
`232`		`- $obj = new class() {`
	`232`	`+ $obj = new class {`
`233`	`233`	`public $foo = 123;`
`234`	`234`
`235`	`235`	`public function setFoo($foo): static`
`@@ -247,7 +247,7 @@ public function setFoo($foo): static`
`247`	`247`
`248`	`248`	`public function testIndirectModification()`
`249`	`249`	`{`
`250`		`- $obj = new class() {`
	`250`	`+ $obj = new class {`
`251`	`251`	`public array $foo;`
`252`	`252`	`};`
`253`	`253`	`$proxy = $this->createLazyProxy($obj::class, fn () => $obj);`
`@@ -274,7 +274,7 @@ public function testReadOnlyClass()`
`274`	`274`
`275`	`275`	`public function testLazyDecoratorClass()`
`276`	`276`	`{`
`277`		`- $obj = new class() extends TestClass {`
	`277`	`+ $obj = new class extends TestClass {`
`278`	`278`	`use LazyProxyTrait {`
`279`	`279`	`createLazyProxy as private;`
`280`	`280`	`}`