Annotated arrays are no longer checked, only when in properties

phpstan · May 30, 2018 · ad01d80 · ad01d80
1 parent d966431
commit ad01d80
Show file tree

Hide file tree

Showing 23 changed files with 141 additions and 169 deletions.
diff --git a/src/Analyser/NodeScopeResolver.php b/src/Analyser/NodeScopeResolver.php
@@ -1056,7 +1056,7 @@ private function lookForAssigns(
 					'file_get_contents',
 				], true)
 			) {
-				$scope = $scope->assignVariable('http_response_header', new ArrayType(new IntegerType(), new StringType(), false), $certainty);
+				$scope = $scope->assignVariable('http_response_header', new ArrayType(new IntegerType(), new StringType()), $certainty);
 			}
 
 			if (
@@ -1538,7 +1538,7 @@ private function assignVariable(
 				}
 
 				if ($valueToWrite instanceof ErrorType) {
-					$valueToWrite = new ArrayType(new MixedType(), new MixedType(), true);
+					$valueToWrite = new ArrayType(new MixedType(), new MixedType());
 				}
 
 				$scope = $scope->assignVariable(

diff --git a/src/Analyser/Scope.php b/src/Analyser/Scope.php
@@ -715,8 +715,7 @@ private function resolveType(Expr $node): Type
 				if ($leftType instanceof ArrayType && $rightType instanceof ArrayType) {
 					return new ArrayType(
 						TypeCombinator::union($leftType->getKeyType(), $rightType->getKeyType()),
-						TypeCombinator::union($leftType->getItemType(), $rightType->getItemType()),
-						$leftType->isItemTypeInferredFromLiteralArray() || $rightType->isItemTypeInferredFromLiteralArray()
+						TypeCombinator::union($leftType->getItemType(), $rightType->getItemType())
 					);
 				}
 			}
@@ -1692,7 +1691,7 @@ public function getFunctionType($type = null, bool $isNullable, bool $isVariadic
 				$type,
 				false,
 				false
-			), false);
+			));
 		}
 		if ($type === null) {
 			return new MixedType();

diff --git a/src/Rules/Arrays/AppendedArrayItemTypeRule.php b/src/Rules/Arrays/AppendedArrayItemTypeRule.php
@@ -6,18 +6,26 @@
 use PhpParser\Node\Expr\Assign;
 use PhpParser\Node\Expr\AssignOp;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Properties\PropertyReflectionFinder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\VerbosityLevel;
 
 class AppendedArrayItemTypeRule implements \PHPStan\Rules\Rule
 {
 
+	/** @var \PHPStan\Rules\Properties\PropertyReflectionFinder */
+	private $propertyReflectionFinder;
+
 	/** @var \PHPStan\Rules\RuleLevelHelper */
 	private $ruleLevelHelper;
 
-	public function __construct(RuleLevelHelper $ruleLevelHelper)
+	public function __construct(
+		PropertyReflectionFinder $propertyReflectionFinder,
+		RuleLevelHelper $ruleLevelHelper
+	)
 	{
+		$this->propertyReflectionFinder = $propertyReflectionFinder;
 		$this->ruleLevelHelper = $ruleLevelHelper;
 	}
 
@@ -44,12 +52,20 @@ public function processNode(\PhpParser\Node $node, Scope $scope): array
 			return [];
 		}
 
-		$assignedToType = $scope->getType($node->var->var);
-		if (!($assignedToType instanceof ArrayType)) {
+		if (
+			!$node->var->var instanceof \PhpParser\Node\Expr\PropertyFetch
+			&& !$node->var->var instanceof \PhpParser\Node\Expr\StaticPropertyFetch
+		) {
 			return [];
 		}
 
-		if ($assignedToType->isItemTypeInferredFromLiteralArray()) {
+		$propertyReflection = $this->propertyReflectionFinder->findPropertyReflectionFromNode($node->var->var, $scope);
+		if ($propertyReflection === null) {
+			return [];
+		}
+
+		$assignedToType = $propertyReflection->getType();
+		if (!($assignedToType instanceof ArrayType)) {
 			return [];
 		}
 

diff --git a/src/Rules/Arrays/AppendedArrayKeyTypeRule.php b/src/Rules/Arrays/AppendedArrayKeyTypeRule.php
@@ -5,6 +5,7 @@
 use PhpParser\Node\Expr\ArrayDimFetch;
 use PhpParser\Node\Expr\Assign;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Properties\PropertyReflectionFinder;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\IntegerType;
 use PHPStan\Type\UnionType;
@@ -13,11 +14,18 @@
 class AppendedArrayKeyTypeRule implements \PHPStan\Rules\Rule
 {
 
+	/** @var PropertyReflectionFinder */
+	private $propertyReflectionFinder;
+
 	/** @var bool */
 	private $checkUnionTypes;
 
-	public function __construct(bool $checkUnionTypes)
+	public function __construct(
+		PropertyReflectionFinder $propertyReflectionFinder,
+		bool $checkUnionTypes
+	)
 	{
+		$this->propertyReflectionFinder = $propertyReflectionFinder;
 		$this->checkUnionTypes = $checkUnionTypes;
 	}
 
@@ -37,12 +45,20 @@ public function processNode(\PhpParser\Node $node, Scope $scope): array
 			return [];
 		}
 
-		$arrayType = $scope->getType($node->var->var);
-		if (!$arrayType instanceof ArrayType) {
+		if (
+			!$node->var->var instanceof \PhpParser\Node\Expr\PropertyFetch
+			&& !$node->var->var instanceof \PhpParser\Node\Expr\StaticPropertyFetch
+		) {
+			return [];
+		}
+
+		$propertyReflection = $this->propertyReflectionFinder->findPropertyReflectionFromNode($node->var->var, $scope);
+		if ($propertyReflection === null) {
 			return [];
 		}
 
-		if ($arrayType->isItemTypeInferredFromLiteralArray()) {
+		$arrayType = $propertyReflection->getType();
+		if (!$arrayType instanceof ArrayType) {
 			return [];
 		}
 

diff --git a/src/Type/ArrayType.php b/src/Type/ArrayType.php
@@ -24,14 +24,10 @@ class ArrayType implements StaticResolvableType
 	/** @var \PHPStan\Type\Type */
 	private $itemType;
 
-	/** @var bool */
-	private $itemTypeInferredFromLiteralArray;
-
-	public function __construct(Type $keyType, Type $itemType, bool $itemTypeInferredFromLiteralArray = false)
+	public function __construct(Type $keyType, Type $itemType)
 	{
 		$this->keyType = $keyType;
 		$this->itemType = $itemType;
-		$this->itemTypeInferredFromLiteralArray = $itemTypeInferredFromLiteralArray;
 	}
 
 	public function getKeyType(): Type
@@ -55,11 +51,6 @@ public function getReferencedClasses(): array
 		);
 	}
 
-	public function isItemTypeInferredFromLiteralArray(): bool
-	{
-		return $this->itemTypeInferredFromLiteralArray;
-	}
-
 	public function accepts(Type $type): bool
 	{
 		if ($type instanceof self) {
@@ -110,28 +101,26 @@ public function unionWith(self $otherArray): Type
 	{
 		return new self(
 			TypeCombinator::union($this->getKeyType(), $otherArray->getKeyType()),
-			TypeCombinator::union($this->getIterableValueType(), $otherArray->getIterableValueType()),
-			$this->isItemTypeInferredFromLiteralArray() || $otherArray->isItemTypeInferredFromLiteralArray()
+			TypeCombinator::union($this->getIterableValueType(), $otherArray->getIterableValueType())
 		);
 	}
 
 	public function getKeysArray(): self
 	{
-		return new self(new IntegerType(), $this->keyType, true);
+		return new self(new IntegerType(), $this->keyType);
 	}
 
 	public function getValuesArray(): self
 	{
-		return new self(new IntegerType(), $this->itemType, true);
+		return new self(new IntegerType(), $this->itemType);
 	}
 
 	public function resolveStatic(string $className): Type
 	{
 		if ($this->getItemType() instanceof StaticResolvableType) {
 			return new self(
 				$this->keyType,
-				$this->getItemType()->resolveStatic($className),
-				$this->isItemTypeInferredFromLiteralArray()
+				$this->getItemType()->resolveStatic($className)
 			);
 		}
 
@@ -143,8 +132,7 @@ public function changeBaseClass(string $className): StaticResolvableType
 		if ($this->getItemType() instanceof StaticResolvableType) {
 			return new self(
 				$this->keyType,
-				$this->getItemType()->changeBaseClass($className),
-				$this->isItemTypeInferredFromLiteralArray()
+				$this->getItemType()->changeBaseClass($className)
 			);
 		}
 
@@ -199,8 +187,7 @@ public function setOffsetValueType(?Type $offsetType, Type $valueType): Type
 
 		return new ArrayType(
 			TypeCombinator::union($this->keyType, self::castToArrayKeyType($offsetType)),
-			TypeCombinator::union($this->itemType, $valueType),
-			$this->itemTypeInferredFromLiteralArray
+			TypeCombinator::union($this->itemType, $valueType)
 		);
 	}
 
@@ -295,8 +282,7 @@ public static function __set_state(array $properties): Type
 	{
 		return new self(
 			$properties['keyType'],
-			$properties['itemType'],
-			$properties['itemTypeInferredFromLiteralArray']
+			$properties['itemType']
 		);
 	}
 

diff --git a/src/Type/Constant/ConstantArrayType.php b/src/Type/Constant/ConstantArrayType.php
@@ -50,8 +50,7 @@ public function __construct(array $keyTypes, array $valueTypes, int $nextAutoInd
 
 		parent::__construct(
 			count($keyTypes) > 0 ? TypeCombinator::union(...$keyTypes) : new NeverType(),
-			count($valueTypes) > 0 ? TypeCombinator::union(...$valueTypes) : new NeverType(),
-			true
+			count($valueTypes) > 0 ? TypeCombinator::union(...$valueTypes) : new NeverType()
 		);
 
 		$this->keyTypes = $keyTypes;
@@ -347,8 +346,7 @@ public function generalize(): Type
 	{
 		return new ArrayType(
 			TypeUtils::generalizeType($this->getKeyType()),
-			$this->getItemType(),
-			true
+			$this->getItemType()
 		);
 	}
 

diff --git a/src/Type/Constant/ConstantArrayTypeBuilder.php b/src/Type/Constant/ConstantArrayTypeBuilder.php
@@ -94,8 +94,7 @@ public function getArray(): ArrayType
 
 		return new ArrayType(
 			TypeCombinator::union(...$this->keyTypes),
-			TypeCombinator::union(...$this->valueTypes),
-			true
+			TypeCombinator::union(...$this->valueTypes)
 		);
 	}
 

diff --git a/src/Type/FileTypeMapper.php b/src/Type/FileTypeMapper.php
@@ -91,7 +91,7 @@ public function getResolvedPhpDoc(
 	private function getResolvedPhpDocMap(string $fileName): array
 	{
 		if (!isset($this->memoryCache[$fileName])) {
-			$cacheKey = sprintf('%s-%d-v42', $fileName, filemtime($fileName));
+			$cacheKey = sprintf('%s-%d-v43', $fileName, filemtime($fileName));
 			$map = $this->cache->load($cacheKey);
 
 			if ($map === null) {

diff --git a/src/Type/Php/ArgumentBasedFunctionReturnTypeExtension.php b/src/Type/Php/ArgumentBasedFunctionReturnTypeExtension.php
@@ -36,8 +36,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 
 		return new ArrayType(
 			$argumentType->getIterableKeyType(),
-			$argumentType->getIterableValueType(),
-			true
+			$argumentType->getIterableValueType()
 		);
 	}
 

diff --git a/src/Type/Php/ArrayFillFunctionReturnTypeExtension.php b/src/Type/Php/ArrayFillFunctionReturnTypeExtension.php
@@ -29,12 +29,12 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 		$valueType = $scope->getType($functionCall->args[2]->value);
 		$startIndexType = $scope->getType($functionCall->args[0]->value);
 		if (!$startIndexType instanceof ConstantIntegerType) {
-			return new ArrayType(new IntegerType(), $valueType, true);
+			return new ArrayType(new IntegerType(), $valueType);
 		}
 
 		$numberType = $scope->getType($functionCall->args[1]->value);
 		if (!$numberType instanceof ConstantIntegerType) {
-			return new ArrayType(new IntegerType(), $valueType, true);
+			return new ArrayType(new IntegerType(), $valueType);
 		}
 
 		$arrayBuilder = ConstantArrayTypeBuilder::createEmpty();

diff --git a/src/Type/Php/ArrayFillKeysFunctionReturnTypeExtension.php b/src/Type/Php/ArrayFillKeysFunctionReturnTypeExtension.php
@@ -30,7 +30,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 		$keysType = $scope->getType($functionCall->args[0]->value);
 		$constantArrays = TypeUtils::getConstantArrays($keysType);
 		if (count($constantArrays) === 0) {
-			return new ArrayType($keysType->getIterableValueType(), $valueType, true);
+			return new ArrayType($keysType->getIterableValueType(), $valueType);
 		}
 
 		$arrayTypes = [];

diff --git a/src/Type/Php/ArrayFilterFunctionReturnTypeReturnTypeExtension.php b/src/Type/Php/ArrayFilterFunctionReturnTypeReturnTypeExtension.php
@@ -49,7 +49,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 			$itemType = new MixedType();
 		}
 
-		return new ArrayType($keyType, $itemType, true);
+		return new ArrayType($keyType, $itemType);
 	}
 
 }
diff --git a/src/Type/Php/ArrayKeysFunctionDynamicReturnTypeExtension.php b/src/Type/Php/ArrayKeysFunctionDynamicReturnTypeExtension.php
@@ -31,8 +31,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 
 		return new ArrayType(
 			new IntegerType(),
-			new UnionType([new StringType(), new IntegerType()]),
-			true
+			new UnionType([new StringType(), new IntegerType()])
 		);
 	}
 

diff --git a/src/Type/Php/ArrayValuesFunctionDynamicReturnTypeExtension.php b/src/Type/Php/ArrayValuesFunctionDynamicReturnTypeExtension.php
@@ -30,8 +30,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 
 		return new ArrayType(
 			new IntegerType(),
-			new MixedType(),
-			true
+			new MixedType()
 		);
 	}
 

diff --git a/src/Type/Php/ExplodeFunctionDynamicReturnTypeExtension.php b/src/Type/Php/ExplodeFunctionDynamicReturnTypeExtension.php
@@ -36,7 +36,7 @@ public function getTypeFromFunctionCall(
 		if ($isSuperset->yes()) {
 			return new ConstantBooleanType(false);
 		} elseif ($isSuperset->no()) {
-			return new ArrayType(new IntegerType(), new StringType(), true);
+			return new ArrayType(new IntegerType(), new StringType());
 		}
 
 		return ParametersAcceptorSelector::selectSingle($functionReflection->getVariants())->getReturnType();

diff --git a/src/Type/Php/IsArrayFunctionTypeSpecifyingExtension.php b/src/Type/Php/IsArrayFunctionTypeSpecifyingExtension.php
@@ -32,7 +32,7 @@ public function specifyTypes(FunctionReflection $functionReflection, FuncCall $n
 			throw new \PHPStan\ShouldNotHappenException();
 		}
 
-		return $this->typeSpecifier->create($node->args[0]->value, new ArrayType(new MixedType(), new MixedType(), true), $context);
+		return $this->typeSpecifier->create($node->args[0]->value, new ArrayType(new MixedType(), new MixedType()), $context);
 	}
 
 	public function setTypeSpecifier(TypeSpecifier $typeSpecifier): void