From d450b40da8220efcbd11515e74753930bc10d8b3 Mon Sep 17 00:00:00 2001
From: Matthew Brown <github@muglug.com>
Date: Fri, 3 Feb 2023 21:08:16 -0500
Subject: [PATCH] Remove some logic that didn't need to be there (#9209)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Remove check to see what breaks

* Simplify following logic

* Add tests from @kkmuffme‘s branch

* Reduce scope of fix

* Clean up logic a little

* Add failing test

* Improvements

* Fix for non-Paradoxical Condition result
---
 .../issues/ParadoxicalCondition.md            |  8 +---
 src/Psalm/Internal/Algebra.php                | 18 ++++-----
 .../Statements/Block/IfElseAnalyzer.php       |  3 ++
 .../Expression/BinaryOp/AndAnalyzer.php       |  5 ++-
 tests/AssertAnnotationTest.php                | 16 ++++++++
 tests/TypeReconciliation/TypeAlgebraTest.php  | 39 ++++++++++++++++++-
 6 files changed, 69 insertions(+), 20 deletions(-)

diff --git a/docs/running_psalm/issues/ParadoxicalCondition.md b/docs/running_psalm/issues/ParadoxicalCondition.md
index 4d355f6cd..334b1b351 100644
--- a/docs/running_psalm/issues/ParadoxicalCondition.md
+++ b/docs/running_psalm/issues/ParadoxicalCondition.md
@@ -5,11 +5,7 @@ Emitted when a paradox is encountered in your programs logic that could not be c
 ```php
 <?php
 
-function foo($a, $b) : void {
-    if ($a && $b) {
-        echo "a";
-    } elseif ($a && $b) {
-        echo "cannot happen";
-    }
+function foo(string $input) : string {
+    return $input === "a" ? "bar" : ($input === "a" ? "foo" : "b");
 }
 ```
diff --git a/src/Psalm/Internal/Algebra.php b/src/Psalm/Internal/Algebra.php
index 09497121f..dae6f7e82 100644
--- a/src/Psalm/Internal/Algebra.php
+++ b/src/Psalm/Internal/Algebra.php
@@ -373,21 +373,17 @@ class Algebra
                     $things_that_can_be_said = [];
 
                     foreach ($possible_types as $assertion) {
-                        if ($assertion instanceof Falsy || !$assertion->isNegation()) {
-                            $things_that_can_be_said[(string)$assertion] = $assertion;
-                        }
+                        $things_that_can_be_said[(string)$assertion] = $assertion;
                     }
 
-                    if ($things_that_can_be_said && count($things_that_can_be_said) === count($possible_types)) {
-                        if ($clause->generated && count($possible_types) > 1) {
-                            unset($cond_referenced_var_ids[$var]);
-                        }
+                    if ($clause->generated && count($possible_types) > 1) {
+                        unset($cond_referenced_var_ids[$var]);
+                    }
 
-                        $truths[$var] = [array_values($things_that_can_be_said)];
+                    $truths[$var] = [array_values($things_that_can_be_said)];
 
-                        if ($creating_conditional_id && $creating_conditional_id === $clause->creating_conditional_id) {
-                            $active_truths[$var] = [array_values($things_that_can_be_said)];
-                        }
+                    if ($creating_conditional_id && $creating_conditional_id === $clause->creating_conditional_id) {
+                        $active_truths[$var] = [array_values($things_that_can_be_said)];
                     }
                 }
             }
diff --git a/src/Psalm/Internal/Analyzer/Statements/Block/IfElseAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Block/IfElseAnalyzer.php
index 1abf90ffc..a5a006a0b 100644
--- a/src/Psalm/Internal/Analyzer/Statements/Block/IfElseAnalyzer.php
+++ b/src/Psalm/Internal/Analyzer/Statements/Block/IfElseAnalyzer.php
@@ -272,6 +272,9 @@ class IfElseAnalyzer
         // this has to go on a separate line because the phar compactor messes with precedence
         $scope_to_clone = $if_scope->post_leaving_if_context ?? $post_if_context;
         $else_context = clone $scope_to_clone;
+        $else_context->clauses = Algebra::simplifyCNF(
+            [...$else_context->clauses, ...$if_scope->negated_clauses],
+        );
 
         // check the elseifs
         foreach ($stmt->elseifs as $elseif) {
diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp/AndAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp/AndAnalyzer.php
index 5732707b9..e5cca5b8a 100644
--- a/src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp/AndAnalyzer.php
+++ b/src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp/AndAnalyzer.php
@@ -151,7 +151,10 @@ class AndAnalyzer
             $right_context = clone $left_context;
         }
 
-        $partitioned_clauses = Context::removeReconciledClauses($left_clauses, $changed_var_ids);
+        $partitioned_clauses = Context::removeReconciledClauses(
+            [...$left_context->clauses, ...$left_clauses],
+            $changed_var_ids
+        );
 
         $right_context->clauses = $partitioned_clauses[0];
 
diff --git a/tests/AssertAnnotationTest.php b/tests/AssertAnnotationTest.php
index 8630d068a..f41c95769 100644
--- a/tests/AssertAnnotationTest.php
+++ b/tests/AssertAnnotationTest.php
@@ -2110,6 +2110,22 @@ class AssertAnnotationTest extends TestCase
                     consumeAOrB($abc);
                 ',
             ],
+            'assertDocblockTypeContradictionCorrectType' => [
+                'code' => '<?php
+                    function takesAnInt(int $i): void {}
+
+                    function takesAFloat(float $i): void {}
+
+                    $foo = rand() / 2;
+
+                    /** @psalm-suppress TypeDoesNotContainType */
+                    if (is_int($foo) || !is_float($foo)) {
+                        takesAnInt($foo);
+                        exit;
+                    }
+
+                    takesAFloat($foo);',
+            ],
         ];
     }
 
diff --git a/tests/TypeReconciliation/TypeAlgebraTest.php b/tests/TypeReconciliation/TypeAlgebraTest.php
index ac14bb665..75b0c6d9f 100644
--- a/tests/TypeReconciliation/TypeAlgebraTest.php
+++ b/tests/TypeReconciliation/TypeAlgebraTest.php
@@ -1211,6 +1211,40 @@ class TypeAlgebraTest extends TestCase
                 'ignored_issues' => [],
                 'php_version' => '8.0',
             ],
+            'subclassAfterNegation' => [
+                'code' => '<?php
+                    abstract class Base {}
+                    class A extends Base {}
+                    class AChild extends A {}
+                    class B extends Base {
+                        public string $s = "";
+                    }
+
+                    function foo(Base $base): void {
+                        if (!$base instanceof A || $base instanceof AChild) {
+                            if ($base instanceof B && rand(0, 1)) {
+                                echo $base->s;
+                            }
+                        }
+                    }'
+            ],
+            'subclassAfterElseifNegation' => [
+                'code' => '<?php
+                    abstract class Base {}
+                    class A extends Base {}
+                    class AChild extends A {}
+                    class B extends Base {
+                        public string $s = "";
+                    }
+
+                    function foo(Base $base): void {
+                        if ($base instanceof A && !($base instanceof AChild)) {
+                            // do nothing
+                        } elseif ($base instanceof B && rand(0, 1)) {
+                            echo $base->s;
+                        }
+                    }'
+            ],
         ];
     }
 
@@ -1347,14 +1381,15 @@ class TypeAlgebraTest extends TestCase
             ],
             'repeatedAndConditional' => [
                 'code' => '<?php
-                    function foo(string $a, string $b): void {
+                    class C {}
+                    function foo(?C $a, ?C $b): void {
                         if ($a && $b) {
                             echo "a";
                         } elseif ($a && $b) {
                             echo "b";
                         }
                     }',
-                'error_message' => 'ParadoxicalCondition',
+                'error_message' => 'TypeDoesNotContainType',
             ],
             'andConditionalAfterOrConditional' => [
                 'code' => '<?php