?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/NodeNameResolver.tar
???????
Contract/NodeNameResolverInterface.php 0000644 00000000620 15127560260 0014065 0 ustar 00 <?php declare (strict_types=1); namespace Rector\NodeNameResolver\Contract; use PhpParser\Node; use PHPStan\Analyser\Scope; /** * @template TNode as Node */ interface NodeNameResolverInterface { /** * @return class-string<TNode> */ public function getNode() : string; /** * @param TNode $node */ public function resolve(Node $node, ?Scope $scope) : ?string; } Regex/RegexPatternDetector.php 0000644 00000002064 15127560260 0012437 0 ustar 00 <?php declare (strict_types=1); namespace Rector\NodeNameResolver\Regex; final class RegexPatternDetector { /** * @var string[] * * This prevents miss matching like "aMethoda" */ private const POSSIBLE_DELIMITERS = ['#', '~', '/']; /** * @var array<string, string> */ private const START_AND_END_DELIMITERS = ['(' => ')', '{' => '}', '[' => ']', '<' => '>']; public function isRegexPattern(string $name) : bool { if (\strlen($name) <= 2) { return \false; } $firstChar = $name[0]; $lastChar = $name[\strlen($name) - 1]; if ($firstChar !== $lastChar) { foreach (self::START_AND_END_DELIMITERS as $start => $end) { if ($firstChar !== $start) { continue; } if ($lastChar !== $end) { continue; } return \true; } return \false; } return \in_array($firstChar, self::POSSIBLE_DELIMITERS, \true); } } NodeNameResolver/PropertyNameResolver.php 0000644 00000001331 15127560260 0014636 0 ustar 00 <?php declare (strict_types=1); namespace Rector\NodeNameResolver\NodeNameResolver; use PhpParser\Node; use PhpParser\Node\Stmt\Property; use PHPStan\Analyser\Scope; use Rector\NodeNameResolver\Contract\NodeNameResolverInterface; /** * @implements NodeNameResolverInterface<Property> */ final class PropertyNameResolver implements NodeNameResolverInterface { public function getNode() : string { return Property::class; } /** * @param Property $node */ public function resolve(Node $node, ?Scope $scope) : ?string { if ($node->props === []) { return null; } $onlyProperty = $node->props[0]; return $onlyProperty->name->toString(); } } NodeNameResolver/FunctionNameResolver.php 0000644 00000001552 15127560260 0014604 0 ustar 00 <?php declare (strict_types=1); namespace Rector\NodeNameResolver\NodeNameResolver; use PhpParser\Node; use PhpParser\Node\Stmt\Function_; use PHPStan\Analyser\Scope; use Rector\NodeNameResolver\Contract\NodeNameResolverInterface; /** * @implements NodeNameResolverInterface<Function_> */ final class FunctionNameResolver implements NodeNameResolverInterface { public function getNode() : string { return Function_::class; } /** * @param Function_ $node */ public function resolve(Node $node, ?Scope $scope) : ?string { $bareName = (string) $node->name; if (!$scope instanceof Scope) { return $bareName; } $namespaceName = $scope->getNamespace(); if ($namespaceName !== null) { return $namespaceName . '\\' . $bareName; } return $bareName; } } NodeNameResolver/ClassConstNameResolver.php 0000644 00000001345 15127560260 0015073 0 ustar 00 <?php declare (strict_types=1); namespace Rector\NodeNameResolver\NodeNameResolver; use PhpParser\Node; use PhpParser\Node\Stmt\ClassConst; use PHPStan\Analyser\Scope; use Rector\NodeNameResolver\Contract\NodeNameResolverInterface; /** * @implements NodeNameResolverInterface<ClassConst> */ final class ClassConstNameResolver implements NodeNameResolverInterface { public function getNode() : string { return ClassConst::class; } /** * @param ClassConst $node */ public function resolve(Node $node, ?Scope $scope) : ?string { if ($node->consts === []) { return null; } $onlyConstant = $node->consts[0]; return $onlyConstant->name->toString(); } } NodeNameResolver/UseNameResolver.php 0000644 00000001270 15127560260 0013550 0 ustar 00 <?php declare (strict_types=1); namespace Rector\NodeNameResolver\NodeNameResolver; use PhpParser\Node; use PhpParser\Node\Stmt\Use_; use PHPStan\Analyser\Scope; use Rector\NodeNameResolver\Contract\NodeNameResolverInterface; /** * @implements NodeNameResolverInterface<Use_> */ final class UseNameResolver implements NodeNameResolverInterface { public function getNode() : string { return Use_::class; } /** * @param Use_ $node */ public function resolve(Node $node, ?Scope $scope) : ?string { if ($node->uses === []) { return null; } $onlyUse = $node->uses[0]; return $onlyUse->name->toString(); } } NodeNameResolver/ParamNameResolver.php 0000644 00000001440 15127560260 0014053 0 ustar 00 <?php declare (strict_types=1); namespace Rector\NodeNameResolver\NodeNameResolver; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\Error; use PhpParser\Node\Param; use PHPStan\Analyser\Scope; use Rector\NodeNameResolver\Contract\NodeNameResolverInterface; /** * @implements NodeNameResolverInterface<Param> */ final class ParamNameResolver implements NodeNameResolverInterface { public function getNode() : string { return Param::class; } /** * @param Param $node */ public function resolve(Node $node, ?Scope $scope) : ?string { if ($node->var instanceof Error) { return null; } if ($node->var->name instanceof Expr) { return null; } return $node->var->name; } } NodeNameResolver/NameNameResolver.php 0000644 00000001103 15127560260 0013667 0 ustar 00 <?php declare (strict_types=1); namespace Rector\NodeNameResolver\NodeNameResolver; use PhpParser\Node; use PhpParser\Node\Name; use PHPStan\Analyser\Scope; use Rector\NodeNameResolver\Contract\NodeNameResolverInterface; /** * @implements NodeNameResolverInterface<Name> */ final class NameNameResolver implements NodeNameResolverInterface { public function getNode() : string { return Name::class; } /** * @param Name $node */ public function resolve(Node $node, ?Scope $scope) : ?string { return $node->toString(); } } NodeNameResolver/ClassConstFetchNameResolver.php 0000644 00000001663 15127560260 0016050 0 ustar 00 <?php declare (strict_types=1); namespace Rector\NodeNameResolver\NodeNameResolver; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\ClassConstFetch; use PhpParser\Node\Identifier; use PHPStan\Analyser\Scope; use Rector\NodeNameResolver\Contract\NodeNameResolverInterface; /** * @implements NodeNameResolverInterface<ClassConstFetch> */ final class ClassConstFetchNameResolver implements NodeNameResolverInterface { public function getNode() : string { return ClassConstFetch::class; } /** * @param ClassConstFetch $node */ public function resolve(Node $node, ?Scope $scope) : ?string { if ($node->class instanceof Expr) { return null; } if (!$node->name instanceof Identifier) { return null; } $class = $node->class->toString(); $name = $node->name->toString(); return $class . '::' . $name; } } NodeNameResolver/FuncCallNameResolver.php 0000644 00000003025 15127560260 0014503 0 ustar 00 <?php declare (strict_types=1); namespace Rector\NodeNameResolver\NodeNameResolver; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\FuncCall; use PhpParser\Node\Name\FullyQualified; use PHPStan\Analyser\Scope; use PHPStan\Reflection\ReflectionProvider; use Rector\NodeNameResolver\Contract\NodeNameResolverInterface; use Rector\NodeTypeResolver\Node\AttributeKey; /** * @implements NodeNameResolverInterface<FuncCall> */ final class FuncCallNameResolver implements NodeNameResolverInterface { /** * @readonly * @var \PHPStan\Reflection\ReflectionProvider */ private $reflectionProvider; public function __construct(ReflectionProvider $reflectionProvider) { $this->reflectionProvider = $reflectionProvider; } public function getNode() : string { return FuncCall::class; } /** * If some function is namespaced, it will be used over global one. * But only if it really exists. * * @param FuncCall $node */ public function resolve(Node $node, ?Scope $scope) : ?string { if ($node->name instanceof Expr) { return null; } $namespaceName = $node->name->getAttribute(AttributeKey::NAMESPACED_NAME); if ($namespaceName instanceof FullyQualified) { $functionFqnName = $namespaceName->toString(); if ($this->reflectionProvider->hasFunction($namespaceName, null)) { return $functionFqnName; } } return (string) $node->name; } } NodeNameResolver/VariableNameResolver.php 0000644 00000001275 15127560260 0014546 0 ustar 00 <?php declare (strict_types=1); namespace Rector\NodeNameResolver\NodeNameResolver; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\Variable; use PHPStan\Analyser\Scope; use Rector\NodeNameResolver\Contract\NodeNameResolverInterface; /** * @implements NodeNameResolverInterface<Variable> */ final class VariableNameResolver implements NodeNameResolverInterface { public function getNode() : string { return Variable::class; } /** * @param Variable $node */ public function resolve(Node $node, ?Scope $scope) : ?string { if ($node->name instanceof Expr) { return null; } return $node->name; } } NodeNameResolver/ClassNameResolver.php 0000644 00000001545 15127560260 0014066 0 ustar 00 <?php declare (strict_types=1); namespace Rector\NodeNameResolver\NodeNameResolver; use PhpParser\Node; use PhpParser\Node\Identifier; use PhpParser\Node\Name; use PhpParser\Node\Stmt\ClassLike; use PHPStan\Analyser\Scope; use Rector\NodeNameResolver\Contract\NodeNameResolverInterface; /** * @implements NodeNameResolverInterface<ClassLike> */ final class ClassNameResolver implements NodeNameResolverInterface { public function getNode() : string { return ClassLike::class; } /** * @param ClassLike $node */ public function resolve(Node $node, ?Scope $scope) : ?string { if ($node->namespacedName instanceof Name) { return $node->namespacedName->toString(); } if (!$node->name instanceof Identifier) { return null; } return $node->name->toString(); } } NodeNameResolver.php 0000644 00000016706 15127560260 0010503 0 ustar 00 <?php declare (strict_types=1); namespace Rector\NodeNameResolver; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\CallLike; use PhpParser\Node\Expr\FuncCall; use PhpParser\Node\Expr\MethodCall; use PhpParser\Node\Expr\NullsafeMethodCall; use PhpParser\Node\Expr\StaticCall; use PhpParser\Node\Identifier; use PhpParser\Node\Name; use PhpParser\Node\Param; use PhpParser\Node\Stmt\ClassLike; use PhpParser\Node\Stmt\ClassMethod; use PhpParser\Node\Stmt\Const_; use PhpParser\Node\Stmt\Interface_; use PhpParser\Node\Stmt\Property; use PhpParser\Node\Stmt\PropertyProperty; use PhpParser\Node\Stmt\Trait_; use PHPStan\Analyser\Scope; use Rector\CodingStyle\Naming\ClassNaming; use Rector\Exception\ShouldNotHappenException; use Rector\NodeAnalyzer\CallAnalyzer; use Rector\NodeNameResolver\Contract\NodeNameResolverInterface; use Rector\NodeTypeResolver\Node\AttributeKey; use Rector\ValueObject\MethodName; final class NodeNameResolver { /** * @readonly * @var \Rector\CodingStyle\Naming\ClassNaming */ private $classNaming; /** * @readonly * @var \Rector\NodeAnalyzer\CallAnalyzer */ private $callAnalyzer; /** * @var NodeNameResolverInterface[] * @readonly */ private $nodeNameResolvers = []; /** * Used to check if a string might contain a regex or fnmatch pattern */ private const REGEX_WILDCARD_CHARS = ['*', '#', '~', '/']; /** * @var array<string, NodeNameResolverInterface|null> */ private $nodeNameResolversByClass = []; /** * @param NodeNameResolverInterface[] $nodeNameResolvers */ public function __construct(ClassNaming $classNaming, CallAnalyzer $callAnalyzer, iterable $nodeNameResolvers = []) { $this->classNaming = $classNaming; $this->callAnalyzer = $callAnalyzer; $this->nodeNameResolvers = $nodeNameResolvers; } /** * @param string[] $names */ public function isNames(Node $node, array $names) : bool { $nodeName = $this->getName($node); if ($nodeName === null) { return \false; } foreach ($names as $name) { if ($this->isStringName($nodeName, $name)) { return \true; } } return \false; } /** * @param Node|Node[] $node * @param MethodName::*|string $name */ public function isName($node, string $name) : bool { $nodes = \is_array($node) ? $node : [$node]; foreach ($nodes as $node) { if ($this->isSingleName($node, $name)) { return \true; } } return \false; } /** * Some nodes have always-known string name. This makes PHPStan smarter. * @see https://phpstan.org/writing-php-code/phpdoc-types#conditional-return-types * * @return ($node is Param ? string : * ($node is ClassMethod ? string : * ($node is Property ? string : * ($node is PropertyProperty ? string : * ($node is Trait_ ? string : * ($node is Interface_ ? string : * ($node is Const_ ? string : * ($node is Node\Const_ ? string : * ($node is Name ? string : * string|null ))))))))) * @param \PhpParser\Node|string $node */ public function getName($node) : ?string { if (\is_string($node)) { return $node; } // useful for looped imported names $namespacedName = $node->getAttribute(AttributeKey::NAMESPACED_NAME); if (\is_string($namespacedName)) { return $namespacedName; } if (($node instanceof MethodCall || $node instanceof StaticCall || $node instanceof NullsafeMethodCall) && $this->isCallOrIdentifier($node->name)) { return null; } $scope = $node->getAttribute(AttributeKey::SCOPE); $resolvedName = $this->resolveNodeName($node, $scope); if ($resolvedName !== null) { return $resolvedName; } // more complex if (!\property_exists($node, 'name')) { return null; } // unable to resolve if ($node->name instanceof Expr) { return null; } return (string) $node->name; } /** * @api */ public function areNamesEqual(Node $firstNode, Node $secondNode) : bool { $secondResolvedName = $this->getName($secondNode); if ($secondResolvedName === null) { return \false; } return $this->isName($firstNode, $secondResolvedName); } /** * @api * * @param Name[]|Node[] $nodes * @return string[] */ public function getNames(array $nodes) : array { $names = []; foreach ($nodes as $node) { $name = $this->getName($node); if (!\is_string($name)) { throw new ShouldNotHappenException(); } $names[] = $name; } return $names; } /** * @param string|\PhpParser\Node\Name|\PhpParser\Node\Identifier|\PhpParser\Node\Stmt\ClassLike $name */ public function getShortName($name) : string { return $this->classNaming->getShortName($name); } public function isStringName(string $resolvedName, string $desiredName) : bool { if ($desiredName === '') { return \false; } // special case if ($desiredName === 'Object') { return $desiredName === $resolvedName; } if (\strcasecmp($resolvedName, $desiredName) === 0) { return \true; } foreach (self::REGEX_WILDCARD_CHARS as $char) { if (\strpos($desiredName, $char) !== \false) { throw new ShouldNotHappenException('Matching of regular expressions is no longer supported. Use $this->getName() and compare with e.g. str_ends_with() or str_starts_with() instead.'); } } return \false; } /** * @param \PhpParser\Node\Expr|\PhpParser\Node\Identifier $node */ private function isCallOrIdentifier($node) : bool { if ($node instanceof Expr) { return $this->callAnalyzer->isObjectCall($node); } return \true; } private function isSingleName(Node $node, string $desiredName) : bool { if ($node instanceof CallLike && !$node instanceof FuncCall) { // method call cannot have a name, only the variable or method name return \false; } $resolvedName = $this->getName($node); if ($resolvedName === null) { return \false; } return $this->isStringName($resolvedName, $desiredName); } private function resolveNodeName(Node $node, ?Scope $scope) : ?string { $nodeClass = \get_class($node); if (\array_key_exists($nodeClass, $this->nodeNameResolversByClass)) { $resolver = $this->nodeNameResolversByClass[$nodeClass]; if ($resolver instanceof NodeNameResolverInterface) { return $resolver->resolve($node, $scope); } return null; } foreach ($this->nodeNameResolvers as $nodeNameResolver) { if (!\is_a($node, $nodeNameResolver->getNode(), \true)) { continue; } $this->nodeNameResolversByClass[$nodeClass] = $nodeNameResolver; return $nodeNameResolver->resolve($node, $scope); } $this->nodeNameResolversByClass[$nodeClass] = null; return null; } }
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0 |
proxy
|
phpinfo
|
???????????