octoleo
/
rector
mirror of https://github.com/rectorphp/rector.git
1
1
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Updated Rector to commit dfd048342b 

dfd048342b [PHP 8.0] Run union types for filled param type too (#331)
This commit is contained in:
Tomas Votruba 2021-06-29 14:24:45 +00:00
parent a7f25f1444
commit 636eeecaf4
80 changed files with 247 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
packages/NodeCollector/NodeCollector/ParsedNodeCollector.php
View File

@ -5,7 +5,6 @@ namespace Rector\NodeCollector\NodeCollector;
use PhpParser\Node;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\ClassLike;
use PhpParser\Node\Stmt\Interface_;
use PhpParser\Node\Stmt\Trait_;
use Rector\Core\Exception\ShouldNotHappenException;
@ -93,9 +92,9 @@ final class ParsedNodeCollector
$this->classes[$className] = $class;
}
/**
* @param Interface_|Trait_ $classLike
* @param \PhpParser\Node\Stmt\Interface_|\PhpParser\Node\Stmt\Trait_ $classLike
*/
private function collectInterfaceOrTrait(\PhpParser\Node\Stmt\ClassLike $classLike) : void
private function collectInterfaceOrTrait($classLike) : void
{
$name = $this->nodeNameResolver->getName($classLike);
if ($name === null) {

5
packages/NodeNameResolver/Error/InvalidNameNodeReporter.php
View File

@ -3,7 +3,6 @@
declare (strict_types=1);
namespace Rector\NodeNameResolver\Error;
use PhpParser\Node;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use Rector\Core\Contract\Rector\RectorInterface;
@ -32,9 +31,9 @@ final class InvalidNameNodeReporter
$this->betterStandardPrinter = $betterStandardPrinter;
}
/**
* @param MethodCall|StaticCall $node
* @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall $node
*/
public function reportInvalidNodeForName(\PhpParser\Node $node) : void
public function reportInvalidNodeForName($node) : void
{
$message = \sprintf('Pick more specific node than "%s", e.g. "$node->name"', \get_class($node));
$file = $this->currentFileProvider->getFile();

4
packages/NodeRemoval/NodeRemover.php
View File

@ -90,9 +90,9 @@ final class NodeRemover
unset($classMethod->params[$key]);
}
/**
* @param FuncCall|MethodCall|StaticCall $node
* @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall $node
*/
public function removeArg(\PhpParser\Node $node, int $key) : void
public function removeArg($node, int $key) : void
{
if ($node->args === null) {
throw new \Rector\Core\Exception\ShouldNotHappenException();

4
packages/PostRector/Collector/NodesToAddCollector.php
View File

@ -133,9 +133,9 @@ final class NodesToAddCollector implements \Rector\PostRector\Contract\Collector
return \spl_object_hash($foundNode);
}
/**
* @param Expr|Stmt $node
* @param \PhpParser\Node\Expr|\PhpParser\Node\Stmt $node
*/
private function wrapToExpression(\PhpParser\Node $node) : \PhpParser\Node\Stmt
private function wrapToExpression($node) : \PhpParser\Node\Stmt
{
return $node instanceof \PhpParser\Node\Stmt ? $node : new \PhpParser\Node\Stmt\Expression($node);
}

5
packages/PostRector/Collector/UseNodesToAddCollector.php
View File

@ -5,7 +5,6 @@ namespace Rector\PostRector\Collector;
use PhpParser\Node;
use PhpParser\Node\Stmt\Use_;
use PHPStan\Type\ObjectType;
use Rector\Core\Provider\CurrentFileProvider;
use Rector\Core\ValueObject\Application\File;
use Rector\NodeTypeResolver\Node\AttributeKey;
@ -40,9 +39,9 @@ final class UseNodesToAddCollector implements \Rector\PostRector\Contract\Collec
return $this->useImportTypesInFilePath !== [] || $this->functionUseImportTypesInFilePath !== [];
}
/**
* @param FullyQualifiedObjectType|AliasedObjectType $objectType
* @param \Rector\StaticTypeMapper\ValueObject\Type\FullyQualifiedObjectType|\Rector\StaticTypeMapper\ValueObject\Type\AliasedObjectType $objectType
*/
public function addUseImport(\PHPStan\Type\ObjectType $objectType) : void
public function addUseImport($objectType) : void
{
$file = $this->currentFileProvider->getFile();
$smartFileInfo = $file->getSmartFileInfo();

4
packages/StaticTypeMapper/ValueObject/Type/AliasedObjectType.php
View File

@ -33,9 +33,9 @@ final class AliasedObjectType extends \PHPStan\Type\ObjectType
return $this->getClassName();
}
/**
* @param AliasedObjectType|FullyQualifiedObjectType $comparedObjectType
* @param $this|\Rector\StaticTypeMapper\ValueObject\Type\FullyQualifiedObjectType $comparedObjectType
*/
public function areShortNamesEqual(\PHPStan\Type\ObjectType $comparedObjectType) : bool
public function areShortNamesEqual($comparedObjectType) : bool
{
return $this->getShortName() === $comparedObjectType->getShortName();
}

4
packages/StaticTypeMapper/ValueObject/Type/FullyQualifiedObjectType.php
View File

@ -16,9 +16,9 @@ final class FullyQualifiedObjectType extends \PHPStan\Type\ObjectType
return new \Rector\StaticTypeMapper\ValueObject\Type\ShortenedObjectType($this->getShortName(), $this->getClassName());
}
/**
* @param AliasedObjectType|FullyQualifiedObjectType $comparedObjectType
* @param \Rector\StaticTypeMapper\ValueObject\Type\AliasedObjectType|\Rector\StaticTypeMapper\ValueObject\Type\FullyQualifiedObjectType $comparedObjectType
*/
public function areShortNamesEqual(\PHPStan\Type\ObjectType $comparedObjectType) : bool
public function areShortNamesEqual($comparedObjectType) : bool
{
return $this->getShortName() === $comparedObjectType->getShortName();
}

5
rules/Arguments/ArgumentDefaultValueReplacer.php
View File

@ -6,7 +6,6 @@ namespace Rector\Arguments;
use PhpParser\BuilderHelpers;
use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
@ -44,9 +43,9 @@ final class ArgumentDefaultValueReplacer
return $node;
}
/**
* @param MethodCall|StaticCall|FuncCall $expr
* @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\FuncCall $expr
*/
private function processArgs(\PhpParser\Node\Expr $expr, \Rector\Arguments\Contract\ReplaceArgumentDefaultValueInterface $replaceArgumentDefaultValue) : void
private function processArgs($expr, \Rector\Arguments\Contract\ReplaceArgumentDefaultValueInterface $replaceArgumentDefaultValue) : void
{
$position = $replaceArgumentDefaultValue->getPosition();
$argValue = $this->valueResolver->getValue($expr->args[$position]->value);

5
rules/Arguments/NodeAnalyzer/ArgumentAddingScope.php
View File

@ -3,7 +3,6 @@
declare (strict_types=1);
namespace Rector\Arguments\NodeAnalyzer;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name;
@ -32,9 +31,9 @@ final class ArgumentAddingScope
$this->nodeNameResolver = $nodeNameResolver;
}
/**
* @param MethodCall|StaticCall $expr
* @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall $expr
*/
public function isInCorrectScope(\PhpParser\Node\Expr $expr, \Rector\Arguments\ValueObject\ArgumentAdder $argumentAdder) : bool
public function isInCorrectScope($expr, \Rector\Arguments\ValueObject\ArgumentAdder $argumentAdder) : bool
{
if ($argumentAdder->getScope() === null) {
return \true;

4
rules/Arguments/Rector/ClassMethod/ArgumentAdderRector.php
View File

@ -108,9 +108,9 @@ CODE_SAMPLE
$this->addedArguments = $addedArguments;
}
/**
* @param MethodCall|StaticCall|ClassMethod $node
* @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Stmt\ClassMethod $node
*/
private function isObjectTypeMatch(\PhpParser\Node $node, \PHPStan\Type\ObjectType $objectType) : bool
private function isObjectTypeMatch($node, \PHPStan\Type\ObjectType $objectType) : bool
{
if ($node instanceof \PhpParser\Node\Expr\MethodCall) {
return $this->isObjectType($node->var, $objectType);

13
rules/CodeQuality/Rector/Assign/SplitListAssignToSeparateLineRector.php
View File

@ -4,7 +4,6 @@ declare (strict_types=1);
namespace Rector\CodeQuality\Rector\Assign;
use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\Array_;
use PhpParser\Node\Expr\ArrayItem;
use PhpParser\Node\Expr\Assign;
@ -82,10 +81,10 @@ CODE_SAMPLE
return $this->isValueSwap($assign->var, $assignExpr);
}
/**
* @param Array_|List_ $expr
* @return Assign[]
* @param \PhpParser\Node\Expr\Array_|\PhpParser\Node\Expr\List_ $expr
*/
private function createStandaloneAssigns(\PhpParser\Node\Expr $expr, \PhpParser\Node\Expr\Array_ $rightArray) : array
private function createStandaloneAssigns($expr, \PhpParser\Node\Expr\Array_ $rightArray) : array
{
$standaloneAssigns = [];
foreach ($expr->items as $key => $leftArrayItem) {
@ -101,18 +100,18 @@ CODE_SAMPLE
return $standaloneAssigns;
}
/**
* @param Array_|List_ $expr
* @param \PhpParser\Node\Expr\Array_|\PhpParser\Node\Expr\List_ $expr
*/
private function isValueSwap(\PhpParser\Node\Expr $expr, \PhpParser\Node\Expr\Array_ $secondArray) : bool
private function isValueSwap($expr, \PhpParser\Node\Expr\Array_ $secondArray) : bool
{
$firstArrayItemsHash = $this->getArrayItemsHash($expr);
$secondArrayItemsHash = $this->getArrayItemsHash($secondArray);
return $firstArrayItemsHash === $secondArrayItemsHash;
}
/**
* @param Array_|List_ $node
* @param \PhpParser\Node\Expr\Array_|\PhpParser\Node\Expr\List_ $node
*/
private function getArrayItemsHash(\PhpParser\Node $node) : string
private function getArrayItemsHash($node) : string
{
$arrayItemsHashes = [];
foreach ($node->items as $arrayItem) {

4
rules/CodeQuality/Rector/Foreach_/ForeachToInArrayRector.php
View File

@ -165,9 +165,9 @@ CODE_SAMPLE
return $this->valueResolver->isTrueOrFalse($ifStatment->expr);
}
/**
* @param Identical|Equal $binaryOp
* @param \PhpParser\Node\Expr\BinaryOp\Identical|\PhpParser\Node\Expr\BinaryOp\Equal $binaryOp
*/
private function createInArrayFunction(\PhpParser\Node\Expr $expr, \PhpParser\Node\Expr\BinaryOp $binaryOp, \PhpParser\Node\Stmt\Foreach_ $foreach) : \PhpParser\Node\Expr\FuncCall
private function createInArrayFunction(\PhpParser\Node\Expr $expr, $binaryOp, \PhpParser\Node\Stmt\Foreach_ $foreach) : \PhpParser\Node\Expr\FuncCall
{
$arguments = $this->nodeFactory->createArgs([$expr, $foreach->expr]);
if ($binaryOp instanceof \PhpParser\Node\Expr\BinaryOp\Identical) {

4
rules/CodeQuality/Rector/If_/SimplifyIfIssetToNullCoalescingRector.php
View File

@ -137,9 +137,9 @@ CODE_SAMPLE
return !$this->nodeComparator->areNodesEqual($if->cond->vars[0], $firstElseStmt->expr->var);
}
/**
* @param If_|Else_ $node
* @param \PhpParser\Node\Stmt\If_|\PhpParser\Node\Stmt\Else_ $node
*/
private function hasOnlyStatementAssign(\PhpParser\Node $node) : bool
private function hasOnlyStatementAssign($node) : bool
{
if (\count($node->stmts) !== 1) {
return \false;

4
rules/CodeQuality/Rector/Return_/SimplifyUselessVariableRector.php
View File

@ -137,9 +137,9 @@ CODE_SAMPLE
return !$phpDocInfo->getVarType() instanceof \PHPStan\Type\MixedType;
}
/**
* @param AssignOp|Assign $previousNode
* @param \PhpParser\Node\Expr\AssignOp|\PhpParser\Node\Expr\Assign $previousNode
*/
private function isPreviousExpressionVisuallySimilar(\PhpParser\Node\Stmt\Expression $previousExpression, \PhpParser\Node $previousNode) : bool
private function isPreviousExpressionVisuallySimilar(\PhpParser\Node\Stmt\Expression $previousExpression, $previousNode) : bool
{
$prePreviousExpression = $previousExpression->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::PREVIOUS_STATEMENT);
if (!$prePreviousExpression instanceof \PhpParser\Node\Stmt\Expression) {

5
rules/CodeQualityStrict/NodeFactory/ClassConstFetchFactory.php
View File

@ -6,7 +6,6 @@ namespace Rector\CodeQualityStrict\NodeFactory;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Name\FullyQualified;
use PHPStan\Type\ObjectType;
use PHPStan\Type\Type;
use PHPStan\Type\TypeWithClassName;
use PHPStan\Type\UnionType;
use Rector\Core\Exception\ShouldNotHappenException;
@ -14,10 +13,10 @@ use Rector\StaticTypeMapper\ValueObject\Type\ShortenedObjectType;
final class ClassConstFetchFactory
{
/**
* @param ObjectType|UnionType $type
* @return ClassConstFetch[]
* @param \PHPStan\Type\ObjectType|\PHPStan\Type\UnionType $type
*/
public function createFromType(\PHPStan\Type\Type $type) : array
public function createFromType($type) : array
{
$classConstTypes = [];
if ($type instanceof \Rector\StaticTypeMapper\ValueObject\Type\ShortenedObjectType) {

4
rules/CodeQualityStrict/Rector/ClassMethod/ParamTypeToAssertTypeRector.php
View File

@ -116,10 +116,10 @@ CODE_SAMPLE
}
/**
* @param Param[] $params
* @param ObjectType|UnionType $type
* @return ObjectType|UnionType
* @param \PHPStan\Type\ObjectType|\PHPStan\Type\UnionType $type
*/
private function getToBeProcessedTypes(array $params, string $key, \PHPStan\Type\Type $type) : ?\PHPStan\Type\Type
private function getToBeProcessedTypes(array $params, string $key, $type) : ?\PHPStan\Type\Type
{
foreach ($params as $param) {
$paramName = \ltrim($key, '$');

24
rules/CodingStyle/Naming/NameRenamer.php
View File

@ -61,9 +61,9 @@ final class NameRenamer
}
}
/**
* @param Name|Identifier $usedNameNode
* @param \PhpParser\Node\Name|\PhpParser\Node\Identifier $usedNameNode
*/
private function renameTraitUse(string $lastName, \PhpParser\Node\Stmt\TraitUse $traitUse, \PhpParser\Node $usedNameNode) : void
private function renameTraitUse(string $lastName, \PhpParser\Node\Stmt\TraitUse $traitUse, $usedNameNode) : void
{
foreach ($traitUse->traits as $key => $traitName) {
if (!$this->nodeNameResolver->areNamesEqual($traitName, $usedNameNode)) {
@ -73,9 +73,9 @@ final class NameRenamer
}
}
/**
* @param Name|Identifier $usedNameNode
* @param \PhpParser\Node\Name|\PhpParser\Node\Identifier $usedNameNode
*/
private function renameClass(string $lastName, \PhpParser\Node\Stmt\Class_ $class, \PhpParser\Node $usedNameNode) : void
private function renameClass(string $lastName, \PhpParser\Node\Stmt\Class_ $class, $usedNameNode) : void
{
if ($class->name !== null && $this->nodeNameResolver->areNamesEqual($class->name, $usedNameNode)) {
$class->name = new \PhpParser\Node\Identifier($lastName);
@ -90,9 +90,9 @@ final class NameRenamer
}
}
/**
* @param Name|Identifier $usedNameNode
* @param \PhpParser\Node\Name|\PhpParser\Node\Identifier $usedNameNode
*/
private function renameParam(string $lastName, \PhpParser\Node\Param $param, \PhpParser\Node $usedNameNode) : void
private function renameParam(string $lastName, \PhpParser\Node\Param $param, $usedNameNode) : void
{
if ($param->type === null) {
return;
@ -115,18 +115,18 @@ final class NameRenamer
}
}
/**
* @param Name|Identifier $usedNameNode
* @param \PhpParser\Node\Name|\PhpParser\Node\Identifier $usedNameNode
*/
private function renameNew(string $lastName, \PhpParser\Node\Expr\New_ $new, \PhpParser\Node $usedNameNode) : void
private function renameNew(string $lastName, \PhpParser\Node\Expr\New_ $new, $usedNameNode) : void
{
if ($this->nodeNameResolver->areNamesEqual($new->class, $usedNameNode)) {
$new->class = new \PhpParser\Node\Name($lastName);
}
}
/**
* @param Name|Identifier $usedNameNode
* @param \PhpParser\Node\Name|\PhpParser\Node\Identifier $usedNameNode
*/
private function renameClassMethod(string $lastName, \PhpParser\Node\Stmt\ClassMethod $classMethod, \PhpParser\Node $usedNameNode) : void
private function renameClassMethod(string $lastName, \PhpParser\Node\Stmt\ClassMethod $classMethod, $usedNameNode) : void
{
if ($classMethod->returnType === null) {
return;
@ -137,9 +137,9 @@ final class NameRenamer
$classMethod->returnType = new \PhpParser\Node\Name($lastName);
}
/**
* @param Name|Identifier $usedNameNode
* @param \PhpParser\Node\Name|\PhpParser\Node\Identifier $usedNameNode
*/
private function renameInterface(string $lastName, \PhpParser\Node\Stmt\Interface_ $interface, \PhpParser\Node $usedNameNode) : void
private function renameInterface(string $lastName, \PhpParser\Node\Stmt\Interface_ $interface, $usedNameNode) : void
{
foreach ($interface->extends as $key => $extendInterfaceName) {
if (!$this->nodeNameResolver->areNamesEqual($extendInterfaceName, $usedNameNode)) {

4
rules/CodingStyle/Rector/Assign/ManualJsonStringToJsonEncodeArrayRector.php
View File

@ -194,9 +194,9 @@ CODE_SAMPLE
return $this->jsonEncodeStaticCallFactory->createFromArray($assign->var, $jsonArray);
}
/**
* @param Assign|ConcatAssign $currentNode
* @param \PhpParser\Node\Expr\Assign|ConcatAssign|\PhpParser\Node\Stmt\Expression|\PhpParser\Node $currentNode
*/
private function matchNextExprAssignConcatToSameVariable(\PhpParser\Node\Expr $expr, \PhpParser\Node $currentNode) : ?\Rector\CodingStyle\ValueObject\NodeToRemoveAndConcatItem
private function matchNextExprAssignConcatToSameVariable(\PhpParser\Node\Expr $expr, $currentNode) : ?\Rector\CodingStyle\ValueObject\NodeToRemoveAndConcatItem
{
$nextExpression = $this->getNextExpression($currentNode);
if (!$nextExpression instanceof \PhpParser\Node\Stmt\Expression) {

4
rules/CodingStyle/Rector/ClassMethod/NewlineBeforeNewAssignSetRector.php
View File

@ -121,9 +121,9 @@ CODE_SAMPLE
return !$this->isPrecededByEmptyLine($node, $key);
}
/**
* @param Assign|MethodCall $node
* @param \PhpParser\Node\Expr\Assign|\PhpParser\Node\Expr\MethodCall $node
*/
private function shouldSkipLeftVariable(\PhpParser\Node $node) : bool
private function shouldSkipLeftVariable($node) : bool
{
if (!$node->var instanceof \PhpParser\Node\Expr\Variable) {
return \false;

8
rules/CodingStyle/Rector/MethodCall/PreferThisOrSelfMethodCallRector.php
View File

@ -87,9 +87,9 @@ CODE_SAMPLE
$this->typeToPreference = $typeToPreference;
}
/**
* @param MethodCall|StaticCall $node
* @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall $node
*/
private function processToSelf(\PhpParser\Node $node) : ?\PhpParser\Node\Expr\StaticCall
private function processToSelf($node) : ?\PhpParser\Node\Expr\StaticCall
{
if ($node instanceof \PhpParser\Node\Expr\StaticCall && !$this->isNames($node->class, [self::SELF, 'static'])) {
return null;
@ -104,9 +104,9 @@ CODE_SAMPLE
return $this->nodeFactory->createStaticCall(self::SELF, $name, $node->args);
}
/**
* @param MethodCall|StaticCall $node
* @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall $node
*/
private function processToThis(\PhpParser\Node $node) : ?\PhpParser\Node\Expr\MethodCall
private function processToThis($node) : ?\PhpParser\Node\Expr\MethodCall
{
if ($node instanceof \PhpParser\Node\Expr\MethodCall) {
return null;

4
rules/CodingStyle/Rector/PostInc/PostIncDecToPreIncDecRector.php
View File

@ -107,10 +107,10 @@ CODE_SAMPLE
return $arrayDimFetch->dim;
}
/**
* @param PostInc|PostDec $node
* @param \PhpParser\Node\Expr\PostInc|\PhpParser\Node\Expr\PostDec $node
* @return \PhpParser\Node\Expr\PreDec|\PhpParser\Node\Expr\PreInc
*/
private function processPreFor(\PhpParser\Node $node, \PhpParser\Node\Stmt\For_ $for)
private function processPreFor($node, \PhpParser\Node\Stmt\For_ $for)
{
$for->loop = [$this->processPrePost($node)];
return $for->loop[0];

8
rules/DeadCode/PhpDoc/TagRemover/VarTagRemover.php
View File

@ -64,9 +64,9 @@ final class VarTagRemover
$phpDocInfo->removeByType(\PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode::class);
}
/**
* @param Expression|Property|Param $node
* @param \PhpParser\Node\Stmt\Expression|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Param $node
*/
public function removeVarPhpTagValueNodeIfNotComment(\PhpParser\Node $node, \PHPStan\Type\Type $type) : void
public function removeVarPhpTagValueNodeIfNotComment($node, \PHPStan\Type\Type $type) : void
{
// keep doctrine collection narrow type
if ($this->doctrineTypeAnalyzer->isDoctrineCollectionWithIterableUnionType($type)) {
@ -92,9 +92,9 @@ final class VarTagRemover
$phpDocInfo->removeByType(\PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode::class);
}
/**
* @param Expression|Param|Property $node
* @param \PhpParser\Node\Stmt\Expression|\PhpParser\Node\Param|\PhpParser\Node\Stmt\Property $node
*/
private function isNonBasicArrayType(\PhpParser\Node $node, \PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode $varTagValueNode) : bool
private function isNonBasicArrayType($node, \PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode $varTagValueNode) : bool
{
if ($varTagValueNode->type instanceof \Rector\BetterPhpDocParser\ValueObject\Type\BracketsAwareUnionTypeNode) {
foreach ($varTagValueNode->type->types as $type) {

4
rules/DeadCode/Rector/Assign/RemoveUnusedVariableAssignRector.php
View File

@ -169,9 +169,9 @@ CODE_SAMPLE
});
}
/**
* @param FuncCall|MethodCall|New_|NullsafeMethodCall|StaticCall $expr
* @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\New_|\PhpParser\Node\Expr\NullsafeMethodCall|\PhpParser\Node\Expr\StaticCall $expr
*/
private function isUsedInAssignExpr(\PhpParser\Node\Expr $expr, \PhpParser\Node\Expr\Assign $assign) : bool
private function isUsedInAssignExpr($expr, \PhpParser\Node\Expr\Assign $assign) : bool
{
foreach ($expr->args as $arg) {
$variable = $arg->value;

8
rules/DeadCode/Rector/Plus/RemoveDeadZeroAndOneOperationRector.php
View File

@ -121,9 +121,9 @@ CODE_SAMPLE
return null;
}
/**
* @param Plus|Minus $binaryOp
* @param \PhpParser\Node\Expr\BinaryOp\Plus|\PhpParser\Node\Expr\BinaryOp\Minus $binaryOp
*/
private function processBinaryPlusAndMinus(\PhpParser\Node\Expr\BinaryOp $binaryOp) : ?\PhpParser\Node\Expr
private function processBinaryPlusAndMinus($binaryOp) : ?\PhpParser\Node\Expr
{
if ($this->valueResolver->isValue($binaryOp->left, 0) && $this->nodeTypeResolver->isNumberType($binaryOp->right)) {
if ($binaryOp instanceof \PhpParser\Node\Expr\BinaryOp\Minus) {
@ -140,9 +140,9 @@ CODE_SAMPLE
return $binaryOp->left;
}
/**
* @param Mul|Div $binaryOp
* @param \PhpParser\Node\Expr\BinaryOp\Mul|\PhpParser\Node\Expr\BinaryOp\Div $binaryOp
*/
private function processBinaryMulAndDiv(\PhpParser\Node\Expr\BinaryOp $binaryOp) : ?\PhpParser\Node\Expr
private function processBinaryMulAndDiv($binaryOp) : ?\PhpParser\Node\Expr
{
if ($binaryOp instanceof \PhpParser\Node\Expr\BinaryOp\Mul && $this->valueResolver->isValue($binaryOp->left, 1) && $this->nodeTypeResolver->isNumberType($binaryOp->right)) {
return $binaryOp->right;

5
rules/DeadCode/UselessIfCondBeforeForeachDetector.php
View File

@ -5,7 +5,6 @@ namespace Rector\DeadCode;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\Array_;
use PhpParser\Node\Expr\BinaryOp;
use PhpParser\Node\Expr\BinaryOp\NotEqual;
use PhpParser\Node\Expr\BinaryOp\NotIdentical;
use PhpParser\Node\Expr\BooleanNot;
@ -68,9 +67,9 @@ final class UselessIfCondBeforeForeachDetector
return $this->isMatchingNotBinaryOp($notIdentical, $foreachExpr);
}
/**
* @param NotIdentical|NotEqual $binaryOp
* @param \PhpParser\Node\Expr\BinaryOp\NotIdentical|\PhpParser\Node\Expr\BinaryOp\NotEqual $binaryOp
*/
private function isMatchingNotBinaryOp(\PhpParser\Node\Expr\BinaryOp $binaryOp, \PhpParser\Node\Expr $foreachExpr) : bool
private function isMatchingNotBinaryOp($binaryOp, \PhpParser\Node\Expr $foreachExpr) : bool
{
if ($this->isEmptyArrayAndForeachedVariable($binaryOp->left, $binaryOp->right, $foreachExpr)) {
return \true;

5
rules/Defluent/NodeResolver/FirstMethodCallVarResolver.php
View File

@ -4,15 +4,14 @@ declare (strict_types=1);
namespace Rector\Defluent\NodeResolver;
use PhpParser\Node\Expr;
use Rector\Defluent\Contract\ValueObject\FirstCallFactoryAwareInterface;
use Rector\Defluent\ValueObject\AssignAndRootExpr;
use Rector\Defluent\ValueObject\FirstAssignFluentCall;
final class FirstMethodCallVarResolver
{
/**
* @param FirstAssignFluentCall|AssignAndRootExpr $firstCallFactoryAware
* @param \Rector\Defluent\ValueObject\FirstAssignFluentCall|\Rector\Defluent\ValueObject\AssignAndRootExpr $firstCallFactoryAware
*/
public function resolve(\Rector\Defluent\Contract\ValueObject\FirstCallFactoryAwareInterface $firstCallFactoryAware, int $key) : \PhpParser\Node\Expr
public function resolve($firstCallFactoryAware, int $key) : \PhpParser\Node\Expr
{
if (!$firstCallFactoryAware->isFirstCallFactory()) {
return $firstCallFactoryAware->getCallerExpr();

5
rules/DowngradePhp70/Rector/FunctionLike/DowngradeScalarTypeDeclarationRector.php
View File

@ -12,7 +12,6 @@ use PhpParser\Node\Expr\Cast\Int_;
use PhpParser\Node\Expr\Cast\String_;
use PhpParser\Node\Expr\Closure;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\FunctionLike;
use PhpParser\Node\Param;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Stmt\Expression;
@ -97,9 +96,9 @@ CODE_SAMPLE
return $node;
}
/**
* @param Function_|ClassMethod $functionLike
* @param \PhpParser\Node\Stmt\Function_|\PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Expr\Closure $functionLike
*/
private function resolveRecastAssign(\PhpParser\Node\Param $param, \PhpParser\Node\FunctionLike $functionLike) : ?\PhpParser\Node\Stmt\Expression
private function resolveRecastAssign(\PhpParser\Node\Param $param, $functionLike) : ?\PhpParser\Node\Stmt\Expression
{
if ($functionLike->stmts === null) {
return null;

4
rules/DowngradePhp71/Rector/List_/DowngradeKeysInListRector.php
View File

@ -112,10 +112,10 @@ CODE_SAMPLE
return null;
}
/**
* @param List_|Array_ $node
* @return Expression[]
* @param \PhpParser\Node\Expr\List_|\PhpParser\Node\Expr\Array_ $node
*/
private function processExtractToItsOwnVariable(\PhpParser\Node $node, \PhpParser\Node $parent, \PhpParser\Node $parentExpression) : array
private function processExtractToItsOwnVariable($node, \PhpParser\Node $parent, \PhpParser\Node $parentExpression) : array
{
$items = $node->items;
$assignExpressions = [];

4
rules/DowngradePhp71/Rector/String_/DowngradeNegativeStringOffsetToStrlenRector.php
View File

@ -54,9 +54,9 @@ CODE_SAMPLE
return $this->processForStringOrVariableOrProperty($node);
}
/**
* @param String_|Variable|PropertyFetch|StaticPropertyFetch $expr
* @param \PhpParser\Node\Scalar\String_|\PhpParser\Node\Expr\Variable|\PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticPropertyFetch $expr
*/
private function processForStringOrVariableOrProperty(\PhpParser\Node\Expr $expr) : ?\PhpParser\Node\Expr
private function processForStringOrVariableOrProperty($expr) : ?\PhpParser\Node\Expr
{
$nextNode = $expr->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::NEXT_NODE);
if (!$nextNode instanceof \PhpParser\Node\Expr\UnaryMinus) {

8
rules/DowngradePhp73/Rector/List_/DowngradeListReferenceAssignmentRector.php
View File

@ -100,10 +100,10 @@ CODE_SAMPLE
* Remove the right-side-most params by reference or empty from `list()`,
* since they are not needed anymore.
* If all of them can be removed, then directly remove `list()`.
* @param List_|Array_ $node
* @return List_|Array_|null
* @param \PhpParser\Node\Expr\List_|\PhpParser\Node\Expr\Array_ $node
*/
public function removeStaleParams(\PhpParser\Node $node, int $rightSideRemovableParamsCount) : ?\PhpParser\Node
public function removeStaleParams($node, int $rightSideRemovableParamsCount) : ?\PhpParser\Node
{
$nodeItemsCount = \count($node->items);
if ($rightSideRemovableParamsCount === $nodeItemsCount) {
@ -119,9 +119,9 @@ CODE_SAMPLE
return $node;
}
/**
* @param List_|Array_ $node
* @param \PhpParser\Node\Expr\List_|\PhpParser\Node\Expr\Array_ $node
*/
private function shouldRefactor(\PhpParser\Node $node) : bool
private function shouldRefactor($node) : bool
{
$parentNode = $node->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::PARENT_NODE);
// Check it follows `list(...) = $foo`

5
rules/DowngradePhp74/Rector/ClassMethod/DowngradeCovariantReturnTypeRector.php
View File

@ -4,6 +4,7 @@ declare (strict_types=1);
namespace Rector\DowngradePhp74\Rector\ClassMethod;
use PhpParser\Node;
use PhpParser\Node\Identifier;
use PhpParser\Node\Name;
use PhpParser\Node\NullableType;
use PhpParser\Node\Stmt\ClassMethod;
@ -128,9 +129,9 @@ CODE_SAMPLE
return $node;
}
/**
* @param UnionType|NullableType|Name|Node\Identifier $returnTypeNode
* @param \PhpParser\Node\UnionType|\PhpParser\Node\NullableType|\PhpParser\Node\Name|\PhpParser\Node\Identifier $returnTypeNode
*/
private function resolveDifferentAncestorReturnType(\PhpParser\Node\Stmt\ClassMethod $classMethod, \PhpParser\Node $returnTypeNode) : \PHPStan\Type\Type
private function resolveDifferentAncestorReturnType(\PhpParser\Node\Stmt\ClassMethod $classMethod, $returnTypeNode) : \PHPStan\Type\Type
{
$scope = $classMethod->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::SCOPE);
if (!$scope instanceof \PHPStan\Analyser\Scope) {

9
rules/DowngradePhp74/Rector/FuncCall/DowngradeStripTagsCallWithArrayRector.php
View File

@ -5,7 +5,6 @@ namespace Rector\DowngradePhp74\Rector\FuncCall;
use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\Array_;
use PhpParser\Node\Expr\Assign;
use PhpParser\Node\Expr\BinaryOp\BooleanAnd;
@ -133,9 +132,9 @@ CODE_SAMPLE
return !$this->valueResolver->isNull($allowableTagsParam);
}
/**
* @param Array_|Variable|PropertyFetch|ConstFetch|ClassConstFetch $expr
* @param \PhpParser\Node\Expr\Array_|\PhpParser\Node\Expr\Variable|\PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\ConstFetch|\PhpParser\Node\Expr\ClassConstFetch $expr
*/
private function createArrayFromString(\PhpParser\Node\Expr $expr) : \PhpParser\Node\Expr\BinaryOp\Concat
private function createArrayFromString($expr) : \PhpParser\Node\Expr\BinaryOp\Concat
{
$args = [new \PhpParser\Node\Arg(new \PhpParser\Node\Scalar\String_('><')), new \PhpParser\Node\Arg($expr)];
$implodeFuncCall = new \PhpParser\Node\Expr\FuncCall(new \PhpParser\Node\Name('implode'), $args);
@ -143,9 +142,9 @@ CODE_SAMPLE
return new \PhpParser\Node\Expr\BinaryOp\Concat($concat, new \PhpParser\Node\Scalar\String_('>'));
}
/**
* @param Variable|PropertyFetch|ConstFetch|ClassConstFetch $expr
* @param \PhpParser\Node\Expr\Variable|\PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\ConstFetch|\PhpParser\Node\Expr\ClassConstFetch $expr
*/
private function createIsArrayTernaryFromExpression(\PhpParser\Node\Expr $expr) : \PhpParser\Node\Expr\Ternary
private function createIsArrayTernaryFromExpression($expr) : \PhpParser\Node\Expr\Ternary
{
$isArrayFuncCall = new \PhpParser\Node\Expr\FuncCall(new \PhpParser\Node\Name('is_array'), [new \PhpParser\Node\Arg($expr)]);
$nullNotIdentical = new \PhpParser\Node\Expr\BinaryOp\NotIdentical($expr, $this->nodeFactory->createNull());

4
rules/DowngradePhp74/Rector/LNumber/DowngradeNumericLiteralSeparatorRector.php
View File

@ -75,9 +75,9 @@ CODE_SAMPLE
return $node;
}
/**
* @param LNumber|DNumber $node
* @param \PhpParser\Node\Scalar\LNumber|\PhpParser\Node\Scalar\DNumber $node
*/
public function shouldRefactor(\PhpParser\Node $node) : bool
public function shouldRefactor($node) : bool
{
// "_" notation can be applied to decimal numbers only
if ($node instanceof \PhpParser\Node\Scalar\LNumber) {

4
rules/DowngradePhp80/Rector/ClassMethod/DowngradeTrailingCommasInParamUseRector.php
View File

@ -93,9 +93,9 @@ CODE_SAMPLE
return $this->processParams($node);
}
/**
* @param FuncCall|MethodCall|StaticCall|New_ $node
* @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\New_ $node
*/
private function processArgs(\PhpParser\Node $node) : ?\PhpParser\Node
private function processArgs($node) : ?\PhpParser\Node
{
if ($node->args === []) {
return null;

8
rules/DowngradePhp80/Rector/Expression/DowngradeMatchToSwitchRector.php
View File

@ -94,11 +94,11 @@ CODE_SAMPLE
return new \PhpParser\Node\Stmt\Switch_($match->cond, $switchCases);
}
/**
* @param Expression|Return_ $node
* @param MatchArm[] $matchArms
* @return Case_[]
* @param \PhpParser\Node\Stmt\Expression|\PhpParser\Node\Stmt\Return_ $node
*/
private function createSwitchCasesFromMatchArms(\PhpParser\Node $node, array $matchArms) : array
private function createSwitchCasesFromMatchArms($node, array $matchArms) : array
{
$switchCases = [];
foreach ($matchArms as $matchArm) {
@ -120,10 +120,10 @@ CODE_SAMPLE
return $switchCases;
}
/**
* @param Expression|Return_ $node
* @return Stmt[]
* @param \PhpParser\Node\Stmt\Expression|\PhpParser\Node\Stmt\Return_ $node
*/
private function createSwitchStmts(\PhpParser\Node $node, \PhpParser\Node\MatchArm $matchArm) : array
private function createSwitchStmts($node, \PhpParser\Node\MatchArm $matchArm) : array
{
$stmts = [];
if ($node instanceof \PhpParser\Node\Stmt\Expression) {

5
rules/DowngradePhp80/Rector/FuncCall/DowngradeStrContainsRector.php
View File

@ -4,7 +4,6 @@ declare (strict_types=1);
namespace Rector\DowngradePhp80\Rector\FuncCall;
use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\BinaryOp\Identical;
use PhpParser\Node\Expr\BinaryOp\NotIdentical;
use PhpParser\Node\Expr\BooleanNot;
@ -67,10 +66,10 @@ CODE_SAMPLE
return new \PhpParser\Node\Expr\BinaryOp\NotIdentical($funcCall, $this->nodeFactory->createFalse());
}
/**
* @param FuncCall|BooleanNot $expr
* @return FuncCall
* @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\BooleanNot $expr
*/
private function matchStrContainsOrNotStrContains(\PhpParser\Node\Expr $expr) : ?\PhpParser\Node\Expr\FuncCall
private function matchStrContainsOrNotStrContains($expr) : ?\PhpParser\Node\Expr\FuncCall
{
$expr = $expr instanceof \PhpParser\Node\Expr\BooleanNot ? $expr->expr : $expr;
if (!$expr instanceof \PhpParser\Node\Expr\FuncCall) {

4
rules/DowngradePhp80/Rector/MethodCall/DowngradeNamedArgumentRector.php
View File

@ -104,12 +104,12 @@ CODE_SAMPLE
return $this->processRemoveNamedArgument($functionLikeReflection, $node, $args);
}
/**
* @param MethodCall|StaticCall|New_ $node
* @param Arg[] $args
* @param \PHPStan\Reflection\MethodReflection|\PHPStan\Reflection\FunctionReflection $reflection
* @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\New_ $node
* @return \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\New_
*/
private function processRemoveNamedArgument($reflection, \PhpParser\Node $node, array $args)
private function processRemoveNamedArgument($reflection, $node, array $args)
{
/** @var Arg[] $newArgs */
$newArgs = [];

4
rules/EarlyReturn/Rector/If_/RemoveAlwaysElseRector.php
View File

@ -109,9 +109,9 @@ CODE_SAMPLE
return $statements;
}
/**
* @param If_|ElseIf_ $node
* @param \PhpParser\Node\Stmt\If_|\PhpParser\Node\Stmt\ElseIf_ $node
*/
private function doesLastStatementBreakFlow(\PhpParser\Node $node) : bool
private function doesLastStatementBreakFlow($node) : bool
{
$lastStmt = \end($node->stmts);
return !($lastStmt instanceof \PhpParser\Node\Stmt\Return_ || $lastStmt instanceof \PhpParser\Node\Stmt\Throw_ || $lastStmt instanceof \PhpParser\Node\Stmt\Continue_ || $lastStmt instanceof \PhpParser\Node\Stmt\Expression && $lastStmt->expr instanceof \PhpParser\Node\Expr\Exit_);

5
rules/MockeryToProphecy/Collector/MockVariableCollector.php
View File

@ -3,7 +3,6 @@
declare (strict_types=1);
namespace Rector\MockeryToProphecy\Collector;
use PhpParser\Node;
use PhpParser\Node\Expr\Assign;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\StaticCall;
@ -27,10 +26,10 @@ final class MockVariableCollector
$this->valueResolver = $valueResolver;
}
/**
* @param FuncCall|StaticCall $node
* @return array<string, class-string>
* @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\StaticCall $node
*/
public function collectMockVariableName(\PhpParser\Node $node) : array
public function collectMockVariableName($node) : array
{
$mockVariableTypesByNames = [];
$parentNode = $node->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::PARENT_NODE);

4
rules/Naming/Matcher/CallMatcher.php
View File

@ -12,10 +12,10 @@ use PhpParser\Node\Stmt\Foreach_;
final class CallMatcher
{
/**
* @param Assign|Foreach_ $node
* @return FuncCall|StaticCall|MethodCall|null
* @param \PhpParser\Node\Expr\Assign|\PhpParser\Node\Stmt\Foreach_ $node
*/
public function matchCall(\PhpParser\Node $node) : ?\PhpParser\Node
public function matchCall($node) : ?\PhpParser\Node
{
if ($node->expr instanceof \PhpParser\Node\Expr\MethodCall) {
return $node->expr;

12
rules/Naming/Naming/ExpectedNameResolver.php
View File

@ -102,9 +102,9 @@ final class ExpectedNameResolver
return $expectedName->getName();
}
/**
* @param MethodCall|StaticCall|FuncCall $expr
* @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\FuncCall $expr
*/
public function resolveForCall(\PhpParser\Node\Expr $expr) : ?string
public function resolveForCall($expr) : ?string
{
if ($this->isDynamicNameCall($expr)) {
return null;
@ -135,9 +135,9 @@ final class ExpectedNameResolver
return null;
}
/**
* @param MethodCall|StaticCall|FuncCall $expr
* @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\FuncCall $expr
*/
public function resolveForForeach(\PhpParser\Node\Expr $expr) : ?string
public function resolveForForeach($expr) : ?string
{
if ($this->isDynamicNameCall($expr)) {
return null;
@ -170,9 +170,9 @@ final class ExpectedNameResolver
return $expectedNameFromMethodName->getSingularized();
}
/**
* @param MethodCall|StaticCall|FuncCall $expr
* @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\FuncCall $expr
*/
private function isDynamicNameCall(\PhpParser\Node\Expr $expr) : bool
private function isDynamicNameCall($expr) : bool
{
if ($expr->name instanceof \PhpParser\Node\Expr\StaticCall) {
return \true;

4
rules/Naming/Naming/VariableNaming.php
View File

@ -198,9 +198,9 @@ final class VariableNaming
return $varName . \ucfirst($propertyName);
}
/**
* @param MethodCall|NullsafeMethodCall|StaticCall $node
* @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\NullsafeMethodCall|\PhpParser\Node\Expr\StaticCall $node
*/
private function resolveFromMethodCall(\PhpParser\Node $node) : ?string
private function resolveFromMethodCall($node) : ?string
{
if ($node->name instanceof \PhpParser\Node\Expr\MethodCall) {
return $this->resolveFromMethodCall($node->name);

6
rules/Naming/NamingConvention/NamingConventionAnalyzer.php
View File

@ -4,7 +4,6 @@ declare (strict_types=1);
namespace Rector\Naming\NamingConvention;
use RectorPrefix20210629\Nette\Utils\Strings;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
@ -25,10 +24,9 @@ final class NamingConventionAnalyzer
* $someNameSuffix = $this->getSomeName();
* $prefixSomeName = $this->getSomeName();
* $someName = $this->getSomeName();
*
* @param FuncCall|StaticCall|MethodCall $expr
* @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall $expr
*/
public function isCallMatchingVariableName(\PhpParser\Node\Expr $expr, string $currentName, string $expectedName) : bool
public function isCallMatchingVariableName($expr, string $currentName, string $expectedName) : bool
{
// skip "$call = $method->call();" based conventions
$callName = $this->nodeNameResolver->getName($expr->name);

9
rules/Naming/Rector/Assign/RenameVariableToMatchMethodCallReturnTypeRector.php
View File

@ -4,7 +4,6 @@ declare (strict_types=1);
namespace Rector\Naming\Rector\Assign;
use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\Assign;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
@ -144,9 +143,9 @@ CODE_SAMPLE
return $node;
}
/**
* @param FuncCall|StaticCall|MethodCall $callNode
* @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall $callNode
*/
private function isMultipleCall(\PhpParser\Node $callNode) : bool
private function isMultipleCall($callNode) : bool
{
$parentNode = $callNode->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::PARENT_NODE);
$callNodeClass = \get_class($callNode);
@ -191,9 +190,9 @@ CODE_SAMPLE
$this->variableRenamer->renameVariableInFunctionLike($variableAndCallAssign->getFunctionLike(), $variableAndCallAssign->getVariableName(), $expectedName, $variableAndCallAssign->getAssign());
}
/**
* @param StaticCall|MethodCall|FuncCall $expr
* @param \PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\FuncCall $expr
*/
private function isClassTypeWithChildren(\PhpParser\Node\Expr $expr) : bool
private function isClassTypeWithChildren($expr) : bool
{
$callStaticType = $this->getStaticType($expr);
$callStaticType = $this->typeUnwrapper->unwrapNullableType($callStaticType);

4
rules/Order/Rector/Class_/OrderPrivateMethodsByUseRector.php
View File

@ -103,9 +103,9 @@ CODE_SAMPLE
return $node;
}
/**
* @param Class_|Trait_ $classLike
* @param \PhpParser\Node\Stmt\Class_|\PhpParser\Node\Stmt\Trait_ $classLike
*/
private function getSortedAndOriginalClassMethods(\PhpParser\Node\Stmt\ClassLike $classLike) : \Rector\Order\ValueObject\SortedClassMethodsAndOriginalClassMethods
private function getSortedAndOriginalClassMethods($classLike) : \Rector\Order\ValueObject\SortedClassMethodsAndOriginalClassMethods
{
return new \Rector\Order\ValueObject\SortedClassMethodsAndOriginalClassMethods($this->getLocalPrivateMethodCallOrder($classLike), $this->resolvePrivateClassMethods($classLike));
}

8
rules/PHPOffice/Rector/StaticCall/AddRemovedDefaultValuesRector.php
View File

@ -69,10 +69,10 @@ CODE_SAMPLE
return $node;
}
/**
* @param StaticCall|MethodCall $node
* @param array<int, mixed> $defaultValuesByPosition
* @param \PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall $node
*/
private function refactorArgs(\PhpParser\Node $node, array $defaultValuesByPosition) : void
private function refactorArgs($node, array $defaultValuesByPosition) : void
{
foreach ($defaultValuesByPosition as $position => $defaultValue) {
// value is already set
@ -90,9 +90,9 @@ CODE_SAMPLE
}
}
/**
* @param StaticCall|MethodCall $node
* @param \PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall $node
*/
private function isCallerObjectType(\PhpParser\Node $node, \PHPStan\Type\ObjectType $objectType) : bool
private function isCallerObjectType($node, \PHPStan\Type\ObjectType $objectType) : bool
{
return $this->isObjectType($node instanceof \PhpParser\Node\Expr\MethodCall ? $node->var : $node->class, $objectType);
}

4
rules/PSR4/Rector/Namespace_/MultipleClassFileToPsr4ClassesRector.php
View File

@ -141,9 +141,9 @@ CODE_SAMPLE
return $nodeToReturn;
}
/**
* @param Namespace_|FileWithoutNamespace $mainNode
* @param \PhpParser\Node\Stmt\Namespace_|\Rector\Core\PhpParser\Node\CustomNode\FileWithoutNamespace $mainNode
*/
private function printNewNodes(\PhpParser\Node\Stmt\ClassLike $classLike, \PhpParser\Node $mainNode) : void
private function printNewNodes(\PhpParser\Node\Stmt\ClassLike $classLike, $mainNode) : void
{
$smartFileInfo = $this->file->getSmartFileInfo();
$declares = [];

5
rules/Php54/Rector/Break_/RemoveZeroBreakContinueRector.php
View File

@ -6,7 +6,6 @@ namespace Rector\Php54\Rector\Break_;
use PhpParser\Node;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\LNumber;
use PhpParser\Node\Stmt;
use PhpParser\Node\Stmt\Break_;
use PhpParser\Node\Stmt\Continue_;
use PHPStan\Type\Constant\ConstantIntegerType;
@ -87,9 +86,9 @@ CODE_SAMPLE
return null;
}
/**
* @param Break_|Continue_ $stmt
* @param \PhpParser\Node\Stmt\Break_|\PhpParser\Node\Stmt\Continue_ $stmt
*/
private function processVariableNum(\PhpParser\Node\Stmt $stmt, \PhpParser\Node\Expr\Variable $numVariable) : ?\PhpParser\Node
private function processVariableNum($stmt, \PhpParser\Node\Expr\Variable $numVariable) : ?\PhpParser\Node
{
$staticType = $this->getStaticType($numVariable);
if ($staticType instanceof \PHPStan\Type\ConstantType) {

8
rules/Php71/Rector/Assign/AssignArrayToStringRector.php
View File

@ -99,9 +99,9 @@ CODE_SAMPLE
return $assign;
}
/**
* @param PropertyFetch|StaticPropertyFetch $propertyFetchExpr
* @param \PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticPropertyFetch $propertyFetchExpr
*/
private function refactorPropertyFetch(\PhpParser\Node\Expr $propertyFetchExpr) : bool
private function refactorPropertyFetch($propertyFetchExpr) : bool
{
foreach ($this->emptyStringProperties as $emptyStringProperty) {
if (!$this->nodeNameResolver->areNamesEqual($emptyStringProperty, $propertyFetchExpr)) {
@ -113,9 +113,9 @@ CODE_SAMPLE
return \false;
}
/**
* @param Variable|PropertyFetch|StaticPropertyFetch|Expr $expr
* @param \PhpParser\Node\Expr\Variable|\PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticPropertyFetch|\PhpParser\Node\Expr $expr
*/
private function processVariable(\PhpParser\Node\Expr\Assign $assign, \PhpParser\Node\Expr $expr) : bool
private function processVariable(\PhpParser\Node\Expr\Assign $assign, $expr) : bool
{
if ($this->shouldSkipVariable($expr)) {
return \true;

4
rules/Php74/Rector/LNumber/AddLiteralSeparatorToNumberRector.php
View File

@ -107,9 +107,9 @@ CODE_SAMPLE
return $node;
}
/**
* @param LNumber|DNumber $node
* @param \PhpParser\Node\Scalar\LNumber|\PhpParser\Node\Scalar\DNumber $node
*/
private function shouldSkip(\PhpParser\Node $node, string $numericValueAsString) : bool
private function shouldSkip($node, string $numericValueAsString) : bool
{
/** @var int $startToken */
$startToken = $node->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::START_TOKEN_POSITION);

4
rules/Php74/Rector/Property/TypedPropertyRector.php
View File

@ -176,9 +176,9 @@ CODE_SAMPLE
return \true;
}
/**
* @param Name|NullableType|PhpParserUnionType $node
* @param \PhpParser\Node\Name|\PhpParser\Node\NullableType|PhpParserUnionType $node
*/
private function shouldSkipNonClassLikeType(\PhpParser\Node $node) : bool
private function shouldSkipNonClassLikeType($node) : bool
{
// unwrap nullable type
if ($node instanceof \PhpParser\Node\NullableType) {

3
rules/Php80/Rector/FunctionLike/UnionTypesRector.php
View File

@ -112,9 +112,6 @@ CODE_SAMPLE
return;
}
foreach ($functionLike->getParams() as $param) {
if ($param->type !== null) {
continue;
}
/** @var string $paramName */
$paramName = $this->getName($param->var);
$paramType = $phpDocInfo->getParamType($paramName);

5
rules/Php80/Rector/NotIdentical/StrContainsRector.php
View File

@ -4,7 +4,6 @@ declare (strict_types=1);
namespace Rector\Php80\Rector\NotIdentical;
use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\BinaryOp\Identical;
use PhpParser\Node\Expr\BinaryOp\NotIdentical;
use PhpParser\Node\Expr\BooleanNot;
@ -69,9 +68,9 @@ CODE_SAMPLE
return $funcCall;
}
/**
* @param Identical|NotIdentical $expr
* @param \PhpParser\Node\Expr\BinaryOp\Identical|\PhpParser\Node\Expr\BinaryOp\NotIdentical $expr
*/
private function matchIdenticalOrNotIdenticalToFalse(\PhpParser\Node\Expr $expr) : ?\PhpParser\Node\Expr\FuncCall
private function matchIdenticalOrNotIdenticalToFalse($expr) : ?\PhpParser\Node\Expr\FuncCall
{
if ($this->valueResolver->isFalse($expr->left)) {
if (!$expr->right instanceof \PhpParser\Node\Expr\FuncCall) {

37
rules/Privatization/NodeManipulator/VisibilityManipulator.php
View File

@ -43,16 +43,16 @@ final class VisibilityManipulator
$node->flags -= \PhpParser\Node\Stmt\Class_::MODIFIER_STATIC;
}
/**
* @param Class_|ClassMethod $node
* @param \PhpParser\Node\Stmt\Class_|\PhpParser\Node\Stmt\ClassMethod $node
*/
public function makeFinal(\PhpParser\Node $node) : void
public function makeFinal($node) : void
{
$this->addVisibilityFlag($node, \Rector\Core\ValueObject\Visibility::FINAL);
}
/**
* @param Class_|ClassMethod $node
* @param \PhpParser\Node\Stmt\Class_|\PhpParser\Node\Stmt\ClassMethod $node
*/
public function makeNonFinal(\PhpParser\Node $node) : void
public function makeNonFinal($node) : void
{
if (!$node->isFinal()) {
return;
@ -61,10 +61,9 @@ final class VisibilityManipulator
}
/**
* This way "abstract", "static", "final" are kept
*
* @param ClassMethod|Property|ClassConst $node
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst $node
*/
public function removeVisibility(\PhpParser\Node $node) : void
public function removeVisibility($node) : void
{
$this->ensureIsClassMethodOrProperty($node, __METHOD__);
// no modifier
@ -82,31 +81,31 @@ final class VisibilityManipulator
}
}
/**
* @param ClassMethod|Property|ClassConst $node
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst $node
*/
public function changeNodeVisibility(\PhpParser\Node $node, int $visibility) : void
public function changeNodeVisibility($node, int $visibility) : void
{
\RectorPrefix20210629\Webmozart\Assert\Assert::oneOf($visibility, [\Rector\Core\ValueObject\Visibility::PUBLIC, \Rector\Core\ValueObject\Visibility::PROTECTED, \Rector\Core\ValueObject\Visibility::PRIVATE, \Rector\Core\ValueObject\Visibility::STATIC, \Rector\Core\ValueObject\Visibility::ABSTRACT, \Rector\Core\ValueObject\Visibility::FINAL]);
$this->replaceVisibilityFlag($node, $visibility);
}
/**
* @param ClassMethod|Property|ClassConst $node
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst $node
*/
public function makePublic(\PhpParser\Node $node) : void
public function makePublic($node) : void
{
$this->replaceVisibilityFlag($node, \Rector\Core\ValueObject\Visibility::PUBLIC);
}
/**
* @param ClassMethod|Property|ClassConst $node
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst $node
*/
public function makeProtected(\PhpParser\Node $node) : void
public function makeProtected($node) : void
{
$this->replaceVisibilityFlag($node, \Rector\Core\ValueObject\Visibility::PROTECTED);
}
/**
* @param ClassMethod|Property|ClassConst $node
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst $node
*/
public function makePrivate(\PhpParser\Node $node) : void
public function makePrivate($node) : void
{
$this->replaceVisibilityFlag($node, \Rector\Core\ValueObject\Visibility::PRIVATE);
}
@ -115,9 +114,9 @@ final class VisibilityManipulator
$class->flags -= \PhpParser\Node\Stmt\Class_::MODIFIER_FINAL;
}
/**
* @param Class_|ClassMethod|Property|ClassConst $node
* @param \PhpParser\Node\Stmt\Class_|\PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst $node
*/
private function addVisibilityFlag(\PhpParser\Node $node, int $visibility) : void
private function addVisibilityFlag($node, int $visibility) : void
{
$this->ensureIsClassMethodOrProperty($node, __METHOD__);
$node->flags |= $visibility;
@ -132,9 +131,9 @@ final class VisibilityManipulator
throw new \Rector\Core\Exception\InvalidNodeTypeException(\sprintf('"%s" only accepts "%s" types. "%s" given.', $location, \implode('", "', self::ALLOWED_NODE_TYPES), \get_class($node)));
}
/**
* @param ClassMethod|Property|ClassConst $node
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst $node
*/
private function replaceVisibilityFlag(\PhpParser\Node $node, int $visibility) : void
private function replaceVisibilityFlag($node, int $visibility) : void
{
$isStatic = $node instanceof \PhpParser\Node\Stmt\ClassMethod && $node->isStatic();
if ($isStatic) {

8
rules/Removing/Rector/ClassMethod/ArgumentRemoverRector.php
View File

@ -72,9 +72,9 @@ CODE_SAMPLE
$this->removedArguments = $removedArguments;
}
/**
* @param ClassMethod|StaticCall|MethodCall $node
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall $node
*/
private function processPosition(\PhpParser\Node $node, \Rector\Removing\ValueObject\ArgumentRemover $argumentRemover) : void
private function processPosition($node, \Rector\Removing\ValueObject\ArgumentRemover $argumentRemover) : void
{
if ($argumentRemover->getValue() === null) {
if ($node instanceof \PhpParser\Node\Expr\MethodCall || $node instanceof \PhpParser\Node\Expr\StaticCall) {
@ -101,9 +101,9 @@ CODE_SAMPLE
}
}
/**
* @param ClassMethod|StaticCall|MethodCall $node
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall $node
*/
private function removeByName(\PhpParser\Node $node, int $position, string $name) : void
private function removeByName($node, int $position, string $name) : void
{
if ($node instanceof \PhpParser\Node\Expr\MethodCall || $node instanceof \PhpParser\Node\Expr\StaticCall) {
if (isset($node->args[$position]) && $this->isName($node->args[$position], $name)) {

4
rules/Renaming/NodeManipulator/IdentifierManipulator.php
View File

@ -53,9 +53,9 @@ final class IdentifierManipulator
$node->name = new \PhpParser\Node\Identifier($newName);
}
/**
* @param ClassConstFetch|MethodCall|PropertyFetch|StaticCall|ClassMethod $node
* @param \PhpParser\Node\Expr\ClassConstFetch|\PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Stmt\ClassMethod $node
*/
private function resolveOldMethodName(\PhpParser\Node $node) : ?string
private function resolveOldMethodName($node) : ?string
{
if ($node instanceof \PhpParser\Node\Expr\StaticCall || $node instanceof \PhpParser\Node\Expr\MethodCall) {
return $this->nodeNameResolver->getName($node->name);

4
rules/Renaming/Rector/FileWithoutNamespace/PseudoNamespaceToNamespaceRector.php
View File

@ -129,10 +129,10 @@ CODE_SAMPLE
return $stmts;
}
/**
* @param Name|Identifier $node
* @return Name|Identifier
* @param \PhpParser\Node\Name|\PhpParser\Node\Identifier $node
*/
private function processNameOrIdentifier(\PhpParser\Node $node) : ?\PhpParser\Node
private function processNameOrIdentifier($node) : ?\PhpParser\Node
{
// no name → skip
if ($node->toString() === '') {

4
rules/Renaming/Rector/MethodCall/RenameMethodRector.php
View File

@ -105,9 +105,9 @@ CODE_SAMPLE
$this->methodCallRenameCollector->addMethodCallRenames($methodCallRenames);
}
/**
* @param MethodCall|StaticCall|ClassMethod $node
* @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Stmt\ClassMethod $node
*/
private function skipClassMethod(\PhpParser\Node $node, \Rector\Renaming\Contract\MethodCallRenameInterface $methodCallRename) : bool
private function skipClassMethod($node, \Rector\Renaming\Contract\MethodCallRenameInterface $methodCallRename) : bool
{
if (!$node instanceof \PhpParser\Node\Stmt\ClassMethod) {
return \false;

9
rules/Transform/NodeAnalyzer/FuncCallStaticCallToMethodCallAnalyzer.php
View File

@ -6,7 +6,6 @@ namespace Rector\Transform\NodeAnalyzer;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\PropertyFetch;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\FunctionLike;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Stmt\Function_;
@ -53,10 +52,10 @@ final class FuncCallStaticCallToMethodCallAnalyzer
$this->propertyAdder = $propertyAdder;
}
/**
* @param ClassMethod|Function_ $functionLike
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
* @return \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\Variable
*/
public function matchTypeProvidingExpr(\PhpParser\Node\Stmt\Class_ $class, \PhpParser\Node\FunctionLike $functionLike, \PHPStan\Type\ObjectType $objectType)
public function matchTypeProvidingExpr(\PhpParser\Node\Stmt\Class_ $class, $functionLike, \PHPStan\Type\ObjectType $objectType)
{
$expr = $this->typeProvidingExprFromClassResolver->resolveTypeProvidingExprFromClass($class, $functionLike, $objectType);
if ($expr !== null) {
@ -70,9 +69,9 @@ final class FuncCallStaticCallToMethodCallAnalyzer
return $this->propertyFetchFactory->createFromType($objectType);
}
/**
* @param ClassMethod|Function_ $functionLike
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
*/
private function addClassMethodParamForVariable(\PhpParser\Node\Expr\Variable $variable, \PHPStan\Type\ObjectType $objectType, \PhpParser\Node\FunctionLike $functionLike) : void
private function addClassMethodParamForVariable(\PhpParser\Node\Expr\Variable $variable, \PHPStan\Type\ObjectType $objectType, $functionLike) : void
{
/** @var string $variableName */
$variableName = $this->nodeNameResolver->getName($variable);

4
rules/Transform/NodeTypeAnalyzer/TypeProvidingExprFromClassResolver.php
View File

@ -51,10 +51,10 @@ final class TypeProvidingExprFromClassResolver
$this->propertyNaming = $propertyNaming;
}
/**
* @param ClassMethod|Function_ $functionLike
* @return MethodCall|PropertyFetch|Variable|null
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
*/
public function resolveTypeProvidingExprFromClass(\PhpParser\Node\Stmt\Class_ $class, \PhpParser\Node\FunctionLike $functionLike, \PHPStan\Type\ObjectType $objectType) : ?\PhpParser\Node\Expr
public function resolveTypeProvidingExprFromClass(\PhpParser\Node\Stmt\Class_ $class, $functionLike, \PHPStan\Type\ObjectType $objectType) : ?\PhpParser\Node\Expr
{
$className = $class->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::CLASS_NAME);
if ($className === null) {

8
rules/Transform/Rector/FileWithoutNamespace/FunctionToStaticMethodRector.php
View File

@ -134,9 +134,9 @@ CODE_SAMPLE
return $stmts;
}
/**
* @param Namespace_|FileWithoutNamespace $node
* @param \PhpParser\Node\Stmt\Namespace_|\Rector\Core\PhpParser\Node\CustomNode\FileWithoutNamespace $node
*/
private function printStaticMethodClass(\Symplify\SmartFileSystem\SmartFileInfo $smartFileInfo, string $shortClassName, \PhpParser\Node $node, \PhpParser\Node\Stmt\Class_ $class) : void
private function printStaticMethodClass(\Symplify\SmartFileSystem\SmartFileInfo $smartFileInfo, string $shortClassName, $node, \PhpParser\Node\Stmt\Class_ $class) : void
{
$classFileDestination = $smartFileInfo->getPath() . \DIRECTORY_SEPARATOR . $shortClassName . '.php';
$nodesToPrint = [$this->resolveNodeToPrint($node, $class)];
@ -144,10 +144,10 @@ CODE_SAMPLE
$this->removedAndAddedFilesCollector->addAddedFile($addedFileWithNodes);
}
/**
* @param Namespace_|FileWithoutNamespace $node
* @param \PhpParser\Node\Stmt\Namespace_|\Rector\Core\PhpParser\Node\CustomNode\FileWithoutNamespace $node
* @return \PhpParser\Node\Stmt\Namespace_|\PhpParser\Node\Stmt\Class_
*/
private function resolveNodeToPrint(\PhpParser\Node $node, \PhpParser\Node\Stmt\Class_ $class)
private function resolveNodeToPrint($node, \PhpParser\Node\Stmt\Class_ $class)
{
if ($node instanceof \PhpParser\Node\Stmt\Namespace_) {
return new \PhpParser\Node\Stmt\Namespace_($node->name, [$class]);

5
rules/TypeDeclaration/ChildPopulator/ChildParamPopulator.php
View File

@ -3,7 +3,6 @@
declare (strict_types=1);
namespace Rector\TypeDeclaration\ChildPopulator;
use PhpParser\Node\FunctionLike;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\ClassLike;
use PhpParser\Node\Stmt\ClassMethod;
@ -42,9 +41,9 @@ final class ChildParamPopulator
}
/**
* Add typehint to all children
* @param ClassMethod|Function_ $functionLike
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
*/
public function populateChildClassMethod(\PhpParser\Node\FunctionLike $functionLike, int $position, \PHPStan\Type\Type $paramType) : void
public function populateChildClassMethod($functionLike, int $position, \PHPStan\Type\Type $paramType) : void
{
if (!$functionLike instanceof \PhpParser\Node\Stmt\ClassMethod) {
return;

5
rules/TypeDeclaration/PhpDocParser/NonInformativeReturnTagRemover.php
View File

@ -3,7 +3,6 @@
declare (strict_types=1);
namespace Rector\TypeDeclaration\PhpDocParser;
use PhpParser\Node\FunctionLike;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Stmt\Function_;
use PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode;
@ -49,9 +48,9 @@ final class NonInformativeReturnTagRemover
$this->typeChecker = $typeChecker;
}
/**
* @param ClassMethod|Function_ $functionLike
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
*/
public function removeReturnTagIfNotUseful(\PhpParser\Node\FunctionLike $functionLike) : void
public function removeReturnTagIfNotUseful($functionLike) : void
{
$phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($functionLike);
$returnTagValueNode = $phpDocInfo->getReturnTagValue();

6
rules/TypeDeclaration/PhpParserTypeAnalyzer.php
View File

@ -20,10 +20,10 @@ final class PhpParserTypeAnalyzer
$this->staticTypeMapper = $staticTypeMapper;
}
/**
* @param Name|NullableType|UnionType|Identifier $possibleSubtype
* @param Name|NullableType|UnionType|Identifier $possibleParentType
* @param \PhpParser\Node\Name|\PhpParser\Node\NullableType|\PhpParser\Node\UnionType|\PhpParser\Node\Identifier $possibleSubtype
* @param \PhpParser\Node\Name|\PhpParser\Node\NullableType|\PhpParser\Node\UnionType|\PhpParser\Node\Identifier $possibleParentType
*/
public function isCovariantSubtypeOf(\PhpParser\Node $possibleSubtype, \PhpParser\Node $possibleParentType) : bool
public function isCovariantSubtypeOf($possibleSubtype, $possibleParentType) : bool
{
// skip until PHP 8 is out
if ($this->isUnionType($possibleSubtype, $possibleParentType)) {

5
rules/TypeDeclaration/Rector/ClassMethod/ReturnNeverTypeRector.php
View File

@ -5,7 +5,6 @@ namespace Rector\TypeDeclaration\Rector\ClassMethod;
use PhpParser\Node;
use PhpParser\Node\Expr\Yield_;
use PhpParser\Node\FunctionLike;
use PhpParser\Node\Name;
use PhpParser\Node\Stmt;
use PhpParser\Node\Stmt\ClassMethod;
@ -114,9 +113,9 @@ CODE_SAMPLE
return $node->returnType && $this->isName($node->returnType, 'never');
}
/**
* @param ClassMethod|Function_ $functionLike
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
*/
private function resolveHasNeverFuncCall(\PhpParser\Node\FunctionLike $functionLike) : bool
private function resolveHasNeverFuncCall($functionLike) : bool
{
$hasNeverType = \false;
foreach ((array) $functionLike->stmts as $stmt) {

4
rules/TypeDeclaration/Rector/ClassMethod/ReturnTypeFromStrictTypedCallRector.php
View File

@ -110,10 +110,10 @@ CODE_SAMPLE
return null;
}
/**
* @param ClassMethod|Function_|Closure $node
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_|\PhpParser\Node\Expr\Closure $node
* @return \PhpParser\Node\Expr\Closure|\PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_
*/
private function processSingleUnionType(\PhpParser\Node $node, \PHPStan\Type\UnionType $unionType, \PhpParser\Node\NullableType $nullableType)
private function processSingleUnionType($node, \PHPStan\Type\UnionType $unionType, \PhpParser\Node\NullableType $nullableType)
{
$types = $unionType->getTypes();
$returnType = $types[0] instanceof \PHPStan\Type\ObjectType && $types[1] instanceof \PHPStan\Type\NullType ? new \PhpParser\Node\NullableType(new \PhpParser\Node\Name\FullyQualified($types[0]->getClassName())) : $nullableType;

4
rules/TypeDeclaration/Rector/FunctionLike/ParamTypeDeclarationRector.php
View File

@ -141,9 +141,9 @@ CODE_SAMPLE
return null;
}
/**
* @param ClassMethod|Function_ $functionLike
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
*/
private function refactorParam(\PhpParser\Node\Param $param, \PhpParser\Node\FunctionLike $functionLike, int $position) : void
private function refactorParam(\PhpParser\Node\Param $param, $functionLike, int $position) : void
{
if ($this->shouldSkipParam($param, $functionLike)) {
return;

24
rules/TypeDeclaration/Rector/FunctionLike/ReturnTypeDeclarationRector.php
View File

@ -139,9 +139,9 @@ CODE_SAMPLE
return $this->processType($node, $inferedReturnType);
}
/**
* @param ClassMethod|Function_ $node
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $node
*/
private function processType(\PhpParser\Node $node, \PHPStan\Type\Type $inferedType) : ?\PhpParser\Node
private function processType($node, \PHPStan\Type\Type $inferedType) : ?\PhpParser\Node
{
$inferredReturnNode = $this->staticTypeMapper->mapPHPStanTypeToPhpParserNode($inferedType, \Rector\PHPStanStaticTypeMapper\ValueObject\TypeKind::KIND_RETURN);
// nothing to change in PHP code
@ -171,9 +171,9 @@ CODE_SAMPLE
return $this->vendorLockResolver->isReturnChangeVendorLockedIn($classMethod);
}
/**
* @param ClassMethod|Function_ $functionLike
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
*/
private function shouldSkipInferredReturnNode(\PhpParser\Node\FunctionLike $functionLike) : bool
private function shouldSkipInferredReturnNode($functionLike) : bool
{
// already overridden by previous populateChild() method run
if ($functionLike->returnType === null) {
@ -182,9 +182,9 @@ CODE_SAMPLE
return (bool) $functionLike->returnType->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::DO_NOT_CHANGE);
}
/**
* @param ClassMethod|Function_ $functionLike
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
*/
private function shouldSkipExistingReturnType(\PhpParser\Node\FunctionLike $functionLike, \PHPStan\Type\Type $inferedType) : bool
private function shouldSkipExistingReturnType($functionLike, \PHPStan\Type\Type $inferedType) : bool
{
if ($functionLike->returnType === null) {
return \false;
@ -199,10 +199,10 @@ CODE_SAMPLE
return $this->isNullableTypeSubType($currentType, $inferedType);
}
/**
* @param ClassMethod|Function_ $functionLike
* @param Name|NullableType|PhpParserUnionType $inferredReturnNode
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
* @param \PhpParser\Node\Name|\PhpParser\Node\NullableType|PhpParserUnionType $inferredReturnNode
*/
private function addReturnType(\PhpParser\Node\FunctionLike $functionLike, \PhpParser\Node $inferredReturnNode) : void
private function addReturnType($functionLike, $inferredReturnNode) : void
{
if ($this->isExternalVoid($functionLike, $inferredReturnNode)) {
return;
@ -222,10 +222,10 @@ CODE_SAMPLE
}
}
/**
* @param ClassMethod|Function_ $functionLike
* @param Name|NullableType|PhpParserUnionType $inferredReturnNode
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
* @param \PhpParser\Node\Name|\PhpParser\Node\NullableType|PhpParserUnionType $inferredReturnNode
*/
private function isExternalVoid(\PhpParser\Node\FunctionLike $functionLike, \PhpParser\Node $inferredReturnNode) : bool
private function isExternalVoid($functionLike, $inferredReturnNode) : bool
{
$classLike = $functionLike->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::CLASS_NODE);
if (!$classLike instanceof \PhpParser\Node\Stmt\Class_) {

14
rules/TypeDeclaration/TypeAlreadyAddedChecker/ReturnTypeAlreadyAddedChecker.php
View File

@ -4,8 +4,6 @@ declare (strict_types=1);
namespace Rector\TypeDeclaration\TypeAlreadyAddedChecker;
use Iterator;
use PhpParser\Node;
use PhpParser\Node\FunctionLike;
use PhpParser\Node\Identifier;
use PhpParser\Node\Name;
use PhpParser\Node\NullableType;
@ -51,9 +49,9 @@ final class ReturnTypeAlreadyAddedChecker
$this->nodeComparator = $nodeComparator;
}
/**
* @param ClassMethod|Function_ $functionLike
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
*/
public function isSameOrBetterReturnTypeAlreadyAdded(\PhpParser\Node\FunctionLike $functionLike, \PHPStan\Type\Type $returnType) : bool
public function isSameOrBetterReturnTypeAlreadyAdded($functionLike, \PHPStan\Type\Type $returnType) : bool
{
$nodeReturnType = $functionLike->returnType;
/** @param Identifier|Name|NullableType|PhpParserUnionType|null $returnTypeNode */
@ -92,9 +90,9 @@ final class ReturnTypeAlreadyAddedChecker
return $nodeContentWithoutPreslash === $className;
}
/**
* @param Identifier|Name|NullableType|PhpParserUnionType $returnTypeNode
* @param \PhpParser\Node\Identifier|\PhpParser\Node\Name|\PhpParser\Node\NullableType|PhpParserUnionType $returnTypeNode
*/
private function isArrayIterableIteratorCoType(\PhpParser\Node $returnTypeNode, \PHPStan\Type\Type $returnType) : bool
private function isArrayIterableIteratorCoType($returnTypeNode, \PHPStan\Type\Type $returnType) : bool
{
if (!$this->nodeNameResolver->isNames($returnTypeNode, self::FOREACHABLE_TYPES)) {
return \false;
@ -102,9 +100,9 @@ final class ReturnTypeAlreadyAddedChecker
return $this->isStaticTypeIterable($returnType);
}
/**
* @param Identifier|Name|NullableType|PhpParserUnionType $returnTypeNode
* @param \PhpParser\Node\Identifier|\PhpParser\Node\Name|\PhpParser\Node\NullableType|PhpParserUnionType $returnTypeNode
*/
private function isUnionCoType(\PhpParser\Node $returnTypeNode, \PHPStan\Type\Type $type) : bool
private function isUnionCoType($returnTypeNode, \PHPStan\Type\Type $type) : bool
{
if (!$type instanceof \PHPStan\Type\UnionType) {
return \false;

9
rules/TypeDeclaration/TypeInferer/SilentVoidResolver.php
View File

@ -5,7 +5,6 @@ namespace Rector\TypeDeclaration\TypeInferer;
use PhpParser\Node\Expr\Closure;
use PhpParser\Node\Expr\Yield_;
use PhpParser\Node\FunctionLike;
use PhpParser\Node\Stmt;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\ClassMethod;
@ -66,9 +65,9 @@ final class SilentVoidResolver
return \true;
}
/**
* @param ClassMethod|Closure|Function_ $functionLike
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Expr\Closure|\PhpParser\Node\Stmt\Function_ $functionLike
*/
public function hasSilentVoid(\PhpParser\Node\FunctionLike $functionLike) : bool
public function hasSilentVoid($functionLike) : bool
{
if ($this->hasStmtsAlwaysReturn((array) $functionLike->stmts)) {
return \false;
@ -132,9 +131,9 @@ final class SilentVoidResolver
}
/**
* @see https://phpstan.org/writing-php-code/phpdoc-types#bottom-type
* @param ClassMethod|Closure|Function_ $functionLike
* @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Expr\Closure|\PhpParser\Node\Stmt\Function_ $functionLike
*/
private function hasNeverType(\PhpParser\Node\FunctionLike $functionLike) : bool
private function hasNeverType($functionLike) : bool
{
return $this->betterNodeFinder->hasInstancesOf($functionLike, [\PhpParser\Node\Stmt\Throw_::class]);
}

4
src/Application/VersionResolver.php
View File

@ -16,11 +16,11 @@ final class VersionResolver
/**
* @var string
*/
public const PACKAGE_VERSION = '2a394c750f518a33d56a0aa80fa2addf6ff1c140';
public const PACKAGE_VERSION = 'dfd048342b88db3c2adcf20ec701a9fd9a4e2319';
/**
* @var string
*/
public const RELEASE_DATE = '2021-06-29 15:25:57';
public const RELEASE_DATE = '2021-06-29 16:11:40';
public static function resolvePackageVersion() : string
{
$process = new \RectorPrefix20210629\Symfony\Component\Process\Process(['git', 'log', '--pretty="%H"', '-n1', 'HEAD'], __DIR__);

5
src/NodeAnalyzer/PropertyFetchAnalyzer.php
View File

@ -4,7 +4,6 @@ declare (strict_types=1);
namespace Rector\Core\NodeAnalyzer;
use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\Assign;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\PropertyFetch;
@ -71,9 +70,9 @@ final class PropertyFetchAnalyzer
});
}
/**
* @param PropertyFetch|StaticPropertyFetch $expr
* @param \PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticPropertyFetch $expr
*/
public function isPropertyToSelf(\PhpParser\Node\Expr $expr) : bool
public function isPropertyToSelf($expr) : bool
{
if ($expr instanceof \PhpParser\Node\Expr\PropertyFetch && !$this->nodeNameResolver->isName($expr->var, 'this')) {
return \false;

4
src/NodeManipulator/ClassInsertManipulator.php
View File

@ -34,9 +34,9 @@ final class ClassInsertManipulator
$this->nodeNameResolver = $nodeNameResolver;
}
/**
* @param ClassMethod|Property|ClassConst|ClassMethod $stmt
* @param \PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst|\PhpParser\Node\Stmt\ClassMethod $stmt
*/
public function addAsFirstMethod(\PhpParser\Node\Stmt\Class_ $class, \PhpParser\Node\Stmt $stmt) : void
public function addAsFirstMethod(\PhpParser\Node\Stmt\Class_ $class, $stmt) : void
{
if ($this->isSuccessToInsertBeforeFirstMethod($class, $stmt)) {
return;

9
src/NodeManipulator/ClassManipulator.php
View File

@ -6,7 +6,6 @@ namespace Rector\Core\NodeManipulator;
use PhpParser\Node\Name;
use PhpParser\Node\Name\FullyQualified;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\ClassLike;
use PhpParser\Node\Stmt\Interface_;
use PhpParser\Node\Stmt\Property;
use PhpParser\Node\Stmt\Trait_;
@ -36,10 +35,10 @@ final class ClassManipulator
}
/**
* @deprecated
* @param Class_|Trait_ $classLike
* @return array<string, Name>
* @param \PhpParser\Node\Stmt\Class_|\PhpParser\Node\Stmt\Trait_ $classLike
*/
public function getUsedTraits(\PhpParser\Node\Stmt\ClassLike $classLike) : array
public function getUsedTraits($classLike) : array
{
$usedTraits = [];
foreach ($classLike->getTraitUses() as $traitUse) {
@ -111,10 +110,10 @@ final class ClassManipulator
}
}
/**
* @param Class_|Interface_ $classLike
* @return string[]
* @param \PhpParser\Node\Stmt\Class_|\PhpParser\Node\Stmt\Interface_ $classLike
*/
public function getClassLikeNodeParentInterfaceNames(\PhpParser\Node\Stmt\ClassLike $classLike) : array
public function getClassLikeNodeParentInterfaceNames($classLike) : array
{
if ($classLike instanceof \PhpParser\Node\Stmt\Class_) {
return $this->nodeNameResolver->getNames($classLike->implements);

9
src/NodeManipulator/MagicPropertyFetchAnalyzer.php
View File

@ -4,7 +4,6 @@ declare (strict_types=1);
namespace Rector\Core\NodeManipulator;
use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\PropertyFetch;
use PhpParser\Node\Expr\StaticPropertyFetch;
use PHPStan\Analyser\Scope;
@ -42,9 +41,9 @@ final class MagicPropertyFetchAnalyzer
$this->reflectionProvider = $reflectionProvider;
}
/**
* @param PropertyFetch|Node\Expr\StaticPropertyFetch $expr
* @param \PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticPropertyFetch $expr
*/
public function isMagicOnType(\PhpParser\Node\Expr $expr, \PHPStan\Type\Type $type) : bool
public function isMagicOnType($expr, \PHPStan\Type\Type $type) : bool
{
$varNodeType = $this->nodeTypeResolver->resolve($expr);
if ($varNodeType instanceof \PHPStan\Type\ErrorType) {
@ -63,9 +62,9 @@ final class MagicPropertyFetchAnalyzer
return !$this->hasPublicProperty($expr, $nodeName);
}
/**
* @param PropertyFetch|StaticPropertyFetch $expr
* @param \PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticPropertyFetch $expr
*/
private function hasPublicProperty(\PhpParser\Node\Expr $expr, string $propertyName) : bool
private function hasPublicProperty($expr, string $propertyName) : bool
{
$scope = $expr->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::SCOPE);
if (!$scope instanceof \PHPStan\Analyser\Scope) {

4
src/NodeManipulator/PropertyManipulator.php
View File

@ -109,9 +109,9 @@ final class PropertyManipulator
return \false;
}
/**
* @param PropertyFetch|StaticPropertyFetch $expr
* @param \PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticPropertyFetch $expr
*/
private function isChangeableContext(\PhpParser\Node\Expr $expr) : bool
private function isChangeableContext($expr) : bool
{
$parent = $expr->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::PARENT_NODE);
if (!$parent instanceof \PhpParser\Node) {

2
vendor/autoload.php vendored
View File

@ -4,4 +4,4 @@
require_once __DIR__ . '/composer/autoload_real.php';
return ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708::getLoader();
return ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a::getLoader();

14
vendor/composer/autoload_real.php vendored
View File

@ -2,7 +2,7 @@
// autoload_real.php @generated by Composer
class ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708
class ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a
{
private static $loader;
@ -22,15 +22,15 @@ class ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708
return self::$loader;
}
spl_autoload_register(array('ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708', 'loadClassLoader'), true, true);
spl_autoload_register(array('ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a', 'loadClassLoader'), true, true);
self::$loader = $loader = new \Composer\Autoload\ClassLoader(\dirname(\dirname(__FILE__)));
spl_autoload_unregister(array('ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708', 'loadClassLoader'));
spl_autoload_unregister(array('ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a', 'loadClassLoader'));
$useStaticLoader = PHP_VERSION_ID >= 50600 && !defined('HHVM_VERSION') && (!function_exists('zend_loader_file_encoded') || !zend_loader_file_encoded());
if ($useStaticLoader) {
require __DIR__ . '/autoload_static.php';
call_user_func(\Composer\Autoload\ComposerStaticInit21b95b602ec0f7bd9066f339873ca708::getInitializer($loader));
call_user_func(\Composer\Autoload\ComposerStaticInitfb379d69a16f3d9bc4af0d6d72567f2a::getInitializer($loader));
} else {
$classMap = require __DIR__ . '/autoload_classmap.php';
if ($classMap) {
@ -42,19 +42,19 @@ class ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708
$loader->register(true);
if ($useStaticLoader) {
$includeFiles = Composer\Autoload\ComposerStaticInit21b95b602ec0f7bd9066f339873ca708::$files;
$includeFiles = Composer\Autoload\ComposerStaticInitfb379d69a16f3d9bc4af0d6d72567f2a::$files;
} else {
$includeFiles = require __DIR__ . '/autoload_files.php';
}
foreach ($includeFiles as $fileIdentifier => $file) {
composerRequire21b95b602ec0f7bd9066f339873ca708($fileIdentifier, $file);
composerRequirefb379d69a16f3d9bc4af0d6d72567f2a($fileIdentifier, $file);
}
return $loader;
}
}
function composerRequire21b95b602ec0f7bd9066f339873ca708($fileIdentifier, $file)
function composerRequirefb379d69a16f3d9bc4af0d6d72567f2a($fileIdentifier, $file)
{
if (empty($GLOBALS['__composer_autoload_files'][$fileIdentifier])) {
require $file;

8
vendor/composer/autoload_static.php vendored
View File

@ -4,7 +4,7 @@
namespace Composer\Autoload;
class ComposerStaticInit21b95b602ec0f7bd9066f339873ca708
class ComposerStaticInitfb379d69a16f3d9bc4af0d6d72567f2a
{
public static $files = array (
'a4a119a56e50fbb293281d9a48007e0e' => __DIR__ . '/..' . '/symfony/polyfill-php80/bootstrap.php',
@ -3838,9 +3838,9 @@ class ComposerStaticInit21b95b602ec0f7bd9066f339873ca708
public static function getInitializer(ClassLoader $loader)
{
return \Closure::bind(function () use ($loader) {
$loader->prefixLengthsPsr4 = ComposerStaticInit21b95b602ec0f7bd9066f339873ca708::$prefixLengthsPsr4;
$loader->prefixDirsPsr4 = ComposerStaticInit21b95b602ec0f7bd9066f339873ca708::$prefixDirsPsr4;
$loader->classMap = ComposerStaticInit21b95b602ec0f7bd9066f339873ca708::$classMap;
$loader->prefixLengthsPsr4 = ComposerStaticInitfb379d69a16f3d9bc4af0d6d72567f2a::$prefixLengthsPsr4;
$loader->prefixDirsPsr4 = ComposerStaticInitfb379d69a16f3d9bc4af0d6d72567f2a::$prefixDirsPsr4;
$loader->classMap = ComposerStaticInitfb379d69a16f3d9bc4af0d6d72567f2a::$classMap;
}, null, ClassLoader::class);
}

10
vendor/scoper-autoload.php vendored
View File

@ -21,8 +21,8 @@ if (!class_exists('SomeTestCase', false) && !interface_exists('SomeTestCase', fa
if (!class_exists('CheckoutEntityFactory', false) && !interface_exists('CheckoutEntityFactory', false) && !trait_exists('CheckoutEntityFactory', false)) {
spl_autoload_call('RectorPrefix20210629\CheckoutEntityFactory');
}
if (!class_exists('ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708', false) && !interface_exists('ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708', false) && !trait_exists('ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708', false)) {
spl_autoload_call('RectorPrefix20210629\ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708');
if (!class_exists('ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a', false) && !interface_exists('ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a', false) && !trait_exists('ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a', false)) {
spl_autoload_call('RectorPrefix20210629\ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a');
}
if (!class_exists('Doctrine\Inflector\Inflector', false) && !interface_exists('Doctrine\Inflector\Inflector', false) && !trait_exists('Doctrine\Inflector\Inflector', false)) {
spl_autoload_call('RectorPrefix20210629\Doctrine\Inflector\Inflector');
@ -3320,9 +3320,9 @@ if (!function_exists('print_node')) {
return \RectorPrefix20210629\print_node(...func_get_args());
}
}
if (!function_exists('composerRequire21b95b602ec0f7bd9066f339873ca708')) {
function composerRequire21b95b602ec0f7bd9066f339873ca708() {
return \RectorPrefix20210629\composerRequire21b95b602ec0f7bd9066f339873ca708(...func_get_args());
if (!function_exists('composerRequirefb379d69a16f3d9bc4af0d6d72567f2a')) {
function composerRequirefb379d69a16f3d9bc4af0d6d72567f2a() {
return \RectorPrefix20210629\composerRequirefb379d69a16f3d9bc4af0d6d72567f2a(...func_get_args());
}
}
if (!function_exists('parseArgs')) {