Rector MixedTypeRector

Author: PowerKiKi

src/PhpSpreadsheet/Calculation/ArrayEnabled.php

@@ -43,10 +43,8 @@ protected static function evaluateSingleArgumentArray(callable $method, array $v
      *     and any of them can be an array argument.
      * Example use for:
      *         ROUND() or DATE().
-     *
-     * @param mixed ...$arguments
      */
-    protected static function evaluateArrayArguments(callable $method, ...$arguments): array
+    protected static function evaluateArrayArguments(callable $method, mixed ...$arguments): array
     {
         self::initialiseHelper($arguments);
         $arguments = self::$arrayArgumentHelper->arguments();
@@ -60,10 +58,8 @@ protected static function evaluateArrayArguments(callable $method, ...$arguments
      * Example use for:
      *         NETWORKDAYS() or CONCATENATE(), where the last argument is a matrix (or a series of values) that need
      *                                         to be treated as a such rather than as an array arguments.
-     *
-     * @param mixed ...$arguments
      */
-    protected static function evaluateArrayArgumentsSubset(callable $method, int $limit, ...$arguments): array
+    protected static function evaluateArrayArgumentsSubset(callable $method, int $limit, mixed ...$arguments): array
     {
         self::initialiseHelper(array_slice($arguments, 0, $limit));
         $trailingArguments = array_slice($arguments, $limit);
@@ -73,10 +69,7 @@ protected static function evaluateArrayArgumentsSubset(callable $method, int $li
         return ArrayArgumentProcessor::processArguments(self::$arrayArgumentHelper, $method, ...$arguments);
     }
 
-    /**
-     * @param mixed $value
-     */
-    private static function testFalse($value): bool
+    private static function testFalse(mixed $value): bool
     {
         return $value === false;
     }
@@ -87,10 +80,8 @@ private static function testFalse($value): bool
      * Example use for:
      *         Z.TEST() or INDEX(), where the first argument 1 is a matrix that needs to be treated as a dataset
      *                   rather than as an array argument.
-     *
-     * @param mixed ...$arguments
      */
-    protected static function evaluateArrayArgumentsSubsetFrom(callable $method, int $start, ...$arguments): array
+    protected static function evaluateArrayArgumentsSubsetFrom(callable $method, int $start, mixed ...$arguments): array
     {
         $arrayArgumentsSubset = array_combine(
             range($start, count($arguments) - $start),
@@ -114,10 +105,8 @@ protected static function evaluateArrayArgumentsSubsetFrom(callable $method, int
      * Example use for:
      *         HLOOKUP() and VLOOKUP(), where argument 1 is a matrix that needs to be treated as a database
      *                                  rather than as an array argument.
-     *
-     * @param mixed ...$arguments
      */
-    protected static function evaluateArrayArgumentsIgnore(callable $method, int $ignore, ...$arguments): array
+    protected static function evaluateArrayArgumentsIgnore(callable $method, int $ignore, mixed ...$arguments): array
     {
         $leadingArguments = array_slice($arguments, 0, $ignore);
         $ignoreArgument = array_slice($arguments, $ignore, 1);

src/PhpSpreadsheet/Calculation/BinaryComparison.php

@@ -36,11 +36,7 @@ private static function strcmpAllowNull($str1, $str2): int
         return strcmp($str1 ?? '', $str2 ?? '');
     }
 
-    /**
-     * @param mixed $operand1
-     * @param mixed $operand2
-     */
-    public static function compare($operand1, $operand2, string $operator): bool
+    public static function compare(mixed $operand1, mixed $operand2, string $operator): bool
     {
         //    Simple validate the two operands if they are string values
         if (is_string($operand1) && $operand1 > '' && $operand1[0] == Calculation::FORMULA_STRING_QUOTE) {
@@ -67,11 +63,7 @@ public static function compare($operand1, $operand2, string $operator): bool
         return self::evaluateComparison($operand1, $operand2, $operator, $useLowercaseFirstComparison);
     }
 
-    /**
-     * @param mixed $operand1
-     * @param mixed $operand2
-     */
-    private static function evaluateComparison($operand1, $operand2, string $operator, bool $useLowercaseFirstComparison): bool
+    private static function evaluateComparison(mixed $operand1, mixed $operand2, string $operator, bool $useLowercaseFirstComparison): bool
     {
         return match ($operator) {
             '=' => self::equal($operand1, $operand2),
@@ -84,11 +76,7 @@ private static function evaluateComparison($operand1, $operand2, string $operato
         };
     }
 
-    /**
-     * @param mixed $operand1
-     * @param mixed $operand2
-     */
-    private static function equal($operand1, $operand2): bool
+    private static function equal(mixed $operand1, mixed $operand2): bool
     {
         if (is_numeric($operand1) && is_numeric($operand2)) {
             $result = (abs($operand1 - $operand2) < self::DELTA);
@@ -101,11 +89,7 @@ private static function equal($operand1, $operand2): bool
         return $result;
     }
 
-    /**
-     * @param mixed $operand1
-     * @param mixed $operand2
-     */
-    private static function greaterThanOrEqual($operand1, $operand2, bool $useLowercaseFirstComparison): bool
+    private static function greaterThanOrEqual(mixed $operand1, mixed $operand2, bool $useLowercaseFirstComparison): bool
     {
         if (is_numeric($operand1) && is_numeric($operand2)) {
             $result = ((abs($operand1 - $operand2) < self::DELTA) || ($operand1 > $operand2));
@@ -120,11 +104,7 @@ private static function greaterThanOrEqual($operand1, $operand2, bool $useLowerc
         return $result;
     }
 
-    /**
-     * @param mixed $operand1
-     * @param mixed $operand2
-     */
-    private static function lessThanOrEqual($operand1, $operand2, bool $useLowercaseFirstComparison): bool
+    private static function lessThanOrEqual(mixed $operand1, mixed $operand2, bool $useLowercaseFirstComparison): bool
     {
         if (is_numeric($operand1) && is_numeric($operand2)) {
             $result = ((abs($operand1 - $operand2) < self::DELTA) || ($operand1 < $operand2));
@@ -139,29 +119,17 @@ private static function lessThanOrEqual($operand1, $operand2, bool $useLowercase
         return $result;
     }
 
-    /**
-     * @param mixed $operand1
-     * @param mixed $operand2
-     */
-    private static function greaterThan($operand1, $operand2, bool $useLowercaseFirstComparison): bool
+    private static function greaterThan(mixed $operand1, mixed $operand2, bool $useLowercaseFirstComparison): bool
     {
         return self::lessThanOrEqual($operand1, $operand2, $useLowercaseFirstComparison) !== true;
     }
 
-    /**
-     * @param mixed $operand1
-     * @param mixed $operand2
-     */
-    private static function lessThan($operand1, $operand2, bool $useLowercaseFirstComparison): bool
+    private static function lessThan(mixed $operand1, mixed $operand2, bool $useLowercaseFirstComparison): bool
     {
         return self::greaterThanOrEqual($operand1, $operand2, $useLowercaseFirstComparison) !== true;
     }
 
-    /**
-     * @param mixed $operand1
-     * @param mixed $operand2
-     */
-    private static function notEqual($operand1, $operand2): bool
+    private static function notEqual(mixed $operand1, mixed $operand2): bool
     {
         return self::equal($operand1, $operand2) !== true;
     }

src/PhpSpreadsheet/Calculation/Calculation.php

@@ -3105,10 +3105,8 @@ public function renameCalculationCacheForWorksheet($fromWorksheetName, $toWorksh
 
     /**
      * Enable/disable calculation cache.
-     *
-     * @param mixed $enabled
      */
-    public function setBranchPruningEnabled($enabled): void
+    public function setBranchPruningEnabled(mixed $enabled): void
     {
         $this->branchPruningEnabled = $enabled;
         $this->branchPruner = new BranchPruner($this->branchPruningEnabled);
@@ -3439,11 +3437,9 @@ public static function wrapResult(mixed $value)
     /**
      * Remove quotes used as a wrapper to identify string values.
      *
-     * @param mixed $value
-     *
      * @return mixed
      */
-    public static function unwrapResult($value)
+    public static function unwrapResult(mixed $value)
     {
         if (is_string($value)) {
             if ((isset($value[0])) && ($value[0] == self::FORMULA_STRING_QUOTE) && (substr($value, -1) == self::FORMULA_STRING_QUOTE)) {
@@ -3637,10 +3633,7 @@ public function calculateFormula($formula, $cellID = null, ?Cell $cell = null)
         return $result;
     }
 
-    /**
-     * @param mixed $cellValue
-     */
-    public function getValueFromCache(string $cellReference, &$cellValue): bool
+    public function getValueFromCache(string $cellReference, mixed &$cellValue): bool
     {
         $this->debugLog->writeDebugLog('Testing cache value for cell %s', $cellReference);
         // Is calculation cacheing enabled?
@@ -3659,9 +3652,8 @@ public function getValueFromCache(string $cellReference, &$cellValue): bool
 
     /**
      * @param string $cellReference
-     * @param mixed $cellValue
      */
-    public function saveValueToCache($cellReference, $cellValue): void
+    public function saveValueToCache($cellReference, mixed $cellValue): void
     {
         if ($this->calculationCacheEnabled) {
             $this->calculationCache[$cellReference] = $cellValue;
@@ -3759,7 +3751,7 @@ public function _calculateFormulaValue($formula, $cellID = null, ?Cell $cell = n
      *                                            1 = shrink to fit
      *                                            2 = extend to fit
      */
-    private static function checkMatrixOperands(&$operand1, &$operand2, $resize = 1): array
+    private static function checkMatrixOperands(mixed &$operand1, mixed &$operand2, $resize = 1): array
     {
         //    Examine each of the two operands, and turn them into an array if they aren't one already
         //    Note that this function should only be called if one or both of the operand is already an array
@@ -3912,7 +3904,7 @@ private static function resizeMatricesExtend(array &$matrix1, array &$matrix2, $
      *
      * @return mixed
      */
-    private function showValue($value)
+    private function showValue(mixed $value)
     {
         if ($this->debugLog->getWriteDebugLog()) {
             $testArray = Functions::flattenArray($value);
@@ -3950,7 +3942,7 @@ private function showValue($value)
      *
      * @param mixed $value First matrix operand
      */
-    private function showTypeDetails($value): ?string
+    private function showTypeDetails(mixed $value): ?string
     {
         if ($this->debugLog->getWriteDebugLog()) {
             $testArray = Functions::flattenArray($value);
@@ -4609,12 +4601,11 @@ private static function dataTestReference(array &$operandData)
     }
 
     /**
-     * @param mixed $tokens
      * @param null|string $cellID
      *
      * @return array<int, mixed>|false
      */
-    private function processTokenStack($tokens, $cellID = null, ?Cell $cell = null)
+    private function processTokenStack(mixed $tokens, $cellID = null, ?Cell $cell = null)
     {
         if ($tokens === false) {
             return false;
@@ -5190,11 +5181,7 @@ private function processTokenStack($tokens, $cellID = null, ?Cell $cell = null)
         return $output;
     }
 
-    /**
-     * @param mixed $operand
-     * @param mixed $stack
-     */
-    private function validateBinaryOperand(&$operand, &$stack): bool
+    private function validateBinaryOperand(mixed &$operand, mixed &$stack): bool
     {
         if (is_array($operand)) {
             if ((count($operand, COUNT_RECURSIVE) - count($operand)) == 1) {
@@ -5232,11 +5219,7 @@ private function validateBinaryOperand(&$operand, &$stack): bool
         return true;
     }
 
-    /**
-     * @param mixed $operand1
-     * @param mixed $operand2
-     */
-    private function executeArrayComparison($operand1, $operand2, string $operation, Stack &$stack, bool $recursingArrays): array
+    private function executeArrayComparison(mixed $operand1, mixed $operand2, string $operation, Stack &$stack, bool $recursingArrays): array
     {
         $result = [];
         if (!is_array($operand2)) {
@@ -5275,11 +5258,7 @@ private function executeArrayComparison($operand1, $operand2, string $operation,
         return $result;
     }
 
-    /**
-     * @param mixed $operand1
-     * @param mixed $operand2
-     */
-    private function executeBinaryComparisonOperation($operand1, $operand2, string $operation, Stack &$stack, bool $recursingArrays = false): array|bool
+    private function executeBinaryComparisonOperation(mixed $operand1, mixed $operand2, string $operation, Stack &$stack, bool $recursingArrays = false): array|bool
     {
         //    If we're dealing with matrix operations, we want a matrix result
         if ((is_array($operand1)) || (is_array($operand2))) {
@@ -5297,14 +5276,12 @@ private function executeBinaryComparisonOperation($operand1, $operand2, string $
     }
 
     /**
-     * @param mixed $operand1
-     * @param mixed $operand2
      * @param string $operation
      * @param Stack $stack
      *
      * @return bool|mixed
      */
-    private function executeNumericBinaryOperation($operand1, $operand2, $operation, &$stack)
+    private function executeNumericBinaryOperation(mixed $operand1, mixed $operand2, $operation, &$stack)
     {
         //    Validate the two operands
         if (
@@ -5740,18 +5717,15 @@ public function getSuppressFormulaErrors(): bool
         return $this->suppressFormulaErrorsNew;
     }
 
-    /** @param mixed $arg */
-    private static function doNothing($arg): bool
+    private static function doNothing(mixed $arg): bool
     {
         return (bool) $arg;
     }
 
     /**
-     * @param mixed $operand1
-     *
      * @return mixed
      */
-    private static function boolToString($operand1)
+    private static function boolToString(mixed $operand1)
     {
         if (is_bool($operand1)) {
             $operand1 = ($operand1) ? self::$localeBoolean['TRUE'] : self::$localeBoolean['FALSE'];
@@ -5762,14 +5736,12 @@ private static function boolToString($operand1)
         return $operand1;
     }
 
-    /** @param mixed $operand */
-    private static function isNumericOrBool($operand): bool
+    private static function isNumericOrBool(mixed $operand): bool
     {
         return is_numeric($operand) || is_bool($operand);
     }
 
-    /** @param mixed $operand */
-    private static function makeError($operand = ''): string
+    private static function makeError(mixed $operand = ''): string
     {
         return Information\ErrorValue::isError($operand) ? $operand : Information\ExcelError::VALUE();
     }

src/PhpSpreadsheet/Calculation/Database/DatabaseAbstract.php

@@ -32,7 +32,7 @@ abstract public static function evaluate($database, $field, $criteria);
      *                                        represents the position of the column within the list: 1 for
      *                                        the first column, 2 for the second column, and so on.
      */
-    protected static function fieldExtract(array $database, $field): ?int
+    protected static function fieldExtract(array $database, mixed $field): ?int
     {
         $field = strtoupper(Functions::flattenSingleValue($field) ?? '');
         if ($field === '') {
@@ -124,10 +124,7 @@ function ($rowValue): string {
         return (count($rowQuery) > 1) ? 'OR(' . implode(',', $rowQuery) . ')' : ($rowQuery[0] ?? '');
     }
 
-    /**
-     * @param mixed $criterion
-     */
-    private static function buildCondition($criterion, string $criterionName): string
+    private static function buildCondition(mixed $criterion, string $criterionName): string
     {
         $ifCondition = Functions::ifCondition($criterion);