Merge abd054f into 51c8146

PHP-CS-Fixer · Feb 18, 2022 · 4891958 · 4891958
2 parents 51c8146 + abd054f
commit 4891958
Show file tree

Hide file tree

Showing 11 changed files with 60 additions and 53 deletions.
diff --git a/dev-tools/install.sh b/dev-tools/install.sh
@@ -20,7 +20,7 @@ cd "$(dirname "$0")"
 
 mkdir -p bin
 
-VERSION_CB="2.21.7"
+VERSION_CB="2.21.7~bpo11+1"
 VERSION_SC="stable"
 
 echo λλλ checkbashisms

diff --git a/src/Console/ConfigurationResolver.php b/src/Console/ConfigurationResolver.php
@@ -348,7 +348,7 @@ static function (FixerInterface $fixer): bool {
     public function getLinter(): LinterInterface
     {
         if (null === $this->linter) {
-            $this->linter = new Linter($this->getConfig()->getPhpExecutable());
+            $this->linter = new Linter();
         }
 
         return $this->linter;

diff --git a/src/Doctrine/Annotation/Tokens.php b/src/Doctrine/Annotation/Tokens.php
@@ -240,23 +240,21 @@ public function insertAt(int $index, Token $token): void
         $this[$index] = $token;
     }
 
-    /**
-     * {@inheritdoc}
-     *
-     * @throws \InvalidArgumentException
-     */
     public function offsetSet($index, $token): void
     {
+        // @phpstan-ignore-next-line as we type checking here
+        if (null === $token) {
+            throw new \InvalidArgumentException('Token must be an instance of PhpCsFixer\\Doctrine\\Annotation\\Token, "null" given.');
+        }
+
         if (!$token instanceof Token) {
             $type = \gettype($token);
+
             if ('object' === $type) {
                 $type = \get_class($token);
             }
 
-            throw new \InvalidArgumentException(sprintf(
-                'Token must be an instance of PhpCsFixer\\Doctrine\\Annotation\\Token, %s given.',
-                $type
-            ));
+            throw new \InvalidArgumentException(sprintf('Token must be an instance of PhpCsFixer\\Doctrine\\Annotation\\Token, "%s" given.', $type));
         }
 
         parent::offsetSet($index, $token);

diff --git a/src/Linter/Linter.php b/src/Linter/Linter.php
@@ -23,44 +23,34 @@
  */
 final class Linter implements LinterInterface
 {
-    /**
-     * @var LinterInterface
-     */
-    private $sublinter;
+    private LinterInterface $subLinter;
 
-    /**
-     * @param null|string $executable PHP executable, null for autodetection
-     */
-    public function __construct(?string $executable = null)
+    public function __construct()
     {
-        try {
-            $this->sublinter = new TokenizerLinter();
-        } catch (UnavailableLinterException $e) {
-            $this->sublinter = new ProcessLinter($executable);
-        }
+        $this->subLinter = new TokenizerLinter();
     }
 
     /**
      * {@inheritdoc}
      */
     public function isAsync(): bool
     {
-        return $this->sublinter->isAsync();
+        return $this->subLinter->isAsync();
     }
 
     /**
      * {@inheritdoc}
      */
     public function lintFile(string $path): LintingResultInterface
     {
-        return $this->sublinter->lintFile($path);
+        return $this->subLinter->lintFile($path);
     }
 
     /**
      * {@inheritdoc}
      */
     public function lintSource(string $source): LintingResultInterface
     {
-        return $this->sublinter->lintSource($source);
+        return $this->subLinter->lintSource($source);
     }
 }
diff --git a/src/Tokenizer/Analyzer/Analysis/ArgumentAnalysis.php b/src/Tokenizer/Analyzer/Analysis/ArgumentAnalysis.php
@@ -31,17 +31,13 @@ final class ArgumentAnalysis
 
     /**
      * The default value of the argument.
-     *
-     * @var null|string
      */
-    private $default;
+    private ?string $default;
 
     /**
      * The type analysis of the argument.
-     *
-     * @var ?TypeAnalysis
      */
-    private $typeAnalysis;
+    private ?TypeAnalysis $typeAnalysis;
 
     public function __construct(string $name, int $nameIndex, ?string $default, ?TypeAnalysis $typeAnalysis = null)
     {

diff --git a/src/Tokenizer/Analyzer/Analysis/MatchAnalysis.php b/src/Tokenizer/Analyzer/Analysis/MatchAnalysis.php
@@ -19,10 +19,7 @@
  */
 final class MatchAnalysis extends AbstractControlCaseStructuresAnalysis
 {
-    /**
-     * @var null|DefaultAnalysis
-     */
-    private $defaultAnalysis;
+    private ?DefaultAnalysis $defaultAnalysis;
 
     public function __construct(int $index, int $open, int $close, ?DefaultAnalysis $defaultAnalysis)
     {

diff --git a/src/Tokenizer/Analyzer/Analysis/TypeAnalysis.php b/src/Tokenizer/Analyzer/Analysis/TypeAnalysis.php
@@ -47,10 +47,7 @@ final class TypeAnalysis implements StartEndTokenAwareAnalysis
         'void',
     ];
 
-    /**
-     * @var string
-     */
-    private $name;
+    private string $name;
 
     private int $startIndex;
 

diff --git a/tests/Doctrine/Annotation/TokensTest.php b/tests/Doctrine/Annotation/TokensTest.php
@@ -35,4 +35,34 @@ public function testCreateFromEmptyPhpdocComment(): void
         static::assertCount(1, $tokens);
         static::assertSame($docComment, $tokens->getCode());
     }
+
+    /**
+     * @dataProvider provideOffSetOtherThanTokenCases
+     */
+    public function testOffSetOtherThanToken(string $message, ?string $wrongType): void
+    {
+        $docComment = '/** */';
+
+        $token = new Token([T_DOC_COMMENT, $docComment]);
+        $tokens = Tokens::createFromDocComment($token);
+
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage($message);
+
+        // @phpstan-ignore-next-line as we are testing the type error
+        $tokens[1] = $wrongType;
+    }
+
+    public function provideOffSetOtherThanTokenCases(): iterable
+    {
+        yield [
+            'Token must be an instance of PhpCsFixer\Doctrine\Annotation\Token, "null" given.',
+            null,
+        ];
+
+        yield [
+            'Token must be an instance of PhpCsFixer\Doctrine\Annotation\Token, "string" given.',
+            'foo',
+        ];
+    }
 }
diff --git a/tests/Fixer/Alias/SetTypeToCastFixerTest.php b/tests/Fixer/Alias/SetTypeToCastFixerTest.php
@@ -74,7 +74,7 @@ public function provideFixCases(): array
                 '<?php $foo = (bool) $foo;',
                 '<?php settype  (  $foo  , "Bool");',
             ],
-            'boolean' => [
+            'boolean with extra space' => [
                 '<?php $foo = (bool) $foo;',
                 '<?php settype  (  $foo  , "boolean");',
             ],
@@ -218,15 +218,11 @@ function settype($a, $b){}    // "
             'unknown type II' => [
                 '<?php settype($foo, "stringX");',
             ],
-            'null cast' => [
-                '<?php $foo = null;',
-                '<?php settype($foo, "null");',
-            ],
             'boolean' => [
                 '<?php $foo = (bool) $foo;',
                 '<?php settype($foo, "boolean", );',
             ],
-            'comments with line breaks' => [
+            'comments with line breaks II' => [
                 '<?php #0
 #1
 $foo = (int) $foo#2

diff --git a/tests/Fixer/Phpdoc/NoSuperfluousPhpdocTagsFixerTest.php b/tests/Fixer/Phpdoc/NoSuperfluousPhpdocTagsFixerTest.php
@@ -1809,7 +1809,7 @@ class Foo {
                 null,
                 ['allow_mixed' => false],
             ],
-            'allow_mixed=>true' => [
+            'allow_mixed=>true ||' => [
                 '<?php
 class Foo {
     /**

diff --git a/tests/Tokenizer/TokensTest.php b/tests/Tokenizer/TokensTest.php
@@ -282,10 +282,11 @@ public function provideFindSequenceCases(): array
      */
     public function testFindSequenceException(string $message, array $sequence): void
     {
+        $tokens = Tokens::fromCode('<?php $x = 1;');
+
         $this->expectException(\InvalidArgumentException::class);
         $this->expectExceptionMessage($message);
 
-        $tokens = Tokens::fromCode('<?php $x = 1;');
         $tokens->findSequence($sequence);
     }
 
@@ -732,21 +733,23 @@ public function provideFindBlockEnd80Cases(): array
 
     public function testFindBlockEndInvalidType(): void
     {
+        Tokens::clearCache();
+        $tokens = Tokens::fromCode('<?php ');
+
         $this->expectException(\InvalidArgumentException::class);
         $this->expectExceptionMessageMatches('/^Invalid param type: "-1"\.$/');
 
-        Tokens::clearCache();
-        $tokens = Tokens::fromCode('<?php ');
         $tokens->findBlockEnd(-1, 0);
     }
 
     public function testFindBlockEndInvalidStart(): void
     {
+        Tokens::clearCache();
+        $tokens = Tokens::fromCode('<?php ');
+
         $this->expectException(\InvalidArgumentException::class);
         $this->expectExceptionMessageMatches('/^Invalid param \$startIndex - not a proper block "start"\.$/');
 
-        Tokens::clearCache();
-        $tokens = Tokens::fromCode('<?php ');
         $tokens->findBlockEnd(Tokens::BLOCK_TYPE_DYNAMIC_VAR_BRACE, 0);
     }