Remove BetterTokenIterator

src/BetterPhpDocParser/DataProvider/CurrentTokenIteratorProvider.php

@@ -4,24 +4,24 @@
 
 namespace Rector\BetterPhpDocParser\DataProvider;
 
-use Rector\BetterPhpDocParser\ValueObject\Parser\BetterTokenIterator;
+use PHPStan\PhpDocParser\Parser\TokenIterator;
 use Rector\Exception\ShouldNotHappenException;
 
 final class CurrentTokenIteratorProvider
 {
-    private ?BetterTokenIterator $betterTokenIterator = null;
+    private ?TokenIterator $tokenIterator = null;
 
-    public function setBetterTokenIterator(BetterTokenIterator $betterTokenIterator): void
+    public function setTokenIterator(TokenIterator $tokenIterator): void
     {
-        $this->betterTokenIterator = $betterTokenIterator;
+        $this->tokenIterator = $tokenIterator;
     }
 
-    public function provide(): BetterTokenIterator
+    public function provide(): TokenIterator
     {
-        if (! $this->betterTokenIterator instanceof BetterTokenIterator) {
+        if (! $this->tokenIterator instanceof TokenIterator) {
             throw new ShouldNotHappenException();
         }
 
-        return $this->betterTokenIterator;
+        return $this->tokenIterator;
     }
 }

src/BetterPhpDocParser/NodeDecorator/DoctrineAnnotationDecorator.php

@@ -426,7 +426,7 @@ private function processDescriptionAsSpacelessPhpDoctagNode(
     private function isClosedContent(string $composedContent): bool
     {
         $composedTokenIterator = $this->tokenIteratorFactory->create($composedContent);
-        $tokenCount = $composedTokenIterator->count();
+        $tokenCount = $composedTokenIterator->getTokenCount();
 
         $openBracketCount = 0;
         $closeBracketCount = 0;
@@ -455,7 +455,7 @@ private function isClosedContent(string $composedContent): bool
             }
 
             $composedTokenIterator->next();
-        } while ($composedTokenIterator->currentPosition() < ($tokenCount - 1));
+        } while ($composedTokenIterator->currentTokenIndex() < ($tokenCount - 1));
 
         return $openBracketCount === $closeBracketCount;
     }

src/BetterPhpDocParser/PhpDocInfo/PhpDocInfo.php

@@ -24,14 +24,14 @@
 use PHPStan\PhpDocParser\Ast\Type\ConstTypeNode;
 use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
 use PHPStan\PhpDocParser\Lexer\Lexer;
+use PHPStan\PhpDocParser\Parser\TokenIterator;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\Type;
 use Rector\BetterPhpDocParser\Annotation\AnnotationNaming;
 use Rector\BetterPhpDocParser\PhpDoc\ArrayItemNode;
 use Rector\BetterPhpDocParser\PhpDoc\DoctrineAnnotationTagValueNode;
 use Rector\BetterPhpDocParser\PhpDoc\SpacelessPhpDocTagNode;
 use Rector\BetterPhpDocParser\PhpDocNodeFinder\PhpDocNodeByTypeFinder;
-use Rector\BetterPhpDocParser\ValueObject\Parser\BetterTokenIterator;
 use Rector\BetterPhpDocParser\ValueObject\PhpDocAttributeKey;
 use Rector\BetterPhpDocParser\ValueObject\Type\ShortenedIdentifierTypeNode;
 use Rector\Exception\ShouldNotHappenException;
@@ -70,7 +70,7 @@ final class PhpDocInfo
 
     public function __construct(
         private readonly PhpDocNode $phpDocNode,
-        private readonly BetterTokenIterator $betterTokenIterator,
+        private readonly TokenIterator $tokenIterator,
         private readonly StaticTypeMapper $staticTypeMapper,
         private readonly \PhpParser\Node $node,
         private readonly AnnotationNaming $annotationNaming,
@@ -79,7 +79,7 @@ public function __construct(
     ) {
         $this->originalPhpDocNode = clone $phpDocNode;
 
-        if (! $betterTokenIterator->containsTokenType(Lexer::TOKEN_PHPDOC_EOL)) {
+        if (! in_array(Lexer::TOKEN_PHPDOC_EOL, array_column($tokenIterator->getTokens(), Lexer::TYPE_OFFSET), true)) {
             $this->isSingleLine = true;
         }
     }
@@ -109,12 +109,12 @@ public function getOriginalPhpDocNode(): PhpDocNode
      */
     public function getTokens(): array
     {
-        return $this->betterTokenIterator->getTokens();
+        return $this->tokenIterator->getTokens();
     }
 
     public function getTokenCount(): int
     {
-        return $this->betterTokenIterator->count();
+        return $this->tokenIterator->getTokenCount();
     }
 
     public function getVarTagValueNode(string $tagName = '@var'): ?VarTagValueNode
@@ -349,7 +349,7 @@ public function isNewNode(): bool
             return false;
         }
 
-        return $this->betterTokenIterator->count() === 0;
+        return $this->tokenIterator->getTokenCount() === 0;
     }
 
     public function isSingleLine(): bool

src/BetterPhpDocParser/PhpDocInfo/PhpDocInfoFactory.php

@@ -8,11 +8,11 @@
 use PhpParser\Node;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocNode;
 use PHPStan\PhpDocParser\Lexer\Lexer;
+use PHPStan\PhpDocParser\Parser\TokenIterator;
 use Rector\BetterPhpDocParser\Annotation\AnnotationNaming;
 use Rector\BetterPhpDocParser\PhpDocNodeFinder\PhpDocNodeByTypeFinder;
 use Rector\BetterPhpDocParser\PhpDocNodeMapper;
 use Rector\BetterPhpDocParser\PhpDocParser\BetterPhpDocParser;
-use Rector\BetterPhpDocParser\ValueObject\Parser\BetterTokenIterator;
 use Rector\BetterPhpDocParser\ValueObject\PhpDocAttributeKey;
 use Rector\BetterPhpDocParser\ValueObject\StartAndEnd;
 use Rector\NodeTypeResolver\Node\AttributeKey;
@@ -68,11 +68,11 @@ public function createFromNode(Node $node): ?PhpDocInfo
             }
 
             // create empty node
-            $tokenIterator = new BetterTokenIterator([]);
+            $tokenIterator = new TokenIterator([]);
             $phpDocNode = new PhpDocNode([]);
         } else {
             $tokens = $this->lexer->tokenize($docComment->getText());
-            $tokenIterator = new BetterTokenIterator($tokens);
+            $tokenIterator = new TokenIterator($tokens);
 
             $phpDocNode = $this->betterPhpDocParser->parseWithNode($tokenIterator, $node);
             $this->setPositionOfLastToken($phpDocNode);
@@ -87,7 +87,7 @@ public function createFromNode(Node $node): ?PhpDocInfo
     public function createEmpty(Node $node): PhpDocInfo
     {
         $phpDocNode = new PhpDocNode([]);
-        $phpDocInfo = $this->createFromPhpDocNode($phpDocNode, new BetterTokenIterator([]), $node);
+        $phpDocInfo = $this->createFromPhpDocNode($phpDocNode, new TokenIterator([]), $node);
 
         // multiline by default
         $phpDocInfo->makeMultiLined();
@@ -115,14 +115,14 @@ private function setPositionOfLastToken(PhpDocNode $phpDocNode): void
 
     private function createFromPhpDocNode(
         PhpDocNode $phpDocNode,
-        BetterTokenIterator $betterTokenIterator,
+        TokenIterator $tokenIterator,
         Node $node
     ): PhpDocInfo {
-        $phpDocNode = $this->phpDocNodeMapper->transform($phpDocNode, $betterTokenIterator);
+        $phpDocNode = $this->phpDocNodeMapper->transform($phpDocNode, $tokenIterator);
 
         $phpDocInfo = new PhpDocInfo(
             $phpDocNode,
-            $betterTokenIterator,
+            $tokenIterator,
             $this->staticTypeMapper,
             $node,
             $this->annotationNaming,

src/BetterPhpDocParser/PhpDocInfo/TokenIteratorFactory.php

@@ -6,7 +6,6 @@
 
 use PHPStan\PhpDocParser\Lexer\Lexer;
 use PHPStan\PhpDocParser\Parser\TokenIterator;
-use Rector\BetterPhpDocParser\ValueObject\Parser\BetterTokenIterator;
 
 final readonly class TokenIteratorFactory
 {
@@ -15,22 +14,9 @@ public function __construct(
     ) {
     }
 
-    public function create(string $content): BetterTokenIterator
+    public function create(string $content): TokenIterator
     {
         $tokens = $this->lexer->tokenize($content);
-        return new BetterTokenIterator($tokens);
-    }
-
-    public function createFromTokenIterator(TokenIterator $tokenIterator): BetterTokenIterator
-    {
-        if ($tokenIterator instanceof BetterTokenIterator) {
-            return $tokenIterator;
-        }
-
-        // keep original tokens and index position
-        $tokens = $tokenIterator->getTokens();
-        $currentIndex = $tokenIterator->currentTokenIndex();
-
-        return new BetterTokenIterator($tokens, $currentIndex);
+        return new TokenIterator($tokens);
     }
 }

src/BetterPhpDocParser/PhpDocNodeMapper.php

@@ -6,9 +6,9 @@
 
 use PHPStan\PhpDocParser\Ast\NodeTraverser;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocNode;
+use PHPStan\PhpDocParser\Parser\TokenIterator;
 use Rector\BetterPhpDocParser\Contract\BasePhpDocNodeVisitorInterface;
 use Rector\BetterPhpDocParser\DataProvider\CurrentTokenIteratorProvider;
-use Rector\BetterPhpDocParser\ValueObject\Parser\BetterTokenIterator;
 use Rector\PhpDocParser\PhpDocParser\PhpDocNodeVisitor\CloningPhpDocNodeVisitor;
 use Rector\PhpDocParser\PhpDocParser\PhpDocNodeVisitor\ParentConnectingPhpDocNodeVisitor;
 use Webmozart\Assert\Assert;
@@ -38,9 +38,9 @@ public function __construct(
         ]);
     }
 
-    public function transform(PhpDocNode $phpDocNode, BetterTokenIterator $betterTokenIterator): PhpDocNode
+    public function transform(PhpDocNode $phpDocNode, TokenIterator $tokenIterator): PhpDocNode
     {
-        $this->currentTokenIteratorProvider->setBetterTokenIterator($betterTokenIterator);
+        $this->currentTokenIteratorProvider->setTokenIterator($tokenIterator);
 
         [$phpDocNode] = $this->phpDocNodeTraverser->traverse([$phpDocNode]);
         Assert::isInstanceOf($phpDocNode, PhpDocNode::class);

src/BetterPhpDocParser/PhpDocNodeVisitor/TemplatePhpDocNodeVisitor.php

@@ -9,10 +9,10 @@
 use PHPStan\PhpDocParser\Ast\Node;
 use PHPStan\PhpDocParser\Ast\PhpDoc\TemplateTagValueNode;
 use PHPStan\PhpDocParser\Lexer\Lexer;
+use PHPStan\PhpDocParser\Parser\TokenIterator;
 use Rector\BetterPhpDocParser\Attributes\AttributeMirrorer;
 use Rector\BetterPhpDocParser\Contract\BasePhpDocNodeVisitorInterface;
 use Rector\BetterPhpDocParser\DataProvider\CurrentTokenIteratorProvider;
-use Rector\BetterPhpDocParser\ValueObject\Parser\BetterTokenIterator;
 use Rector\BetterPhpDocParser\ValueObject\PhpDoc\SpacingAwareTemplateTagValueNode;
 use Rector\Exception\ShouldNotHappenException;
 
@@ -34,15 +34,15 @@ public function enterNode(Node $node): ?Node
             return null;
         }
 
-        $betterTokenIterator = $this->currentTokenIteratorProvider->provide();
+        $tokenIterator = $this->currentTokenIteratorProvider->provide();
 
         $startIndex = $node->getAttribute(Attribute::START_INDEX);
         $endIndex = $node->getAttribute(Attribute::END_INDEX);
         if ($startIndex === null || $endIndex === null) {
             throw new ShouldNotHappenException();
         }
 
-        $prepositions = $this->resolvePreposition($betterTokenIterator, $startIndex, $endIndex);
+        $prepositions = $this->resolvePreposition($tokenIterator, $startIndex, $endIndex);
         $spacingAwareTemplateTagValueNode = new SpacingAwareTemplateTagValueNode(
             $node->name,
             $node->bound,
@@ -56,11 +56,11 @@ public function enterNode(Node $node): ?Node
     }
 
     private function resolvePreposition(
-        BetterTokenIterator $betterTokenIterator,
+        TokenIterator $tokenIterator,
         int $startIndex,
         int $endIndex
     ): string {
-        $partialTokens = $betterTokenIterator->partialTokens($startIndex, $endIndex);
+        $partialTokens = array_slice($tokenIterator->getTokens(), $startIndex, $endIndex - $startIndex + 1);
 
         foreach ($partialTokens as $partialToken) {
             if ($partialToken[1] !== Lexer::TOKEN_IDENTIFIER) {

src/BetterPhpDocParser/PhpDocNodeVisitor/UnionTypeNodePhpDocNodeVisitor.php

@@ -8,10 +8,10 @@
 use PHPStan\PhpDocParser\Ast\Node;
 use PHPStan\PhpDocParser\Ast\Type\UnionTypeNode;
 use PHPStan\PhpDocParser\Lexer\Lexer;
+use PHPStan\PhpDocParser\Parser\TokenIterator;
 use Rector\BetterPhpDocParser\Attributes\AttributeMirrorer;
 use Rector\BetterPhpDocParser\Contract\BasePhpDocNodeVisitorInterface;
 use Rector\BetterPhpDocParser\DataProvider\CurrentTokenIteratorProvider;
-use Rector\BetterPhpDocParser\ValueObject\Parser\BetterTokenIterator;
 use Rector\BetterPhpDocParser\ValueObject\PhpDocAttributeKey;
 use Rector\BetterPhpDocParser\ValueObject\StartAndEnd;
 use Rector\BetterPhpDocParser\ValueObject\Type\BracketsAwareUnionTypeNode;
@@ -45,26 +45,28 @@ public function enterNode(Node $node): ?Node
             );
         }
 
-        $betterTokenProvider = $this->currentTokenIteratorProvider->provide();
+        $tokenIterator = $this->currentTokenIteratorProvider->provide();
 
-        $isWrappedInCurlyBrackets = $this->isWrappedInCurlyBrackets($betterTokenProvider, $startAndEnd);
+        $isWrappedInCurlyBrackets = $this->isWrappedInCurlyBrackets($tokenIterator, $startAndEnd);
         $bracketsAwareUnionTypeNode = new BracketsAwareUnionTypeNode($node->types, $isWrappedInCurlyBrackets);
 
         $this->attributeMirrorer->mirror($node, $bracketsAwareUnionTypeNode);
 
         return $bracketsAwareUnionTypeNode;
     }
 
-    private function isWrappedInCurlyBrackets(BetterTokenIterator $betterTokenProvider, StartAndEnd $startAndEnd): bool
+    private function isWrappedInCurlyBrackets(TokenIterator $tokenIterator, StartAndEnd $startAndEnd): bool
     {
         $previousPosition = $startAndEnd->getStart() - 1;
         $nextPosition = $startAndEnd->getEnd() + 1;
 
         // A union is wrapped only when BOTH parens flank it. Either alone may be unrelated —
         // e.g. an `@method`'s parameter-list `(` before a first-position union, or the matching
         // `)` after a last-position union — neither belongs to the union type itself.
-        return $betterTokenProvider->isTokenTypeOnPosition(Lexer::TOKEN_OPEN_PARENTHESES, $previousPosition)
-            && $betterTokenProvider->isTokenTypeOnPosition(Lexer::TOKEN_CLOSE_PARENTHESES, $nextPosition);
+        $tokens = $tokenIterator->getTokens();
+
+        return ($tokens[$previousPosition][Lexer::TYPE_OFFSET] ?? null) === Lexer::TOKEN_OPEN_PARENTHESES
+            && ($tokens[$nextPosition][Lexer::TYPE_OFFSET] ?? null) === Lexer::TOKEN_CLOSE_PARENTHESES;
     }
 
     private function resolveStartAndEnd(UnionTypeNode $unionTypeNode): ?StartAndEnd