indexes -> indices

src/AbstractDoctrineAnnotationFixer.php

@@ -47,7 +47,7 @@ public function isCandidate(Tokens $tokens): bool
      */
     protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
     {
-        // fetch indexes one time, this is safe as we never add or remove a token during fixing
+        // fetch indices one time, this is safe as we never add or remove a token during fixing
         $analyzer = new TokensAnalyzer($tokens);
         $this->classyElements = $analyzer->getClassyElements();
 

src/DocBlock/Line.php

@@ -102,7 +102,7 @@ public function setContent(string $content): void
      * Remove this line by clearing its contents.
      *
      * Note that this method technically brakes the internal state of the
-     * docblock, but is useful when we need to retain the indexes of lines
+     * docblock, but is useful when we need to retain the indices of lines
      * during the execution of an algorithm.
      */
     public function remove(): void
@@ -114,7 +114,7 @@ public function remove(): void
      * Append a blank docblock line to this line's contents.
      *
      * Note that this method technically brakes the internal state of the
-     * docblock, but is useful when we need to retain the indexes of lines
+     * docblock, but is useful when we need to retain the indices of lines
      * during the execution of an algorithm.
      */
     public function addBlank(): void

src/Fixer/Alias/BacktickToShellExecFixer.php

@@ -102,7 +102,7 @@ protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
      */
     private function fixBackticks(Tokens $tokens, array $backtickTokens): void
     {
-        // Track indexes for final override
+        // Track indices for final override
         ksort($backtickTokens);
         $openingBacktickIndex = key($backtickTokens);
         end($backtickTokens);

src/Fixer/Alias/EregToPregFixer.php

@@ -97,7 +97,7 @@ protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
                     break;
                 }
 
-                // findSequence also returns the tokens, but we're only interested in the indexes, i.e.:
+                // findSequence also returns the tokens, but we're only interested in the indices, i.e.:
                 // 0 => function name,
                 // 1 => bracket "("
                 // 2 => quoted string passed as 1st parameter

src/Fixer/Alias/ModernizeStrposFixer.php

@@ -127,19 +127,19 @@ protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
         }
     }
 
-    private function fixCall(Tokens $tokens, int $functionIndex, array $operatorIndexes): void
+    private function fixCall(Tokens $tokens, int $functionIndex, array $operatorIndices): void
     {
         foreach (self::REPLACEMENTS as $replacement) {
-            if (!$tokens[$operatorIndexes['operator_index']]->equals($replacement['operator'])) {
+            if (!$tokens[$operatorIndices['operator_index']]->equals($replacement['operator'])) {
                 continue;
             }
 
-            if (!$tokens[$operatorIndexes['operand_index']]->equals($replacement['operand'], false)) {
+            if (!$tokens[$operatorIndices['operand_index']]->equals($replacement['operand'], false)) {
                 continue;
             }
 
-            $tokens->clearTokenAndMergeSurroundingWhitespace($operatorIndexes['operator_index']);
-            $tokens->clearTokenAndMergeSurroundingWhitespace($operatorIndexes['operand_index']);
+            $tokens->clearTokenAndMergeSurroundingWhitespace($operatorIndices['operator_index']);
+            $tokens->clearTokenAndMergeSurroundingWhitespace($operatorIndices['operand_index']);
             $tokens->clearTokenAndMergeSurroundingWhitespace($functionIndex);
 
             if ($replacement['negate']) {

src/Fixer/Alias/PowToExponentiationFixer.php

@@ -73,7 +73,7 @@ protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
 
         foreach (array_reverse($candidates) as $candidate) {
             // if in the previous iteration(s) tokens were added to the collection and this is done within the tokens
-            // indexes of the current candidate than the index of the close ')' of the candidate has moved and so
+            // indices of the current candidate than the index of the close ')' of the candidate has moved and so
             // the index needs to be updated
             if ($previousCloseParenthesisIndex < $candidate[2]) {
                 $previousCloseParenthesisIndex = $candidate[2];

src/Fixer/ClassNotation/NoPhp4ConstructorFixer.php

@@ -221,7 +221,7 @@ private function fixParent(Tokens $tokens, int $classStart, int $classEnd): void
             ], $classStart, $classEnd, [2 => false]);
 
             if (null !== $parentSeq) {
-                // we only need indexes
+                // we only need indices
                 $parentSeq = array_keys($parentSeq);
 
                 // match either of the possibilities
@@ -242,7 +242,7 @@ private function fixParent(Tokens $tokens, int $classStart, int $classEnd): void
                 ], $classStart, $classEnd, [2 => false]);
 
                 if (null !== $parentSeq) {
-                    // we only need indexes
+                    // we only need indices
                     $parentSeq = array_keys($parentSeq);
 
                     // replace call with parent::__construct()
@@ -378,7 +378,7 @@ private function findFunction(Tokens $tokens, string $name, int $startIndex, int
             return null;
         }
 
-        // keep only the indexes
+        // keep only the indices
         $function = array_keys($function);
 
         // find previous block, saving method modifiers for later use

src/Fixer/ClassNotation/SingleTraitInsertPerStatementFixer.php

@@ -70,7 +70,7 @@ protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
     }
 
     /**
-     * @param int[] $candidates ',' indexes to fix
+     * @param int[] $candidates ',' indices to fix
      */
     private function fixTraitUse(Tokens $tokens, int $useTraitIndex, array $candidates): void
     {
@@ -99,18 +99,18 @@ private function fixTraitUse(Tokens $tokens, int $useTraitIndex, array $candidat
      */
     private function getCandidates(Tokens $tokens, int $index): array
     {
-        $indexes = [];
+        $indices = [];
         $index = $tokens->getNextTokenOfKind($index, [',', ';', '{']);
 
         while (!$tokens[$index]->equals(';')) {
             if ($tokens[$index]->equals('{')) {
                 return []; // do not fix use cases with grouping
             }
 
-            $indexes[] = $index;
+            $indices[] = $index;
             $index = $tokens->getNextTokenOfKind($index, [',', ';', '{']);
         }
 
-        return array_reverse($indexes);
+        return array_reverse($indices);
     }
 }

src/Fixer/Comment/HeaderCommentFixer.php

@@ -141,19 +141,19 @@ public function getPriority(): int
     protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
     {
         $location = $this->configuration['location'];
-        $locationIndexes = [];
+        $locationIndices = [];
 
         foreach (['after_open', 'after_declare_strict'] as $possibleLocation) {
             $locationIndex = $this->findHeaderCommentInsertionIndex($tokens, $possibleLocation);
 
-            if (!isset($locationIndexes[$locationIndex]) || $possibleLocation === $location) {
-                $locationIndexes[$locationIndex] = $possibleLocation;
+            if (!isset($locationIndices[$locationIndex]) || $possibleLocation === $location) {
+                $locationIndices[$locationIndex] = $possibleLocation;
 
                 continue;
             }
         }
 
-        foreach (array_values($locationIndexes) as $possibleLocation) {
+        foreach (array_values($locationIndices) as $possibleLocation) {
             // figure out where the comment should be placed
             $headerNewIndex = $this->findHeaderCommentInsertionIndex($tokens, $possibleLocation);
 

src/Fixer/ControlStructure/SimplifiedIfReturnFixer.php

@@ -119,11 +119,11 @@ protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
                     continue;
                 }
 
-                $indexesToClear = array_keys($sequenceFound);
-                array_pop($indexesToClear); // Preserve last semicolon
-                rsort($indexesToClear);
+                $indicesToClear = array_keys($sequenceFound);
+                array_pop($indicesToClear); // Preserve last semicolon
+                rsort($indicesToClear);
 
-                foreach ($indexesToClear as $index) {
+                foreach ($indicesToClear as $index) {
                     $tokens->clearTokenAndMergeSurroundingWhitespace($index);
                 }
 

src/Fixer/DoctrineAnnotation/DoctrineAnnotationIndentationFixer.php

@@ -168,7 +168,7 @@ private function isClosingLineWithMeaningfulContent(Tokens $tokens, int $index):
     }
 
     /**
-     * @param array<array<int>> $annotationPositions Pairs of begin and end indexes of main annotations
+     * @param array<array<int>> $annotationPositions Pairs of begin and end indices of main annotations
      */
     private function indentationCanBeFixed(Tokens $tokens, int $newLineTokenIndex, array $annotationPositions): bool
     {

src/Fixer/FunctionNotation/PhpdocToPropertyTypeFixer.php

@@ -128,14 +128,14 @@ private function fixClass(Tokens $tokens, int $index): void
             }
 
             $docCommentIndex = $index;
-            $propertyIndexes = $this->findNextUntypedPropertiesDeclaration($tokens, $docCommentIndex);
+            $propertyIndices = $this->findNextUntypedPropertiesDeclaration($tokens, $docCommentIndex);
 
-            if ([] === $propertyIndexes) {
+            if ([] === $propertyIndices) {
                 continue;
             }
 
             $typeInfo = $this->resolveApplicableType(
-                $propertyIndexes,
+                $propertyIndices,
                 $this->getAnnotationsFromDocComment('var', $tokens, $docCommentIndex)
             );
 
@@ -154,9 +154,9 @@ private function fixClass(Tokens $tokens, int $index): void
                 [new Token([T_WHITESPACE, ' '])]
             );
 
-            $tokens->insertAt(current($propertyIndexes), $newTokens);
+            $tokens->insertAt(current($propertyIndices), $newTokens);
 
-            $index = max($propertyIndexes) + \count($newTokens) + 1;
+            $index = max($propertyIndices) + \count($newTokens) + 1;
             $classEndIndex += \count($newTokens);
         }
     }
@@ -194,25 +194,25 @@ private function findNextUntypedPropertiesDeclaration(Tokens $tokens, int $index
     }
 
     /**
-     * @param array<string, int> $propertyIndexes
+     * @param array<string, int> $propertyIndices
      * @param Annotation[]       $annotations
      */
-    private function resolveApplicableType(array $propertyIndexes, array $annotations): ?array
+    private function resolveApplicableType(array $propertyIndices, array $annotations): ?array
     {
         $propertyTypes = [];
 
         foreach ($annotations as $annotation) {
             $propertyName = $annotation->getVariableName();
 
             if (null === $propertyName) {
-                if (1 !== \count($propertyIndexes)) {
+                if (1 !== \count($propertyIndices)) {
                     continue;
                 }
 
-                $propertyName = key($propertyIndexes);
+                $propertyName = key($propertyIndices);
             }
 
-            if (!isset($propertyIndexes[$propertyName])) {
+            if (!isset($propertyIndices[$propertyName])) {
                 continue;
             }
 
@@ -227,7 +227,7 @@ private function resolveApplicableType(array $propertyIndexes, array $annotation
             $propertyTypes[$propertyName] = $typeInfo;
         }
 
-        if (\count($propertyTypes) !== \count($propertyIndexes)) {
+        if (\count($propertyTypes) !== \count($propertyIndices)) {
             return null;
         }
 

src/Fixer/Import/GlobalNamespaceImportFixer.php

@@ -201,8 +201,7 @@ private function importConstants(Tokens $tokens, array $useDeclarations): array
         }
 
         $analyzer = new TokensAnalyzer($tokens);
-
-        $indexes = [];
+        $indices = [];
 
         for ($index = $tokens->count() - 1; $index >= 0; --$index) {
             $token = $tokens[$index];
@@ -237,10 +236,10 @@ private function importConstants(Tokens $tokens, array $useDeclarations): array
                 continue;
             }
 
-            $indexes[] = $index;
+            $indices[] = $index;
         }
 
-        return $this->prepareImports($tokens, $indexes, $global, $other, true);
+        return $this->prepareImports($tokens, $indices, $global, $other, true);
     }
 
     /**
@@ -259,8 +258,7 @@ private function importFunctions(Tokens $tokens, array $useDeclarations): array
         }
 
         $analyzer = new FunctionsAnalyzer();
-
-        $indexes = [];
+        $indices = [];
 
         for ($index = $tokens->count() - 1; $index >= 0; --$index) {
             $token = $tokens[$index];
@@ -288,10 +286,10 @@ private function importFunctions(Tokens $tokens, array $useDeclarations): array
                 continue;
             }
 
-            $indexes[] = $index;
+            $indices[] = $index;
         }
 
-        return $this->prepareImports($tokens, $indexes, $global, $other, false);
+        return $this->prepareImports($tokens, $indices, $global, $other, false);
     }
 
     /**
@@ -339,8 +337,7 @@ private function importClasses(Tokens $tokens, array $useDeclarations): array
         }
 
         $analyzer = new ClassyAnalyzer();
-
-        $indexes = [];
+        $indices = [];
 
         for ($index = $tokens->count() - 1; $index >= 0; --$index) {
             $token = $tokens[$index];
@@ -372,7 +369,7 @@ private function importClasses(Tokens $tokens, array $useDeclarations): array
                 continue;
             }
 
-            $indexes[] = $index;
+            $indices[] = $index;
         }
 
         $imports = [];
@@ -404,21 +401,21 @@ private function importClasses(Tokens $tokens, array $useDeclarations): array
             }
         }
 
-        return $imports + $this->prepareImports($tokens, $indexes, $global, $other, false);
+        return $imports + $this->prepareImports($tokens, $indices, $global, $other, false);
     }
 
     /**
-     * Removes the leading slash at the given indexes (when the name is not already used).
+     * Removes the leading slash at the given indices (when the name is not already used).
      *
-     * @param int[] $indexes
+     * @param int[] $indices
      *
      * @return array array keys contain the names that must be imported
      */
-    private function prepareImports(Tokens $tokens, array $indexes, array $global, array $other, bool $caseSensitive): array
+    private function prepareImports(Tokens $tokens, array $indices, array $global, array $other, bool $caseSensitive): array
     {
         $imports = [];
 
-        foreach ($indexes as $index) {
+        foreach ($indices as $index) {
             $name = $tokens[$index]->getContent();
             $checkName = $caseSensitive ? $name : strtolower($name);
 

src/Fixer/Import/NoLeadingImportSlashFixer.php

@@ -64,9 +64,9 @@ public function isCandidate(Tokens $tokens): bool
     protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
     {
         $tokensAnalyzer = new TokensAnalyzer($tokens);
-        $usesIndexes = $tokensAnalyzer->getImportUseIndexes();
+        $usesIndices = $tokensAnalyzer->getImportUseIndexes();
 
-        foreach ($usesIndexes as $idx) {
+        foreach ($usesIndices as $idx) {
             $nextTokenIdx = $tokens->getNextMeaningfulToken($idx);
             $nextToken = $tokens[$nextTokenIdx];