ConstantArrayType - preserve array being a list

Author: ondrejmirtes

src/Type/Php/ArrayMapFunctionReturnTypeExtension.php

@@ -6,6 +6,7 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\FunctionReflection;
 use PHPStan\Reflection\ParametersAcceptorSelector;
+use PHPStan\Type\Accessory\AccessoryArrayListType;
 use PHPStan\Type\Accessory\NonEmptyArrayType;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\Constant\ConstantArrayTypeBuilder;
@@ -75,7 +76,11 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 $constantArray->isOptionalKey($i),
 );
 }
-$arrayTypes[] = $returnedArrayBuilder->getArray();
+$returnedArray = $returnedArrayBuilder->getArray();
+if ($constantArray->isList()->yes()) {
+$returnedArray = AccessoryArrayListType::intersectWith($returnedArray);
+}
+$arrayTypes[] = $returnedArray;
 }
 
 $mappedArrayType = TypeCombinator::union(...$arrayTypes);

tests/PHPStan/Rules/Methods/ReturnTypeRuleTest.php

@@ -934,6 +934,11 @@ public function testLists(): void
 ]);
 }
 
+public function testConditionalListRule(): void
+{
+$this->analyse([__DIR__ . '/data/return-list-rule.php'], []);
+}
+
 public function testBug6856(): void
 {
 $this->analyse([__DIR__ . '/data/bug-6856.php'], []);

tests/PHPStan/Rules/Methods/data/return-list-rule.php

@@ -0,0 +1,87 @@
+<?php
+
+namespace ReturnListRule;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\BinaryOp;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\Type;
+use PHPStan\Type\VerbosityLevel;
+/**
+ * @implements Rule<BinaryOp>
+ */
+class BinaryOpEnumValueRule implements Rule
+{
+
+/** @var class-string<BinaryOp> */
+private string $className;
+
+/**
+ * @param class-string $operator
+ */
+public function __construct(string $operator, ?string $okMessage = null)
+{
+$this->className = $operator;
+}
+
+public function getNodeType(): string
+{
+return $this->className;
+}
+
+/**
+ * @param BinaryOp $node
+ * @return list<RuleError>
+ */
+public function processNode(Node $node, Scope $scope): array
+{
+$leftType = $scope->getType($node->left);
+$rightType = $scope->getType($node->right);
+$isDirectCompareType = true;
+
+if (!$this->isEnumWithValue($leftType) || !$this->isEnumWithValue($rightType)) {
+$isDirectCompareType = false;
+}
+
+$errors = [];
+$leftError = $this->processOpExpression($node->left, $leftType, $node->getOperatorSigil());
+$rightError = $this->processOpExpression($node->right, $rightType, $node->getOperatorSigil());
+
+if ($leftError !== null) {
+$errors[] = $leftError;
+}
+
+if ($rightError !== null && $rightError !== $leftError) {
+$errors[] = $rightError;
+}
+
+if (!$isDirectCompareType && $errors === []) {
+return [];
+}
+
+if ($isDirectCompareType && $errors === []) {
+$errors[] = sprintf(
+'Cannot compare %s to %s',
+$leftType->describe(VerbosityLevel::typeOnly()),
+$rightType->describe(VerbosityLevel::typeOnly()),
+);
+}
+
+return array_map(static fn (string $message) => RuleErrorBuilder::message($message)->build(), $errors);
+}
+
+private function processOpExpression(Expr $expression, Type $expressionType, string $sigil): ?string
+{
+return null;
+}
+
+private function isEnumWithValue(Type $type): bool
+{
+return false;
+}
+
+}