tests: use namespaces in code samples (#23)

janedbal · web-flow · commit 1053dae1653f · 2022-08-20T11:40:26.000+02:00
diff --git a/tests/Rule/data/AllowComparingOnlyComparableTypesRule/code.php b/tests/Rule/data/AllowComparingOnlyComparableTypesRule/code.php
@@ -1,5 +1,10 @@
 <?php declare(strict_types = 1);
 
+namespace AllowComparingOnlyComparableTypesRule;
+
+use DateTime;
+use DateTimeImmutable;
+
 interface Foo {}
 interface Bar {}
 
@@ -21,20 +26,20 @@ interface Bar {}
     float $float,
     bool $bool,
 ) {
-    $foos > $foo; // error: Comparison array > Foo contains non-comparable type, only int|float|string|DateTimeInterface is allowed.
+    $foos > $foo; // error: Comparison array > AllowComparingOnlyComparableTypesRule\Foo contains non-comparable type, only int|float|string|DateTimeInterface is allowed.
     $nullableInt > $int; // error: Comparison int|null > int contains non-comparable type, only int|float|string|DateTimeInterface is allowed.
     null > $int; // error: Comparison null > int contains non-comparable type, only int|float|string|DateTimeInterface is allowed.
-    $foo > $foo2; // error: Comparison Foo > Foo contains non-comparable type, only int|float|string|DateTimeInterface is allowed.
-    $foo > $fooOrBar; // error: Comparison Foo > Bar|Foo contains non-comparable type, only int|float|string|DateTimeInterface is allowed.
-    $foo > $fooAndBar; // error: Comparison Foo > Bar&Foo contains non-comparable type, only int|float|string|DateTimeInterface is allowed.
+    $foo > $foo2; // error: Comparison AllowComparingOnlyComparableTypesRule\Foo > AllowComparingOnlyComparableTypesRule\Foo contains non-comparable type, only int|float|string|DateTimeInterface is allowed.
+    $foo > $fooOrBar; // error: Comparison AllowComparingOnlyComparableTypesRule\Foo > AllowComparingOnlyComparableTypesRule\Bar|AllowComparingOnlyComparableTypesRule\Foo contains non-comparable type, only int|float|string|DateTimeInterface is allowed.
+    $foo > $fooAndBar; // error: Comparison AllowComparingOnlyComparableTypesRule\Foo > AllowComparingOnlyComparableTypesRule\Bar&AllowComparingOnlyComparableTypesRule\Foo contains non-comparable type, only int|float|string|DateTimeInterface is allowed.
     $string > 'foo';
     $int > 2;
     $float > 2;
     $int > $intOrFloat;
     $string > $intOrFloat; // error: Cannot compare different types in string > float|int.
     $bool > true; // error: Comparison bool > true contains non-comparable type, only int|float|string|DateTimeInterface is allowed.
     $dateTime > $dateTimeImmutable;
-    $dateTime > $foo; // error: Comparison DateTime > Foo contains non-comparable type, only int|float|string|DateTimeInterface is allowed.
+    $dateTime > $foo; // error: Comparison DateTime > AllowComparingOnlyComparableTypesRule\Foo contains non-comparable type, only int|float|string|DateTimeInterface is allowed.
 
     $string > $int; // error: Cannot compare different types in string > int.
     $float > $int;
diff --git a/tests/Rule/data/AllowNamedArgumentOnlyInAttributesRule/code.php b/tests/Rule/data/AllowNamedArgumentOnlyInAttributesRule/code.php
@@ -1,7 +1,10 @@
 <?php declare(strict_types = 1);
 
+namespace AllowNamedArgumentOnlyInAttributesRule;
 
-#[\Attribute(flags: \Attribute::TARGET_ALL)]
+use Attribute;
+
+#[Attribute(flags: Attribute::TARGET_ALL)]
 class UniversalAttribute
 {
     public function __construct(int $argument)
diff --git a/tests/Rule/data/BackedEnumGenericsRule/code.php b/tests/Rule/data/BackedEnumGenericsRule/code.php
@@ -1,5 +1,9 @@
 <?php
 
+namespace BackedEnumGenericsRule;
+
+use BackedEnum;
+
 /**
  * @implements BackedEnum<string>
  */
@@ -19,7 +23,7 @@ interface MyBackedEnum extends BackedEnum {
 
 }
 
-enum MyIntEnumWithoutImplements: int { // error: Class MyIntEnumWithoutImplements extends generic BackedEnum, but does not specify its type. Use @implements BackedEnum<int>
+enum MyIntEnumWithoutImplements: int { // error: Class BackedEnumGenericsRule\MyIntEnumWithoutImplements extends generic BackedEnum, but does not specify its type. Use @implements BackedEnum<int>
 }
 
 enum MyIntEnumWithImplementsInParent: int implements MyBackedEnum {
diff --git a/tests/Rule/data/ForbidEnumInFunctionArgumentsRule/code.php b/tests/Rule/data/ForbidEnumInFunctionArgumentsRule/code.php
@@ -1,5 +1,7 @@
 <?php declare(strict_types = 1);
 
+namespace ForbidEnumInFunctionArgumentsRule;
+
 enum SomeEnum: string {
     case Bar = 'bar';
     case Baz = 'baz';
diff --git a/tests/Rule/data/ForbidFetchOnMixedRuleTest/code.php b/tests/Rule/data/ForbidFetchOnMixedRuleTest/code.php
@@ -1,5 +1,9 @@
 <?php
 
+namespace ForbidFetchOnMixedRuleTest;
+
+use ReflectionClass;
+
 $fn = function (mixed $mixed, $unknown, array $array, ReflectionClass $reflection) {
     $mixed->fetch1; // error: Property fetch ->fetch1 is prohibited on unknown type ($mixed)
     $unknown->fetch2; // error: Property fetch ->fetch2 is prohibited on unknown type ($unknown)
diff --git a/tests/Rule/data/ForbidMatchDefaultArmForEnumsRule/code.php b/tests/Rule/data/ForbidMatchDefaultArmForEnumsRule/code.php
@@ -1,5 +1,7 @@
 <?php declare(strict_types = 1);
 
+namespace ForbidMatchDefaultArmForEnumsRule;
+
 enum MyEnum: string {
     case MyCase1 = 'MyCase1';
     case MyCase2 = 'MyCase2';
diff --git a/tests/Rule/data/ForbidMethodCallOnMixedRule/code.php b/tests/Rule/data/ForbidMethodCallOnMixedRule/code.php
@@ -1,5 +1,9 @@
 <?php
 
+namespace ForbidMethodCallOnMixedRule;
+
+use ReflectionClass;
+
 $fn = function (mixed $mixed, $unknown, array $array, ReflectionClass $reflection) {
     $mixed->call1(); // error: Method call ->call1() is prohibited on unknown type ($mixed)
     $unknown->call2(); // error: Method call ->call2() is prohibited on unknown type ($unknown)
diff --git a/tests/Rule/data/ForbidReturnInConstructorRule/code.php b/tests/Rule/data/ForbidReturnInConstructorRule/code.php
@@ -1,5 +1,7 @@
 <?php declare(strict_types = 1);
 
+namespace ForbidReturnInConstructorRule;
+
 class WithReturn {
 
     public function __construct()
diff --git a/tests/Rule/data/ForbidUnsetClassFieldRule/code.php b/tests/Rule/data/ForbidUnsetClassFieldRule/code.php
@@ -1,5 +1,7 @@
 <?php
 
+namespace ForbidUnsetClassFieldRule;
+
 class Clazz {
 
     public ?int $foo;
diff --git a/tests/Rule/data/ForbidUnusedExceptionRule/code.php b/tests/Rule/data/ForbidUnusedExceptionRule/code.php
@@ -1,23 +1,30 @@
 <?php declare(strict_types = 1);
 
+namespace ForbidUnusedExceptionRule;
+
+use Exception;
+use LogicException;
+use RuntimeException;
+use Throwable;
+
 class ExampleClass
 {
 
     public function __construct()
     {
         $this->getExceptionAtRuntime(); // error: Method $this->getExceptionAtRuntime() returns exception that was not used in any way.
         $this->getException(); // error: Method $this->getException() returns exception that was not used in any way.
-        new \Exception(); // error: Exception new \Exception() was not used in any way.
+        new Exception(); // error: Exception new \Exception() was not used in any way.
 
         $this->okUsage1();
         $this->okUsage2();
         $this->okUsage3();
-        $this->okUsage4(new \LogicException());
+        $this->okUsage4(new LogicException());
     }
 
     public function okUsage1(): void
     {
-        throw new \LogicException();
+        throw new LogicException();
     }
 
     public function okUsage2(): void
@@ -35,14 +42,14 @@ public function okUsage4(Throwable $throwable): void
         $this->okUsage4($throwable);
     }
 
-    public function getExceptionAtRuntime(): \RuntimeException
+    public function getExceptionAtRuntime(): RuntimeException
     {
-        return new \RuntimeException();
+        return new RuntimeException();
     }
 
-    public static function getException(): \RuntimeException
+    public static function getException(): RuntimeException
     {
-        return new \RuntimeException();
+        return new RuntimeException();
     }
 
 }
diff --git a/tests/Rule/data/ForbidUselessNullableReturnRule/code.php b/tests/Rule/data/ForbidUselessNullableReturnRule/code.php
@@ -1,5 +1,7 @@
 <?php
 
+namespace ForbidUselessNullableReturnRule;
+
 class ExampleClass {
 
     private ?int $foo;
diff --git a/tests/Rule/data/RequirePreviousExceptionPassRule/with-accept-check.php b/tests/Rule/data/RequirePreviousExceptionPassRule/with-accept-check.php
@@ -1,5 +1,12 @@
 <?php
 
+namespace RequirePreviousExceptionPassRule;
+
+use Exception;
+use LogicException;
+use RuntimeException;
+use Throwable;
+
 class MyException extends RuntimeException {
 
     public static function createForAnyPrevious(?Throwable $previous = null): self
@@ -35,12 +42,12 @@ public static function createWithoutPrevious(): self
 
 try {
 } catch (LogicException $e) {
-    throw MyException::createForAnyPrevious(); // error: Exception $e not passed as previous to \MyException::createForAnyPrevious()
+    throw MyException::createForAnyPrevious(); // error: Exception $e not passed as previous to \RequirePreviousExceptionPassRule\MyException::createForAnyPrevious()
 }
 
 try {
 } catch (RuntimeException $e) {
-    throw MyException::createForSpecificPrevious(); // error: Exception $e not passed as previous to \MyException::createForSpecificPrevious()
+    throw MyException::createForSpecificPrevious(); // error: Exception $e not passed as previous to \RequirePreviousExceptionPassRule\MyException::createForSpecificPrevious()
 }
 
 try {
@@ -61,5 +68,5 @@ public static function createWithoutPrevious(): self
 try {
 } catch (LogicException $e) {
 } catch (LogicException|RuntimeException $e) { // Logic can never occur here, so Runtime must be passed
-    throw MyException::createForSpecificPrevious(); // error: Exception $e not passed as previous to \MyException::createForSpecificPrevious()
+    throw MyException::createForSpecificPrevious(); // error: Exception $e not passed as previous to \RequirePreviousExceptionPassRule\MyException::createForSpecificPrevious()
 }
diff --git a/tests/Rule/data/RequirePreviousExceptionPassRule/without-accept-check.php b/tests/Rule/data/RequirePreviousExceptionPassRule/without-accept-check.php
@@ -1,5 +1,12 @@
 <?php
 
+namespace RequirePreviousExceptionPassRule;
+
+use Exception;
+use LogicException;
+use RuntimeException;
+use Throwable;
+
 class MyException extends RuntimeException {
 
     public static function createForAnyPrevious(?Throwable $previous = null): self
@@ -35,26 +42,26 @@ public static function createWithoutPrevious(): self
 
 try {
 } catch (LogicException $e) {
-    throw MyException::createForAnyPrevious(); // error: Exception $e not passed as previous to \MyException::createForAnyPrevious()
+    throw MyException::createForAnyPrevious(); // error: Exception $e not passed as previous to \RequirePreviousExceptionPassRule\MyException::createForAnyPrevious()
 }
 
 try {
 } catch (RuntimeException $e) {
-    throw MyException::createForSpecificPrevious(); // error: Exception $e not passed as previous to \MyException::createForSpecificPrevious()
+    throw MyException::createForSpecificPrevious(); // error: Exception $e not passed as previous to \RequirePreviousExceptionPassRule\MyException::createForSpecificPrevious()
 }
 
 try {
 } catch (Throwable $e) {
-    throw MyException::createWithoutPrevious(); // error: Exception $e not passed as previous to \MyException::createWithoutPrevious()
+    throw MyException::createWithoutPrevious(); // error: Exception $e not passed as previous to \RequirePreviousExceptionPassRule\MyException::createWithoutPrevious()
 }
 
 try {
 } catch (LogicException $e) {
-    throw MyException::createForSpecificPrevious(); // error: Exception $e not passed as previous to \MyException::createForSpecificPrevious()
+    throw MyException::createForSpecificPrevious(); // error: Exception $e not passed as previous to \RequirePreviousExceptionPassRule\MyException::createForSpecificPrevious()
 }
 
 try {
 } catch (LogicException|RuntimeException $e) {
-    throw MyException::createForSpecificPrevious(); // error: Exception $e not passed as previous to \MyException::createForSpecificPrevious()
+    throw MyException::createForSpecificPrevious(); // error: Exception $e not passed as previous to \RequirePreviousExceptionPassRule\MyException::createForSpecificPrevious()
 }
 
diff --git a/tests/Rule/data/UselessPrivatePropertyDefaultValueRule/code.php b/tests/Rule/data/UselessPrivatePropertyDefaultValueRule/code.php
@@ -1,12 +1,14 @@
 <?php declare(strict_types = 1);
 
-class UselessPrivatePropertyDefaultValueRuleExampleClass
+namespace UselessPrivatePropertyDefaultValueRule;
+
+class ExampleClass
 {
     public int $isPublic = 0;
 
     protected int $isProtected = 0;
 
-    private int $isPrivate = 0; // error: Property UselessPrivatePropertyDefaultValueRuleExampleClass::isPrivate has useless default value (overwritten in constructor)
+    private int $isPrivate = 0; // error: Property UselessPrivatePropertyDefaultValueRule\ExampleClass::isPrivate has useless default value (overwritten in constructor)
 
     private int $isPrivateWithConditionalAssignment = 0; // not detected due to condition used in ctor
 
diff --git a/tests/Rule/data/UselessPrivatePropertyNullabilityRule/code.php b/tests/Rule/data/UselessPrivatePropertyNullabilityRule/code.php
@@ -1,20 +1,22 @@
 <?php declare(strict_types = 1);
 
-class UselessPrivatePropertyNullabilityRuleExampleClass
+namespace UselessPrivatePropertyNullabilityRule;
+
+class ExampleClass
 {
     public ?int $isPublic;
 
     protected ?int $isProtected;
 
-    private ?int $isPrivate; // error: Property UselessPrivatePropertyNullabilityRuleExampleClass::isPrivate is defined as nullable, but null is never assigned
+    private ?int $isPrivate; // error: Property UselessPrivatePropertyNullabilityRule\ExampleClass::isPrivate is defined as nullable, but null is never assigned
 
     private ?int $isPrivateAssigned;
 
     private ?int $isPrivateWithConditionalAssignment;
 
     private ?int $isPrivateWithDefaultNull = null;
 
-    private ?int $isPrivateWithDefaultNotNull = 1; // error: Property UselessPrivatePropertyNullabilityRuleExampleClass::isPrivateWithDefaultNotNull is defined as nullable, but null is never assigned
+    private ?int $isPrivateWithDefaultNotNull = 1; // error: Property UselessPrivatePropertyNullabilityRule\ExampleClass::isPrivateWithDefaultNotNull is defined as nullable, but null is never assigned
 
     private ?int $isUninitialized;
 

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,9 @@`
`1`	`1`	`<?php`
`2`	`2`
	`3`	`+namespace BackedEnumGenericsRule;`
	`4`	`+`
	`5`	`+use BackedEnum;`
	`6`	`+`
`3`	`7`	`/**`
`4`	`8`	`* @implements BackedEnum<string>`
`5`	`9`	`*/`
`@@ -19,7 +23,7 @@ interface MyBackedEnum extends BackedEnum {`
`19`	`23`
`20`	`24`	`}`
`21`	`25`
`22`		`-enum MyIntEnumWithoutImplements: int { // error: Class MyIntEnumWithoutImplements extends generic BackedEnum, but does not specify its type. Use @implements BackedEnum<int>`
	`26`	`+enum MyIntEnumWithoutImplements: int { // error: Class BackedEnumGenericsRule\MyIntEnumWithoutImplements extends generic BackedEnum, but does not specify its type. Use @implements BackedEnum<int>`
`23`	`27`	`}`
`24`	`28`
`25`	`29`	`enum MyIntEnumWithImplementsInParent: int implements MyBackedEnum {`
Original file line number	Diff line number	Diff line change
`@@ -1,23 +1,30 @@`
`1`	`1`	`<?php declare(strict_types = 1);`
`2`	`2`
	`3`	`+namespace ForbidUnusedExceptionRule;`
	`4`	`+`
	`5`	`+use Exception;`
	`6`	`+use LogicException;`
	`7`	`+use RuntimeException;`
	`8`	`+use Throwable;`
	`9`	`+`
`3`	`10`	`class ExampleClass`
`4`	`11`	`{`
`5`	`12`
`6`	`13`	`public function __construct()`
`7`	`14`	`{`
`8`	`15`	`$this->getExceptionAtRuntime(); // error: Method $this->getExceptionAtRuntime() returns exception that was not used in any way.`
`9`	`16`	`$this->getException(); // error: Method $this->getException() returns exception that was not used in any way.`
`10`		`- new \Exception(); // error: Exception new \Exception() was not used in any way.`
	`17`	`+ new Exception(); // error: Exception new \Exception() was not used in any way.`
`11`	`18`
`12`	`19`	`$this->okUsage1();`
`13`	`20`	`$this->okUsage2();`
`14`	`21`	`$this->okUsage3();`
`15`		`- $this->okUsage4(new \LogicException());`
	`22`	`+ $this->okUsage4(new LogicException());`
`16`	`23`	`}`
`17`	`24`
`18`	`25`	`public function okUsage1(): void`
`19`	`26`	`{`
`20`		`- throw new \LogicException();`
	`27`	`+ throw new LogicException();`
`21`	`28`	`}`
`22`	`29`
`23`	`30`	`public function okUsage2(): void`
`@@ -35,14 +42,14 @@ public function okUsage4(Throwable $throwable): void`
`35`	`42`	`$this->okUsage4($throwable);`
`36`	`43`	`}`
`37`	`44`
`38`		`- public function getExceptionAtRuntime(): \RuntimeException`
	`45`	`+ public function getExceptionAtRuntime(): RuntimeException`
`39`	`46`	`{`
`40`		`- return new \RuntimeException();`
	`47`	`+ return new RuntimeException();`
`41`	`48`	`}`
`42`	`49`
`43`		`- public static function getException(): \RuntimeException`
	`50`	`+ public static function getException(): RuntimeException`
`44`	`51`	`{`
`45`		`- return new \RuntimeException();`
	`52`	`+ return new RuntimeException();`
`46`	`53`	`}`
`47`	`54`
`48`	`55`	`}`