From 32b3d0a14d77da15b5339e4e5278b5abcdf00c17 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20M=C3=B6ller?= Date: Mon, 17 Feb 2025 15:44:33 +0100 Subject: [PATCH] Enhancement: Implement NoParameterPassedByReferenceRule --- README.md | 48 ++++++++++ rules.neon | 20 ++++ .../NoParameterPassedByReferenceRule.php | 64 +++++++++++++ src/ErrorIdentifier.php | 5 + .../NoParameterPassedByReferenceRule.php | 67 +++++++++++++ .../NoParameterPassedByReferenceRule.php | 94 +++++++++++++++++++ .../NoParameterPassedByReferenceRule/Bar.php | 9 ++ .../script.php | 24 +++++ .../NoParameterPassedByReferenceRule/Bar.php | 9 ++ .../script.php | 24 +++++ .../NoParameterPassedByReferenceRule/Bar.php | 9 ++ .../MethodInClassWithParameter.php | 13 +++ ...edParameterExplicitlyPassedByReference.php | 13 +++ ...edParameterImplicitlyPassedByReference.php | 13 +++ ...edParameterExplicitlyPassedByReference.php | 13 +++ .../MethodInClassWithoutParameters.php | 12 +++ .../MethodInInterfaceWithParameter.php | 10 ++ ...edParameterExplicitlyPassedByReference.php | 10 ++ ...edParameterImplicitlyPassedByReference.php | 10 ++ ...edParameterExplicitlyPassedByReference.php | 10 ++ .../MethodInInterfaceWithoutParameters.php | 10 ++ .../MethodInTraitWithParameter.php | 13 +++ ...edParameterExplicitlyPassedByReference.php | 13 +++ ...edParameterImplicitlyPassedByReference.php | 13 +++ ...edParameterExplicitlyPassedByReference.php | 13 +++ .../MethodInTraitWithoutParameters.php | 12 +++ .../script.php | 39 ++++++++ .../NoParameterPassedByReferenceRuleTest.php | 53 +++++++++++ .../NoParameterPassedByReferenceRuleTest.php | 53 +++++++++++ .../NoParameterPassedByReferenceTest.php | 81 ++++++++++++++++ test/Unit/ErrorIdentifierTest.php | 7 ++ 31 files changed, 784 insertions(+) create mode 100644 src/Closures/NoParameterPassedByReferenceRule.php create mode 100644 src/Functions/NoParameterPassedByReferenceRule.php create mode 100644 src/Methods/NoParameterPassedByReferenceRule.php create mode 100644 test/Fixture/Closures/NoParameterPassedByReferenceRule/Bar.php create mode 100644 test/Fixture/Closures/NoParameterPassedByReferenceRule/script.php create mode 100644 test/Fixture/Functions/NoParameterPassedByReferenceRule/Bar.php create mode 100644 test/Fixture/Functions/NoParameterPassedByReferenceRule/script.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/Bar.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInClassWithParameter.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInClassWithTypedParameterExplicitlyPassedByReference.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInClassWithTypedParameterImplicitlyPassedByReference.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInClassWithUntypedParameterExplicitlyPassedByReference.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInClassWithoutParameters.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInInterfaceWithParameter.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInInterfaceWithTypedParameterExplicitlyPassedByReference.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInInterfaceWithTypedParameterImplicitlyPassedByReference.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInInterfaceWithUntypedParameterExplicitlyPassedByReference.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInInterfaceWithoutParameters.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInTraitWithParameter.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInTraitWithTypedParameterExplicitlyPassedByReference.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInTraitWithTypedParameterImplicitlyPassedByReference.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInTraitWithUntypedParameterExplicitlyPassedByReference.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/MethodInTraitWithoutParameters.php create mode 100644 test/Fixture/Methods/NoParameterPassedByReferenceRule/script.php create mode 100644 test/Integration/Closures/NoParameterPassedByReferenceRuleTest.php create mode 100644 test/Integration/Functions/NoParameterPassedByReferenceRuleTest.php create mode 100644 test/Integration/Methods/NoParameterPassedByReferenceTest.php diff --git a/README.md b/README.md index 7a97363b..1fce8c9d 100644 --- a/README.md +++ b/README.md @@ -48,6 +48,7 @@ This package provides the following rules for use with [`phpstan/phpstan`](https - [`Ergebnis\PHPStan\Rules\Classes\NoExtendsRule`](https://github.com/ergebnis/phpstan-rules#classesnoextendsrule) - [`Ergebnis\PHPStan\Rules\Classes\PHPUnit\Framework\TestCaseWithSuffixRule`](https://github.com/ergebnis/phpstan-rules#classesphpunitframeworktestcasewithsuffixrule) - [`Ergebnis\PHPStan\Rules\Closures\NoNullableReturnTypeDeclarationRule`](https://github.com/ergebnis/phpstan-rules#closuresnonullablereturntypedeclarationrule) +- [`Ergebnis\PHPStan\Rules\Closures\NoParameterPassedByReferenceRule`](https://github.com/ergebnis/phpstan-rules#closuresnoparameterpassedbyreferencerule) - [`Ergebnis\PHPStan\Rules\Closures\NoParameterWithNullableTypeDeclarationRule`](https://github.com/ergebnis/phpstan-rules#closuresnoparameterwithnullabletypedeclarationrule) - [`Ergebnis\PHPStan\Rules\Closures\NoParameterWithNullDefaultValueRule`](https://github.com/ergebnis/phpstan-rules#closuresnoparameterwithnulldefaultvaluerule) - [`Ergebnis\PHPStan\Rules\Expressions\NoCompactRule`](https://github.com/ergebnis/phpstan-rules#expressionsnocompactrule) @@ -56,11 +57,13 @@ This package provides the following rules for use with [`phpstan/phpstan`](https - [`Ergebnis\PHPStan\Rules\Expressions\NoIssetRule`](https://github.com/ergebnis/phpstan-rules#expressionsnoissetrule) - [`Ergebnis\PHPStan\Rules\Files\DeclareStrictTypesRule`](https://github.com/ergebnis/phpstan-rules#filesdeclarestricttypesrule) - [`Ergebnis\PHPStan\Rules\Functions\NoNullableReturnTypeDeclarationRule`](https://github.com/ergebnis/phpstan-rules#functionsnonullablereturntypedeclarationrule) +- [`Ergebnis\PHPStan\Rules\Functions\NoParameterPassedByReferenceRule`](https://github.com/ergebnis/phpstan-rules#functionsnoparameterpassedbyreferencerule) - [`Ergebnis\PHPStan\Rules\Functions\NoParameterWithNullableTypeDeclarationRule`](https://github.com/ergebnis/phpstan-rules#functionsnoparameterwithnullabletypedeclarationrule) - [`Ergebnis\PHPStan\Rules\Functions\NoParameterWithNullDefaultValueRule`](https://github.com/ergebnis/phpstan-rules#functionsnoparameterwithnulldefaultvaluerule) - [`Ergebnis\PHPStan\Rules\Methods\FinalInAbstractClassRule`](https://github.com/ergebnis/phpstan-rules#methodsfinalinabstractclassrule) - [`Ergebnis\PHPStan\Rules\Methods\NoConstructorParameterWithDefaultValueRule`](https://github.com/ergebnis/phpstan-rules#methodsnoconstructorparameterwithdefaultvaluerule) - [`Ergebnis\PHPStan\Rules\Methods\NoNullableReturnTypeDeclarationRule`](https://github.com/ergebnis/phpstan-rules#methodsnonullablereturntypedeclarationrule) +- [`Ergebnis\PHPStan\Rules\Methods\NoParameterPassedByReferenceRule`](https://github.com/ergebnis/phpstan-rules#methodsnoparameterpassedbyreferencerule) - [`Ergebnis\PHPStan\Rules\Methods\NoParameterWithContainerTypeDeclarationRule`](https://github.com/ergebnis/phpstan-rules#methodsnoparameterwithcontainertypedeclarationrule) - [`Ergebnis\PHPStan\Rules\Methods\NoParameterWithNullableTypeDeclarationRule`](https://github.com/ergebnis/phpstan-rules#methodsnoparameterwithnullabletypedeclarationrule) - [`Ergebnis\PHPStan\Rules\Methods\NoParameterWithNullDefaultValueRule`](https://github.com/ergebnis/phpstan-rules#methodsnoparameterwithnulldefaultvaluerule) @@ -183,6 +186,21 @@ parameters: enabled: false ``` +#### `Closures\NoParameterPassedByReferenceRule` + +This rule reports an error when a closure has a parameter that is [passed by reference](https://www.php.net/manual/en/language.references.pass.php). + +##### Disabling the rule + +You can set the `enabled` parameter to `false` to disable this rule. + +```neon +parameters: + ergebnis: + noParameterPassedByReference: + enabled: false +``` + #### `Closures\NoParameterWithNullableTypeDeclarationRule` This rule reports an error when a closure has a parameter with a nullable type declaration. @@ -309,6 +327,21 @@ parameters: enabled: false ``` +#### `Functions\NoParameterPassedByReferenceRule` + +This rule reports an error when a function has a parameter that is [passed by reference](https://www.php.net/manual/en/language.references.pass.php). + +##### Disabling the rule + +You can set the `enabled` parameter to `false` to disable this rule. + +```neon +parameters: + ergebnis: + noParameterPassedByReference: + enabled: false +``` + #### `Functions\NoParameterWithNullableTypeDeclarationRule` This rule reports an error when a function has a parameter with a nullable type declaration. @@ -381,6 +414,21 @@ parameters: enabled: false ``` +#### `Methods\NoParameterPassedByReferenceRule` + +This rule reports an error when a method has a parameter that is [passed by reference](https://www.php.net/manual/en/language.references.pass.php). + +##### Disabling the rule + +You can set the `enabled` parameter to `false` to disable this rule. + +```neon +parameters: + ergebnis: + noParameterPassedByReference: + enabled: false +``` + #### `Methods\NoNullableReturnTypeDeclarationRule` This rule reports an error when a method declared in diff --git a/rules.neon b/rules.neon index 7f827de8..994a1feb 100644 --- a/rules.neon +++ b/rules.neon @@ -7,6 +7,8 @@ conditionalTags: phpstan.rules.rule: %ergebnis.testCaseWithSuffix.enabled% Ergebnis\PHPStan\Rules\Closures\NoNullableReturnTypeDeclarationRule: phpstan.rules.rule: %ergebnis.noNullableReturnTypeDeclaration.enabled% + Ergebnis\PHPStan\Rules\Closures\NoParameterPassedByReferenceRule: + phpstan.rules.rule: %ergebnis.noParameterPassedByReference.enabled% Ergebnis\PHPStan\Rules\Closures\NoParameterWithNullableTypeDeclarationRule: phpstan.rules.rule: %ergebnis.noParameterWithNullableTypeDeclaration.enabled% Ergebnis\PHPStan\Rules\Expressions\NoCompactRule: @@ -21,6 +23,8 @@ conditionalTags: phpstan.rules.rule: %ergebnis.declareStrictTypes.enabled% Ergebnis\PHPStan\Rules\Functions\NoNullableReturnTypeDeclarationRule: phpstan.rules.rule: %ergebnis.noNullableReturnTypeDeclaration.enabled% + Ergebnis\PHPStan\Rules\Functions\NoParameterPassedByReferenceRule: + phpstan.rules.rule: %ergebnis.noParameterPassedByReference.enabled% Ergebnis\PHPStan\Rules\Functions\NoParameterWithNullableTypeDeclarationRule: phpstan.rules.rule: %ergebnis.noParameterWithNullableTypeDeclaration.enabled% Ergebnis\PHPStan\Rules\Functions\NoParameterWithNullDefaultValueRule: @@ -31,6 +35,8 @@ conditionalTags: phpstan.rules.rule: %ergebnis.noConstructorParameterWithDefaultValue.enabled% Ergebnis\PHPStan\Rules\Methods\NoNullableReturnTypeDeclarationRule: phpstan.rules.rule: %ergebnis.noNullableReturnTypeDeclaration.enabled% + Ergebnis\PHPStan\Rules\Methods\NoParameterPassedByReferenceRule: + phpstan.rules.rule: %ergebnis.noParameterPassedByReference.enabled% Ergebnis\PHPStan\Rules\Methods\NoParameterWithContainerTypeDeclarationRule: phpstan.rules.rule: %ergebnis.noParameterWithContainerTypeDeclaration.enabled% Ergebnis\PHPStan\Rules\Methods\NoParameterWithNullableTypeDeclarationRule: @@ -67,6 +73,8 @@ parameters: enabled: true noNullableReturnTypeDeclaration: enabled: true + noParameterPassedByReference: + enabled: true noParameterWithContainerTypeDeclaration: enabled: true interfacesImplementedByContainers: @@ -118,6 +126,9 @@ parametersSchema: noNullableReturnTypeDeclaration: structure([ enabled: bool(), ]) + noParameterPassedByReference: structure([ + enabled: bool(), + ]) noParameterWithContainerTypeDeclaration: structure([ enabled: bool(), interfacesImplementedByContainers: listOf(string()) @@ -161,6 +172,9 @@ services: - class: Ergebnis\PHPStan\Rules\Closures\NoNullableReturnTypeDeclarationRule + - + class: Ergebnis\PHPStan\Rules\Closures\NoParameterPassedByReferenceRule + - class: Ergebnis\PHPStan\Rules\Closures\NoParameterWithNullableTypeDeclarationRule @@ -182,6 +196,9 @@ services: - class: Ergebnis\PHPStan\Rules\Functions\NoNullableReturnTypeDeclarationRule + - + class: Ergebnis\PHPStan\Rules\Functions\NoParameterPassedByReferenceRule + - class: Ergebnis\PHPStan\Rules\Functions\NoParameterWithNullableTypeDeclarationRule @@ -197,6 +214,9 @@ services: - class: Ergebnis\PHPStan\Rules\Methods\NoNullableReturnTypeDeclarationRule + - + class: Ergebnis\PHPStan\Rules\Methods\NoParameterPassedByReferenceRule + - class: Ergebnis\PHPStan\Rules\Methods\NoParameterWithContainerTypeDeclarationRule arguments: diff --git a/src/Closures/NoParameterPassedByReferenceRule.php b/src/Closures/NoParameterPassedByReferenceRule.php new file mode 100644 index 00000000..2c47cb74 --- /dev/null +++ b/src/Closures/NoParameterPassedByReferenceRule.php @@ -0,0 +1,64 @@ + + */ +final class NoParameterPassedByReferenceRule implements Rules\Rule +{ + public function getNodeType(): string + { + return Node\Expr\Closure::class; + } + + public function processNode( + Node $node, + Analyser\Scope $scope + ): array { + if (0 === \count($node->params)) { + return []; + } + + $parametersPassedByReference = \array_values(\array_filter($node->params, static function (Node\Param $parameter): bool { + return $parameter->byRef; + })); + + if (0 === \count($parametersPassedByReference)) { + return []; + } + + return \array_map(static function (Node\Param $parameterPassedByReference): Rules\RuleError { + /** @var Node\Expr\Variable $variable */ + $variable = $parameterPassedByReference->var; + + /** @var string $parameterName */ + $parameterName = $variable->name; + + $message = \sprintf( + 'Closure has parameter $%s that is passed by reference.', + $parameterName, + ); + + return Rules\RuleErrorBuilder::message($message) + ->identifier(ErrorIdentifier::noParameterPassedByReference()->toString()) + ->build(); + }, $parametersPassedByReference); + } +} diff --git a/src/ErrorIdentifier.php b/src/ErrorIdentifier.php index 3559fb90..a0a67429 100644 --- a/src/ErrorIdentifier.php +++ b/src/ErrorIdentifier.php @@ -70,6 +70,11 @@ public static function noIsset(): self return new self('noIsset'); } + public static function noParameterPassedByReference(): self + { + return new self('noParameterPassedByReference'); + } + public static function noParameterWithContainerTypeDeclaration(): self { return new self('noParameterWithContainerTypeDeclaration'); diff --git a/src/Functions/NoParameterPassedByReferenceRule.php b/src/Functions/NoParameterPassedByReferenceRule.php new file mode 100644 index 00000000..e461aa13 --- /dev/null +++ b/src/Functions/NoParameterPassedByReferenceRule.php @@ -0,0 +1,67 @@ + + */ +final class NoParameterPassedByReferenceRule implements Rules\Rule +{ + public function getNodeType(): string + { + return Node\Stmt\Function_::class; + } + + public function processNode( + Node $node, + Analyser\Scope $scope + ): array { + if (0 === \count($node->params)) { + return []; + } + + $parametersPassedByReference = \array_values(\array_filter($node->params, static function (Node\Param $parameter): bool { + return $parameter->byRef; + })); + + if (0 === \count($parametersPassedByReference)) { + return []; + } + + $functionName = $node->namespacedName; + + return \array_map(static function (Node\Param $parameterPassedByReference) use ($functionName): Rules\RuleError { + /** @var Node\Expr\Variable $variable */ + $variable = $parameterPassedByReference->var; + + /** @var string $parameterName */ + $parameterName = $variable->name; + + $message = \sprintf( + 'Function %s() has parameter $%s that is passed by reference.', + $functionName, + $parameterName, + ); + + return Rules\RuleErrorBuilder::message($message) + ->identifier(ErrorIdentifier::noParameterWithNullDefaultValue()->toString()) + ->build(); + }, $parametersPassedByReference); + } +} diff --git a/src/Methods/NoParameterPassedByReferenceRule.php b/src/Methods/NoParameterPassedByReferenceRule.php new file mode 100644 index 00000000..4c90f696 --- /dev/null +++ b/src/Methods/NoParameterPassedByReferenceRule.php @@ -0,0 +1,94 @@ + + */ +final class NoParameterPassedByReferenceRule implements Rules\Rule +{ + public function getNodeType(): string + { + return Node\Stmt\ClassMethod::class; + } + + public function processNode( + Node $node, + Analyser\Scope $scope + ): array { + if (0 === \count($node->params)) { + return []; + } + + $parametersExplicitlyPassedByReference = \array_values(\array_filter($node->params, static function (Node\Param $parameter): bool { + return $parameter->byRef; + })); + + if (0 === \count($parametersExplicitlyPassedByReference)) { + return []; + } + + $methodName = $node->name->toString(); + + /** @var Reflection\ClassReflection $classReflection */ + $classReflection = $scope->getClassReflection(); + + if ($classReflection->isAnonymous()) { + return \array_map(static function (Node\Param $parameterExplicitlyPassedByReference) use ($methodName): Rules\RuleError { + /** @var Node\Expr\Variable $variable */ + $variable = $parameterExplicitlyPassedByReference->var; + + /** @var string $parameterName */ + $parameterName = $variable->name; + + $message = \sprintf( + 'Method %s() in anonymous class has parameter $%s that is passed by reference.', + $methodName, + $parameterName, + ); + + return Rules\RuleErrorBuilder::message($message) + ->identifier(ErrorIdentifier::noParameterPassedByReference()->toString()) + ->build(); + }, $parametersExplicitlyPassedByReference); + } + + $className = $classReflection->getName(); + + return \array_map(static function (Node\Param $parameterExplicitlyPassedByReference) use ($className, $methodName): Rules\RuleError { + /** @var Node\Expr\Variable $variable */ + $variable = $parameterExplicitlyPassedByReference->var; + + /** @var string $parameterName */ + $parameterName = $variable->name; + + $message = \sprintf( + 'Method %s::%s() has parameter $%s that is passed by reference.', + $className, + $methodName, + $parameterName, + ); + + return Rules\RuleErrorBuilder::message($message) + ->identifier(ErrorIdentifier::noParameterPassedByReference()->toString()) + ->build(); + }, $parametersExplicitlyPassedByReference); + } +} diff --git a/test/Fixture/Closures/NoParameterPassedByReferenceRule/Bar.php b/test/Fixture/Closures/NoParameterPassedByReferenceRule/Bar.php new file mode 100644 index 00000000..01455e8f --- /dev/null +++ b/test/Fixture/Closures/NoParameterPassedByReferenceRule/Bar.php @@ -0,0 +1,9 @@ + + */ +final class NoParameterPassedByReferenceRuleTest extends Testing\RuleTestCase +{ + use Test\Util\Helper; + + public function testNoParameterPassedByReferenceRule(): void + { + $this->analyse( + self::phpFilesIn(__DIR__ . '/../../Fixture/Closures/NoParameterPassedByReferenceRule'), + [ + [ + 'Closure has parameter $bar that is passed by reference.', + 18, + ], + [ + 'Closure has parameter $bar that is passed by reference.', + 22, + ], + ], + ); + } + + protected function getRule(): Rules\Rule + { + return new Closures\NoParameterPassedByReferenceRule(); + } +} diff --git a/test/Integration/Functions/NoParameterPassedByReferenceRuleTest.php b/test/Integration/Functions/NoParameterPassedByReferenceRuleTest.php new file mode 100644 index 00000000..008600e9 --- /dev/null +++ b/test/Integration/Functions/NoParameterPassedByReferenceRuleTest.php @@ -0,0 +1,53 @@ + + */ +final class NoParameterPassedByReferenceRuleTest extends Testing\RuleTestCase +{ + use Test\Util\Helper; + + public function testNoParameterPassedByReferenceRule(): void + { + $this->analyse( + self::phpFilesIn(__DIR__ . '/../../Fixture/Functions/NoParameterPassedByReferenceRule'), + [ + [ + 'Function Ergebnis\PHPStan\Rules\Test\Fixture\Functions\NoParameterPassedByReferenceRule\baz() has parameter $bar that is passed by reference.', + 16, + ], + [ + 'Function Ergebnis\PHPStan\Rules\Test\Fixture\Functions\NoParameterPassedByReferenceRule\qux() has parameter $bar that is passed by reference.', + 21, + ], + ], + ); + } + + protected function getRule(): Rules\Rule + { + return new Functions\NoParameterPassedByReferenceRule(); + } +} diff --git a/test/Integration/Methods/NoParameterPassedByReferenceTest.php b/test/Integration/Methods/NoParameterPassedByReferenceTest.php new file mode 100644 index 00000000..4a4622ef --- /dev/null +++ b/test/Integration/Methods/NoParameterPassedByReferenceTest.php @@ -0,0 +1,81 @@ + + */ +final class NoParameterPassedByReferenceTest extends Testing\RuleTestCase +{ + use Test\Util\Helper; + + public function testNoParameterPassedByReferenceRule(): void + { + $this->analyse( + self::phpFilesIn(__DIR__ . '/../../Fixture/Methods/NoParameterPassedByReferenceRule'), + [ + [ + \sprintf( + 'Method %s::foo() has parameter $bar that is passed by reference.', + Test\Fixture\Methods\NoParameterPassedByReferenceRule\MethodInClassWithTypedParameterExplicitlyPassedByReference::class, + ), + 9, + ], + [ + \sprintf( + 'Method %s::foo() has parameter $bar that is passed by reference.', + Test\Fixture\Methods\NoParameterPassedByReferenceRule\MethodInClassWithUntypedParameterExplicitlyPassedByReference::class, + ), + 9, + ], + [ + \sprintf( + 'Method %s::foo() has parameter $bar that is passed by reference.', + Test\Fixture\Methods\NoParameterPassedByReferenceRule\MethodInInterfaceWithTypedParameterExplicitlyPassedByReference::class, + ), + 9, + ], + [ + \sprintf( + 'Method %s::foo() has parameter $bar that is passed by reference.', + Test\Fixture\Methods\NoParameterPassedByReferenceRule\MethodInInterfaceWithUntypedParameterExplicitlyPassedByReference::class, + ), + 9, + ], + [ + 'Method foo() in anonymous class has parameter $bar that is passed by reference.', + 28, + ], + [ + 'Method foo() in anonymous class has parameter $bar that is passed by reference.', + 35, + ], + ], + ); + } + + protected function getRule(): Rules\Rule + { + return new Methods\NoParameterPassedByReferenceRule(); + } +} diff --git a/test/Unit/ErrorIdentifierTest.php b/test/Unit/ErrorIdentifierTest.php index 4774d240..2045bdfe 100644 --- a/test/Unit/ErrorIdentifierTest.php +++ b/test/Unit/ErrorIdentifierTest.php @@ -98,6 +98,13 @@ public function testNoParameterWithContainerTypeDeclarationReturnsErrorIdentifie self::assertSame('ergebnis.noParameterWithContainerTypeDeclaration', $errorIdentifier->toString()); } + public function testNoParameterPassedByReferenceReturnsErrorIdentifier(): void + { + $errorIdentifier = ErrorIdentifier::noParameterPassedByReference(); + + self::assertSame('ergebnis.noParameterPassedByReference', $errorIdentifier->toString()); + } + public function testNoParameterWithNullDefaultValueReturnsErrorIdentifier(): void { $errorIdentifier = ErrorIdentifier::noParameterWithNullDefaultValue();