Update

Author: kubawerlos

README.md

@@ -5,7 +5,7 @@
 [![Latest stable version](https://img.shields.io/packagist/v/kubawerlos/php-cs-fixer-custom-fixers.svg?label=current%20version)](https://packagist.org/packages/kubawerlos/php-cs-fixer-custom-fixers)
 [![PHP version](https://img.shields.io/packagist/php-v/kubawerlos/php-cs-fixer-custom-fixers.svg)](https://php.net)
 [![License](https://img.shields.io/github/license/kubawerlos/php-cs-fixer-custom-fixers.svg)](LICENSE)
-![Tests](https://img.shields.io/badge/tests-3726-brightgreen.svg)
+![Tests](https://img.shields.io/badge/tests-3727-brightgreen.svg)
 [![Downloads](https://img.shields.io/packagist/dt/kubawerlos/php-cs-fixer-custom-fixers.svg)](https://packagist.org/packages/kubawerlos/php-cs-fixer-custom-fixers)
 
 [![CI status](https://github.com/kubawerlos/php-cs-fixer-custom-fixers/actions/workflows/ci.yaml/badge.svg)](https://github.com/kubawerlos/php-cs-fixer-custom-fixers/actions/workflows/ci.yaml)
@@ -726,7 +726,7 @@ The string key of an array or generator must be trimmed and have no double space
 
 #### TypedClassConstantFixer
 Class constants must have a type.
-  *Risky: when constant is not of single type.*
+  *Risky: when constant can be of different types.*
 ```diff
  <?php
  class Foo {

src/Fixer/TypedClassConstantFixer.php

@@ -21,6 +21,13 @@
 
 final class TypedClassConstantFixer extends AbstractFixer
 {
+    private const TOKEN_TO_TYPE_MAP = [
+        \T_DNUMBER => 'float',
+        \T_LNUMBER => 'int',
+        \T_CONSTANT_ENCAPSED_STRING => 'string',
+        CT::T_ARRAY_SQUARE_BRACE_CLOSE => 'array',
+    ];
+
     public function getDefinition(): FixerDefinitionInterface
     {
         return new FixerDefinition(
@@ -39,7 +46,7 @@ class Foo {
                 ),
             ],
             '',
-            'when constant is not of single type',
+            'when constant can be of different types',
         );
     }
 
@@ -91,55 +98,50 @@ private static function fixClass(Tokens $tokens, int $openParenthesisIndex, int
                 continue;
             }
 
+            $type = self::getTypeOfExpression($tokens, $assignmentIndex);
+
             $tokens->insertAt(
                 $constantNameIndex,
                 [
-                    self::getTypeOfExpression($tokens, $assignmentIndex),
+                    new Token([$type === 'array' ? CT::T_ARRAY_TYPEHINT : \T_STRING, $type]),
                     new Token([\T_WHITESPACE, ' ']),
                 ],
             );
         }
     }
 
-    private static function getTypeOfExpression(Tokens $tokens, int $assignmentIndex): Token
+    private static function getTypeOfExpression(Tokens $tokens, int $assignmentIndex): string
     {
         $semicolonIndex = $tokens->getNextTokenOfKind($assignmentIndex, [';']);
         \assert(\is_int($semicolonIndex));
 
         $beforeSemicolonIndex = $tokens->getPrevMeaningfulToken($semicolonIndex);
         \assert(\is_int($beforeSemicolonIndex));
 
-        $map = [
-            \T_DNUMBER => [\T_STRING, 'float'],
-            \T_LNUMBER => [\T_STRING, 'int'],
-            \T_CONSTANT_ENCAPSED_STRING => [\T_STRING, 'string'],
-            CT::T_ARRAY_SQUARE_BRACE_CLOSE => [CT::T_ARRAY_TYPEHINT, 'array'],
-        ];
-
         $tokenId = $tokens[$beforeSemicolonIndex]->getId();
 
+        if (isset(self::TOKEN_TO_TYPE_MAP[$tokenId])) {
+            return self::TOKEN_TO_TYPE_MAP[$tokenId];
+        }
+
         if ($tokens[$beforeSemicolonIndex]->isGivenKind(\T_STRING)) {
             $lowercasedContent = \strtolower($tokens[$beforeSemicolonIndex]->getContent());
             if (\in_array($lowercasedContent, ['false', 'true', 'null'], true)) {
-                return new Token([\T_STRING, $lowercasedContent]);
+                return $lowercasedContent;
             }
         }
 
-        if ($tokenId === null && $tokens[$beforeSemicolonIndex]->equals(')')) {
+        if ($tokens[$beforeSemicolonIndex]->equals(')')) {
             $openParenthesisIndex = $tokens->findBlockStart(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $beforeSemicolonIndex);
 
             $arrayIndex = $tokens->getPrevMeaningfulToken($openParenthesisIndex);
             \assert(\is_int($arrayIndex));
 
             if ($tokens[$arrayIndex]->isGivenKind(\T_ARRAY)) {
-                $tokenId = CT::T_ARRAY_SQUARE_BRACE_CLOSE;
+                return 'array';
             }
         }
 
-        if (isset($map[$tokenId])) {
-            return new Token($map[$tokenId]);
-        }
-
-        return new Token([\T_STRING, 'mixed']);
+        return 'mixed';
     }
 }

tests/Fixer/TypedClassConstantFixerTest.php

@@ -105,30 +105,35 @@ public static function provideFixCases(): iterable
                 <?php
                 class Foo {
                     public const int ONE = 1;
-                    public const bool ALREADY_TYPED = true;
-                    public const string NAME = 'name';
+                    protected const bool|float ALREADY_TYPED = true;
+                    private const string NAME = 'name';
                 }
                 const NOT_CLASS = true;
                 class Bar {
-                    public const array ARRAY_LONG_SYNTAX = array();
-                    public const array ARRAY_SHORT_SYNTAX = [];
-                    public const string lowercased_name = 'lowercased_name';
+                    const array ARRAY_LONG_SYNTAX = array();
+                    const array ARRAY_SHORT_SYNTAX = [];
+                    const string lowercased_name = 'lowercased_name';
                 }
                 PHP,
             <<<'PHP'
                 <?php
                 class Foo {
                     public const ONE = 1;
-                    public const bool ALREADY_TYPED = true;
-                    public const NAME = 'name';
+                    protected const bool|float ALREADY_TYPED = true;
+                    private const NAME = 'name';
                 }
                 const NOT_CLASS = true;
                 class Bar {
-                    public const ARRAY_LONG_SYNTAX = array();
-                    public const ARRAY_SHORT_SYNTAX = [];
-                    public const lowercased_name = 'lowercased_name';
+                    const ARRAY_LONG_SYNTAX = array();
+                    const ARRAY_SHORT_SYNTAX = [];
+                    const lowercased_name = 'lowercased_name';
                 }
                 PHP,
         ];
+
+        yield 'constant that can be of different types' => [
+            '<?php class Foo { public const string BAR = SHOULD_BE_INT ? 1 : "one"; }',
+            '<?php class Foo { public const BAR = SHOULD_BE_INT ? 1 : "one"; }',
+        ];
     }
 }