,error_levels?:string[]}> */ public function providerValidCodeParse(): iterable { return [ 'intIsMixed' => [ ' [ ' [], 'error_levels' => ['RedundantConditionGivenDocblockType'], ], 'arrayTypeResolutionFromDocblock' => [ ' [], 'error_levels' => ['RedundantConditionGivenDocblockType'], ], 'typeResolutionFromDocblockInside' => [ ' [], 'error_levels' => ['DocblockTypeContradiction'], ], 'notInstanceof' => [ ' [ '$out' => 'A|null', ], ], 'notInstanceOfProperty' => [ 'foo = new B(); } } $a = new A(); $out = null; if ($a->foo instanceof C) { // do something } else { $out = $a->foo; }', 'assertions' => [ '$out' => 'B|null', ], 'error_levels' => [], ], 'notInstanceOfPropertyElseif' => [ 'foo)) { } elseif ($a->foo instanceof C) { // do something } else { $out = $a->foo; }', 'assertions' => [ '$out' => 'B|null', ], 'error_levels' => [], ], 'typeRefinementWithIsNumericOnIntOrFalse' => [ ' [ ' [ ' 4 ? "hello" : 5; if (is_numeric($a)) { exit; }', 'assertions' => [ '$a' => 'string', ], ], 'typeRefinementWithStringOrTrue' => [ ' 4 ? "hello" : true; if (is_bool($a)) { exit; }', 'assertions' => [ '$a' => 'string', ], ], 'updateMultipleIssetVars' => [ ' [ ' [ ' [ ' [], 'error_levels' => ['RedundantConditionGivenDocblockType'], ], 'ignoreNullCheckAndMaintainNullValue' => [ ' [ '$b' => 'null', ], 'error_levels' => ['TypeDoesNotContainType', 'RedundantCondition'], ], 'ignoreNullCheckAndMaintainNullableValue' => [ ' [ '$b' => 'int|null', ], ], 'ternaryByRefVar' => [ ' [ ' [ ' [ 'bar(); $this->bat(); takesA($this); takesI($this); takesAandI($this); takesIandA($this); } } protected function bar(): void {} } class B extends A implements I { public function bat(): void {} }', ], 'createIntersectionOfInterfaceAndClass' => [ 'bat(); $i->baz(); } } function bar(A $a) : void { if ($a instanceof I) { $a->bat(); $a->baz(); } } class B extends A implements I { public function baz() : void {} } foo(new B); bar(new B);', ], 'unionOfArrayOrTraversable' => [ ' [ ' [ ' [ ' [ ' [ ' 2) { $a = "hello"; } else { $a = false; } } return $a; }', ], 'nullableIntReplacement' => [ ' [ '$a' => 'int|null', ], ], 'eraseNullAfterInequalityCheck' => [ ' 0) { echo $a + 3; } if (0 < $a) { echo $a + 3; }', ], 'twoWrongsDontMakeARight' => [ ' [ '$a' => 'false', ], ], 'instanceofStatic' => [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ 'foo(); }', ], 'SKIPPED-isArrayOnArrayKeyOffset' => [ '|string>} */ $doc = []; if (!is_array($doc["s"]["t"])) { $doc["s"]["t"] = [$doc["s"]["t"]]; }', 'assertions' => [ '$doc[\'s\'][\'t\']' => 'array', ], ], 'removeTrue' => [ ' [ ' [ ' [ '$a' => 'null', ], ], 'removeNullWithIsScalar' => [ ' [ '$a' => 'string', ], ], 'scalarToNumeric' => [ ' [ ' [ ' [ ' [ '|null $foo */ function d(?iterable $foo): void { if (is_iterable($foo)) { foreach ($foo as $f) {} } if (!is_iterable($foo)) { } else { foreach ($foo as $f) {} } }', ], 'isStringServerVar' => [ ' [ ' [ 'b())) {} }', ], 'reconcileFloatToEmpty' => [ ' [ ' 'scalar' ] ], 'scalarToString' => [ ' 'scalar' ] ], 'scalarToInt' => [ ' 'scalar' ] ], 'scalarToFloat' => [ ' 'scalar' ] ], 'removeFromArray' => [ ' $v */ function foo(array $v) : void { if (!isset($v[0])) { return; } if ($v[0] === " ") { array_shift($v); } if (!isset($v[0])) {} }', ], 'arrayEquality' => [ '> $haystack * @param array $needle */ function foo(array $haystack, array $needle) : void { foreach ($haystack as $arr) { if ($arr === $needle) {} } }', ], 'classResolvesBackToSelfAfterComparison' => [ ' [ '$a' => 'A', ], ], 'isNumericCanBeScalar' => [ ' [ '|null $val */ function foo(?string $val) : void { if (!$val) {} if ($val) {} }', ], 'allowStringToObjectReconciliation' => [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ 'foo(); } function baz(A $a) : void { if ((!$a instanceof B && !$a instanceof C) === false) { return; } $a->foo(); }', ], 'selfInstanceofStatic' => [ ' [ ' [ 'foo) { $this->foo = []; } } public function iffer() : bool { return $this->foo || $this->bar; } }', ], 'noLeakyForeachType' => [ '_array_value = $this->getArrayValue(); if ($this->_array_value !== null && !count($this->_array_value)) { return; } switch ($var) { case "a": foreach ($this->_array_value ?: [] as $v) {} break; case "b": foreach ($this->_array_value ?: [] as $v) {} break; } } }', [], ['MixedAssignment'], ], 'nonEmptyThing' => [ ' [ ' $b */ function foo(array $a, array $b) : void { if ($a === $b) {} }', ], 'preventCombinatorialExpansion' => [ ' [ ' $x */ function takesArray (array $x): void {} /** @var iterable */ $x = null; assert(is_array($x)); takesArray($x); /** * @param Traversable $x */ function takesTraversable (Traversable $x): void {} /** @var iterable */ $x = null; assert($x instanceof Traversable); takesTraversable($x);', ], 'dontReconcileArrayOffset' => [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ 'id])) {} }', ], 'assertArrayReturnTypeNarrowed' => [ ' [ ' [ ' [ 'format("Y-m-d"); } }', ], 'assertCheckOnNonZeroArrayOffset' => [ ' [ ' $arr */ function uriToPath(array $arr) : string { if (!isset($arr["a"]) || $arr["b"] !== "foo") { throw new \InvalidArgumentException("bad"); } return (string) $arr["c"]; }', ], 'combineAfterLoopAssert' => [ ' $array */ function foo(array $array) : void { $c = 0; if ($array["a"] === "a") { foreach ([rand(0, 1), rand(0, 1)] as $i) { if ($array["b"] === "c") {} $c++; } } }', ], 'assertOnArrayTwice' => [ ' $array */ function f(array $array) : void { if ($array["bar"] === "a") {} if ($array["bar"] === "b") {} }', ], 'assertOnArrayThrice' => [ ' $array */ function f(array $array) : void { if ($array["foo"] === "ok") { if ($array["bar"] === "a") {} if ($array["bar"] === "b") {} } }', ], 'assertOnBacktrace' => [ ' [ ' [ ' [ ' [ ' 0; }', ], 'assertHasArrayAccessSimple' => [ ' [ '> $array * @return array */ function getBar(array $array) : array { if (isset($array[\'foo\'][\'bar\'])) { return $array[\'foo\']; } return []; }', ], 'assertHasArrayAccessOnSimpleXMLElement' => [ 'bar)) {} }', ], 'assertArrayOffsetToTraversable' => [ ' [ ' [ ' [ ' $arr * @return non-empty-array */ function foo(array $arr) : array { if (isset($arr["a"])) { return $arr; } return ["b" => 1]; }' ], 'setArrayConstantOffset' => [ ' [ ' $arr */ function foo(A $a, array $arr): void { if (!isset($arr[$a->id])) { $arr[$a->id] = new B(); } $arr[$a->id]->foo(); }' ], 'assertAfterNotEmptyArrayCheck' => [ ' [ 'c[$s]) && empty($this->c[$t])) {} } }' ], 'assertNotEmptyTwiceOnStaticPropertyArray' => [ ' [ ' [ ' [ ' [ 'arr[0])) { return $this->arr[0]; } $this->arr[0] = new stdClass; return $this->arr[0]; } }' ], 'assertArrayKeyExistsRefinesType' => [ ' */ public const DAYS = [ 1 => "mon", 2 => "tue", 3 => "wed", 4 => "thu", 5 => "fri", 6 => "sat", 7 => "sun", ]; /** @param key-of $dayNum*/ private static function doGetDayName(int $dayNum): string { return self::DAYS[$dayNum]; } /** @throws LogicException */ public static function getDayName(int $dayNum): string { if (! array_key_exists($dayNum, self::DAYS)) { throw new \LogicException(); } return self::doGetDayName($dayNum); } }' ], 'assertPropertiesOfElseStatement' => [ 'a === "foo") { } elseif ($obj->b === "bar") { } else if ($obj->b === "baz") {} if ($obj->b === "baz") {} }' ], 'assertPropertiesOfElseifStatement' => [ 'a === "foo") { } elseif ($obj->b === "bar") { } elseif ($obj->b === "baz") {} if ($obj->b === "baz") {} }' ], 'assertArrayWithOffset' => [ ' [ ' [ ' [ 'foo()) { return $value; } return new O(); }' ], 'SKIPPED-assertVarRedefinedInIfWithOr' => [ ' [ ' [ 'foo();', [ '$a' => 'bool', ] ], 'SKIPPED-assertVarRedefinedInOpWithOr' => [ 'foo();', [ '$a' => 'bool', ] ], 'assertVarInOrAfterAnd' => [ ' [ 'b && !$b->b; echo $a->b ? 1 : 0; }' ], 'assertAssertionsWithCreation' => [ ' [ 'foo(); } }' ], 'definedInConditionalAndCheckedInSubbranch' => [ 'foo(); } } }' ], 'definedInRhsOfConditionalInNegation' => [ 'foo(); } }' ], 'literalStringComparisonInIf' => [ ' [ ' [ ' [ 'foo(); }' ], 'assertOnArrayThings' => [ '> */ $a = null; if (isset($a["b"]) || isset($a["c"])) { $all_params = ($a["b"] ?? []) + ($a["c"] ?? []); }' ], 'assertOnNestedLogic' => [ ' 5) {} } }' ], 'arrayUnionTypeSwitching' => [ ' $map */ function foo(array $map, string $o) : void { if ($mapped_type = $map[$o] ?? null) { if (is_int($mapped_type)) { return; } } if (($mapped_type = $map[""] ?? null) && is_string($mapped_type)) { } }' ], 'propertySetOnElementInConditional' => [ 'old) && is_string($diff_elem->new)) || (is_int($diff_elem->old) && is_int($diff_elem->new)) ) { } }' ], 'manyNestedAsserts' => [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ ' [ 'test()) { return; } echo isset($a); }' ], 'assertOnVarStaticClassKey' => [ '> $arr * @return array */ public static function getArr(array $arr) : array { if (!isset($arr[static::class])) { $arr[static::class] = ["hello" => 5]; } return $arr[static::class]; } }' ], 'assertOnVarVar' => [ '> $arr * @return array */ function getArr(array $arr, string $s) : array { if (!isset($arr[$s])) { $arr[$s] = ["hello" => 5]; } return $arr[$s]; } }' ], 'assertOnPropertyStaticClassKey' => [ '> */ private static $arr = []; /** @return array */ public static function getArr() : array { $arr = self::$arr; if (!isset($arr[static::class])) { $arr[static::class] = ["hello" => 5]; } return $arr[static::class]; } }' ], 'assertOnStaticPropertyOffset' => [ '|null */ private static $map = []; public static function foo(string $id) : ?string { if (isset(self::$map[$id])) { return self::$map[$id]; } return null; } }', ], 'issetTwice' => [ ' $p */ function foo(array $p, int $id) : void { if ((isset($p[$id]) && rand(0, 1)) || (!isset($p[$id]) && rand(0, 1)) ) { isset($p[$id]) ? $p[$id] : new B; isset($p[$id]) ? $p[$id]->foo() : "bar"; } }' ], 'reconcileEmptinessBetter' => [ ' [ ' [ ' 4 ? "test" : null; } function test(): string { $foo = maybeString(); ($foo !== null) || ($foo = ""); return $foo; }' ], 'andWithAssignment' => [ ' 4 ? "test" : null; } function test(): string { $foo = maybeString(); ($foo === null) && ($foo = ""); return $foo; }' ], 'isNotTraversable' => [ ' $collection * @psalm-return array */ function order(iterable $collection): array { if ($collection instanceof \Traversable) { $collection = iterator_to_array($collection, false); } return $collection; }' ], 'memoizeChainedImmutableCallsInside' => [ 'root; } } class Project { private ?Assessment $assessment = null; /** @psalm-mutation-free */ public function getAssessment(): ?Assessment { return $this->assessment; } } function f(Project $project): int { if (($project->getAssessment() !== null) && ($project->getAssessment()->getRoot() !== null) ) { return strlen($project->getAssessment()->getRoot()); } throw new RuntimeException(); }', ], 'memoizeChainedImmutableCallsOutside' => [ 'root; } } class Project { private ?Assessment $assessment = null; /** @psalm-mutation-free */ public function getAssessment(): ?Assessment { return $this->assessment; } } function f(Project $project): int { if (($project->getAssessment() === null) || ($project->getAssessment()->getRoot() === null) ) { throw new RuntimeException(); } return strlen($project->getAssessment()->getRoot()); }', ], 'propertyChainedOutside' => [ 'assessment === null) || ($project->assessment->root === null) ) { throw new RuntimeException(); } return strlen($project->assessment->root); }' ], 'castIsType' => [ ' [ ' [ 'maybeConvert($value)) === null || !$value->isValid()) { throw new Exception(); } return $value; // $value is SomeObject here and cannot be a string }' ], 'nonEmptyStringFromConcat' => [ ' [ ' [ ' [ ' */ public $args = []; } function barr(FuncCall $function) : void { if (!$function->name instanceof A) { return; } if ($function->name->parts === ["function_exists"] && isset($function->args[0]) ) { // do something } elseif ($function->name->parts === ["class_exists"] && isset($function->args[0]) ) { // do something else } }' ], 'largeConditional' => [ ' */ function splitDocLine($return_block) { $brackets = \'\'; $type = \'\'; $expects_callable_return = false; $return_block = str_replace("\t", \' \', $return_block); $quote_char = null; $escaped = false; for ($i = 0, $l = strlen($return_block); $i < $l; ++$i) { $char = $return_block[$i]; $next_char = $i < $l - 1 ? $return_block[$i + 1] : null; $last_char = $i > 0 ? $return_block[$i - 1] : null; if ($quote_char) { if ($char === $quote_char && $i > 1 && !$escaped) { $quote_char = null; $type .= $char; continue; } if (rand(0, 1)) { $escaped = true; $type .= $char; continue; } $escaped = false; $type .= $char; continue; } if ($char === \'"\' || $char === \'\\\\\') { $quote_char = $char; $type .= $char; continue; } if (rand(0, 1)) { $expects_callable_return = true; $type .= $char; continue; } if ($char === \'[\' || $char === \'{\' || $char === \'(\' || $char === \'<\') { $brackets .= $char; } elseif ($char === \']\' || $char === \'}\' || $char === \')\' || $char === \'>\') { $last_bracket = substr($brackets, -1); $brackets = substr($brackets, 0, -1); if (($char === \']\' && $last_bracket !== \'[\') || ($char === \'}\' && $last_bracket !== \'{\') || ($char === \')\' && $last_bracket !== \'(\') || ($char === \'>\' && $last_bracket !== \'<\') ) { return []; } } elseif ($char === \' \') { if ($brackets) { $expects_callable_return = false; $type .= \' \'; continue; } if ($next_char === \'|\' || $next_char === \'&\') { $nexter_char = $i < $l - 2 ? $return_block[$i + 2] : null; if ($nexter_char === \' \') { ++$i; $type .= $next_char . \' \'; continue; } } if ($last_char === \'|\' || $last_char === \'&\') { $type .= \' \'; continue; } if ($next_char === \':\') { ++$i; $type .= \' :\'; $expects_callable_return = true; continue; } if ($expects_callable_return) { $type .= \' \'; $expects_callable_return = false; continue; } $remaining = trim(preg_replace(\'@^[ \t]*\* *@m\', \' \', substr($return_block, $i + 1))); if ($remaining) { /** @var array */ return array_merge([rtrim($type)], preg_split(\'/[ \s]+/\', $remaining)); } return [$type]; } $expects_callable_return = false; $type .= $char; } return [$type]; }' ], 'nonEmptyStringAfterLiteralCheck' => [ ' [ 'format("Y") === "2020") == true) { $a->format("d-m-Y"); }', ], 'getClassIsStatic' => [ ' [ ' [ 'c)) { // do something } else { /** @psalm-suppress MixedMethodCall */ $a->foo(); } }' ], 'getClassInterfaceCanBeClass' => [ ' [ 'next?->value; } function skipTwo(IntLinkedList $l) : ?int { return $l->next?->next?->value; }', [], [], '8.0' ], 'nullsafeMethodCall' => [ 'next; } } function skipOne(IntLinkedList $l) : ?int { return $l->getNext()?->value; } function skipTwo(IntLinkedList $l) : ?int { return $l->getNext()?->getNext()?->value; }', [], [], '8.0' ], 'allowBasicOrAssignment' => [ ' */ public function providerInvalidCodeParse(): iterable { return [ 'makeNonNullableNull' => [ ' 'TypeDoesNotContainNull', ], 'makeInstanceOfThingInElseif' => [ ' 5 ? new A(): new B(); if ($a instanceof A) { } elseif ($a instanceof C) { }', 'error_message' => 'TypeDoesNotContainType', ], 'functionValueIsNotType' => [ ' 'TypeDoesNotContainType', ], 'stringIsNotTnt' => [ ' 'TypeDoesNotContainType', ], 'stringIsNotNull' => [ ' 'TypeDoesNotContainNull', ], 'stringIsNotFalse' => [ ' 'TypeDoesNotContainType', ], 'typeTransformation' => [ ' 'TypeDoesNotContainType', ], 'dontEraseNullAfterLessThanCheck' => [ ' 'PossiblyNullOperand', ], 'dontEraseNullAfterGreaterThanCheck' => [ ' $a) { echo $a + 3; }', 'error_message' => 'PossiblyNullOperand', ], 'nonRedundantConditionGivenDocblockType' => [ ' 'TypeDoesNotContainType', ], 'lessSpecificArrayFields' => [ ' "name"]);', 'error_message' => 'InvalidArgument', ], 'intersectionIncorrect' => [ ' 'InvalidArgument', ], 'catchTypeMismatchInBinaryOp' => [ ' */ function getStrings(): array { return ["hello", "world", 50]; } $a = getStrings(); if (is_bool($a[0]) && $a[0]) {}', 'error_message' => 'DocblockTypeContradiction', ], 'preventWeakEqualityToObject' => [ ' 'TypeDoesNotContainType', ], 'properReconciliationInElseIf' => [ ' 'RedundantCondition', ], 'allRemovalOfStringWithIsScalar' => [ ' 'RedundantCondition', ], 'noRemovalOfStringWithIsScalar' => [ ' 'TypeDoesNotContainType', ], 'impossibleNullEquality' => [ ' 'TypeDoesNotContainNull', ], 'impossibleTrueEquality' => [ ' 'TypeDoesNotContainType', ], 'impossibleFalseEquality' => [ ' 'TypeDoesNotContainType', ], 'impossibleNumberEquality' => [ ' 'TypeDoesNotContainType', ], 'SKIPPED-noIntersectionOfArrayOrTraversable' => [ ' 'TypeDoesNotContainType', ], 'scalarToBoolContradiction' => [ ' 'TypeDoesNotContainType', ], 'noCrashWhenCastingArray' => [ ' 1, "b" => 2]; }', 'error_message' => 'InvalidReturnStatement', ], 'preventStrongEqualityScalarType' => [ ' 'TypeDoesNotContainType', ], 'preventYodaStrongEqualityScalarType' => [ ' 'TypeDoesNotContainType', ], 'classCannotNotBeSelf' => [ ' 'RedundantCondition', ], 'preventImpossibleComparisonToTrue' => [ ' 'DocblockTypeContradiction', ], 'preventAlwaysPossibleComparisonToTrue' => [ ' 'RedundantConditionGivenDocblockType', ], 'preventAlwaysImpossibleComparisonToFalse' => [ ' 'TypeDoesNotContainType', ], 'preventAlwaysPossibleComparisonToFalse' => [ ' 'RedundantCondition', ], 'nullCoalesceImpossible' => [ ' 'TypeDoesNotContainType' ], 'allowEmptyScalarAndNonEmptyScalarAssertions1' => [ ' 'RedundantCondition', ], 'allowEmptyScalarAndNonEmptyScalarAssertions2' => [ ' 'RedundantCondition', ], 'allowEmptyScalarAndNonEmptyScalarAssertions3' => [ ' 'RedundantCondition', ], 'allowEmptyScalarAndNonEmptyScalarAssertions4' => [ ' 'RedundantCondition', ], 'catchRedundantConditionOnBinaryOpForwards' => [ ' 'RedundantCondition', ], 'nonEmptyString' => [ ' 'ArgumentTypeCoercion', ], 'getClassCannotBeStringEquals' => [ ' 'TypeDoesNotContainType', ], ]; } }