From 52aeeb290e57732c82c8f741396efcfda1c5a2d1 Mon Sep 17 00:00:00 2001
From: Matthew Brown <github@muglug.com>
Date: Thu, 20 Jan 2022 16:06:31 -0500
Subject: [PATCH 1/5] Use objects, not strings, for assertions

---
 phpcs.xml                                     |   4 +
 psalm.xml.dist                                |   6 +
 src/Psalm/Context.php                         |  12 +-
 src/Psalm/Internal/Algebra.php                | 113 ++-
 .../Internal/Algebra/FormulaGenerator.php     |  16 +-
 .../Internal/Analyzer/AlgebraAnalyzer.php     |   5 +-
 .../Statements/Expression/ArrayAnalyzer.php   |   2 +
 .../Statements/Expression/AssertionFinder.php | 677 ++++++++++--------
 .../Expression/AssignmentAnalyzer.php         |   3 +-
 .../Expression/BinaryOp/OrAnalyzer.php        |   3 +-
 .../Call/ArrayFunctionArgumentsAnalyzer.php   |   6 +-
 .../Expression/Call/FunctionCallAnalyzer.php  |  14 +-
 .../ExistingAtomicMethodCallAnalyzer.php      |  14 +-
 .../Expression/Call/NewAnalyzer.php           |   8 +-
 .../ExistingAtomicStaticCallAnalyzer.php      |  14 +-
 .../Statements/Expression/CallAnalyzer.php    | 244 +++----
 .../Expression/Fetch/ArrayFetchAnalyzer.php   |   3 +-
 .../Statements/Expression/TernaryAnalyzer.php |   3 +-
 src/Psalm/Internal/Clause.php                 |  66 +-
 .../Reflector/FunctionLikeDocblockScanner.php | 117 +--
 .../Reflector/FunctionLikeNodeScanner.php     |  29 +-
 .../Internal/Provider/NodeDataProvider.php    |  19 +-
 .../ArrayFilterReturnTypeProvider.php         |  12 +-
 .../ArrayMapReturnTypeProvider.php            |   5 +-
 src/Psalm/Internal/Scope/IfScope.php          |   3 +-
 .../Internal/Type/AssertionReconciler.php     | 512 ++++++-------
 .../Type/NegatedAssertionReconciler.php       | 212 +++---
 .../Type/SimpleAssertionReconciler.php        | 540 ++++++++------
 .../Type/SimpleNegatedAssertionReconciler.php | 368 +++++-----
 src/Psalm/Internal/Type/TypeCombination.php   |   3 +
 src/Psalm/Internal/Type/TypeCombiner.php      |  39 +
 src/Psalm/Internal/Type/TypeExpander.php      |   3 +-
 .../Internal/TypeVisitor/TypeChecker.php      |  11 -
 src/Psalm/IssueBuffer.php                     |   4 +-
 src/Psalm/Storage/Assertion.php               | 110 +--
 src/Psalm/Storage/Assertion/Any.php           |  25 +
 .../Assertion/ArrayKeyDoesNotExist.php        |  30 +
 .../Storage/Assertion/ArrayKeyExists.php      |  25 +
 .../Assertion/DoesNotHaveAtLeastCount.php     |  40 ++
 .../Assertion/DoesNotHaveExactCount.php       |  39 +
 .../Storage/Assertion/DoesNotHaveMethod.php   |  37 +
 src/Psalm/Storage/Assertion/Empty_.php        |  30 +
 src/Psalm/Storage/Assertion/Falsy.php         |  30 +
 src/Psalm/Storage/Assertion/HasArrayKey.php   |  33 +
 .../Storage/Assertion/HasAtLeastCount.php     |  34 +
 src/Psalm/Storage/Assertion/HasExactCount.php |  40 ++
 .../Assertion/HasIntOrStringArrayAccess.php   |  26 +
 src/Psalm/Storage/Assertion/HasMethod.php     |  32 +
 .../Assertion/HasStringArrayAccess.php        |  26 +
 src/Psalm/Storage/Assertion/InArray.php       |  33 +
 src/Psalm/Storage/Assertion/IsAClass.php      |  45 ++
 src/Psalm/Storage/Assertion/IsClassEqual.php  |  38 +
 .../Storage/Assertion/IsClassNotEqual.php     |  37 +
 src/Psalm/Storage/Assertion/IsCountable.php   |  25 +
 src/Psalm/Storage/Assertion/IsEqualIsset.php  |  31 +
 src/Psalm/Storage/Assertion/IsGreaterThan.php |  32 +
 .../Assertion/IsGreaterThanOrEqualTo.php      |  37 +
 src/Psalm/Storage/Assertion/IsIdentical.php   |  50 ++
 src/Psalm/Storage/Assertion/IsIsset.php       |  25 +
 src/Psalm/Storage/Assertion/IsLessThan.php    |  32 +
 .../Storage/Assertion/IsLessThanOrEqualTo.php |  37 +
 .../Storage/Assertion/IsLooselyEqual.php      |  50 ++
 src/Psalm/Storage/Assertion/IsNotAClass.php   |  44 ++
 .../Storage/Assertion/IsNotCountable.php      |  37 +
 .../Storage/Assertion/IsNotIdentical.php      |  55 ++
 src/Psalm/Storage/Assertion/IsNotIsset.php    |  30 +
 .../Storage/Assertion/IsNotLooselyEqual.php   |  55 ++
 .../Assertion/IsNotPositiveNumeric.php        |  30 +
 src/Psalm/Storage/Assertion/IsNotType.php     |  49 ++
 .../Storage/Assertion/IsPositiveNumeric.php   |  38 +
 src/Psalm/Storage/Assertion/IsType.php        |  44 ++
 .../Storage/Assertion/NestedAssertions.php    |  38 +
 src/Psalm/Storage/Assertion/NonEmpty.php      |  25 +
 .../Storage/Assertion/NonEmptyCountable.php   |  38 +
 src/Psalm/Storage/Assertion/NotInArray.php    |  38 +
 .../Storage/Assertion/NotNestedAssertions.php |  43 ++
 .../Assertion/NotNonEmptyCountable.php        |  30 +
 src/Psalm/Storage/Assertion/Truthy.php        |  25 +
 src/Psalm/Storage/FunctionLikeStorage.php     |   6 +-
 src/Psalm/Storage/Possibilities.php           |  71 ++
 src/Psalm/Type/Atomic.php                     |   8 -
 src/Psalm/Type/Atomic/TAssertionEmpty.php     |  38 -
 src/Psalm/Type/Atomic/TAssertionFalsy.php     |  43 --
 src/Psalm/Type/Atomic/TClassString.php        |  13 +-
 src/Psalm/Type/Atomic/TNonEmptyArray.php      |   7 +-
 src/Psalm/Type/Atomic/TNonEmptyList.php       |   7 +-
 src/Psalm/Type/Reconciler.php                 | 150 ++--
 src/Psalm/Type/Union.php                      |  16 -
 tests/AlgebraTest.php                         |  94 ++-
 tests/ArrayAccessTest.php                     |  69 ++
 tests/ClassLikeStringTest.php                 |  51 ++
 tests/ClassTest.php                           |   2 +-
 tests/FunctionCallTest.php                    |   7 +
 tests/IntRangeTest.php                        |   5 +-
 .../FunctionClassStringTemplateTest.php       |   2 +-
 tests/Template/FunctionTemplateAssertTest.php |  91 ++-
 tests/TypeReconciliation/EmptyTest.php        |  13 -
 tests/TypeReconciliation/ReconcilerTest.php   | 151 ++--
 .../RedundantConditionTest.php                |  28 +
 99 files changed, 3723 insertions(+), 1887 deletions(-)
 create mode 100644 src/Psalm/Storage/Assertion/Any.php
 create mode 100644 src/Psalm/Storage/Assertion/ArrayKeyDoesNotExist.php
 create mode 100644 src/Psalm/Storage/Assertion/ArrayKeyExists.php
 create mode 100644 src/Psalm/Storage/Assertion/DoesNotHaveAtLeastCount.php
 create mode 100644 src/Psalm/Storage/Assertion/DoesNotHaveExactCount.php
 create mode 100644 src/Psalm/Storage/Assertion/DoesNotHaveMethod.php
 create mode 100644 src/Psalm/Storage/Assertion/Empty_.php
 create mode 100644 src/Psalm/Storage/Assertion/Falsy.php
 create mode 100644 src/Psalm/Storage/Assertion/HasArrayKey.php
 create mode 100644 src/Psalm/Storage/Assertion/HasAtLeastCount.php
 create mode 100644 src/Psalm/Storage/Assertion/HasExactCount.php
 create mode 100644 src/Psalm/Storage/Assertion/HasIntOrStringArrayAccess.php
 create mode 100644 src/Psalm/Storage/Assertion/HasMethod.php
 create mode 100644 src/Psalm/Storage/Assertion/HasStringArrayAccess.php
 create mode 100644 src/Psalm/Storage/Assertion/InArray.php
 create mode 100644 src/Psalm/Storage/Assertion/IsAClass.php
 create mode 100644 src/Psalm/Storage/Assertion/IsClassEqual.php
 create mode 100644 src/Psalm/Storage/Assertion/IsClassNotEqual.php
 create mode 100644 src/Psalm/Storage/Assertion/IsCountable.php
 create mode 100644 src/Psalm/Storage/Assertion/IsEqualIsset.php
 create mode 100644 src/Psalm/Storage/Assertion/IsGreaterThan.php
 create mode 100644 src/Psalm/Storage/Assertion/IsGreaterThanOrEqualTo.php
 create mode 100644 src/Psalm/Storage/Assertion/IsIdentical.php
 create mode 100644 src/Psalm/Storage/Assertion/IsIsset.php
 create mode 100644 src/Psalm/Storage/Assertion/IsLessThan.php
 create mode 100644 src/Psalm/Storage/Assertion/IsLessThanOrEqualTo.php
 create mode 100644 src/Psalm/Storage/Assertion/IsLooselyEqual.php
 create mode 100644 src/Psalm/Storage/Assertion/IsNotAClass.php
 create mode 100644 src/Psalm/Storage/Assertion/IsNotCountable.php
 create mode 100644 src/Psalm/Storage/Assertion/IsNotIdentical.php
 create mode 100644 src/Psalm/Storage/Assertion/IsNotIsset.php
 create mode 100644 src/Psalm/Storage/Assertion/IsNotLooselyEqual.php
 create mode 100644 src/Psalm/Storage/Assertion/IsNotPositiveNumeric.php
 create mode 100644 src/Psalm/Storage/Assertion/IsNotType.php
 create mode 100644 src/Psalm/Storage/Assertion/IsPositiveNumeric.php
 create mode 100644 src/Psalm/Storage/Assertion/IsType.php
 create mode 100644 src/Psalm/Storage/Assertion/NestedAssertions.php
 create mode 100644 src/Psalm/Storage/Assertion/NonEmpty.php
 create mode 100644 src/Psalm/Storage/Assertion/NonEmptyCountable.php
 create mode 100644 src/Psalm/Storage/Assertion/NotInArray.php
 create mode 100644 src/Psalm/Storage/Assertion/NotNestedAssertions.php
 create mode 100644 src/Psalm/Storage/Assertion/NotNonEmptyCountable.php
 create mode 100644 src/Psalm/Storage/Assertion/Truthy.php
 create mode 100644 src/Psalm/Storage/Possibilities.php
 delete mode 100644 src/Psalm/Type/Atomic/TAssertionEmpty.php
 delete mode 100644 src/Psalm/Type/Atomic/TAssertionFalsy.php

diff --git a/phpcs.xml b/phpcs.xml
index b1f79cf0c44..7965983c1ee 100644
--- a/phpcs.xml
+++ b/phpcs.xml
@@ -110,6 +110,10 @@
         </properties>
     </rule>
 
+    <rule ref="Squiz.Classes.ValidClassName">
+        <exclude-pattern>src/Psalm/Storage/Assertion/Empty_.php</exclude-pattern>
+    </rule>
+
     <!--
         Handle imports from namespaces.
         https://github.com/slevomat/coding-standard#slevomatcodingstandardnamespacesreferenceusednamesonly-
diff --git a/psalm.xml.dist b/psalm.xml.dist
index e31c7ec9c29..bdb53be6ec9 100644
--- a/psalm.xml.dist
+++ b/psalm.xml.dist
@@ -102,6 +102,12 @@
             </errorLevel>
         </PossiblyUndefinedIntArrayOffset>
 
+        <ImpureMethodCall>
+            <errorLevel type="suppress">
+                <directory name="src/Psalm/Storage/Assertion"/>
+            </errorLevel>
+        </ImpureMethodCall>
+
         <MissingThrowsDocblock errorLevel="info"/>
 
         <PossiblyUnusedProperty>
diff --git a/src/Psalm/Context.php b/src/Psalm/Context.php
index 78b116ba034..42da5343fcc 100644
--- a/src/Psalm/Context.php
+++ b/src/Psalm/Context.php
@@ -564,7 +564,6 @@ public static function filterClauses(
         ?StatementsAnalyzer $statements_analyzer = null
     ): array {
         $new_type_string = $new_type ? $new_type->getId() : '';
-
         $clauses_to_keep = [];
 
         foreach ($clauses as $clause) {
@@ -578,8 +577,9 @@ public static function filterClauses(
                 }
             }
 
-            if (!isset($clause->possibilities[$remove_var_id]) ||
-                $clause->possibilities[$remove_var_id] === [$new_type_string]
+            if (!isset($clause->possibilities[$remove_var_id])
+                || (count($clause->possibilities[$remove_var_id]) === 1
+                    && (string)$clause->possibilities[$remove_var_id][0] === $new_type_string)
             ) {
                 $clauses_to_keep[] = $clause;
             } elseif ($statements_analyzer &&
@@ -590,15 +590,15 @@ public static function filterClauses(
 
                 // if the clause contains any possibilities that would be altered
                 // by the new type
-                foreach ($clause->possibilities[$remove_var_id] as $type) {
+                foreach ($clause->possibilities[$remove_var_id] as $assertion) {
                     // if we're negating a type, we generally don't need the clause anymore
-                    if ($type[0] === '!' && $type !== '!falsy' && $type !== '!empty') {
+                    if ($assertion->isNegation()) {
                         $type_changed = true;
                         break;
                     }
 
                     $result_type = AssertionReconciler::reconcile(
-                        $type,
+                        $assertion,
                         clone $new_type,
                         null,
                         $statements_analyzer,
diff --git a/src/Psalm/Internal/Algebra.php b/src/Psalm/Internal/Algebra.php
index d6ff1b7bde1..f59a49bcb65 100644
--- a/src/Psalm/Internal/Algebra.php
+++ b/src/Psalm/Internal/Algebra.php
@@ -3,6 +3,8 @@
 namespace Psalm\Internal;
 
 use Psalm\Exception\ComplicatedExpressionException;
+use Psalm\Storage\Assertion;
+use Psalm\Storage\Assertion\Falsy;
 use UnexpectedValueException;
 
 use function array_diff_key;
@@ -14,9 +16,7 @@
 use function array_unique;
 use function array_values;
 use function count;
-use function in_array;
 use function mt_rand;
-use function substr;
 
 /**
  * @internal
@@ -24,9 +24,9 @@
 class Algebra
 {
     /**
-     * @param array<string, non-empty-list<non-empty-list<string>>>  $all_types
+     * @param array<string, non-empty-list<non-empty-list<Assertion>>>  $all_types
      *
-     * @return array<string, non-empty-list<non-empty-list<string>>>
+     * @return array<string, non-empty-list<non-empty-list<Assertion>>>
      *
      * @psalm-pure
      */
@@ -35,9 +35,9 @@ public static function negateTypes(array $all_types): array
         return array_filter(
             array_map(
                 /**
-                 * @param  non-empty-list<non-empty-list<string>> $anded_types
+                 * @param  non-empty-list<non-empty-list<Assertion>> $anded_types
                  *
-                 * @return list<non-empty-list<string>>
+                 * @return list<non-empty-list<Assertion>>
                  */
                 function (array $anded_types): array {
                     if (count($anded_types) > 1) {
@@ -48,7 +48,7 @@ function (array $anded_types): array {
                                 return [];
                             }
 
-                            $new_anded_types[] = self::negateType($orred_types[0]);
+                            $new_anded_types[] = $orred_types[0]->getNegation();
                         }
 
                         return [$new_anded_types];
@@ -57,7 +57,7 @@ function (array $anded_types): array {
                     $new_orred_types = [];
 
                     foreach ($anded_types[0] as $orred_type) {
-                        $new_orred_types[] = [self::negateType($orred_type)];
+                        $new_orred_types[] = [$orred_type->getNegation()];
                     }
 
                     return $new_orred_types;
@@ -67,18 +67,6 @@ function (array $anded_types): array {
         );
     }
 
-    /**
-     * @psalm-pure
-     */
-    public static function negateType(string $type): string
-    {
-        if ($type === 'mixed') {
-            return $type;
-        }
-
-        return $type[0] === '!' ? substr($type, 1) : '!' . $type;
-    }
-
     /**
      * This is a very simple simplification heuristic
      * for CNF formulae.
@@ -152,14 +140,12 @@ public static function simplifyCNF(array $clauses): array
                         foreach ($clause_a->possibilities as $key => $a_possibilities) {
                             $b_possibilities = $clause_b->possibilities[$key];
 
-                            if ($a_possibilities === $b_possibilities) {
+                            if ($clause_a->possibility_strings[$key] === $clause_b->possibility_strings[$key]) {
                                 continue;
                             }
 
                             if (count($a_possibilities) === 1 && count($b_possibilities) === 1) {
-                                if ($a_possibilities[0] === '!' . $b_possibilities[0]
-                                    || $b_possibilities[0] === '!' . $a_possibilities[0]
-                                ) {
+                                if ($a_possibilities[0]->isNegationOf($b_possibilities[0])) {
                                     $opposing_keys[] = $key;
                                     continue;
                                 }
@@ -187,38 +173,45 @@ public static function simplifyCNF(array $clauses): array
 
             $clause_var = array_keys($clause_a->possibilities)[0];
             $only_type = array_pop(array_values($clause_a->possibilities)[0]);
-            $negated_clause_type = self::negateType($only_type);
+            $negated_clause_type = $only_type->getNegation();
+            $negated_clause_type_string = (string)$negated_clause_type;
 
             foreach ($cloned_clauses as $clause_b_hash => $clause_b) {
                 if ($clause_a === $clause_b || !$clause_b->reconcilable || $clause_b->wedge) {
                     continue;
                 }
 
-                if (isset($clause_b->possibilities[$clause_var]) &&
-                    in_array($negated_clause_type, $clause_b->possibilities[$clause_var], true)
-                ) {
-                    $clause_var_possibilities = array_values(
-                        array_filter(
-                            $clause_b->possibilities[$clause_var],
-                            fn(string $possible_type): bool => $possible_type !== $negated_clause_type
-                        )
-                    );
+                if (isset($clause_b->possibilities[$clause_var])) {
+                    $unmatched = [];
+                    $matched = [];
+
+                    foreach ($clause_b->possibilities[$clause_var] as $possible_type) {
+                        if ((string)$possible_type === $negated_clause_type_string) {
+                            $matched[] = $possible_type;
+                        } else {
+                            $unmatched[] = $possible_type;
+                        }
+                    }
 
-                    unset($cloned_clauses[$clause_b_hash]);
+                    if ($matched) {
+                        $clause_var_possibilities = $unmatched;
 
-                    if (!$clause_var_possibilities) {
-                        $updated_clause = $clause_b->removePossibilities($clause_var);
+                        unset($cloned_clauses[$clause_b_hash]);
+
+                        if (!$clause_var_possibilities) {
+                            $updated_clause = $clause_b->removePossibilities($clause_var);
+
+                            if ($updated_clause) {
+                                $cloned_clauses[$updated_clause->hash] = $updated_clause;
+                            }
+                        } else {
+                            $updated_clause = $clause_b->addPossibilities(
+                                $clause_var,
+                                $clause_var_possibilities
+                            );
 
-                        if ($updated_clause) {
                             $cloned_clauses[$updated_clause->hash] = $updated_clause;
                         }
-                    } else {
-                        $updated_clause = $clause_b->addPossibilities(
-                            $clause_var,
-                            $clause_var_possibilities
-                        );
-
-                        $cloned_clauses[$updated_clause->hash] = $updated_clause;
                     }
                 }
             }
@@ -257,9 +250,9 @@ public static function simplifyCNF(array $clauses): array
      *
      * @param  list<Clause>  $clauses
      * @param  array<string, bool> $cond_referenced_var_ids
-     * @param  array<string, array<int, array<int, string>>> $active_truths
+     * @param  array<string, array<int, array<int, Assertion>>> $active_truths
      *
-     * @return array<string, list<array<int, string>>>
+     * @return array<string, list<list<Assertion>>>
      */
     public static function getTruthsFromFormula(
         array $clauses,
@@ -303,23 +296,23 @@ public static function getTruthsFromFormula(
                     }
                 } else {
                     // if there's only one active clause, return all the non-negation clause members ORed together
-                    $things_that_can_be_said = array_filter(
-                        $possible_types,
-                        fn(string $possible_type): bool => $possible_type[0] !== '!'
-                    );
+                    $things_that_can_be_said = [];
 
-                    if ($things_that_can_be_said && count($things_that_can_be_said) === count($possible_types)) {
-                        $things_that_can_be_said = array_unique($things_that_can_be_said);
+                    foreach ($possible_types as $assertion) {
+                        if ($assertion instanceof Falsy || !$assertion->isNegation()) {
+                            $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]);
                         }
 
-                        /** @var array<int, string> $things_that_can_be_said */
-                        $truths[$var] = [$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] = [$things_that_can_be_said];
+                            $active_truths[$var] = [array_values($things_that_can_be_said)];
                         }
                     }
                 }
@@ -396,7 +389,7 @@ public static function groupImpossibilities(array $clauses): array
                                     $ith = $new_clause_possibilities[$var][$i];
                                     $jth = $new_clause_possibilities[$var][$j];
 
-                                    if ($ith === '!' . $jth || $jth === '!' . $ith) {
+                                    if ($ith->isNegationOf($jth)) {
                                         $removed_indexes[$i] = true;
                                         $removed_indexes[$j] = true;
                                     }
@@ -492,7 +485,7 @@ public static function combineOredClauses(
                     continue;
                 }
 
-                /** @var  array<string, non-empty-list<string>> */
+                /** @var  array<string, non-empty-list<Assertion>> */
                 $possibilities = [];
 
                 $can_reconcile = true;
@@ -533,9 +526,7 @@ public static function combineOredClauses(
 
                 foreach ($possibilities as $var_possibilities) {
                     if (count($var_possibilities) === 2) {
-                        if ($var_possibilities[0] === '!' . $var_possibilities[1]
-                            || $var_possibilities[1] === '!' . $var_possibilities[0]
-                        ) {
+                        if ($var_possibilities[0]->isNegationOf($var_possibilities[1])) {
                             continue 2;
                         }
                     }
diff --git a/src/Psalm/Internal/Algebra/FormulaGenerator.php b/src/Psalm/Internal/Algebra/FormulaGenerator.php
index 66ae5f7fb63..96cffed9139 100644
--- a/src/Psalm/Internal/Algebra/FormulaGenerator.php
+++ b/src/Psalm/Internal/Algebra/FormulaGenerator.php
@@ -12,11 +12,11 @@
 use Psalm\Node\Expr\BinaryOp\VirtualBooleanAnd;
 use Psalm\Node\Expr\BinaryOp\VirtualBooleanOr;
 use Psalm\Node\Expr\VirtualBooleanNot;
+use Psalm\Storage\Assertion\Truthy;
 
 use function array_merge;
 use function count;
 use function spl_object_id;
-use function strlen;
 use function substr;
 
 /**
@@ -165,11 +165,7 @@ public static function getFormula(
                                 spl_object_id($conditional->expr),
                                 false,
                                 true,
-                                $orred_types[0][0] === '='
-                                    || $orred_types[0][0] === '~'
-                                    || (strlen($orred_types[0]) > 1
-                                        && ($orred_types[0][1] === '='
-                                            || $orred_types[0][1] === '~')),
+                                $orred_types[0]->hasEquality(),
                                 $redefined ? [$var => true] : []
                             );
                         }
@@ -436,11 +432,7 @@ public static function getFormula(
                         $creating_object_id,
                         false,
                         true,
-                        $orred_types[0][0] === '='
-                            || $orred_types[0][0] === '~'
-                            || (strlen($orred_types[0]) > 1
-                                && ($orred_types[0][1] === '='
-                                    || $orred_types[0][1] === '~')),
+                        $orred_types[0]->hasEquality(),
                         $redefined ? [$var => true] : []
                     );
                 }
@@ -455,6 +447,6 @@ public static function getFormula(
         $conditional_ref = '*' . $conditional->getAttribute('startFilePos')
             . ':' . $conditional->getAttribute('endFilePos');
 
-        return [new Clause([$conditional_ref => ['!falsy']], $conditional_object_id, $creating_object_id)];
+        return [new Clause([$conditional_ref => [new Truthy()]], $conditional_object_id, $creating_object_id)];
     }
 }
diff --git a/src/Psalm/Internal/Analyzer/AlgebraAnalyzer.php b/src/Psalm/Internal/Analyzer/AlgebraAnalyzer.php
index 6a63b6e1189..813513decb4 100644
--- a/src/Psalm/Internal/Analyzer/AlgebraAnalyzer.php
+++ b/src/Psalm/Internal/Analyzer/AlgebraAnalyzer.php
@@ -10,11 +10,12 @@
 use Psalm\Issue\ParadoxicalCondition;
 use Psalm\Issue\RedundantCondition;
 use Psalm\IssueBuffer;
+use Psalm\Storage\Assertion\InArray;
+use Psalm\Storage\Assertion\NotInArray;
 
 use function array_intersect_key;
 use function count;
 use function implode;
-use function preg_match;
 
 /**
  * @internal
@@ -100,7 +101,7 @@ public static function checkForParadox(
                         break;
                     }
                     foreach ($keyed_possibilities as $possibility) {
-                        if (preg_match('@^!?in-array-@', $possibility)) {
+                        if ($possibility instanceof InArray || $possibility instanceof NotInArray) {
                             $negated_clause_2_contains_1_possibilities = false;
                             break;
                         }
diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/ArrayAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Expression/ArrayAnalyzer.php
index a3f7b191afc..af55952a1ea 100644
--- a/src/Psalm/Internal/Analyzer/Statements/Expression/ArrayAnalyzer.php
+++ b/src/Psalm/Internal/Analyzer/Statements/Expression/ArrayAnalyzer.php
@@ -147,6 +147,7 @@ public static function analyze(
                 $array_type = new TList($item_value_type ?? Type::getMixed());
             } else {
                 $array_type = new TNonEmptyList($item_value_type ?? Type::getMixed());
+                /** @psalm-suppress PossiblyInvalidPropertyAssignmentValue */
                 $array_type->count = count($array_creation_info->property_types);
             }
 
@@ -234,6 +235,7 @@ public static function analyze(
             $item_value_type ?? Type::getMixed(),
         ]);
 
+        /** @psalm-suppress PossiblyInvalidPropertyAssignmentValue */
         $array_type->count = count($array_creation_info->property_types);
 
         $stmt_type = new Union([
diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/AssertionFinder.php b/src/Psalm/Internal/Analyzer/Statements/Expression/AssertionFinder.php
index e58f437a653..feeab52442f 100644
--- a/src/Psalm/Internal/Analyzer/Statements/Expression/AssertionFinder.php
+++ b/src/Psalm/Internal/Analyzer/Statements/Expression/AssertionFinder.php
@@ -35,10 +35,44 @@
 use Psalm\Issue\TypeDoesNotContainType;
 use Psalm\Issue\UnevaluatedCode;
 use Psalm\IssueBuffer;
+use Psalm\Storage\Assertion;
+use Psalm\Storage\Assertion\ArrayKeyExists;
+use Psalm\Storage\Assertion\DoesNotHaveAtLeastCount;
+use Psalm\Storage\Assertion\DoesNotHaveExactCount;
+use Psalm\Storage\Assertion\Empty_;
+use Psalm\Storage\Assertion\Falsy;
+use Psalm\Storage\Assertion\HasAtLeastCount;
+use Psalm\Storage\Assertion\HasExactCount;
+use Psalm\Storage\Assertion\HasMethod;
+use Psalm\Storage\Assertion\InArray;
+use Psalm\Storage\Assertion\IsAClass;
+use Psalm\Storage\Assertion\IsClassEqual;
+use Psalm\Storage\Assertion\IsClassNotEqual;
+use Psalm\Storage\Assertion\IsCountable;
+use Psalm\Storage\Assertion\IsEqualIsset;
+use Psalm\Storage\Assertion\IsGreaterThan;
+use Psalm\Storage\Assertion\IsIdentical;
+use Psalm\Storage\Assertion\IsIsset;
+use Psalm\Storage\Assertion\IsLessThan;
+use Psalm\Storage\Assertion\IsLooselyEqual;
+use Psalm\Storage\Assertion\IsNotIdentical;
+use Psalm\Storage\Assertion\IsNotLooselyEqual;
+use Psalm\Storage\Assertion\IsNotType;
+use Psalm\Storage\Assertion\IsPositiveNumeric;
+use Psalm\Storage\Assertion\IsType;
+use Psalm\Storage\Assertion\NestedAssertions;
+use Psalm\Storage\Assertion\NonEmptyCountable;
+use Psalm\Storage\Assertion\NotNonEmptyCountable;
+use Psalm\Storage\Assertion\Truthy;
 use Psalm\Storage\PropertyStorage;
 use Psalm\Type;
+use Psalm\Type\Atomic;
 use Psalm\Type\Atomic\TArray;
+use Psalm\Type\Atomic\TCallable;
+use Psalm\Type\Atomic\TCallableString;
+use Psalm\Type\Atomic\TClassConstant;
 use Psalm\Type\Atomic\TClassString;
+use Psalm\Type\Atomic\TClosedResource;
 use Psalm\Type\Atomic\TEnumCase;
 use Psalm\Type\Atomic\TFalse;
 use Psalm\Type\Atomic\TKeyedArray;
@@ -50,7 +84,11 @@
 use Psalm\Type\Atomic\TMixed;
 use Psalm\Type\Atomic\TNamedObject;
 use Psalm\Type\Atomic\TNull;
+use Psalm\Type\Atomic\TObject;
+use Psalm\Type\Atomic\TResource;
+use Psalm\Type\Atomic\TTemplateParam;
 use Psalm\Type\Atomic\TTemplateParamClass;
+use Psalm\Type\Atomic\TTraitString;
 use Psalm\Type\Atomic\TTrue;
 use Psalm\Type\Reconciler;
 use Psalm\Type\Union;
@@ -61,19 +99,15 @@
 use function count;
 use function explode;
 use function in_array;
-use function is_callable;
 use function is_int;
 use function is_numeric;
 use function is_string;
-use function json_encode;
 use function sprintf;
 use function str_replace;
 use function strpos;
 use function strtolower;
 use function substr;
 
-use const JSON_THROW_ON_ERROR;
-
 /**
  * @internal
  * This class transform conditions in code into "assertions" that will be reconciled with the type already known of a
@@ -86,29 +120,10 @@ class AssertionFinder
     public const ASSIGNMENT_TO_RIGHT = 1;
     public const ASSIGNMENT_TO_LEFT = -1;
 
-    public const IS_TYPE_CHECKS = [
-        'is_string' => ['string', [Type::class, 'getString']],
-        'is_int' => ['int', [Type::class, 'getInt']],
-        'is_integer' => ['int', [Type::class, 'getInt']],
-        'is_long' => ['int', [Type::class, 'getInt']],
-        'is_bool' => ['bool', [Type::class, 'getBool']],
-        'is_resource' => ['resource', [Type::class, 'getResource']],
-        'is_object' => ['object', [Type::class, 'getObject']],
-        'array_is_list' => ['list', [Type::class, 'getList']],
-        'is_array' => ['array', [Type::class, 'getArray']],
-        'is_numeric' => ['numeric', [Type::class, 'getNumeric']],
-        'is_null' => ['null', [Type::class, 'getNull']],
-        'is_float' => ['float', [Type::class, 'getFloat']],
-        'is_real' => ['float', [Type::class, 'getFloat']],
-        'is_double' => ['float', [Type::class, 'getFloat']],
-        'is_scalar' => ['scalar', [Type::class, 'getScalar']],
-        'is_iterable' => ['iterable'],
-        'is_countable' => ['countable'],
-    ];
     /**
      * Gets all the type assertions in a conditional
      *
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     public static function scrapeAssertions(
         PhpParser\Node\Expr $conditional,
@@ -122,7 +137,7 @@ public static function scrapeAssertions(
         $if_types = [];
 
         if ($conditional instanceof PhpParser\Node\Expr\Instanceof_) {
-            return self::getInstanceofAssertions(
+            return self::getAndCheckInstanceofAssertions(
                 $conditional,
                 $codebase,
                 $source,
@@ -152,9 +167,9 @@ public static function scrapeAssertions(
 
             if ($var_name) {
                 if ($candidate_if_types) {
-                    $if_types[$var_name] = [['@' . json_encode($candidate_if_types[0], JSON_THROW_ON_ERROR)]];
+                    $if_types[$var_name] = [[new NestedAssertions($candidate_if_types[0])]];
                 } else {
-                    $if_types[$var_name] = [['!falsy']];
+                    $if_types[$var_name] = [[new Truthy()]];
                 }
             }
 
@@ -168,7 +183,7 @@ public static function scrapeAssertions(
         );
 
         if ($var_name) {
-            $if_types[$var_name] = [['!falsy']];
+            $if_types[$var_name] = [[new Truthy()]];
 
             if (!$conditional instanceof PhpParser\Node\Expr\MethodCall
                 && !$conditional instanceof PhpParser\Node\Expr\StaticCall
@@ -218,7 +233,7 @@ public static function scrapeAssertions(
             );
 
             if ($var_name) {
-                $if_types[$var_name] = [['!null']];
+                $if_types[$var_name] = [[new IsNotType(new TNull())]];
             }
 
             //we may throw a RedundantNullsafeMethodCall here in the future if $var_name is never null
@@ -283,9 +298,9 @@ public static function scrapeAssertions(
                     && !$var_type->isMixed()
                     && !$var_type->possibly_undefined
                 ) {
-                    $if_types[$var_name] = [['falsy']];
+                    $if_types[$var_name] = [[new Falsy()]];
                 } else {
-                    $if_types[$var_name] = [['empty']];
+                    $if_types[$var_name] = [[new Empty_()]];
                 }
             }
 
@@ -308,9 +323,9 @@ public static function scrapeAssertions(
                         && !$var_type->possibly_undefined
                         && !$var_type->possibly_undefined_from_try
                     ) {
-                        $if_types[$var_name] = [['!null']];
+                        $if_types[$var_name] = [[new IsNotType(new TNull())]];
                     } else {
-                        $if_types[$var_name] = [['isset']];
+                        $if_types[$var_name] = [[new IsIsset]];
                     }
                 } else {
                     // look for any variables we *can* use for an isset assertion
@@ -327,7 +342,7 @@ public static function scrapeAssertions(
                     }
 
                     if ($var_name) {
-                        $if_types[$var_name] = [['=isset']];
+                        $if_types[$var_name] = [[new IsEqualIsset]];
                     }
                 }
             }
@@ -340,7 +355,7 @@ public static function scrapeAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\Identical|PhpParser\Node\Expr\BinaryOp\Equal $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function scrapeEqualityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -467,10 +482,10 @@ private static function scrapeEqualityAssertions(
             }
 
             if ($var_name) {
-                if ($count !== 0) {
-                    $if_types[$var_name] = [['=has-exactly-' . $count]];
+                if ($count > 0) {
+                    $if_types[$var_name] = [[new HasExactCount($count)]];
                 } else {
-                    $if_types[$var_name] = [['!non-empty-countable']];
+                    $if_types[$var_name] = [[new NotNonEmptyCountable()]];
                 }
             }
 
@@ -522,12 +537,6 @@ private static function scrapeEqualityAssertions(
                 $intersection_type = Type::intersectUnionTypes($var_type, $other_type, $codebase);
 
                 if ($intersection_type !== null && $intersection_type->isSingle()) {
-                    try {
-                        $assertion = $intersection_type->getAssertionString();
-                    } catch (UnexpectedValueException $e) {
-                        // getAssertionString can't work if the Union has more than one type
-                        return [];
-                    }
                     $if_types = [];
 
                     $var_name_left = ExpressionIdentifier::getArrayVarId(
@@ -536,15 +545,10 @@ private static function scrapeEqualityAssertions(
                         $source
                     );
 
-                    try {
-                        $var_assertion_different = $var_type->getAssertionString() !== $assertion;
-                    } catch (UnexpectedValueException $e) {
-                        // if getAssertionString threw, it's different
-                        $var_assertion_different = true;
-                    }
+                    $var_assertion_different = $var_type->getId() !== $intersection_type->getId();
 
                     if ($var_name_left && $var_assertion_different) {
-                        $if_types[$var_name_left] = [['='.$assertion]];
+                        $if_types[$var_name_left] = [[new IsIdentical($intersection_type->getSingleAtomic())]];
                     }
 
                     $var_name_right = ExpressionIdentifier::getArrayVarId(
@@ -553,16 +557,10 @@ private static function scrapeEqualityAssertions(
                         $source
                     );
 
-
-                    try {
-                        $other_assertion_different = $other_type->getAssertionString() !== $assertion;
-                    } catch (UnexpectedValueException $e) {
-                        // if getAssertionString threw, it's different
-                        $other_assertion_different = true;
-                    }
+                    $other_assertion_different = $other_type->getId() !== $intersection_type->getId();
 
                     if ($var_name_right && $other_assertion_different) {
-                        $if_types[$var_name_right] = [['='.$assertion]];
+                        $if_types[$var_name_right] = [[new IsIdentical($intersection_type->getSingleAtomic())]];
                     }
 
                     return $if_types ? [$if_types] : [];
@@ -575,7 +573,7 @@ private static function scrapeEqualityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\NotIdentical|PhpParser\Node\Expr\BinaryOp\NotEqual $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function scrapeInequalityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -647,10 +645,10 @@ private static function scrapeInequalityAssertions(
             );
 
             if ($var_name) {
-                if ($count) {
-                    $if_types[$var_name] = [['!has-exactly-' . $count]];
+                if ($count > 0) {
+                    $if_types[$var_name] = [[new DoesNotHaveExactCount($count)]];
                 } else {
-                    $if_types[$var_name] = [['non-empty-countable']];
+                    $if_types[$var_name] = [[new NonEmptyCountable(true)]];
                 }
             }
 
@@ -722,7 +720,7 @@ private static function scrapeInequalityAssertions(
     }
 
     /**
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     public static function processFunctionCall(
         PhpParser\Node\Expr\FuncCall $expr,
@@ -760,7 +758,7 @@ public static function processFunctionCall(
             return self::getIsaAssertions($expr, $source, $this_class_name, $first_var_name);
         } elseif (self::hasCallableCheck($expr)) {
             if ($first_var_name) {
-                $if_types[$first_var_name] = [['callable']];
+                $if_types[$first_var_name] = [[new IsType(new TCallable())]];
             } elseif ($expr->getArgs()[0]->value instanceof PhpParser\Node\Expr\Array_
                 && isset($expr->getArgs()[0]->value->items[0], $expr->getArgs()[0]->value->items[1])
                 && $expr->getArgs()[0]->value->items[1]->value instanceof PhpParser\Node\Scalar\String_
@@ -772,30 +770,37 @@ public static function processFunctionCall(
                 );
                 if ($first_var_name_in_array_argument) {
                     $if_types[$first_var_name_in_array_argument] = [
-                        ['hasmethod-' . $expr->getArgs()[0]->value->items[1]->value->value]
+                        [new HasMethod($expr->getArgs()[0]->value->items[1]->value->value)]
                     ];
                 }
             }
         } elseif ($class_exists_check_type = self::hasClassExistsCheck($expr)) {
             if ($first_var_name) {
-                $class_string_type = ($class_exists_check_type === 1 ? 'loaded-' : '') . 'class-string';
-                $if_types[$first_var_name] = [[$class_string_type]];
+                $class_string_type = new TClassString();
+                if ($class_exists_check_type === 1) {
+                    $class_string_type->is_loaded = true;
+                    $if_types[$first_var_name] = [[new IsType($class_string_type)]];
+                } else {
+                    $if_types[$first_var_name] = [[new IsType($class_string_type)]];
+                }
             }
         } elseif ($class_exists_check_type = self::hasTraitExistsCheck($expr)) {
             if ($first_var_name) {
                 if ($class_exists_check_type === 2) {
-                    $if_types[$first_var_name] = [['trait-string']];
+                    $if_types[$first_var_name] = [[new IsType(new TTraitString())]];
                 } else {
-                    $if_types[$first_var_name] = [['=trait-string']];
+                    $if_types[$first_var_name] = [[new IsIdentical(new TTraitString())]];
                 }
             }
         } elseif (self::hasInterfaceExistsCheck($expr)) {
             if ($first_var_name) {
-                $if_types[$first_var_name] = [['interface-string']];
+                $class_string = new TClassString();
+                $class_string->is_interface = true;
+                $if_types[$first_var_name] = [[new IsType($class_string)]];
             }
         } elseif (self::hasFunctionExistsCheck($expr)) {
             if ($first_var_name) {
-                $if_types[$first_var_name] = [['callable-string']];
+                $if_types[$first_var_name] = [[new IsType(new TCallableString())]];
             }
         } elseif ($expr->name instanceof PhpParser\Node\Name
             && strtolower($expr->name->parts[0]) === 'method_exists'
@@ -803,7 +808,7 @@ public static function processFunctionCall(
             && $expr->getArgs()[1]->value instanceof PhpParser\Node\Scalar\String_
         ) {
             if ($first_var_name) {
-                $if_types[$first_var_name] = [['hasmethod-' . $expr->getArgs()[1]->value->value]];
+                $if_types[$first_var_name] = [[new HasMethod($expr->getArgs()[1]->value->value)]];
             }
         } elseif (self::hasInArrayCheck($expr) && $source instanceof StatementsAnalyzer) {
             return self::getInarrayAssertions($expr, $source, $first_var_name);
@@ -817,7 +822,7 @@ public static function processFunctionCall(
             );
         } elseif (self::hasNonEmptyCountCheck($expr)) {
             if ($first_var_name) {
-                $if_types[$first_var_name] = [['non-empty-countable']];
+                $if_types[$first_var_name] = [[new NonEmptyCountable(true)]];
             }
         } else {
             return self::processCustomAssertion($expr, $this_class_name, $source);
@@ -892,7 +897,7 @@ private static function processIrreconcilableFunctionCall(
     /**
      * @param  PhpParser\Node\Expr\FuncCall|PhpParser\Node\Expr\MethodCall|PhpParser\Node\Expr\StaticCall $expr
      *
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     protected static function processCustomAssertion(
         PhpParser\Node\Expr $expr,
@@ -926,22 +931,21 @@ protected static function processCustomAssertion(
 
                 $assertion = clone $assertion;
 
-                foreach ($assertion->rule as $i => $and_rules) {
-                    foreach ($and_rules as $j => $rule) {
-                        if (strpos($rule, 'class-constant(') === 0) {
-                            $codebase = $source->getCodebase();
-                            try {
-                                $assertion->rule[$i][$j] = TypeExpander::expandUnion(
-                                    $codebase,
-                                    Type::parseString(substr($rule, 15, -1)),
-                                    null,
-                                    null,
-                                    null
-                                )->getAssertionString();
-                            } catch (UnexpectedValueException $e) {
-                                continue;
-                            }
-                        }
+                foreach ($assertion->rule as $i => $rule) {
+                    $rule_type = $rule->getAtomicType();
+
+                    if ($rule_type instanceof TClassConstant) {
+                        $codebase = $source->getCodebase();
+
+                        $assertion->rule[$i]->setAtomicType(
+                            TypeExpander::expandAtomic(
+                                $codebase,
+                                $rule_type,
+                                null,
+                                null,
+                                null
+                            )[0]
+                        );
                     }
                 }
 
@@ -957,7 +961,7 @@ protected static function processCustomAssertion(
                     }
 
                     if ($var_name) {
-                        $if_types[$var_name] = [[$assertion->rule[0][0]]];
+                        $if_types[$var_name] = [[clone $assertion->rule[0]]];
                     }
                 } elseif ($assertion->var_id === '$this') {
                     if (!$expr instanceof PhpParser\Node\Expr\MethodCall) {
@@ -977,7 +981,7 @@ protected static function processCustomAssertion(
                     );
 
                     if ($var_id) {
-                        $if_types[$var_id] = [[$assertion->rule[0][0]]];
+                        $if_types[$var_id] = [[clone $assertion->rule[0]]];
                     }
                 } elseif (is_string($assertion->var_id)) {
                     $is_function = substr($assertion->var_id, -2) === '()';
@@ -1046,7 +1050,7 @@ protected static function processCustomAssertion(
                         );
                         continue;
                     }
-                    $if_types[$assertion_var_id] = [[$assertion->rule[0][0]]];
+                    $if_types[$assertion_var_id] = [[clone $assertion->rule[0]]];
                 }
 
                 if ($if_types) {
@@ -1061,23 +1065,21 @@ protected static function processCustomAssertion(
 
                 $assertion = clone $assertion;
 
-                foreach ($assertion->rule as $i => $and_rules) {
-                    foreach ($and_rules as $j => $rule) {
-                        if (strpos($rule, 'class-constant(') === 0) {
-                            $codebase = $source->getCodebase();
-
-                            try {
-                                $assertion->rule[$i][$j] = TypeExpander::expandUnion(
-                                    $codebase,
-                                    Type::parseString(substr($rule, 15, -1)),
-                                    null,
-                                    null,
-                                    null
-                                )->getAssertionString();
-                            } catch (UnexpectedValueException $e) {
-                                continue;
-                            }
-                        }
+                foreach ($assertion->rule as $i => $rule) {
+                    $rule_type = $rule->getAtomicType();
+
+                    if ($rule_type instanceof TClassConstant) {
+                        $codebase = $source->getCodebase();
+
+                        $assertion->rule[$i]->setAtomicType(
+                            TypeExpander::expandAtomic(
+                                $codebase,
+                                $rule_type,
+                                null,
+                                null,
+                                null
+                            )[0]
+                        );
                     }
                 }
 
@@ -1093,11 +1095,7 @@ protected static function processCustomAssertion(
                     }
 
                     if ($var_name) {
-                        if ('!' === $assertion->rule[0][0][0]) {
-                            $if_types[$var_name] = [[substr($assertion->rule[0][0], 1)]];
-                        } else {
-                            $if_types[$var_name] = [['!' . $assertion->rule[0][0]]];
-                        }
+                        $if_types[$var_name] = [[clone $assertion->rule[0]->getNegation()]];
                     }
                 } elseif ($assertion->var_id === '$this' && $expr instanceof PhpParser\Node\Expr\MethodCall) {
                     $var_id = ExpressionIdentifier::getArrayVarId(
@@ -1107,11 +1105,7 @@ protected static function processCustomAssertion(
                     );
 
                     if ($var_id) {
-                        if ('!' === $assertion->rule[0][0][0]) {
-                            $if_types[$var_id] = [[substr($assertion->rule[0][0], 1)]];
-                        } else {
-                            $if_types[$var_id] = [['!' . $assertion->rule[0][0]]];
-                        }
+                        $if_types[$var_id] = [[clone $assertion->rule[0]->getNegation()]];
                     }
                 } elseif (is_string($assertion->var_id)) {
                     $is_function = substr($assertion->var_id, -2) === '()';
@@ -1163,11 +1157,8 @@ protected static function processCustomAssertion(
                             }
                         }
 
-                        if ('!' === $assertion->rule[0][0][0]) {
-                            $rule = substr($assertion->rule[0][0], 1);
-                        } else {
-                            $rule = '!' . $assertion->rule[0][0];
-                        }
+                        $rule = clone $assertion->rule[0]->getNegation();
+
                         $assertion_var_id = str_replace($var_id, $arg_var_id, $assertion->var_id);
 
                         $if_types[$assertion_var_id] = [[$rule]];
@@ -1176,7 +1167,7 @@ protected static function processCustomAssertion(
                         if (strpos($var_id, 'self::') === 0) {
                             $var_id = $this_class_name.'::'.substr($var_id, 6);
                         }
-                        $if_types[$var_id] = [['!'.$assertion->rule[0][0]]];
+                        $if_types[$var_id] = [[clone $assertion->rule[0]->getNegation()]];
                     } else {
                         IssueBuffer::maybeAdd(
                             new InvalidDocblock(
@@ -1197,9 +1188,9 @@ protected static function processCustomAssertion(
     }
 
     /**
-     * @return list<string>
+     * @return list<Assertion>
      */
-    protected static function getInstanceOfTypes(
+    protected static function getInstanceOfAssertions(
         PhpParser\Node\Expr\Instanceof_ $stmt,
         ?string $this_class_name,
         FileSource $source
@@ -1216,16 +1207,19 @@ protected static function getInstanceOfTypes(
                     $instanceof_class = $codebase->classlikes->getUnAliasedName($instanceof_class);
                 }
 
-                return [$instanceof_class];
+                return [new IsType(new TNamedObject($instanceof_class))];
             }
 
             if ($this_class_name
                 && (in_array(strtolower($stmt->class->parts[0]), ['self', 'static'], true))) {
+                $named_object =new TNamedObject($this_class_name);
+
                 if ($stmt->class->parts[0] === 'static') {
-                    return ['=' . $this_class_name . '&static'];
+                    $named_object->is_static = true;
+                    return [new IsIdentical($named_object)];
                 }
 
-                return [$this_class_name];
+                return [new IsType($named_object)];
             }
         } elseif ($source instanceof StatementsAnalyzer) {
             $stmt_class_type = $source->node_data->getType($stmt->class);
@@ -1235,11 +1229,19 @@ protected static function getInstanceOfTypes(
 
                 foreach ($stmt_class_type->getAtomicTypes() as $atomic_type) {
                     if ($atomic_type instanceof TLiteralClassString) {
-                        $literal_class_strings[] = $atomic_type->value;
+                        $literal_class_strings[] = new IsType(new TNamedObject($atomic_type->value));
                     } elseif ($atomic_type instanceof TTemplateParamClass) {
-                        $literal_class_strings[] = $atomic_type->param_name;
+                        $literal_class_strings[] = new IsType(
+                            new TTemplateParam(
+                                $atomic_type->param_name,
+                                new Union([$atomic_type->as_type ?: new TObject()]),
+                                $atomic_type->defining_class
+                            )
+                        );
                     } elseif ($atomic_type instanceof TClassString && $atomic_type->as !== 'object') {
-                        $literal_class_strings[] = $atomic_type->as;
+                        $literal_class_strings[] = new IsType(
+                            $atomic_type->as_type ?: new TNamedObject($atomic_type->as)
+                        );
                     }
                 }
 
@@ -1853,8 +1855,46 @@ protected static function hasIsACheck(
         return false;
     }
 
+    private static function getIsAssertion(string $function_name): ?Assertion
+    {
+        switch ($function_name) {
+            case 'is_string':
+                return new IsType(new Atomic\TString());
+            case 'is_int':
+            case 'is_integer':
+                return new IsType(new Atomic\TInt());
+            case 'is_float':
+            case 'is_long':
+            case 'is_double':
+            case 'is_real':
+                return new IsType(new Atomic\TFloat());
+            case 'is_scalar':
+                return new IsType(new Atomic\TScalar());
+            case 'is_bool':
+                return new IsType(new Atomic\TBool());
+            case 'is_resource':
+                return new IsType(new Atomic\TResource());
+            case 'is_object':
+                return new IsType(new Atomic\TObject());
+            case 'array_is_list':
+                return new IsType(new Atomic\TList(Type::getMixed()));
+            case 'is_array':
+                return new IsType(new Atomic\TArray([Type::getArrayKey(), Type::getMixed()]));
+            case 'is_numeric':
+                return new IsType(new Atomic\TNumeric());
+            case 'is_null':
+                return new IsType(new Atomic\TNull());
+            case 'is_iterable':
+                return new IsType(new Atomic\TIterable());
+            case 'is_countable':
+                return new IsCountable();
+        }
+        
+        return null;
+    }
+
     /**
-     * @return array<string, non-empty-list<non-empty-list<string>>>
+     * @return array<string, non-empty-list<non-empty-list<Assertion>>>
      */
     private static function handleIsTypeCheck(
         ?Codebase $codebase,
@@ -1868,7 +1908,7 @@ private static function handleIsTypeCheck(
         $if_types = [];
         if ($stmt->name instanceof PhpParser\Node\Name
             && ($function_name = strtolower($stmt->name->parts[0]))
-            && isset(self::IS_TYPE_CHECKS[$function_name])
+            && ($assertion_type = self::getIsAssertion($function_name))
             && $source instanceof StatementsAnalyzer
             && ($source->getNamespace() === null //either the namespace is null
                 || $stmt->name instanceof PhpParser\Node\Name\FullyQualified //or we have a FQ to base function
@@ -1880,24 +1920,19 @@ private static function handleIsTypeCheck(
             )
         ) {
             if ($first_var_name) {
-                $if_types[$first_var_name] = [[self::IS_TYPE_CHECKS[$function_name][0]]];
+                $if_types[$first_var_name] = [[$assertion_type]];
             } elseif ($first_var_type
                 && $codebase
+                && $assertion_type instanceof IsType
             ) {
-                if (isset(self::IS_TYPE_CHECKS[$function_name][1])) {
-                    $callable = self::IS_TYPE_CHECKS[$function_name][1];
-                    assert(is_callable($callable));
-                    $type = $callable();
-                    assert($type instanceof Union);
-                    self::processIrreconcilableFunctionCall(
-                        $first_var_type,
-                        $type,
-                        $expr,
-                        $source,
-                        $codebase,
-                        $negate
-                    );
-                }
+                self::processIrreconcilableFunctionCall(
+                    $first_var_type,
+                    new Union([$assertion_type->type]),
+                    $expr,
+                    $source,
+                    $codebase,
+                    $negate
+                );
             }
         }
 
@@ -2001,7 +2036,7 @@ protected static function hasArrayKeyExistsCheck(PhpParser\Node\Expr\FuncCall $s
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\NotIdentical|PhpParser\Node\Expr\BinaryOp\NotEqual $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getNullInequalityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -2032,9 +2067,9 @@ private static function getNullInequalityAssertions(
             }
 
             if ($conditional instanceof PhpParser\Node\Expr\BinaryOp\NotIdentical) {
-                $if_types[$var_name] = [['!null']];
+                $if_types[$var_name] = [[new IsNotType(new TNull())]];
             } else {
-                $if_types[$var_name] = [['!falsy']];
+                $if_types[$var_name] = [[new Truthy()]];
             }
         }
 
@@ -2082,7 +2117,7 @@ private static function getNullInequalityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\NotIdentical|PhpParser\Node\Expr\BinaryOp\NotEqual $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getFalseInequalityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -2111,9 +2146,9 @@ private static function getFalseInequalityAssertions(
 
         if ($var_name) {
             if ($conditional instanceof PhpParser\Node\Expr\BinaryOp\NotIdentical) {
-                $if_types[$var_name] = [['!false']];
+                $if_types[$var_name] = [[new IsNotType(new TFalse())]];
             } else {
-                $if_types[$var_name] = [['!falsy']];
+                $if_types[$var_name] = [[new Truthy()]];
             }
 
             $if_types = [$if_types];
@@ -2200,7 +2235,7 @@ private static function getFalseInequalityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\NotIdentical|PhpParser\Node\Expr\BinaryOp\NotEqual $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getTrueInequalityAssertions(
         int $true_position,
@@ -2238,9 +2273,9 @@ private static function getTrueInequalityAssertions(
 
             if ($var_name) {
                 if ($conditional instanceof PhpParser\Node\Expr\BinaryOp\NotIdentical) {
-                    $if_types[$var_name] = [['!true']];
+                    $if_types[$var_name] = [[new IsNotType(new TTrue())]];
                 } else {
-                    $if_types[$var_name] = [['falsy']];
+                    $if_types[$var_name] = [[new Falsy()]];
                 }
 
                 $notif_types = [];
@@ -2323,7 +2358,7 @@ private static function getTrueInequalityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\NotIdentical|PhpParser\Node\Expr\BinaryOp\NotEqual $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getEmptyInequalityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -2350,9 +2385,9 @@ private static function getEmptyInequalityAssertions(
 
         if ($var_name) {
             if ($conditional instanceof PhpParser\Node\Expr\BinaryOp\NotIdentical) {
-                $if_types[$var_name] = [['non-empty-countable']];
+                $if_types[$var_name] = [[new NonEmptyCountable(true)]];
             } else {
-                $if_types[$var_name] = [['!falsy']];
+                $if_types[$var_name] = [[new Truthy()]];
             }
         }
 
@@ -2400,7 +2435,7 @@ private static function getEmptyInequalityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\NotIdentical|PhpParser\Node\Expr\BinaryOp\NotEqual $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getGettypeInequalityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -2450,13 +2485,13 @@ private static function getGettypeInequalityAssertions(
         } else {
             if ($var_name && $var_type) {
                 if ($var_type === 'class@anonymous') {
-                    $if_types[$var_name] = [['!=object']];
+                    $if_types[$var_name] = [[new IsNotIdentical(new TObject())]];
                 } elseif ($var_type === 'resource (closed)') {
-                    $if_types[$var_name] = [['!closed-resource']];
+                    $if_types[$var_name] = [[new IsNotType(new TClosedResource())]];
                 } elseif (strpos($var_type, 'resource (') === 0) {
-                    $if_types[$var_name] = [['!=resource']];
+                    $if_types[$var_name] = [[new IsNotIdentical(new TResource())]];
                 } else {
-                    $if_types[$var_name] = [['!' . $var_type]];
+                    $if_types[$var_name] = [[new IsNotType(Atomic::create($var_type))]];
                 }
             }
         }
@@ -2466,7 +2501,7 @@ private static function getGettypeInequalityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\NotIdentical|PhpParser\Node\Expr\BinaryOp\NotEqual $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getGetdebugTypeInequalityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -2508,13 +2543,13 @@ private static function getGetdebugTypeInequalityAssertions(
 
         if ($var_name && $var_type) {
             if ($var_type === 'class@anonymous') {
-                $if_types[$var_name] = [['!=object']];
+                $if_types[$var_name] = [[new IsNotIdentical(new TObject())]];
             } elseif ($var_type === 'resource (closed)') {
-                $if_types[$var_name] = [['!closed-resource']];
+                $if_types[$var_name] = [[new IsNotType(new TClosedResource())]];
             } elseif (strpos($var_type, 'resource (') === 0) {
-                $if_types[$var_name] = [['!=resource']];
+                $if_types[$var_name] = [[new IsNotIdentical(new TResource())]];
             } else {
-                $if_types[$var_name] = [['!' . $var_type]];
+                $if_types[$var_name] = [[new IsNotType(Atomic::create($var_type))]];
             }
         }
 
@@ -2523,7 +2558,7 @@ private static function getGetdebugTypeInequalityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\NotIdentical|PhpParser\Node\Expr\BinaryOp\NotEqual $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getGetclassInequalityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -2582,7 +2617,13 @@ private static function getGetclassInequalityAssertions(
             if ($type && $var_name) {
                 foreach ($type->getAtomicTypes() as $type_part) {
                     if ($type_part instanceof TTemplateParamClass) {
-                        $if_types[$var_name] = [['!=' . $type_part->param_name]];
+                        $if_types[$var_name] = [[new IsNotIdentical(
+                            new TTemplateParam(
+                                $type_part->param_name,
+                                new Union([$type_part->as_type ?: new TObject()]),
+                                $type_part->defining_class
+                            )
+                        )]];
                     }
                 }
             }
@@ -2603,7 +2644,7 @@ private static function getGetclassInequalityAssertions(
             // fall through
         } else {
             if ($var_name && $var_type) {
-                $if_types[$var_name] = [['!=getclass-' . $var_type]];
+                $if_types[$var_name] = [[new IsClassNotEqual($var_type)]];
             }
         }
 
@@ -2612,7 +2653,7 @@ private static function getGetclassInequalityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\NotIdentical|PhpParser\Node\Expr\BinaryOp\NotEqual $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getTypedValueInequalityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -2649,27 +2690,21 @@ private static function getTypedValueInequalityAssertions(
             if ($var_name) {
                 $not_identical = $conditional instanceof PhpParser\Node\Expr\BinaryOp\NotIdentical
                     || ($other_type
-                        && (($var_type->isString() && $other_type->isString())
-                            || ($var_type->isInt() && $other_type->isInt())
-                            || ($var_type->isFloat() && $other_type->isFloat())
-                        )
+                        && (($var_type->isInt() && $other_type->isInt())
+                            || ($var_type->isFloat() && $other_type->isFloat()))
                     );
 
-                try {
-                    $assertion = $var_type->getAssertionString();
-                } catch (UnexpectedValueException $e) {
-                    $assertion = null;
-                }
+                $anded_types = [];
 
-                if ($not_identical) {
-                    if ($assertion) {
-                        $if_types[$var_name] = [['!=' . $assertion]];
-                    }
-                } else {
-                    if ($assertion) {
-                        $if_types[$var_name] = [['!~' . $assertion]];
+                foreach ($var_type->getAtomicTypes() as $atomic_var_type) {
+                    if ($not_identical) {
+                        $anded_types[] = [new IsNotIdentical($atomic_var_type)];
+                    } else {
+                        $anded_types[] = [new IsNotLooselyEqual($atomic_var_type)];
                     }
                 }
+
+                $if_types[$var_name] = $anded_types;
             }
 
             if ($codebase
@@ -2692,7 +2727,7 @@ private static function getTypedValueInequalityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\Identical|PhpParser\Node\Expr\BinaryOp\Equal $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getNullEqualityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -2723,9 +2758,9 @@ private static function getNullEqualityAssertions(
 
         if ($var_name) {
             if ($conditional instanceof PhpParser\Node\Expr\BinaryOp\Identical) {
-                $if_types[$var_name] = [['null']];
+                $if_types[$var_name] = [[new IsType(new TNull())]];
             } else {
-                $if_types[$var_name] = [['falsy']];
+                $if_types[$var_name] = [[new Falsy()]];
             }
         }
 
@@ -2772,7 +2807,7 @@ private static function getNullEqualityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\Identical|PhpParser\Node\Expr\BinaryOp\Equal $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getTrueEqualityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -2809,9 +2844,9 @@ private static function getTrueEqualityAssertions(
 
             if ($var_name) {
                 if ($conditional instanceof PhpParser\Node\Expr\BinaryOp\Identical) {
-                    $if_types[$var_name] = [['true']];
+                    $if_types[$var_name] = [[new IsType(new TTrue())]];
                 } else {
-                    $if_types[$var_name] = [['!falsy']];
+                    $if_types[$var_name] = [[new Truthy()]];
                 }
 
                 $if_types = [$if_types];
@@ -2896,7 +2931,7 @@ private static function getTrueEqualityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\Identical|PhpParser\Node\Expr\BinaryOp\Equal $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getFalseEqualityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -2934,9 +2969,9 @@ private static function getFalseEqualityAssertions(
 
             if ($var_name) {
                 if ($conditional instanceof PhpParser\Node\Expr\BinaryOp\Identical) {
-                    $if_types[$var_name] = [['false']];
+                    $if_types[$var_name] = [[new IsType(new TFalse())]];
                 } else {
-                    $if_types[$var_name] = [['falsy']];
+                    $if_types[$var_name] = [[new Falsy()]];
                 }
 
                 $notif_types = [];
@@ -3015,7 +3050,7 @@ private static function getFalseEqualityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\Identical|PhpParser\Node\Expr\BinaryOp\Equal $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getEmptyArrayEqualityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -3042,9 +3077,9 @@ private static function getEmptyArrayEqualityAssertions(
 
         if ($var_name) {
             if ($conditional instanceof PhpParser\Node\Expr\BinaryOp\Identical) {
-                $if_types[$var_name] = [['!non-empty-countable']];
+                $if_types[$var_name] = [[new NotNonEmptyCountable()]];
             } else {
-                $if_types[$var_name] = [['falsy']];
+                $if_types[$var_name] = [[new Falsy()]];
             }
         }
 
@@ -3087,7 +3122,7 @@ private static function getEmptyArrayEqualityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\Identical|PhpParser\Node\Expr\BinaryOp\Equal $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getGettypeEqualityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -3127,13 +3162,19 @@ private static function getGettypeEqualityAssertions(
         } else {
             if ($var_name && $var_type) {
                 if ($var_type === 'class@anonymous') {
-                    $if_types[$var_name] = [['=object']];
+                    $if_types[$var_name] = [[new IsIdentical(new TObject())]];
                 } elseif ($var_type === 'resource (closed)') {
-                    $if_types[$var_name] = [['closed-resource']];
+                    $if_types[$var_name] = [[new IsType(new TClosedResource())]];
                 } elseif (strpos($var_type, 'resource (') === 0) {
-                    $if_types[$var_name] = [['=resource']];
+                    $if_types[$var_name] = [[new IsIdentical(new TResource())]];
+                } elseif ($var_type === 'integer') {
+                    $if_types[$var_name] = [[new IsType(new Atomic\TInt())]];
+                } elseif ($var_type === 'double') {
+                    $if_types[$var_name] = [[new IsType(new Atomic\TFloat())]];
+                } elseif ($var_type === 'boolean') {
+                    $if_types[$var_name] = [[new IsType(new Atomic\TBool())]];
                 } else {
-                    $if_types[$var_name] = [[$var_type]];
+                    $if_types[$var_name] = [[new IsType(Atomic::create($var_type))]];
                 }
             }
         }
@@ -3143,7 +3184,7 @@ private static function getGettypeEqualityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\Identical|PhpParser\Node\Expr\BinaryOp\Equal $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getGetdebugtypeEqualityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -3185,13 +3226,19 @@ private static function getGetdebugtypeEqualityAssertions(
 
         if ($var_name && $var_type) {
             if ($var_type === 'class@anonymous') {
-                $if_types[$var_name] = [['=object']];
+                $if_types[$var_name] = [[new IsIdentical(new TObject())]];
             } elseif ($var_type === 'resource (closed)') {
-                $if_types[$var_name] = [['closed-resource']];
+                $if_types[$var_name] = [[new IsType(new TClosedResource())]];
             } elseif (strpos($var_type, 'resource (') === 0) {
-                $if_types[$var_name] = [['=resource']];
+                $if_types[$var_name] = [[new IsIdentical(new TResource())]];
+            } elseif ($var_type === 'integer') {
+                $if_types[$var_name] = [[new IsType(new Atomic\TInt())]];
+            } elseif ($var_type === 'double') {
+                $if_types[$var_name] = [[new IsType(new Atomic\TFloat())]];
+            } elseif ($var_type === 'boolean') {
+                $if_types[$var_name] = [[new IsType(new Atomic\TBool())]];
             } else {
-                $if_types[$var_name] = [[$var_type]];
+                $if_types[$var_name] = [[new IsType(Atomic::create($var_type))]];
             }
         }
 
@@ -3200,7 +3247,7 @@ private static function getGetdebugtypeEqualityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\Identical|PhpParser\Node\Expr\BinaryOp\Equal $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getGetclassEqualityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -3268,7 +3315,7 @@ private static function getGetclassEqualityAssertions(
             }
 
             if ($var_name && $var_type) {
-                $if_types[$var_name] = [['=getclass-' . $var_type]];
+                $if_types[$var_name] = [[new IsClassEqual($var_type)]];
             }
         } else {
             $type = $source->node_data->getType($whichclass_expr);
@@ -3276,7 +3323,15 @@ private static function getGetclassEqualityAssertions(
             if ($type && $var_name) {
                 foreach ($type->getAtomicTypes() as $type_part) {
                     if ($type_part instanceof TTemplateParamClass) {
-                        $if_types[$var_name] = [['=' . $type_part->param_name]];
+                        $if_types[$var_name] = [[
+                            new IsIdentical(new TTemplateParam(
+                                $type_part->param_name,
+                                $type_part->as_type
+                                    ? new Union([clone $type_part->as_type])
+                                    : Type::getObject(),
+                                $type_part->defining_class
+                            ))
+                        ]];
                     }
                 }
             }
@@ -3287,7 +3342,7 @@ private static function getGetclassEqualityAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\Identical|PhpParser\Node\Expr\BinaryOp\Equal $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getTypedValueEqualityAssertions(
         PhpParser\Node\Expr\BinaryOp $conditional,
@@ -3341,51 +3396,36 @@ private static function getTypedValueEqualityAssertions(
                     )
                 );
 
-            if ($identical) {
-                try {
-                    $assertion = $var_type->getAssertionString(true);
-                } catch (UnexpectedValueException $e) {
-                    $assertion = null;
-                }
+            if (count($var_type->getAtomicTypes()) === 1) {
+                $orred_types = [];
 
-                if ($assertion) {
-                    $if_types[$var_name] = [['=' . $assertion]];
-                }
-            } else {
-                try {
-                    $assertion = $var_type->getAssertionString();
-                } catch (UnexpectedValueException $e) {
-                    $assertion = null;
+                foreach ($var_type->getAtomicTypes() as $atomic_var_type) {
+                    if ($identical) {
+                        $orred_types[] = new IsIdentical($atomic_var_type);
+                    } else {
+                        $orred_types[] = new IsLooselyEqual($atomic_var_type);
+                    }
                 }
 
-                if ($assertion) {
-                    $if_types[$var_name] = [['~' . $assertion]];
-                }
+                $if_types[$var_name] = [$orred_types];
             }
 
+            if ($other_var_name
+                && $other_type
+                && !$other_type->isMixed()
+                && count($other_type->getAtomicTypes()) === 1
+            ) {
+                $orred_types = [];
 
-            if ($other_var_name && $other_type && !$other_type->isMixed()) {
-                if ($identical) {
-                    try {
-                        $assertion = $other_type->getAssertionString(true);
-                    } catch (UnexpectedValueException $e) {
-                        $assertion = null;
-                    }
-
-                    if ($assertion) {
-                        $if_types[$other_var_name] = [['=' . $assertion]];
-                    }
-                } else {
-                    try {
-                        $assertion = $other_type->getAssertionString();
-                    } catch (UnexpectedValueException $e) {
-                        $assertion = null;
-                    }
-
-                    if ($assertion) {
-                        $if_types[$other_var_name] = [['~' . $assertion]];
+                foreach ($other_type->getAtomicTypes() as $atomic_other_type) {
+                    if ($identical) {
+                        $orred_types[] = new IsIdentical($atomic_other_type);
+                    } else {
+                        $orred_types[] = new IsLooselyEqual($atomic_other_type);
                     }
                 }
+
+                $if_types[$other_var_name] = [$orred_types];
             }
         }
 
@@ -3413,7 +3453,7 @@ private static function getTypedValueEqualityAssertions(
     /**
      * @param PhpParser\Node\Expr\FuncCall $expr
      * @param StatementsAnalyzer $source
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getIsaAssertions(
         PhpParser\Node\Expr\FuncCall $expr,
@@ -3451,8 +3491,6 @@ private static function getIsaAssertions(
                     : 'false';
             }
 
-            $is_a_prefix = $third_arg_value === 'true' ? 'isa-string-' : 'isa-';
-
             if (($first_arg_type = $source->node_data->getType($first_arg))
                 && $first_arg_type->isSingleStringLiteral()
                 && $source->getSource()->getSource() instanceof TraitAnalyzer
@@ -3466,7 +3504,8 @@ private static function getIsaAssertions(
                         $fq_class_name = substr($fq_class_name, 1);
                     }
 
-                    $if_types[$first_var_name] = [[$is_a_prefix . $fq_class_name]];
+                    $obj = new TNamedObject($fq_class_name);
+                    $if_types[$first_var_name] = [[new IsAClass($obj, $third_arg_value === 'true')]];
                 } elseif ($second_arg instanceof PhpParser\Node\Expr\ClassConstFetch
                     && $second_arg->class instanceof PhpParser\Node\Name
                     && $second_arg->name instanceof PhpParser\Node\Identifier
@@ -3476,22 +3515,26 @@ private static function getIsaAssertions(
 
                     if ($class_node->parts === ['static']) {
                         if ($this_class_name) {
-                            $if_types[$first_var_name] = [[$is_a_prefix . $this_class_name . '&static']];
+                            $object = new TNamedObject($this_class_name);
+                            $object->is_static = true;
+
+                            $if_types[$first_var_name] = [[new IsAClass($object, $third_arg_value === 'true')]];
                         }
                     } elseif ($class_node->parts === ['self']) {
                         if ($this_class_name) {
-                            $if_types[$first_var_name] = [[$is_a_prefix . $this_class_name]];
+                            $object = new TNamedObject($this_class_name);
+                            $if_types[$first_var_name] = [[new IsAClass($object, $third_arg_value === 'true')]];
                         }
                     } elseif ($class_node->parts === ['parent']) {
                         // do nothing
                     } else {
-                        $if_types[$first_var_name] = [[
-                            $is_a_prefix
-                            . ClassLikeAnalyzer::getFQCLNFromNameObject(
+                        $object = new TNamedObject(
+                            ClassLikeAnalyzer::getFQCLNFromNameObject(
                                 $class_node,
                                 $source->getAliases()
                             )
-                        ]];
+                        );
+                        $if_types[$first_var_name] = [[new IsAClass($object, $third_arg_value === 'true')]];
                     }
                 } elseif (($second_arg_type = $source->node_data->getType($second_arg))
                     && $second_arg_type->hasString()
@@ -3500,7 +3543,7 @@ private static function getIsaAssertions(
 
                     foreach ($second_arg_type->getAtomicTypes() as $second_arg_atomic_type) {
                         if ($second_arg_atomic_type instanceof TTemplateParamClass) {
-                            $vals[] = [$is_a_prefix . $second_arg_atomic_type->param_name];
+                            $vals[] = [new IsAClass($second_arg_atomic_type, $third_arg_value === 'true')];
                         }
                     }
 
@@ -3518,7 +3561,7 @@ private static function getIsaAssertions(
      * @param PhpParser\Node\Expr\FuncCall $expr
      * @param StatementsAnalyzer $source
      * @param string|null $first_var_name
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getInarrayAssertions(
         PhpParser\Node\Expr\FuncCall $expr,
@@ -3560,7 +3603,7 @@ private static function getInarrayAssertions(
                         //
                         // NOTE: the negation of the negation is the original assertion.
                         if ($value_type->getId() !== '' && !$value_type->isMixed() && !$value_type->hasTemplate()) {
-                            $assertions[] = 'in-array-' . $value_type->getId();
+                            $assertions[] = new InArray($value_type);
                         }
                     } else {
                         foreach ($value_type->getAtomicTypes() as $atomic_value_type) {
@@ -3569,17 +3612,17 @@ private static function getInarrayAssertions(
                                 || $atomic_value_type instanceof TLiteralFloat
                                 || $atomic_value_type instanceof TEnumCase
                             ) {
-                                $assertions[] = '=' . $atomic_value_type->getAssertionString();
+                                $assertions[] = new IsIdentical($atomic_value_type);
                             } elseif ($atomic_value_type instanceof TFalse
                                 || $atomic_value_type instanceof TTrue
                                 || $atomic_value_type instanceof TNull
                             ) {
-                                $assertions[] = $atomic_value_type->getAssertionString();
+                                $assertions[] = new IsType($atomic_value_type);
                             } elseif (!$atomic_value_type instanceof TMixed) {
                                 // mixed doesn't tell us anything and can be omitted.
                                 //
                                 // For the meaning of in-array, see the above comment.
-                                $assertions[] = 'in-array-' . $value_type->getId();
+                                $assertions[] = new InArray($value_type);
                             }
                         }
                     }
@@ -3598,7 +3641,7 @@ private static function getInarrayAssertions(
      * @param PhpParser\Node\Expr\FuncCall $expr
      * @param Union|null $first_var_type
      * @param string|null $first_var_name
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getArrayKeyExistsAssertions(
         PhpParser\Node\Expr\FuncCall $expr,
@@ -3644,11 +3687,11 @@ private static function getArrayKeyExistsAssertions(
 
                     if ($key_type->allStringLiterals() && !$key_type->possibly_undefined) {
                         foreach ($key_type->getLiteralStrings() as $array_literal_type) {
-                            $literal_assertions[] = '=' . $array_literal_type->getAssertionString();
+                            $literal_assertions[] = new IsIdentical($array_literal_type);
                         }
                     } elseif ($key_type->allIntLiterals() && !$key_type->possibly_undefined) {
                         foreach ($key_type->getLiteralInts() as $array_literal_type) {
-                            $literal_assertions[] = '~' . $array_literal_type->getAssertionString();
+                            $literal_assertions[] = new IsLooselyEqual($array_literal_type);
                         }
                     }
                 }
@@ -3703,10 +3746,10 @@ private static function getArrayKeyExistsAssertions(
                     && ($first_var_type = $source->node_data->getType($expr->getArgs()[0]->value))
                 ) {
                     foreach ($first_var_type->getLiteralStrings() as $array_literal_type) {
-                        $if_types[$array_root . "['" . $array_literal_type->value . "']"] = [['array-key-exists']];
+                        $if_types[$array_root . "['" . $array_literal_type->value . "']"] = [[new ArrayKeyExists()]];
                     }
                     foreach ($first_var_type->getLiteralInts() as $array_literal_type) {
-                        $if_types[$array_root . "[" . $array_literal_type->value . "]"] = [['array-key-exists']];
+                        $if_types[$array_root . "[" . $array_literal_type->value . "]"] = [[new ArrayKeyExists()]];
                     }
                 }
 
@@ -3714,7 +3757,7 @@ private static function getArrayKeyExistsAssertions(
                     && !strpos($first_var_name, '->')
                     && !strpos($first_var_name, '[')
                 ) {
-                    $if_types[$array_root . '[' . $first_var_name . ']'] = [['array-key-exists']];
+                    $if_types[$array_root . '[' . $first_var_name . ']'] = [[new ArrayKeyExists()]];
                 }
             }
         }
@@ -3724,7 +3767,7 @@ private static function getArrayKeyExistsAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\Greater|PhpParser\Node\Expr\BinaryOp\GreaterOrEqual $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getGreaterAssertions(
         PhpParser\Node\Expr $conditional,
@@ -3762,12 +3805,12 @@ private static function getGreaterAssertions(
 
             if ($var_name) {
                 if (self::hasReconcilableNonEmptyCountEqualityCheck($conditional)) {
-                    $if_types[$var_name] = [['non-empty-countable']];
+                    $if_types[$var_name] = [[new NonEmptyCountable(true)]];
                 } else {
-                    if ($min_count) {
-                        $if_types[$var_name] = [['=has-at-least-' . $min_count]];
+                    if ($min_count > 0) {
+                        $if_types[$var_name] = [[new HasAtLeastCount($min_count)]];
                     } else {
-                        $if_types[$var_name] = [['=non-empty-countable']];
+                        $if_types[$var_name] = [[new NonEmptyCountable(false)]];
                     }
                 }
             }
@@ -3790,10 +3833,10 @@ private static function getGreaterAssertions(
             );
 
             if ($var_name) {
-                if ($max_count) {
-                    $if_types[$var_name] = [['!has-at-least-' . ($max_count + 1)]];
+                if ($max_count > 0) {
+                    $if_types[$var_name] = [[new DoesNotHaveAtLeastCount($max_count + 1)]];
                 } else {
-                    $if_types[$var_name] = [['!non-empty-countable']];
+                    $if_types[$var_name] = [[new NotNonEmptyCountable()]];
                 }
             }
 
@@ -3818,18 +3861,18 @@ private static function getGreaterAssertions(
             if ($var_name !== null) {
                 if ($superior_value_position === self::ASSIGNMENT_TO_RIGHT) {
                     if ($superior_value_comparison === 0) {
-                        $if_types[$var_name] = [['=positive-numeric', '=int(0)']];
+                        $if_types[$var_name] = [[new IsPositiveNumeric(true), new IsIdentical(new TLiteralInt(0))]];
                     } elseif ($superior_value_comparison === 1) {
-                        $if_types[$var_name] = [['positive-numeric']];
+                        $if_types[$var_name] = [[new IsPositiveNumeric(true)]];
                     } else {
-                        $if_types[$var_name] = [['>' . $superior_value_comparison]];
+                        $if_types[$var_name] = [[new IsGreaterThan($superior_value_comparison)]];
                     }
                 } else {
-                    $if_types[$var_name] = [['<' . $superior_value_comparison]];
+                    $if_types[$var_name] = [[new IsLessThan($superior_value_comparison)]];
                 }
 
                 if ($isset_assert) {
-                    $if_types[$var_name][] = ['=isset'];
+                    $if_types[$var_name][] = [new IsEqualIsset()];
                 }
             }
 
@@ -3841,7 +3884,7 @@ private static function getGreaterAssertions(
 
     /**
      * @param PhpParser\Node\Expr\BinaryOp\Smaller|PhpParser\Node\Expr\BinaryOp\SmallerOrEqual $conditional
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
     private static function getSmallerAssertions(
         PhpParser\Node\Expr $conditional,
@@ -3877,10 +3920,10 @@ private static function getSmallerAssertions(
             );
 
             if ($var_name) {
-                if ($min_count) {
-                    $if_types[$var_name] = [['=has-at-least-' . $min_count]];
+                if ($min_count > 0) {
+                    $if_types[$var_name] = [[new HasAtLeastCount($min_count)]];
                 } else {
-                    $if_types[$var_name] = [['=non-empty-countable']];
+                    $if_types[$var_name] = [[new NonEmptyCountable(false)]];
                 }
             }
 
@@ -3902,10 +3945,10 @@ private static function getSmallerAssertions(
             );
 
             if ($var_name) {
-                if ($max_count) {
-                    $if_types[$var_name] = [['!has-at-least-' . ($max_count + 1)]];
+                if ($max_count > 0) {
+                    $if_types[$var_name] = [[new DoesNotHaveAtLeastCount($max_count + 1)]];
                 } else {
-                    $if_types[$var_name] = [['!non-empty-countable']];
+                    $if_types[$var_name] = [[new NotNonEmptyCountable()]];
                 }
             }
 
@@ -3930,19 +3973,19 @@ private static function getSmallerAssertions(
 
             if ($var_name !== null) {
                 if ($inferior_value_position === self::ASSIGNMENT_TO_RIGHT) {
-                    $if_types[$var_name] = [['<' . $inferior_value_comparison]];
+                    $if_types[$var_name] = [[new IsLessThan($inferior_value_comparison)]];
                 } else {
                     if ($inferior_value_comparison === 0) {
-                        $if_types[$var_name] = [['=positive-numeric', '=int(0)']];
+                        $if_types[$var_name] = [[new IsPositiveNumeric(false), new IsIdentical(new TLiteralInt(0))]];
                     } elseif ($inferior_value_comparison === 1) {
-                        $if_types[$var_name] = [['positive-numeric']];
+                        $if_types[$var_name] = [[new IsPositiveNumeric(true)]];
                     } else {
-                        $if_types[$var_name] = [['>' . $inferior_value_comparison]];
+                        $if_types[$var_name] = [[new IsGreaterThan($inferior_value_comparison)]];
                     }
                 }
 
                 if ($isset_assert) {
-                    $if_types[$var_name][] = ['=isset'];
+                    $if_types[$var_name][] = [new IsEqualIsset()];
                 }
             }
 
@@ -3953,9 +3996,9 @@ private static function getSmallerAssertions(
     }
 
     /**
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>
      */
-    private static function getInstanceofAssertions(
+    private static function getAndCheckInstanceofAssertions(
         PhpParser\Node\Expr\Instanceof_ $conditional,
         ?Codebase $codebase,
         FileSource $source,
@@ -3964,9 +4007,9 @@ private static function getInstanceofAssertions(
     ): array {
         $if_types = [];
 
-        $instanceof_types = self::getInstanceOfTypes($conditional, $this_class_name, $source);
+        $instanceof_assertions = self::getInstanceOfAssertions($conditional, $this_class_name, $source);
 
-        if ($instanceof_types) {
+        if ($instanceof_assertions) {
             $var_name = ExpressionIdentifier::getArrayVarId(
                 $conditional->expr,
                 $this_class_name,
@@ -3974,15 +4017,17 @@ private static function getInstanceofAssertions(
             );
 
             if ($var_name) {
-                $if_types[$var_name] = [$instanceof_types];
+                $if_types[$var_name] = [$instanceof_assertions];
 
                 $var_type = $source instanceof StatementsAnalyzer
                     ? $source->node_data->getType($conditional->expr)
                     : null;
 
-                foreach ($instanceof_types as $instanceof_type) {
-                    if ($instanceof_type[0] === '=') {
-                        $instanceof_type = substr($instanceof_type, 1);
+                foreach ($instanceof_assertions as $instanceof_assertion) {
+                    $instanceof_type = $instanceof_assertion->getAtomicType();
+
+                    if (!$instanceof_type instanceof TNamedObject) {
+                        continue;
                     }
 
                     if ($codebase
@@ -3990,15 +4035,11 @@ private static function getInstanceofAssertions(
                         && $inside_negation
                         && $source instanceof StatementsAnalyzer
                     ) {
-                        if ($codebase->interfaceExists($instanceof_type)) {
+                        if ($codebase->interfaceExists($instanceof_type->value)) {
                             continue;
                         }
 
-                        $instanceof_type = Type::parseString(
-                            $instanceof_type,
-                            null,
-                            $source->getTemplateTypeMap() ?: []
-                        );
+                        $instanceof_type = new Union([$instanceof_type]);
 
                         if (!UnionTypeComparator::canExpressionTypesBeIdentical(
                             $codebase,
diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/AssignmentAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Expression/AssignmentAnalyzer.php
index 6cb610b2b1e..65f53921b48 100644
--- a/src/Psalm/Internal/Analyzer/Statements/Expression/AssignmentAnalyzer.php
+++ b/src/Psalm/Internal/Analyzer/Statements/Expression/AssignmentAnalyzer.php
@@ -66,6 +66,7 @@
 use Psalm\Node\Expr\BinaryOp\VirtualShiftRight;
 use Psalm\Node\Expr\VirtualAssign;
 use Psalm\Plugin\EventHandler\Event\AddRemoveTaintsEvent;
+use Psalm\Storage\Assertion\Falsy;
 use Psalm\Type;
 use Psalm\Type\Atomic\TArray;
 use Psalm\Type\Atomic\TFalse;
@@ -1678,7 +1679,7 @@ private static function analyzeAssignmentToVariable(
                     );
 
                     $assignment_clauses = Algebra::combineOredClauses(
-                        [new Clause([$var_id => ['falsy']], $var_object_id, $var_object_id)],
+                        [new Clause([$var_id => [new Falsy()]], $var_object_id, $var_object_id)],
                         $right_clauses,
                         $cond_object_id
                     );
diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp/OrAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp/OrAnalyzer.php
index d6d675b522c..db3db5f3a0a 100644
--- a/src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp/OrAnalyzer.php
+++ b/src/Psalm/Internal/Analyzer/Statements/Expression/BinaryOp/OrAnalyzer.php
@@ -20,6 +20,7 @@
 use Psalm\Node\Expr\VirtualBooleanNot;
 use Psalm\Node\Stmt\VirtualExpression;
 use Psalm\Node\Stmt\VirtualIf;
+use Psalm\Storage\Assertion\Truthy;
 use Psalm\Type;
 use Psalm\Type\Reconciler;
 
@@ -335,7 +336,7 @@ public static function analyze(
 
             if ($var_id && isset($left_context->vars_in_scope[$var_id])) {
                 $left_inferred_reconciled = AssertionReconciler::reconcile(
-                    '!falsy',
+                    new Truthy(),
                     clone $left_context->vars_in_scope[$var_id],
                     '',
                     $statements_analyzer,
diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/Call/ArrayFunctionArgumentsAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Expression/Call/ArrayFunctionArgumentsAnalyzer.php
index 81517036547..c6870a4b968 100644
--- a/src/Psalm/Internal/Analyzer/Statements/Expression/Call/ArrayFunctionArgumentsAnalyzer.php
+++ b/src/Psalm/Internal/Analyzer/Statements/Expression/Call/ArrayFunctionArgumentsAnalyzer.php
@@ -539,7 +539,7 @@ public static function handleByRefArrayAdjustment(
 
                     if ($array_atomic_type instanceof TNonEmptyArray) {
                         if (!$context->inside_loop && $array_atomic_type->count !== null) {
-                            if ($array_atomic_type->count === 0) {
+                            if ($array_atomic_type->count === 1) {
                                 $array_atomic_type = new TArray(
                                     [
                                         new Union([new TNever]),
@@ -547,6 +547,7 @@ public static function handleByRefArrayAdjustment(
                                     ]
                                 );
                             } else {
+                                /** @psalm-suppress PropertyTypeCoercion */
                                 $array_atomic_type->count--;
                             }
                         } else {
@@ -556,7 +557,7 @@ public static function handleByRefArrayAdjustment(
                         $array_type->addType($array_atomic_type);
                     } elseif ($array_atomic_type instanceof TNonEmptyList) {
                         if (!$context->inside_loop && $array_atomic_type->count !== null) {
-                            if ($array_atomic_type->count === 0) {
+                            if ($array_atomic_type->count === 1) {
                                 $array_atomic_type = new TArray(
                                     [
                                         new Union([new TNever]),
@@ -564,6 +565,7 @@ public static function handleByRefArrayAdjustment(
                                     ]
                                 );
                             } else {
+                                /** @psalm-suppress PropertyTypeCoercion */
                                 $array_atomic_type->count--;
                             }
                         } else {
diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/Call/FunctionCallAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Expression/Call/FunctionCallAnalyzer.php
index cc4483cd1f5..84327ae7073 100644
--- a/src/Psalm/Internal/Analyzer/Statements/Expression/Call/FunctionCallAnalyzer.php
+++ b/src/Psalm/Internal/Analyzer/Statements/Expression/Call/FunctionCallAnalyzer.php
@@ -37,8 +37,8 @@
 use Psalm\Node\VirtualIdentifier;
 use Psalm\Plugin\EventHandler\Event\AddRemoveTaintsEvent;
 use Psalm\Plugin\EventHandler\Event\AfterEveryFunctionCallAnalysisEvent;
-use Psalm\Storage\Assertion;
 use Psalm\Storage\FunctionLikeParameter;
+use Psalm\Storage\Possibilities;
 use Psalm\Type;
 use Psalm\Type\Atomic;
 use Psalm\Type\Atomic\TArray;
@@ -345,15 +345,13 @@ public static function analyze(
         );
 
         if ($function_call_info->function_storage) {
-            $inferred_lower_bounds = $template_result->lower_bounds;
-
             if ($function_call_info->function_storage->assertions && $function_name instanceof PhpParser\Node\Name) {
                 self::applyAssertionsToContext(
                     $function_name,
                     null,
                     $function_call_info->function_storage->assertions,
                     $stmt->getArgs(),
-                    $inferred_lower_bounds,
+                    $template_result,
                     $context,
                     $statements_analyzer
                 );
@@ -363,8 +361,8 @@ public static function analyze(
                 $statements_analyzer->node_data->setIfTrueAssertions(
                     $stmt,
                     array_map(
-                        fn(Assertion $assertion): Assertion =>
-                            $assertion->getUntemplatedCopy($inferred_lower_bounds ?: [], null, $codebase),
+                        fn(Possibilities $assertion): Possibilities =>
+                            $assertion->getUntemplatedCopy($template_result, null, $codebase),
                         $function_call_info->function_storage->if_true_assertions
                     )
                 );
@@ -374,8 +372,8 @@ public static function analyze(
                 $statements_analyzer->node_data->setIfFalseAssertions(
                     $stmt,
                     array_map(
-                        fn(Assertion $assertion): Assertion =>
-                            $assertion->getUntemplatedCopy($inferred_lower_bounds ?: [], null, $codebase),
+                        fn(Possibilities $assertion): Possibilities =>
+                            $assertion->getUntemplatedCopy($template_result, null, $codebase),
                         $function_call_info->function_storage->if_false_assertions
                     )
                 );
diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/Call/Method/ExistingAtomicMethodCallAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Expression/Call/Method/ExistingAtomicMethodCallAnalyzer.php
index 71b73c9cd16..cef97e11d4a 100644
--- a/src/Psalm/Internal/Analyzer/Statements/Expression/Call/Method/ExistingAtomicMethodCallAnalyzer.php
+++ b/src/Psalm/Internal/Analyzer/Statements/Expression/Call/Method/ExistingAtomicMethodCallAnalyzer.php
@@ -34,7 +34,7 @@
 use Psalm\IssueBuffer;
 use Psalm\Node\Expr\VirtualFuncCall;
 use Psalm\Plugin\EventHandler\Event\AfterMethodCallAnalysisEvent;
-use Psalm\Storage\Assertion;
+use Psalm\Storage\Possibilities;
 use Psalm\Type;
 use Psalm\Type\Atomic;
 use Psalm\Type\Atomic\TNamedObject;
@@ -400,15 +400,13 @@ public static function analyze(
                 }
             }
 
-            $class_template_params = $template_result->lower_bounds;
-
             if ($method_storage->assertions) {
                 self::applyAssertionsToContext(
                     $stmt_name,
                     ExpressionIdentifier::getArrayVarId($stmt->var, null, $statements_analyzer),
                     $method_storage->assertions,
                     $args,
-                    $class_template_params,
+                    $template_result,
                     $context,
                     $statements_analyzer
                 );
@@ -418,8 +416,8 @@ public static function analyze(
                 $statements_analyzer->node_data->setIfTrueAssertions(
                     $stmt,
                     array_map(
-                        fn(Assertion $assertion): Assertion => $assertion->getUntemplatedCopy(
-                            $class_template_params ?: [],
+                        fn(Possibilities $assertion): Possibilities => $assertion->getUntemplatedCopy(
+                            $template_result,
                             $lhs_var_id,
                             $codebase
                         ),
@@ -432,8 +430,8 @@ public static function analyze(
                 $statements_analyzer->node_data->setIfFalseAssertions(
                     $stmt,
                     array_map(
-                        fn(Assertion $assertion): Assertion => $assertion->getUntemplatedCopy(
-                            $class_template_params ?: [],
+                        fn(Possibilities $assertion): Possibilities => $assertion->getUntemplatedCopy(
+                            $template_result,
                             $lhs_var_id,
                             $codebase
                         ),
diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/Call/NewAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Expression/Call/NewAnalyzer.php
index e01f3be786e..087aea63660 100644
--- a/src/Psalm/Internal/Analyzer/Statements/Expression/Call/NewAnalyzer.php
+++ b/src/Psalm/Internal/Analyzer/Statements/Expression/Call/NewAnalyzer.php
@@ -446,15 +446,13 @@ private static function analyzeNamedConstructor(
                     }
                 }
 
-                $generic_params = $template_result->lower_bounds;
-
                 if ($method_storage->assertions && $stmt->class instanceof PhpParser\Node\Name) {
                     self::applyAssertionsToContext(
                         $stmt->class,
                         null,
                         $method_storage->assertions,
                         $stmt->getArgs(),
-                        $generic_params,
+                        $template_result,
                         $context,
                         $statements_analyzer
                     );
@@ -464,7 +462,7 @@ private static function analyzeNamedConstructor(
                     $statements_analyzer->node_data->setIfTrueAssertions(
                         $stmt,
                         array_map(
-                            fn($assertion) => $assertion->getUntemplatedCopy($generic_params, null, $codebase),
+                            fn($assertion) => $assertion->getUntemplatedCopy($template_result, null, $codebase),
                             $method_storage->if_true_assertions
                         )
                     );
@@ -474,7 +472,7 @@ private static function analyzeNamedConstructor(
                     $statements_analyzer->node_data->setIfFalseAssertions(
                         $stmt,
                         array_map(
-                            fn($assertion) => $assertion->getUntemplatedCopy($generic_params, null, $codebase),
+                            fn($assertion) => $assertion->getUntemplatedCopy($template_result, null, $codebase),
                             $method_storage->if_false_assertions
                         )
                     );
diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/Call/StaticMethod/ExistingAtomicStaticCallAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Expression/Call/StaticMethod/ExistingAtomicStaticCallAnalyzer.php
index 8f1a6773eb6..4c4bcf1686d 100644
--- a/src/Psalm/Internal/Analyzer/Statements/Expression/Call/StaticMethod/ExistingAtomicStaticCallAnalyzer.php
+++ b/src/Psalm/Internal/Analyzer/Statements/Expression/Call/StaticMethod/ExistingAtomicStaticCallAnalyzer.php
@@ -25,8 +25,8 @@
 use Psalm\Issue\ImpureMethodCall;
 use Psalm\IssueBuffer;
 use Psalm\Plugin\EventHandler\Event\AfterMethodCallAnalysisEvent;
-use Psalm\Storage\Assertion;
 use Psalm\Storage\ClassLikeStorage;
+use Psalm\Storage\Possibilities;
 use Psalm\Type;
 use Psalm\Type\Atomic;
 use Psalm\Type\Atomic\TNamedObject;
@@ -312,15 +312,13 @@ public static function analyze(
                 }
             }
 
-            $generic_params = $template_result->lower_bounds;
-
             if ($method_storage->assertions) {
                 CallAnalyzer::applyAssertionsToContext(
                     $stmt_name,
                     null,
                     $method_storage->assertions,
                     $stmt->getArgs(),
-                    $generic_params,
+                    $template_result,
                     $context,
                     $statements_analyzer
                 );
@@ -330,8 +328,8 @@ public static function analyze(
                 $statements_analyzer->node_data->setIfTrueAssertions(
                     $stmt,
                     array_map(
-                        fn(Assertion $assertion): Assertion =>
-                            $assertion->getUntemplatedCopy($generic_params, null, $codebase),
+                        fn(Possibilities $assertion): Possibilities =>
+                            $assertion->getUntemplatedCopy($template_result, null, $codebase),
                         $method_storage->if_true_assertions
                     )
                 );
@@ -341,8 +339,8 @@ public static function analyze(
                 $statements_analyzer->node_data->setIfFalseAssertions(
                     $stmt,
                     array_map(
-                        fn(Assertion $assertion): Assertion =>
-                            $assertion->getUntemplatedCopy($generic_params, null, $codebase),
+                        fn(Possibilities $assertion): Possibilities =>
+                            $assertion->getUntemplatedCopy($template_result, null, $codebase),
                         $method_storage->if_false_assertions
                     )
                 );
diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/CallAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Expression/CallAnalyzer.php
index 941d88f7088..df54b95d64f 100644
--- a/src/Psalm/Internal/Analyzer/Statements/Expression/CallAnalyzer.php
+++ b/src/Psalm/Internal/Analyzer/Statements/Expression/CallAnalyzer.php
@@ -29,23 +29,23 @@
 use Psalm\Issue\InvalidDocblock;
 use Psalm\Issue\InvalidScalarArgument;
 use Psalm\Issue\MixedArgumentTypeCoercion;
+use Psalm\Issue\TypeDoesNotContainType;
 use Psalm\Issue\UndefinedFunction;
 use Psalm\IssueBuffer;
 use Psalm\Node\Expr\BinaryOp\VirtualIdentical;
 use Psalm\Node\Expr\VirtualConstFetch;
 use Psalm\Node\VirtualName;
-use Psalm\Storage\Assertion;
+use Psalm\Storage\Assertion\Falsy;
+use Psalm\Storage\Assertion\IsIdentical;
+use Psalm\Storage\Assertion\IsType;
+use Psalm\Storage\Assertion\Truthy;
 use Psalm\Storage\ClassLikeStorage;
+use Psalm\Storage\Possibilities;
 use Psalm\Type;
-use Psalm\Type\Atomic\Scalar;
-use Psalm\Type\Atomic\TArray;
-use Psalm\Type\Atomic\TKeyedArray;
-use Psalm\Type\Atomic\TList;
-use Psalm\Type\Atomic\TMixed;
 use Psalm\Type\Atomic\TNamedObject;
-use Psalm\Type\Atomic\TNull;
 use Psalm\Type\Atomic\TObjectWithProperties;
 use Psalm\Type\Atomic\TTemplateParam;
+use Psalm\Type\Atomic\TTrue;
 use Psalm\Type\Reconciler;
 use Psalm\Type\Union;
 use UnexpectedValueException;
@@ -67,7 +67,6 @@
 use function str_replace;
 use function strpos;
 use function strtolower;
-use function substr;
 
 /**
  * @internal
@@ -643,17 +642,16 @@ public static function checkFunctionExists(
 
     /**
      * @param Identifier|Name $expr
-     * @param  Assertion[] $assertions
+     * @param  Possibilities[] $var_assertions
      * @param  list<PhpParser\Node\Arg> $args
-     * @param  array<string, array<string, non-empty-list<TemplateBound>>> $inferred_lower_bounds,
      *
      */
     public static function applyAssertionsToContext(
         PhpParser\NodeAbstract $expr,
         ?string $thisName,
-        array $assertions,
+        array $var_assertions,
         array $args,
-        array $inferred_lower_bounds,
+        TemplateResult $template_result,
         Context $context,
         StatementsAnalyzer $statements_analyzer
     ): void {
@@ -661,36 +659,36 @@ public static function applyAssertionsToContext(
 
         $asserted_keys = [];
 
-        foreach ($assertions as $assertion) {
+        foreach ($var_assertions as $var_possibilities) {
             $assertion_var_id = null;
 
             $arg_value = null;
 
-            if (is_int($assertion->var_id)) {
-                if (!isset($args[$assertion->var_id])) {
+            if (is_int($var_possibilities->var_id)) {
+                if (!isset($args[$var_possibilities->var_id])) {
                     continue;
                 }
 
-                $arg_value = $args[$assertion->var_id]->value;
+                $arg_value = $args[$var_possibilities->var_id]->value;
 
                 $arg_var_id = ExpressionIdentifier::getArrayVarId($arg_value, null, $statements_analyzer);
 
                 if ($arg_var_id) {
                     $assertion_var_id = $arg_var_id;
                 }
-            } elseif ($assertion->var_id === '$this' && $thisName !== null) {
+            } elseif ($var_possibilities->var_id === '$this' && $thisName !== null) {
                 $assertion_var_id = $thisName;
-            } elseif (strpos($assertion->var_id, '$this->') === 0 && $thisName !== null) {
-                $assertion_var_id = $thisName . str_replace('$this->', '->', $assertion->var_id);
-            } elseif (strpos($assertion->var_id, 'self::') === 0 && $context->self) {
-                $assertion_var_id = $context->self . str_replace('self::', '::', $assertion->var_id);
-            } elseif (strpos($assertion->var_id, '::$') !== false) {
+            } elseif (strpos($var_possibilities->var_id, '$this->') === 0 && $thisName !== null) {
+                $assertion_var_id = $thisName . str_replace('$this->', '->', $var_possibilities->var_id);
+            } elseif (strpos($var_possibilities->var_id, 'self::') === 0 && $context->self) {
+                $assertion_var_id = $context->self . str_replace('self::', '::', $var_possibilities->var_id);
+            } elseif (strpos($var_possibilities->var_id, '::$') !== false) {
                 // allow assertions to bring external static props into scope
-                $assertion_var_id = $assertion->var_id;
-            } elseif (isset($context->vars_in_scope[$assertion->var_id])) {
-                $assertion_var_id = $assertion->var_id;
-            } elseif (strpos($assertion->var_id, '->') !== false) {
-                $exploded = explode('->', $assertion->var_id);
+                $assertion_var_id = $var_possibilities->var_id;
+            } elseif (isset($context->vars_in_scope[$var_possibilities->var_id])) {
+                $assertion_var_id = $var_possibilities->var_id;
+            } elseif (strpos($var_possibilities->var_id, '->') !== false) {
+                $exploded = explode('->', $var_possibilities->var_id);
 
                 if (count($exploded) < 2) {
                     IssueBuffer::add(
@@ -747,84 +745,103 @@ public static function applyAssertionsToContext(
                     }
                 }
 
-                $assertion_var_id = str_replace((string) $var_id, $arg_var_id, $assertion->var_id);
+                $assertion_var_id = str_replace((string) $var_id, $arg_var_id, $var_possibilities->var_id);
             }
 
             $codebase = $statements_analyzer->getCodebase();
 
             if ($assertion_var_id) {
-                $rule = $assertion->rule[0][0];
+                $orred_rules = [];
 
-                $prefix = '';
-                if ($rule[0] === '!') {
-                    $prefix .= '!';
-                    $rule = substr($rule, 1);
-                }
-                if ($rule[0] === '=') {
-                    $prefix .= '=';
-                    $rule = substr($rule, 1);
-                }
-                if ($rule[0] === '~') {
-                    $prefix .= '~';
-                    $rule = substr($rule, 1);
-                }
+                foreach ($var_possibilities->rule as $assertion_rule) {
+                    $assertion_type = $assertion_rule->getAtomicType();
 
-                if (isset($inferred_lower_bounds[$rule])) {
-                    foreach ($inferred_lower_bounds[$rule] as $lower_bounds) {
-                        $lower_bound_type = TemplateStandinTypeReplacer::getMostSpecificTypeFromBounds(
-                            $lower_bounds,
+                    if ($assertion_type) {
+                        $union = new Union([clone $assertion_type]);
+                        TemplateInferredTypeReplacer::replace(
+                            $union,
+                            $template_result,
                             $codebase
                         );
 
-                        if ($lower_bound_type->hasMixed()) {
-                            continue 2;
-                        }
-
-                        $replacement_atomic_types = $lower_bound_type->getAtomicTypes();
-
-                        if (count($replacement_atomic_types) > 1) {
-                            continue 2;
-                        }
-
-                        $ored_type_assertions = [];
-
-                        foreach ($replacement_atomic_types as $replacement_atomic_type) {
-                            if ($replacement_atomic_type instanceof TMixed) {
-                                continue 3;
+                        if ($union->isSingle()) {
+                            foreach ($union->getAtomicTypes() as $atomic_type) {
+                                if ($assertion_type instanceof TTemplateParam
+                                    && $assertion_type->as->getId() === $atomic_type->getId()
+                                ) {
+                                    continue;
+                                }
+                                $assertion_rule = clone $assertion_rule;
+                                $assertion_rule->setAtomicType($atomic_type);
+                                $orred_rules[] = $assertion_rule;
                             }
+                        } elseif (isset($context->vars_in_scope[$var_possibilities->var_id])) {
+                            $other_type = $context->vars_in_scope[$var_possibilities->var_id];
 
-                            if ($replacement_atomic_type instanceof TArray
-                                || $replacement_atomic_type instanceof TKeyedArray
-                                || $replacement_atomic_type instanceof TList
+                            if ($assertion_rule instanceof IsIdentical
+                                || $assertion_rule instanceof IsType
                             ) {
-                                $ored_type_assertions[] = $prefix . $replacement_atomic_type->getId();
-                            } elseif ($replacement_atomic_type instanceof TNamedObject) {
-                                $ored_type_assertions[] = $prefix . $replacement_atomic_type->value;
-                            } elseif ($replacement_atomic_type instanceof Scalar) {
-                                $ored_type_assertions[] = $prefix . $replacement_atomic_type->getAssertionString();
-                            } elseif ($replacement_atomic_type instanceof TNull) {
-                                $ored_type_assertions[] = $prefix . 'null';
-                            } elseif ($replacement_atomic_type instanceof TTemplateParam) {
-                                $ored_type_assertions[] = $prefix . $replacement_atomic_type->param_name;
+                                if (!UnionTypeComparator::canExpressionTypesBeIdentical(
+                                    $codebase,
+                                    $union,
+                                    $context->vars_in_scope[$var_possibilities->var_id]
+                                )) {
+                                    IssueBuffer::maybeAdd(
+                                        new TypeDoesNotContainType(
+                                            $union->getId() . ' cannot be identical to ' . $other_type->getId(),
+                                            new CodeLocation($statements_analyzer->getSource(), $expr),
+                                            $union->getId() . ' ' . $other_type->getId()
+                                        ),
+                                        $statements_analyzer->getSuppressedIssues()
+                                    );
+                                }
                             }
                         }
-
-                        if ($ored_type_assertions) {
-                            $type_assertions[$assertion_var_id] = [$ored_type_assertions];
-                        }
+                    } else {
+                        $orred_rules[] = $assertion_rule;
                     }
-                } else {
+                }
+
+                if ($orred_rules) {
                     if (isset($type_assertions[$assertion_var_id])) {
                         $type_assertions[$assertion_var_id] = array_merge(
                             $type_assertions[$assertion_var_id],
-                            $assertion->rule
+                            [$orred_rules]
                         );
                     } else {
-                        $type_assertions[$assertion_var_id] = $assertion->rule;
+                        $type_assertions[$assertion_var_id] = [$orred_rules];
                     }
                 }
-            } elseif ($arg_value && ($assertion->rule === [['!falsy']] || $assertion->rule === [['true']])) {
-                if ($assertion->rule === [['true']]) {
+            } elseif ($arg_value
+                && count($var_possibilities->rule) === 1
+            ) {
+                $assert_clauses = [];
+
+                $single_rule = $var_possibilities->rule[0];
+
+                if ($single_rule instanceof Truthy) {
+                    $assert_clauses = FormulaGenerator::getFormula(
+                        spl_object_id($arg_value),
+                        spl_object_id($arg_value),
+                        $arg_value,
+                        $context->self,
+                        $statements_analyzer,
+                        $statements_analyzer->getCodebase()
+                    );
+                } elseif ($single_rule instanceof Falsy) {
+                    $assert_clauses = Algebra::negateFormula(
+                        FormulaGenerator::getFormula(
+                            spl_object_id($arg_value),
+                            spl_object_id($arg_value),
+                            $arg_value,
+                            $context->self,
+                            $statements_analyzer,
+                            $codebase
+                        )
+                    );
+                } elseif ($single_rule instanceof IsType
+                    && $single_rule->type instanceof TTrue
+                ) {
                     $conditional = new VirtualIdentical(
                         $arg_value,
                         new VirtualConstFetch(new VirtualName('true'))
@@ -838,15 +855,6 @@ public static function applyAssertionsToContext(
                         $statements_analyzer,
                         $codebase
                     );
-                } else {
-                    $assert_clauses = FormulaGenerator::getFormula(
-                        spl_object_id($arg_value),
-                        spl_object_id($arg_value),
-                        $arg_value,
-                        $context->self,
-                        $statements_analyzer,
-                        $statements_analyzer->getCodebase()
-                    );
                 }
 
                 $simplified_clauses = Algebra::simplifyCNF(
@@ -857,27 +865,6 @@ public static function applyAssertionsToContext(
                     $simplified_clauses
                 );
 
-                $type_assertions = array_merge($type_assertions, $assert_type_assertions);
-            } elseif ($arg_value && $assertion->rule === [['falsy']]) {
-                $assert_clauses = Algebra::negateFormula(
-                    FormulaGenerator::getFormula(
-                        spl_object_id($arg_value),
-                        spl_object_id($arg_value),
-                        $arg_value,
-                        $context->self,
-                        $statements_analyzer,
-                        $codebase
-                    )
-                );
-
-                $simplified_clauses = Algebra::simplifyCNF(
-                    array_merge($context->clauses, $assert_clauses)
-                );
-
-                $assert_type_assertions = Algebra::getTruthsFromFormula(
-                    $simplified_clauses
-                );
-
                 $type_assertions = array_merge($type_assertions, $assert_type_assertions);
             }
         }
@@ -891,28 +878,7 @@ public static function applyAssertionsToContext(
         $codebase = $statements_analyzer->getCodebase();
 
         if ($type_assertions) {
-            $template_type_map = array_map(
-                fn($type_map) => array_map(
-                    fn($bounds) => TemplateStandinTypeReplacer::getMostSpecificTypeFromBounds(
-                        $bounds,
-                        $codebase
-                    ),
-                    $type_map
-                ),
-                $inferred_lower_bounds
-            );
-
-            foreach (($statements_analyzer->getTemplateTypeMap() ?: []) as $template_name => $map) {
-                foreach ($map as $ref => $type) {
-                    $template_type_map[$template_name][$ref] = new Union([
-                        new TTemplateParam(
-                            $template_name,
-                            $type,
-                            $ref
-                        )
-                    ]);
-                }
-            }
+            $template_type_map = [];
 
             // while in an and, we allow scope to boil over to support
             // statements of the form if ($x && $x->foo())
@@ -953,16 +919,6 @@ public static function applyAssertionsToContext(
                         );
                     }
 
-                    if ($template_type_map) {
-                        $readonly_template_result = new TemplateResult($template_type_map, $template_type_map);
-
-                         TemplateInferredTypeReplacer::replace(
-                             $op_vars_in_scope[$var_id],
-                             $readonly_template_result,
-                             $codebase
-                         );
-                    }
-
                     $op_vars_in_scope[$var_id]->from_docblock = true;
 
                     foreach ($op_vars_in_scope[$var_id]->getAtomicTypes() as $changed_atomic_type) {
diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/Fetch/ArrayFetchAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Expression/Fetch/ArrayFetchAnalyzer.php
index 90675e5d728..e4af074ccff 100644
--- a/src/Psalm/Internal/Analyzer/Statements/Expression/Fetch/ArrayFetchAnalyzer.php
+++ b/src/Psalm/Internal/Analyzer/Statements/Expression/Fetch/ArrayFetchAnalyzer.php
@@ -1708,7 +1708,8 @@ private static function handleArrayAccessOnList(
                 || (count($key_values) === 1
                     && is_int($key_values[0])
                     && $key_values[0] > 0
-                    && $key_values[0] > ($type->count - 1))
+                    && $key_values[0] > ($type->count - 1)
+                    && $key_values[0] > ($type->min_count - 1))
             ) {
                 $expected_offset_type = Type::getInt();
 
diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/TernaryAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Expression/TernaryAnalyzer.php
index d436ebcaae0..99ed3eb6c45 100644
--- a/src/Psalm/Internal/Analyzer/Statements/Expression/TernaryAnalyzer.php
+++ b/src/Psalm/Internal/Analyzer/Statements/Expression/TernaryAnalyzer.php
@@ -15,6 +15,7 @@
 use Psalm\Internal\Clause;
 use Psalm\Internal\Scope\IfScope;
 use Psalm\Internal\Type\AssertionReconciler;
+use Psalm\Storage\Assertion\Truthy;
 use Psalm\Type;
 use Psalm\Type\Reconciler;
 
@@ -280,7 +281,7 @@ function (Clause $c) use ($mixed_var_ids, $cond_id): Clause {
             }
         } elseif ($stmt_cond_type = $statements_analyzer->node_data->getType($stmt->cond)) {
             $if_return_type_reconciled = AssertionReconciler::reconcile(
-                '!falsy',
+                new Truthy(),
                 clone $stmt_cond_type,
                 '',
                 $statements_analyzer,
diff --git a/src/Psalm/Internal/Clause.php b/src/Psalm/Internal/Clause.php
index a3c6e70232f..b9bf306b7ce 100644
--- a/src/Psalm/Internal/Clause.php
+++ b/src/Psalm/Internal/Clause.php
@@ -2,7 +2,12 @@
 
 namespace Psalm\Internal;
 
-use Psalm\Internal\Algebra;
+use Psalm\Storage\Assertion;
+use Psalm\Type\Atomic\TClassConstant;
+use Psalm\Type\Atomic\TEnumCase;
+use Psalm\Type\Atomic\TLiteralFloat;
+use Psalm\Type\Atomic\TLiteralInt;
+use Psalm\Type\Atomic\TLiteralString;
 
 use function array_diff;
 use function array_keys;
@@ -16,7 +21,6 @@
 use function md5;
 use function reset;
 use function sort;
-use function strpos;
 use function substr;
 
 use const JSON_THROW_ON_ERROR;
@@ -47,10 +51,15 @@ class Clause
      *
      * !$a || $b || $c !== null || is_string($d) || is_int($d)
      *
-     * @var array<string, non-empty-list<string>>
+     * @var array<string, non-empty-list<Assertion>>
      */
     public $possibilities;
 
+    /**
+     * @var array<string, non-empty-list<string>>
+     */
+    public $possibility_strings = [];
+
     /**
      * An array of things that are not true
      * [
@@ -63,7 +72,7 @@ class Clause
      *
      * $a && !$b && $c === null && !is_string($d) && !is_int($d)
      *
-     * @var array<string, non-empty-list<string>>|null
+     * @var array<string, non-empty-list<Assertion>>|null
      */
     public $impossibilities;
 
@@ -83,7 +92,7 @@ class Clause
     public $hash;
 
     /**
-     * @param array<string, non-empty-list<string>>  $possibilities
+     * @param array<string, non-empty-list<Assertion>>  $possibilities
      * @param array<string, bool> $redefined_vars
      */
     public function __construct(
@@ -95,14 +104,6 @@ public function __construct(
         bool $generated = false,
         array $redefined_vars = []
     ) {
-        $this->possibilities = $possibilities;
-        $this->wedge = $wedge;
-        $this->reconcilable = $reconcilable;
-        $this->generated = $generated;
-        $this->redefined_vars = $redefined_vars;
-        $this->creating_conditional_id = $creating_conditional_id;
-        $this->creating_object_id = $creating_object_id;
-
         if ($wedge || !$reconcilable) {
             $this->hash = ($wedge ? 'w' : '') . $creating_object_id;
         } else {
@@ -112,8 +113,25 @@ public function __construct(
                 sort($possibilities[$i]);
             }
 
-            $this->hash = md5(json_encode($possibilities, JSON_THROW_ON_ERROR));
+            $possibility_strings = array_map(
+                fn($possibility_map) => array_map(
+                    fn($possibility) => (string)$possibility,
+                    $possibility_map
+                ),
+                $possibilities
+            );
+
+            $this->hash = md5(json_encode($possibility_strings, JSON_THROW_ON_ERROR));
+            $this->possibility_strings = $possibility_strings;
         }
+
+        $this->possibilities = $possibilities;
+        $this->wedge = $wedge;
+        $this->reconcilable = $reconcilable;
+        $this->generated = $generated;
+        $this->redefined_vars = $redefined_vars;
+        $this->creating_conditional_id = $creating_conditional_id;
+        $this->creating_object_id = $creating_object_id;
     }
 
     public function contains(Clause $other_clause): bool
@@ -138,7 +156,7 @@ public function __toString(): string
     {
         $clause_strings = array_map(
             /**
-             * @param non-empty-list<string> $values
+             * @param non-empty-list<Assertion> $values
              */
             function (string $var_id, array $values): string {
                 if ($var_id[0] === '*') {
@@ -146,7 +164,8 @@ function (string $var_id, array $values): string {
                 }
 
                 $var_id_clauses = array_map(
-                    function (string $value) use ($var_id): string {
+                    function (Assertion $value) use ($var_id): string {
+                        $value = (string) $value;
                         if ($value === 'falsy') {
                             return '!' . $var_id;
                         }
@@ -232,7 +251,7 @@ public function removePossibilities(string $var_id): ?self
     }
 
     /**
-     * @param non-empty-list<string> $clause_var_possibilities
+     * @param non-empty-list<Assertion> $clause_var_possibilities
      */
     public function addPossibilities(string $var_id, array $clause_var_possibilities): self
     {
@@ -262,12 +281,15 @@ public function calculateNegation(): self
             $impossibility = [];
 
             foreach ($possibility as $type) {
-                if (($type[0] !== '=' && $type[0] !== '~'
-                        && (!isset($type[1]) || ($type[1] !== '=' && $type[1] !== '~')))
-                    || strpos($type, '(')
-                    || strpos($type, 'getclass-')
+                if (!$type->hasEquality()
+                    || (($inner_type = $type->getAtomicType())
+                        && ($inner_type instanceof TLiteralInt
+                            || $inner_type instanceof TLiteralFloat
+                            || $inner_type instanceof TLiteralString
+                            || $inner_type instanceof TClassConstant
+                            || $inner_type instanceof TEnumCase))
                 ) {
-                    $impossibility[] = Algebra::negateType($type);
+                    $impossibility[] = $type->getNegation();
                 }
             }
 
diff --git a/src/Psalm/Internal/PhpVisitor/Reflector/FunctionLikeDocblockScanner.php b/src/Psalm/Internal/PhpVisitor/Reflector/FunctionLikeDocblockScanner.php
index 889bcb3b8a7..87c2c9edef5 100644
--- a/src/Psalm/Internal/PhpVisitor/Reflector/FunctionLikeDocblockScanner.php
+++ b/src/Psalm/Internal/PhpVisitor/Reflector/FunctionLikeDocblockScanner.php
@@ -19,17 +19,25 @@
 use Psalm\Issue\InvalidDocblock;
 use Psalm\Issue\PossiblyInvalidDocblockTag;
 use Psalm\Storage\Assertion;
+use Psalm\Storage\Assertion\Empty_;
+use Psalm\Storage\Assertion\Falsy;
+use Psalm\Storage\Assertion\IsIdentical;
+use Psalm\Storage\Assertion\IsLooselyEqual;
+use Psalm\Storage\Assertion\IsNotIdentical;
+use Psalm\Storage\Assertion\IsNotLooselyEqual;
+use Psalm\Storage\Assertion\IsNotType;
+use Psalm\Storage\Assertion\IsType;
+use Psalm\Storage\Assertion\NonEmpty;
+use Psalm\Storage\Assertion\Truthy;
 use Psalm\Storage\ClassLikeStorage;
 use Psalm\Storage\FileStorage;
 use Psalm\Storage\FunctionLikeParameter;
 use Psalm\Storage\FunctionLikeStorage;
 use Psalm\Storage\MethodStorage;
+use Psalm\Storage\Possibilities;
 use Psalm\Type;
 use Psalm\Type\Atomic\TArray;
-use Psalm\Type\Atomic\TAssertionFalsy;
-use Psalm\Type\Atomic\TClassConstant;
 use Psalm\Type\Atomic\TConditional;
-use Psalm\Type\Atomic\TIterable;
 use Psalm\Type\Atomic\TKeyedArray;
 use Psalm\Type\Atomic\TList;
 use Psalm\Type\Atomic\TNull;
@@ -537,7 +545,7 @@ private static function getConditionalSanitizedTypeTokens(
      * @param array<string, array<string, Union>> $class_template_types
      * @param array<string, array<string, Union>> $function_template_types
      * @param array<string, TypeAlias> $type_aliases
-     * @return non-empty-list<string>|null
+     * @return non-empty-list<Assertion>|null
      */
     private static function getAssertionParts(
         Codebase $codebase,
@@ -552,20 +560,22 @@ private static function getAssertionParts(
         array $type_aliases,
         ?string $self_fqcln
     ): ?array {
-        $prefix = '';
+        $is_negation = false;
+        $is_loose_equality = false;
+        $is_strict_equality = false;
 
         if ($assertion_type[0] === '!') {
-            $prefix = '!';
+            $is_negation = true;
             $assertion_type = substr($assertion_type, 1);
         }
 
         if ($assertion_type[0] === '~') {
-            $prefix .= '~';
+            $is_loose_equality = true;
             $assertion_type = substr($assertion_type, 1);
         }
 
         if ($assertion_type[0] === '=') {
-            $prefix .= '=';
+            $is_strict_equality = true;
             $assertion_type = substr($assertion_type, 1);
         }
 
@@ -573,17 +583,33 @@ private static function getAssertionParts(
             ? $class_template_types
             : [];
 
+        if ($assertion_type === 'falsy') {
+            return [$is_negation ? new Truthy() : new Falsy()];
+        }
+
+        if ($assertion_type === 'truthy') {
+            return [$is_negation ? new Falsy() : new Truthy()];
+        }
+
+        if ($assertion_type === 'empty') {
+            return [$is_negation ? new NonEmpty() : new Empty_()];
+        }
+
+        $template_types = $function_template_types + $class_template_types;
+
         try {
             $namespaced_type = TypeParser::parseTokens(
                 TypeTokenizer::getFullyQualifiedTokens(
                     $assertion_type,
                     $aliases,
-                    $function_template_types + $class_template_types,
+                    $template_types,
                     $type_aliases,
                     $self_fqcln,
                     null,
                     true
-                )
+                ),
+                null,
+                $template_types
             );
         } catch (TypeParseTreeException $e) {
             $storage->docblock_issues[] = new InvalidDocblock(
@@ -594,10 +620,11 @@ private static function getAssertionParts(
             return null;
         }
 
-
-        if ($prefix && count($namespaced_type->getAtomicTypes()) > 1) {
+        if (($is_negation || $is_loose_equality || $is_strict_equality)
+            && count($namespaced_type->getAtomicTypes()) > 1
+        ) {
             $storage->docblock_issues[] = new InvalidDocblock(
-                'Docblock assertions cannot contain | characters together with ' . $prefix,
+                'Docblock assertions cannot contain | characters together with a prefix',
                 new CodeLocation($file_scanner, $stmt, null, true)
             );
 
@@ -613,20 +640,22 @@ private static function getAssertionParts(
         $assertion_type_parts = [];
 
         foreach ($namespaced_type->getAtomicTypes() as $namespaced_type_part) {
-            if ($namespaced_type_part instanceof TAssertionFalsy
-                || $namespaced_type_part instanceof TClassConstant
-                || ($namespaced_type_part instanceof TList
-                    && $namespaced_type_part->type_param->isMixed())
-                || ($namespaced_type_part instanceof TArray
-                    && $namespaced_type_part->type_params[0]->isArrayKey()
-                    && $namespaced_type_part->type_params[1]->isMixed())
-                || ($namespaced_type_part instanceof TIterable
-                    && $namespaced_type_part->type_params[0]->isMixed()
-                    && $namespaced_type_part->type_params[1]->isMixed())
-            ) {
-                $assertion_type_parts[] = $prefix . $namespaced_type_part->getAssertionString();
+            if ($is_negation) {
+                if ($is_strict_equality) {
+                    $assertion_type_parts[] = new IsNotIdentical($namespaced_type_part);
+                } elseif ($is_loose_equality) {
+                    $assertion_type_parts[] = new IsNotLooselyEqual($namespaced_type_part);
+                } else {
+                    $assertion_type_parts[] = new IsNotType($namespaced_type_part);
+                }
             } else {
-                $assertion_type_parts[] = $prefix . $namespaced_type_part->getId();
+                if ($is_strict_equality) {
+                    $assertion_type_parts[] = new IsIdentical($namespaced_type_part);
+                } elseif ($is_loose_equality) {
+                    $assertion_type_parts[] = new IsLooselyEqual($namespaced_type_part);
+                } else {
+                    $assertion_type_parts[] = new IsType($namespaced_type_part);
+                }
             }
         }
 
@@ -1190,25 +1219,25 @@ private static function handleAssertions(
 
                 foreach ($storage->params as $i => $param) {
                     if ($param->name === $assertion['param_name']) {
-                        $storage->assertions[] = new Assertion(
+                        $storage->assertions[] = new Possibilities(
                             $i,
-                            [$assertion_type_parts]
+                            $assertion_type_parts
                         );
                         continue 2;
                     }
 
                     if (strpos($assertion['param_name'], $param->name.'->') === 0) {
-                        $storage->assertions[] = new Assertion(
+                        $storage->assertions[] = new Possibilities(
                             str_replace($param->name, (string) $i, $assertion['param_name']),
-                            [$assertion_type_parts]
+                            $assertion_type_parts
                         );
                         continue 2;
                     }
                 }
 
-                $storage->assertions[] = new Assertion(
+                $storage->assertions[] = new Possibilities(
                     (strpos($assertion['param_name'], '$') === false ? '$' : '') . $assertion['param_name'],
-                    [$assertion_type_parts]
+                    $assertion_type_parts
                 );
             }
         }
@@ -1237,25 +1266,25 @@ private static function handleAssertions(
 
                 foreach ($storage->params as $i => $param) {
                     if ($param->name === $assertion['param_name']) {
-                        $storage->if_true_assertions[] = new Assertion(
+                        $storage->if_true_assertions[] = new Possibilities(
                             $i,
-                            [$assertion_type_parts]
+                            $assertion_type_parts
                         );
                         continue 2;
                     }
 
                     if (strpos($assertion['param_name'], $param->name.'->') === 0) {
-                        $storage->if_true_assertions[] = new Assertion(
+                        $storage->if_true_assertions[] = new Possibilities(
                             str_replace($param->name, (string) $i, $assertion['param_name']),
-                            [$assertion_type_parts]
+                            $assertion_type_parts
                         );
                         continue 2;
                     }
                 }
 
-                $storage->if_true_assertions[] = new Assertion(
+                $storage->if_true_assertions[] = new Possibilities(
                     (strpos($assertion['param_name'], '$') === false ? '$' : '') . $assertion['param_name'],
-                    [$assertion_type_parts]
+                    $assertion_type_parts
                 );
             }
         }
@@ -1284,25 +1313,25 @@ private static function handleAssertions(
 
                 foreach ($storage->params as $i => $param) {
                     if ($param->name === $assertion['param_name']) {
-                        $storage->if_false_assertions[] = new Assertion(
+                        $storage->if_false_assertions[] = new Possibilities(
                             $i,
-                            [$assertion_type_parts]
+                            $assertion_type_parts
                         );
                         continue 2;
                     }
 
                     if (strpos($assertion['param_name'], $param->name.'->') === 0) {
-                        $storage->if_false_assertions[] = new Assertion(
+                        $storage->if_false_assertions[] = new Possibilities(
                             str_replace($param->name, (string) $i, $assertion['param_name']),
-                            [$assertion_type_parts]
+                            $assertion_type_parts
                         );
                         continue 2;
                     }
                 }
 
-                $storage->if_false_assertions[] = new Assertion(
+                $storage->if_false_assertions[] = new Possibilities(
                     (strpos($assertion['param_name'], '$') === false ? '$' : '') . $assertion['param_name'],
-                    [$assertion_type_parts]
+                    $assertion_type_parts
                 );
             }
         }
diff --git a/src/Psalm/Internal/PhpVisitor/Reflector/FunctionLikeNodeScanner.php b/src/Psalm/Internal/PhpVisitor/Reflector/FunctionLikeNodeScanner.php
index f1caac12d17..94546ec9745 100644
--- a/src/Psalm/Internal/PhpVisitor/Reflector/FunctionLikeNodeScanner.php
+++ b/src/Psalm/Internal/PhpVisitor/Reflector/FunctionLikeNodeScanner.php
@@ -34,13 +34,13 @@
 use Psalm\Issue\MissingDocblockType;
 use Psalm\Issue\ParseError;
 use Psalm\IssueBuffer;
-use Psalm\Storage\Assertion;
 use Psalm\Storage\ClassLikeStorage;
 use Psalm\Storage\FileStorage;
 use Psalm\Storage\FunctionLikeParameter;
 use Psalm\Storage\FunctionLikeStorage;
 use Psalm\Storage\FunctionStorage;
 use Psalm\Storage\MethodStorage;
+use Psalm\Storage\Possibilities;
 use Psalm\Storage\PropertyStorage;
 use Psalm\Type;
 use Psalm\Type\Atomic\TArray;
@@ -340,22 +340,23 @@ public function start(PhpParser\Node\FunctionLike $stmt, bool $fake_method = fal
                         foreach ($rules as $var_id => $rule) {
                             foreach ($rule as $rule_part) {
                                 if (count($rule_part) > 1) {
+                                    $var_assertions = [];
                                     continue 2;
                                 }
-                            }
 
-                            if (isset($existing_params[$var_id])) {
-                                $param_offset = $existing_params[$var_id];
-
-                                $var_assertions[] = new Assertion(
-                                    $param_offset,
-                                    $rule
-                                );
-                            } elseif (strpos($var_id, '$this->') === 0) {
-                                $var_assertions[] = new Assertion(
-                                    $var_id,
-                                    $rule
-                                );
+                                if (isset($existing_params[$var_id])) {
+                                    $param_offset = $existing_params[$var_id];
+
+                                    $var_assertions[] = new Possibilities(
+                                        $param_offset,
+                                        $rule_part
+                                    );
+                                } elseif (strpos($var_id, '$this->') === 0) {
+                                    $var_assertions[] = new Possibilities(
+                                        $var_id,
+                                        $rule_part
+                                    );
+                                }
                             }
                         }
                     } else {
diff --git a/src/Psalm/Internal/Provider/NodeDataProvider.php b/src/Psalm/Internal/Provider/NodeDataProvider.php
index c642d3788f4..e3d62a55a1b 100644
--- a/src/Psalm/Internal/Provider/NodeDataProvider.php
+++ b/src/Psalm/Internal/Provider/NodeDataProvider.php
@@ -13,6 +13,7 @@
 use PhpParser\NodeAbstract;
 use Psalm\NodeTypeProvider;
 use Psalm\Storage\Assertion;
+use Psalm\Storage\Possibilities;
 use Psalm\Type\Union;
 use SplObjectStorage;
 
@@ -25,14 +26,14 @@ class NodeDataProvider implements NodeTypeProvider
     private $node_types;
 
     /**
-     * @var SplObjectStorage<Node,list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>|null>
+     * @var SplObjectStorage<Node,list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>|null>
      */
     private $node_assertions;
 
-    /** @var SplObjectStorage<Node, array<int, Assertion>> */
+    /** @var SplObjectStorage<Node, array<int, Possibilities>> */
     private $node_if_true_assertions;
 
-    /** @var SplObjectStorage<Node, array<int, Assertion>> */
+    /** @var SplObjectStorage<Node, array<int, Possibilities>> */
     private $node_if_false_assertions;
 
     /** @var bool */
@@ -63,7 +64,7 @@ public function getType(NodeAbstract $node): ?Union
     }
 
     /**
-     * @param list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>|null $assertions
+     * @param list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>|null $assertions
      */
     public function setAssertions(Expr $node, ?array $assertions): void
     {
@@ -75,7 +76,7 @@ public function setAssertions(Expr $node, ?array $assertions): void
     }
 
     /**
-     * @return list<non-empty-array<string, non-empty-list<non-empty-list<string>>>>|null
+     * @return list<non-empty-array<string, non-empty-list<non-empty-list<Assertion>>>>|null
      */
     public function getAssertions(Expr $node): ?array
     {
@@ -88,7 +89,7 @@ public function getAssertions(Expr $node): ?array
 
     /**
      * @param FuncCall|MethodCall|StaticCall|New_ $node
-     * @param array<int, Assertion>  $assertions
+     * @param array<int, Possibilities>  $assertions
      */
     public function setIfTrueAssertions(Expr $node, array $assertions): void
     {
@@ -97,7 +98,7 @@ public function setIfTrueAssertions(Expr $node, array $assertions): void
 
     /**
      * @param Expr\FuncCall|MethodCall|StaticCall|New_ $node
-     * @return array<int, Assertion>|null
+     * @return array<int, Possibilities>|null
      */
     public function getIfTrueAssertions(Expr $node): ?array
     {
@@ -106,7 +107,7 @@ public function getIfTrueAssertions(Expr $node): ?array
 
     /**
      * @param FuncCall|MethodCall|StaticCall|New_ $node
-     * @param array<int, Assertion>  $assertions
+     * @param array<int, Possibilities>  $assertions
      */
     public function setIfFalseAssertions(Expr $node, array $assertions): void
     {
@@ -115,7 +116,7 @@ public function setIfFalseAssertions(Expr $node, array $assertions): void
 
     /**
      * @param FuncCall|MethodCall|StaticCall|New_ $node
-     * @return array<int, Assertion>|null
+     * @return array<int, Possibilities>|null
      */
     public function getIfFalseAssertions(Expr $node): ?array
     {
diff --git a/src/Psalm/Internal/Provider/ReturnTypeProvider/ArrayFilterReturnTypeProvider.php b/src/Psalm/Internal/Provider/ReturnTypeProvider/ArrayFilterReturnTypeProvider.php
index 385f7fda3d3..f26ef15cbf1 100644
--- a/src/Psalm/Internal/Provider/ReturnTypeProvider/ArrayFilterReturnTypeProvider.php
+++ b/src/Psalm/Internal/Provider/ReturnTypeProvider/ArrayFilterReturnTypeProvider.php
@@ -15,6 +15,7 @@
 use Psalm\IssueBuffer;
 use Psalm\Plugin\EventHandler\Event\FunctionReturnTypeProviderEvent;
 use Psalm\Plugin\EventHandler\FunctionReturnTypeProviderInterface;
+use Psalm\Storage\Assertion\Truthy;
 use Psalm\Type;
 use Psalm\Type\Atomic\TArray;
 use Psalm\Type\Atomic\TInt;
@@ -95,7 +96,7 @@ static function ($keyed_type) use ($statements_source, $context) {
                             $prev_keyed_type = $keyed_type;
 
                             $keyed_type = AssertionReconciler::reconcile(
-                                '!falsy',
+                                new Truthy(),
                                 clone $keyed_type,
                                 '',
                                 $statements_source,
@@ -129,7 +130,7 @@ static function ($keyed_type) use ($statements_source, $context) {
 
         if (!isset($call_args[1])) {
             $inner_type = AssertionReconciler::reconcile(
-                '!falsy',
+                new Truthy(),
                 clone $inner_type,
                 '',
                 $statements_source,
@@ -203,12 +204,13 @@ static function ($keyed_type) use ($statements_source, $context) {
                         $statements_source
                     );
 
-                    if (isset($assertions[$array_var_id . "[\$__fake_{$fake_var_discriminator}_offset_var__]"])) {
+                    $assertion_id = $array_var_id . "[\$__fake_{$fake_var_discriminator}_offset_var__]";
+
+                    if (isset($assertions[$assertion_id])) {
                         $changed_var_ids = [];
 
                         $assertions = [
-                            '$inner_type' =>
-                                $assertions["{$array_var_id}[\$__fake_{$fake_var_discriminator}_offset_var__]"],
+                            '$inner_type' => $assertions[$assertion_id],
                         ];
 
                         $reconciled_types = Reconciler::reconcileKeyedTypes(
diff --git a/src/Psalm/Internal/Provider/ReturnTypeProvider/ArrayMapReturnTypeProvider.php b/src/Psalm/Internal/Provider/ReturnTypeProvider/ArrayMapReturnTypeProvider.php
index 882acf8b6a0..225b865d72b 100644
--- a/src/Psalm/Internal/Provider/ReturnTypeProvider/ArrayMapReturnTypeProvider.php
+++ b/src/Psalm/Internal/Provider/ReturnTypeProvider/ArrayMapReturnTypeProvider.php
@@ -21,6 +21,7 @@
 use Psalm\Node\VirtualIdentifier;
 use Psalm\Plugin\EventHandler\Event\FunctionReturnTypeProviderEvent;
 use Psalm\Plugin\EventHandler\FunctionReturnTypeProviderInterface;
+use Psalm\Storage\Assertion;
 use Psalm\Type;
 use Psalm\Type\Atomic\TArray;
 use Psalm\Type\Atomic\TKeyedArray;
@@ -255,7 +256,7 @@ public static function getFunctionReturnType(FunctionReturnTypeProviderEvent $ev
     }
 
     /**
-     * @param-out array<string, array<array<int, string>>>|null $assertions
+     * @param array<string, array<array<int, Assertion>>>|null $assertions
      */
     private static function executeFakeCall(
         StatementsAnalyzer $statements_analyzer,
@@ -338,7 +339,7 @@ private static function executeFakeCall(
      * @param list<PhpParser\Node\Arg> $array_args
      * @param int|null $fake_var_discriminator Set the fake variable id to a known value with the discriminator
      *                                         as a substring, and don't clear it from the context.
-     * @param-out array<string, array<array<int, string>>>|null $assertions
+     * @param array<string, array<array<int, Assertion>>>|null $assertions
      */
     public static function getReturnTypeFromMappingIds(
         StatementsAnalyzer $statements_source,
diff --git a/src/Psalm/Internal/Scope/IfScope.php b/src/Psalm/Internal/Scope/IfScope.php
index 314d93f89af..93de1e9359b 100644
--- a/src/Psalm/Internal/Scope/IfScope.php
+++ b/src/Psalm/Internal/Scope/IfScope.php
@@ -4,6 +4,7 @@
 
 use Psalm\Context;
 use Psalm\Internal\Clause;
+use Psalm\Storage\Assertion;
 use Psalm\Type\Union;
 
 /**
@@ -47,7 +48,7 @@ class IfScope
     public $updated_vars = [];
 
     /**
-     * @var array<string, array<int, array<int, string>>>
+     * @var array<string, list<array<int, Assertion>>>
      */
     public $negated_types = [];
 
diff --git a/src/Psalm/Internal/Type/AssertionReconciler.php b/src/Psalm/Internal/Type/AssertionReconciler.php
index cc931851233..8343e9e4f9e 100644
--- a/src/Psalm/Internal/Type/AssertionReconciler.php
+++ b/src/Psalm/Internal/Type/AssertionReconciler.php
@@ -2,10 +2,8 @@
 
 namespace Psalm\Internal\Type;
 
-use Exception;
 use Psalm\CodeLocation;
 use Psalm\Codebase;
-use Psalm\Exception\TypeParseTreeException;
 use Psalm\Internal\Analyzer\Statements\Expression\Fetch\VariableFetchAnalyzer;
 use Psalm\Internal\Analyzer\StatementsAnalyzer;
 use Psalm\Internal\Analyzer\TraitAnalyzer;
@@ -13,12 +11,25 @@
 use Psalm\Internal\Type\Comparator\TypeComparisonResult;
 use Psalm\Internal\Type\Comparator\UnionTypeComparator;
 use Psalm\Issue\DocblockTypeContradiction;
-use Psalm\Issue\InvalidDocblock;
 use Psalm\Issue\TypeDoesNotContainNull;
 use Psalm\Issue\TypeDoesNotContainType;
 use Psalm\IssueBuffer;
+use Psalm\Storage\Assertion;
+use Psalm\Storage\Assertion\ArrayKeyExists;
+use Psalm\Storage\Assertion\Falsy;
+use Psalm\Storage\Assertion\HasAtLeastCount;
+use Psalm\Storage\Assertion\HasExactCount;
+use Psalm\Storage\Assertion\IsAClass;
+use Psalm\Storage\Assertion\IsClassEqual;
+use Psalm\Storage\Assertion\IsEqualIsset;
+use Psalm\Storage\Assertion\IsIsset;
+use Psalm\Storage\Assertion\IsLooselyEqual;
+use Psalm\Storage\Assertion\NestedAssertions;
+use Psalm\Storage\Assertion\NonEmpty;
+use Psalm\Storage\Assertion\NonEmptyCountable;
 use Psalm\Type;
 use Psalm\Type\Atomic;
+use Psalm\Type\Atomic\Scalar;
 use Psalm\Type\Atomic\TArray;
 use Psalm\Type\Atomic\TArrayKey;
 use Psalm\Type\Atomic\TClassConstant;
@@ -37,22 +48,22 @@
 use Psalm\Type\Atomic\TLiteralString;
 use Psalm\Type\Atomic\TMixed;
 use Psalm\Type\Atomic\TNamedObject;
+use Psalm\Type\Atomic\TNull;
 use Psalm\Type\Atomic\TNumeric;
+use Psalm\Type\Atomic\TObject;
 use Psalm\Type\Atomic\TPositiveInt;
 use Psalm\Type\Atomic\TScalar;
 use Psalm\Type\Atomic\TString;
 use Psalm\Type\Atomic\TTemplateParam;
+use Psalm\Type\Atomic\TTemplateParamClass;
 use Psalm\Type\Reconciler;
 use Psalm\Type\Union;
 
 use function array_intersect_key;
 use function array_merge;
 use function count;
-use function explode;
 use function get_class;
 use function is_string;
-use function strpos;
-use function substr;
 
 /**
  * @internal
@@ -73,7 +84,7 @@ class AssertionReconciler extends Reconciler
      * @param-out Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     public static function reconcile(
-        string $assertion,
+        Assertion $assertion,
         ?Union $existing_var_type,
         ?string $key,
         StatementsAnalyzer $statements_analyzer,
@@ -86,33 +97,12 @@ public static function reconcile(
     ): Union {
         $codebase = $statements_analyzer->getCodebase();
 
-        $is_strict_equality = false;
-        $is_loose_equality = false;
-        $is_equality = false;
-        $is_negation = false;
         $failed_reconciliation = Reconciler::RECONCILIATION_OK;
 
-        if ($assertion[0] === '!') {
-            $assertion = substr($assertion, 1);
-            $is_negation = true;
-        }
-
-        if ($assertion[0] === '=') {
-            $assertion = substr($assertion, 1);
-            $is_strict_equality = true;
-            $is_equality = true;
-        }
-
-        if ($assertion[0] === '~') {
-            $assertion = substr($assertion, 1);
-            $is_loose_equality = true;
-            $is_equality = true;
-        }
-
-        $original_assertion = $assertion;
+        $is_negation = $assertion->isNegation();
 
-        if ($assertion[0] === '@') {
-            $assertion = 'falsy';
+        if ($assertion instanceof NestedAssertions) {
+            $assertion = new Falsy();
             $is_negation = true;
         }
 
@@ -126,10 +116,7 @@ public static function reconcile(
         if ($existing_var_type === null) {
             return self::getMissingType(
                 $assertion,
-                $is_negation,
-                $inside_loop,
-                $is_equality,
-                $template_type_map
+                $inside_loop
             );
         }
 
@@ -139,10 +126,7 @@ public static function reconcile(
             return NegatedAssertionReconciler::reconcile(
                 $statements_analyzer,
                 $assertion,
-                $is_strict_equality,
-                $is_loose_equality,
                 $existing_var_type,
-                $template_type_map,
                 $old_var_type_string,
                 $key,
                 $negated,
@@ -153,32 +137,33 @@ public static function reconcile(
             );
         }
 
-        $simply_reconciled_type = SimpleAssertionReconciler::reconcile(
-            $assertion,
-            $codebase,
-            $existing_var_type,
-            $key,
-            $negated,
-            $code_location,
-            $suppressed_issues,
-            $failed_reconciliation,
-            $is_equality,
-            $is_strict_equality,
-            $inside_loop
-        );
+        $assertion_type = $assertion->getAtomicType();
 
-        if ($simply_reconciled_type) {
-            return $simply_reconciled_type;
+        if ($assertion_type instanceof TLiteralInt
+            || $assertion_type instanceof TLiteralString
+            || $assertion_type instanceof TLiteralFloat
+            || $assertion_type instanceof TEnumCase
+        ) {
+            return self::handleLiteralEquality(
+                $statements_analyzer,
+                $assertion,
+                $assertion_type,
+                $existing_var_type,
+                $old_var_type_string,
+                $key,
+                $negated,
+                $code_location,
+                $suppressed_issues
+            );
         }
 
-        if (strpos($assertion, 'isa-') === 0) {
+        if ($assertion instanceof IsAClass) {
             $should_return = false;
 
-            $new_type = self::handleIsA(
+            $new_type_parts = self::handleIsA(
+                $assertion,
                 $codebase,
                 $existing_var_type,
-                $assertion,
-                $template_type_map,
                 $code_location,
                 $key,
                 $suppressed_issues,
@@ -186,62 +171,54 @@ public static function reconcile(
             );
 
             if ($should_return) {
-                return $new_type;
+                return new Union($new_type_parts);
             }
-        } elseif (strpos($assertion, 'getclass-') === 0) {
-            $assertion = substr($assertion, 9);
-            $new_type = Type::parseString($assertion, null, $template_type_map);
-        } else {
-            $bracket_pos = strpos($assertion, '(');
 
-            if ($bracket_pos) {
-                return self::handleLiteralEquality(
-                    $statements_analyzer,
-                    $assertion,
-                    $bracket_pos,
-                    $is_loose_equality,
-                    $existing_var_type,
-                    $old_var_type_string,
-                    $key,
-                    $negated,
-                    $code_location,
-                    $suppressed_issues
-                );
-            }
+            $new_type_part = $new_type_parts[0];
+        } else {
+            $simply_reconciled_type = SimpleAssertionReconciler::reconcile(
+                $assertion,
+                $codebase,
+                $existing_var_type,
+                $key,
+                $negated,
+                $code_location,
+                $suppressed_issues,
+                $failed_reconciliation,
+                $inside_loop
+            );
 
-            if ($assertion === 'loaded-class-string') {
-                $assertion = 'class-string';
+            if ($simply_reconciled_type) {
+                return $simply_reconciled_type;
             }
 
-            try {
-                $new_type = Type::parseString($assertion, null, $template_type_map);
-            } catch (TypeParseTreeException $e) {
-                $new_type = Type::getMixed();
+            if ($assertion instanceof IsClassEqual) {
+                $new_type_part = Atomic::create($assertion->type, null, $template_type_map);
+            } elseif ($assertion_type = $assertion->getAtomicType()) {
+                $new_type_part = clone $assertion_type;
+            } else {
+                $new_type_part = new TMixed();
             }
         }
 
         if ($existing_var_type->hasMixed()) {
-            if ($is_loose_equality
-                && $new_type->hasScalarType()
+            if ($assertion instanceof IsLooselyEqual
+                && $new_type_part instanceof Scalar
             ) {
                 return $existing_var_type;
             }
 
-            return $new_type;
+            return new Union([$new_type_part]);
         }
 
         $refined_type = self::refine(
             $statements_analyzer,
             $assertion,
-            $original_assertion,
-            $new_type,
+            $new_type_part,
             $existing_var_type,
-            $template_type_map,
             $key,
             $negated,
             $code_location,
-            $is_equality,
-            $is_loose_equality,
             $suppressed_issues,
             $failed_reconciliation
         );
@@ -263,39 +240,28 @@ public static function reconcile(
      * @param array<string, array<string, Union>> $template_type_map
      */
     private static function getMissingType(
-        string $assertion,
-        bool $is_negation,
-        bool $inside_loop,
-        bool $is_equality,
-        array $template_type_map
+        Assertion $assertion,
+        bool $inside_loop
     ): Union {
-        if (($assertion === 'isset' && !$is_negation)
-            || ($assertion === 'empty' && $is_negation)
+        if (($assertion instanceof IsIsset || $assertion instanceof IsEqualIsset)
+            || $assertion instanceof NonEmpty
         ) {
             return Type::getMixed($inside_loop);
         }
 
-        if ($assertion === 'array-key-exists'
-            || $assertion === 'non-empty-countable'
-            || strpos($assertion, 'has-at-least-') === 0
-            || strpos($assertion, 'has-exactly-') === 0
+        if ($assertion instanceof ArrayKeyExists
+            || $assertion instanceof NonEmptyCountable
+            || $assertion instanceof HasExactCount
+            || $assertion instanceof HasAtLeastCount
         ) {
             return Type::getMixed();
         }
 
-        if (!$is_negation && $assertion !== 'falsy' && $assertion !== 'empty') {
-            if ($is_equality) {
-                $bracket_pos = strpos($assertion, '(');
-
-                if ($bracket_pos) {
-                    $assertion = substr($assertion, 0, $bracket_pos);
-                }
-            }
+        if (!$assertion->isNegation()) {
+            $assertion_type = $assertion->getAtomicType();
 
-            try {
-                return Type::parseString($assertion, null, $template_type_map);
-            } catch (Exception $e) {
-                return Type::getMixed();
+            if ($assertion_type) {
+                return new Union([clone $assertion_type]);
             }
         }
 
@@ -313,16 +279,12 @@ private static function getMissingType(
      */
     private static function refine(
         StatementsAnalyzer $statements_analyzer,
-        string $assertion,
-        string $original_assertion,
-        Union $new_type,
+        Assertion $assertion,
+        Atomic $new_type_part,
         Union $existing_var_type,
-        array $template_type_map,
         ?string $key,
         bool $negated,
         ?CodeLocation $code_location,
-        bool $is_equality,
-        bool $is_loose_equality,
         array $suppressed_issues,
         int &$failed_reconciliation
     ): Union {
@@ -332,14 +294,11 @@ private static function refine(
 
         $new_type_has_interface = false;
 
-        if ($new_type->hasObjectType()) {
-            foreach ($new_type->getAtomicTypes() as $new_type_part) {
-                if ($new_type_part instanceof TNamedObject &&
-                    $codebase->interfaceExists($new_type_part->value)
-                ) {
-                    $new_type_has_interface = true;
-                    break;
-                }
+        if ($new_type_part->isObjectType()) {
+            if ($new_type_part instanceof TNamedObject &&
+                $codebase->interfaceExists($new_type_part->value)
+            ) {
+                $new_type_has_interface = true;
             }
         }
 
@@ -356,28 +315,6 @@ private static function refine(
             }
         }
 
-        try {
-            if (strpos($assertion, '<') || strpos($assertion, '[') || strpos($assertion, '{')) {
-                $new_type_union = Type::parseString($assertion);
-
-                $new_type_part = $new_type_union->getSingleAtomic();
-            } else {
-                $new_type_part = Atomic::create($assertion, null, $template_type_map);
-            }
-        } catch (TypeParseTreeException $e) {
-            $new_type_part = new TMixed();
-
-            if ($code_location) {
-                IssueBuffer::maybeAdd(
-                    new InvalidDocblock(
-                        $assertion . ' cannot be used in an assertion',
-                        $code_location
-                    ),
-                    $suppressed_issues
-                );
-            }
-        }
-
         if ($new_type_part instanceof TTemplateParam
             && $new_type_part->as->isSingle()
         ) {
@@ -433,11 +370,13 @@ private static function refine(
             }
         }
 
+        $new_type = null;
+
         if ($new_type_part instanceof TNamedObject
             && ($new_type_has_interface || $old_type_has_interface)
             && !UnionTypeComparator::canExpressionTypesBeIdentical(
                 $codebase,
-                $new_type,
+                new Union([$new_type_part]),
                 $existing_var_type,
                 false
             )
@@ -473,21 +412,20 @@ private static function refine(
             if ($acceptable_atomic_types) {
                 return new Union($acceptable_atomic_types);
             }
-        } elseif (!$new_type->hasMixed()) {
+        } elseif (!$new_type_part instanceof TMixed) {
             $any_scalar_type_match_found = false;
 
             if ($code_location
                 && $key
-                && !$is_equality
+                && !$assertion->hasEquality()
                 && $new_type_part instanceof TNamedObject
                 && !$new_type_has_interface
                 && (!($statements_analyzer->getSource()->getSource() instanceof TraitAnalyzer)
-                    || ($key !== '$this'
-                        && strpos($original_assertion, 'isa-') !== 0))
+                    || $key !== '$this')
                 && UnionTypeComparator::isContainedBy(
                     $codebase,
                     $existing_var_type,
-                    $new_type,
+                    new Union([$new_type_part]),
                     false,
                     false,
                     null,
@@ -499,7 +437,7 @@ private static function refine(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    $original_assertion,
+                    $assertion,
                     true,
                     $negated,
                     $code_location,
@@ -510,15 +448,15 @@ private static function refine(
             $intersection_type = self::filterTypeWithAnother(
                 $codebase,
                 $existing_var_type,
-                $new_type,
+                new Union([$new_type_part]),
                 $any_scalar_type_match_found
             );
 
             if ($code_location
                 && !$intersection_type
-                && (!$is_loose_equality || !$any_scalar_type_match_found)
+                && (!$assertion instanceof IsLooselyEqual || !$any_scalar_type_match_found)
             ) {
-                if ($assertion === 'null') {
+                if ($new_type_part instanceof TNull) {
                     if ($existing_var_type->from_docblock) {
                         IssueBuffer::maybeAdd(
                             new DocblockTypeContradiction(
@@ -542,15 +480,16 @@ private static function refine(
                     }
                 } elseif (!($statements_analyzer->getSource()->getSource() instanceof TraitAnalyzer)
                     || ($key !== '$this'
-                        && !($existing_var_type->hasLiteralClassString() && $new_type->hasLiteralClassString()))
+                        && !($existing_var_type->hasLiteralClassString()
+                            && $assertion instanceof IsAClass))
                 ) {
                     if ($existing_var_type->from_docblock) {
                         IssueBuffer::maybeAdd(
                             new DocblockTypeContradiction(
                                 'Cannot resolve types for ' . $key . ' - docblock-defined type '
-                                    . $existing_var_type->getId() . ' does not contain ' . $new_type->getId(),
+                                    . $existing_var_type->getId() . ' does not contain ' . $new_type_part->getId(),
                                 $code_location,
-                                $existing_var_type->getId() . ' ' . $new_type->getId()
+                                $existing_var_type->getId() . ' ' . $new_type_part->getId()
                             ),
                             $suppressed_issues
                         );
@@ -558,9 +497,9 @@ private static function refine(
                         IssueBuffer::maybeAdd(
                             new TypeDoesNotContainType(
                                 'Cannot resolve types for ' . $key . ' - ' . $existing_var_type->getId()
-                                    . ' does not contain ' . $new_type->getId(),
+                                    . ' does not contain ' . $new_type_part->getId(),
                                 $code_location,
-                                $existing_var_type->getId() . ' ' . $new_type->getId()
+                                $existing_var_type->getId() . ' ' . $new_type_part->getId()
                             ),
                             $suppressed_issues
                         );
@@ -575,7 +514,7 @@ private static function refine(
             }
         }
 
-        return $new_type;
+        return $new_type ?: new Union([$new_type_part]);
     }
 
     /**
@@ -914,13 +853,13 @@ private static function refineContainedAtomicWithAnother(
     }
 
     /**
+     * @param  TLiteralInt|TLiteralFloat|TLiteralString|TEnumCase $assertion_type
      * @param  string[]          $suppressed_issues
      */
     private static function handleLiteralEquality(
         StatementsAnalyzer $statements_analyzer,
-        string             $assertion,
-        int                $bracket_pos,
-        bool               $is_loose_equality,
+        Assertion          $assertion,
+        Atomic             $assertion_type,
         Union              $existing_var_type,
         string             $old_var_type_string,
         ?string            $var_id,
@@ -928,10 +867,6 @@ private static function handleLiteralEquality(
         ?CodeLocation      $code_location,
         array              $suppressed_issues
     ): Union {
-        $value = substr($assertion, $bracket_pos + 1, -1);
-
-        $scalar_type = substr($assertion, 0, $bracket_pos);
-
         $existing_var_atomic_types = [];
 
         foreach ($existing_var_type->getAtomicTypes() as $existing_var_atomic_type) {
@@ -954,12 +889,11 @@ private static function handleLiteralEquality(
             }
         }
 
-        if ($scalar_type === 'int') {
+        if ($assertion_type instanceof TLiteralInt) {
             return self::handleLiteralEqualityWithInt(
                 $statements_analyzer,
                 $assertion,
-                $bracket_pos,
-                $is_loose_equality,
+                $assertion_type,
                 $existing_var_type,
                 $existing_var_atomic_types,
                 $old_var_type_string,
@@ -968,18 +902,11 @@ private static function handleLiteralEquality(
                 $code_location,
                 $suppressed_issues
             );
-        } elseif ($scalar_type === 'string'
-            || $scalar_type === 'class-string'
-            || $scalar_type === 'interface-string'
-            || $scalar_type === 'callable-string'
-            || $scalar_type === 'trait-string'
-        ) {
+        } elseif ($assertion_type instanceof TLiteralString) {
             return self::handleLiteralEqualityWithString(
                 $statements_analyzer,
                 $assertion,
-                $scalar_type,
-                $bracket_pos,
-                $is_loose_equality,
+                $assertion_type,
                 $existing_var_type,
                 $existing_var_atomic_types,
                 $old_var_type_string,
@@ -988,12 +915,11 @@ private static function handleLiteralEquality(
                 $code_location,
                 $suppressed_issues
             );
-        } elseif ($scalar_type === 'float') {
+        } elseif ($assertion_type instanceof TLiteralFloat) {
             return self::handleLiteralEqualityWithFloat(
                 $statements_analyzer,
                 $assertion,
-                $bracket_pos,
-                $is_loose_equality,
+                $assertion_type,
                 $existing_var_type,
                 $existing_var_atomic_types,
                 $old_var_type_string,
@@ -1002,11 +928,12 @@ private static function handleLiteralEquality(
                 $code_location,
                 $suppressed_issues
             );
-        } elseif ($scalar_type === 'enum') {
-            [$fq_enum_name, $case_name] = explode('::', $value);
+        } else {
+            $fq_enum_name = $assertion_type->value;
+            $case_name = $assertion_type->case_name;
 
             if ($existing_var_type->hasMixed()) {
-                if ($is_loose_equality) {
+                if ($assertion instanceof IsLooselyEqual) {
                     return $existing_var_type;
                 }
 
@@ -1024,7 +951,7 @@ private static function handleLiteralEquality(
                     $did_remove_type = true;
                     $existing_var_type->removeType($atomic_key);
                     $existing_var_type->addType(new TEnumCase($fq_enum_name, $case_name));
-                } elseif ($atomic_key !== $assertion) {
+                } elseif ($atomic_key !== $assertion_type->getKey()) {
                     $existing_var_type->removeType($atomic_key);
                     $did_remove_type = true;
                 } else {
@@ -1058,9 +985,8 @@ private static function handleLiteralEquality(
      */
     private static function handleLiteralEqualityWithInt(
         StatementsAnalyzer $statements_analyzer,
-        string             $assertion,
-        int                $bracket_pos,
-        bool               $is_loose_equality,
+        Assertion      $assertion,
+        TLiteralInt        $assertion_type,
         Union              $existing_var_type,
         array              $existing_var_atomic_types,
         string             $old_var_type_string,
@@ -1069,7 +995,7 @@ private static function handleLiteralEqualityWithInt(
         ?CodeLocation      $code_location,
         array              $suppressed_issues
     ): Union {
-        $value = (int) substr($assertion, $bracket_pos + 1, -1);
+        $value = $assertion_type->value;
 
         // we create the literal that is being asserted. We'll return this when we're sure this is the resulting type
         $literal_asserted_type = new Union([new TLiteralInt($value)]);
@@ -1078,8 +1004,8 @@ private static function handleLiteralEqualityWithInt(
         $compatible_int_type = self::getCompatibleIntType(
             $existing_var_type,
             $existing_var_atomic_types,
-            $value,
-            $is_loose_equality
+            $assertion_type,
+            $assertion instanceof IsLooselyEqual
         );
 
         if ($compatible_int_type !== null) {
@@ -1124,8 +1050,8 @@ private static function handleLiteralEqualityWithInt(
                 $compatible_int_type = self::getCompatibleIntType(
                     $existing_var_type,
                     $existing_var_atomic_type->as->getAtomicTypes(),
-                    $value,
-                    $is_loose_equality
+                    $assertion_type,
+                    $assertion instanceof IsLooselyEqual
                 );
                 if ($compatible_int_type !== null) {
                     return $compatible_int_type;
@@ -1136,8 +1062,7 @@ private static function handleLiteralEqualityWithInt(
                 $existing_var_atomic_type->as = self::handleLiteralEquality(
                     $statements_analyzer,
                     $assertion,
-                    $bracket_pos,
-                    false,
+                    $assertion_type,
                     $existing_var_atomic_type->as,
                     $old_var_type_string,
                     $var_id,
@@ -1149,14 +1074,14 @@ private static function handleLiteralEqualityWithInt(
                 return new Union([$existing_var_atomic_type]);
             }
 
-            if ($is_loose_equality
+            if ($assertion instanceof IsLooselyEqual
                 && $existing_var_atomic_type instanceof TLiteralFloat
                 && (int)$existing_var_atomic_type->value === $value
             ) {
                 return new Union([$existing_var_atomic_type]);
             }
 
-            if ($is_loose_equality
+            if ($assertion instanceof IsLooselyEqual
                 && $existing_var_atomic_type instanceof TLiteralString
                 && (int)$existing_var_atomic_type->value === $value
             ) {
@@ -1167,7 +1092,7 @@ private static function handleLiteralEqualityWithInt(
         //here we'll accept non-literal type that *could* match on loose equality and return the original type
         foreach ($existing_var_atomic_types as $existing_var_atomic_type) {
             //here we'll accept non-literal type that *could* match on loose equality and return the original type
-            if ($is_loose_equality) {
+            if ($assertion instanceof IsLooselyEqual) {
                 if ($existing_var_atomic_type instanceof TString
                     && !$existing_var_atomic_type instanceof TLiteralString
                 ) {
@@ -1205,10 +1130,8 @@ private static function handleLiteralEqualityWithInt(
      */
     private static function handleLiteralEqualityWithString(
         StatementsAnalyzer $statements_analyzer,
-        string             $assertion,
-        string             $scalar_type,
-        int                $bracket_pos,
-        bool               $is_loose_equality,
+        Assertion      $assertion,
+        TLiteralString     $assertion_type,
         Union              $existing_var_type,
         array              $existing_var_atomic_types,
         string             $old_var_type_string,
@@ -1217,7 +1140,7 @@ private static function handleLiteralEqualityWithString(
         ?CodeLocation      $code_location,
         array              $suppressed_issues
     ): Union {
-        $value = substr($assertion, $bracket_pos + 1, -1);
+        $value = $assertion_type->value;
 
         // we create the literal that is being asserted. We'll return this when we're sure this is the resulting type
         $literal_asserted_type_string = new Union([new TLiteralString($value)]);
@@ -1228,9 +1151,8 @@ private static function handleLiteralEqualityWithString(
         $compatible_string_type = self::getCompatibleStringType(
             $existing_var_type,
             $existing_var_atomic_types,
-            $value,
-            $scalar_type,
-            $is_loose_equality
+            $assertion_type,
+            $assertion instanceof IsLooselyEqual
         );
 
         if ($compatible_string_type !== null) {
@@ -1257,10 +1179,7 @@ private static function handleLiteralEqualityWithString(
                     return $existing_var_type;
                 }
 
-                if ($scalar_type === 'class-string'
-                    || $scalar_type === 'interface-string'
-                    || $scalar_type === 'trait-string'
-                ) {
+                if ($assertion_type instanceof TLiteralClassString) {
                     return $literal_asserted_type_classstring;
                 }
 
@@ -1268,10 +1187,7 @@ private static function handleLiteralEqualityWithString(
             }
 
             if ($existing_var_atomic_type instanceof TString && !$existing_var_atomic_type instanceof TLiteralString) {
-                if ($scalar_type === 'class-string'
-                    || $scalar_type === 'interface-string'
-                    || $scalar_type === 'trait-string'
-                ) {
+                if ($assertion_type instanceof TLiteralClassString) {
                     return $literal_asserted_type_classstring;
                 }
 
@@ -1282,19 +1198,15 @@ private static function handleLiteralEqualityWithString(
                 $compatible_string_type = self::getCompatibleStringType(
                     $existing_var_type,
                     $existing_var_atomic_type->as->getAtomicTypes(),
-                    $value,
-                    $scalar_type,
-                    $is_loose_equality
+                    $assertion_type,
+                    $assertion instanceof IsLooselyEqual
                 );
                 if ($compatible_string_type !== null) {
                     return $compatible_string_type;
                 }
 
                 if ($existing_var_atomic_type->as->hasString()) {
-                    if ($scalar_type === 'class-string'
-                        || $scalar_type === 'interface-string'
-                        || $scalar_type === 'trait-string'
-                    ) {
+                    if ($assertion_type instanceof TLiteralClassString) {
                         return $literal_asserted_type_classstring;
                     }
 
@@ -1306,8 +1218,7 @@ private static function handleLiteralEqualityWithString(
                 $existing_var_atomic_type->as = self::handleLiteralEquality(
                     $statements_analyzer,
                     $assertion,
-                    $bracket_pos,
-                    false,
+                    $assertion_type,
                     $existing_var_atomic_type->as,
                     $old_var_type_string,
                     $var_id,
@@ -1319,14 +1230,14 @@ private static function handleLiteralEqualityWithString(
                 return new Union([$existing_var_atomic_type]);
             }
 
-            if ($is_loose_equality
+            if ($assertion instanceof IsLooselyEqual
                 && $existing_var_atomic_type instanceof TLiteralInt
                 && (string)$existing_var_atomic_type->value === $value
             ) {
                 return new Union([$existing_var_atomic_type]);
             }
 
-            if ($is_loose_equality
+            if ($assertion instanceof IsLooselyEqual
                 && $existing_var_atomic_type instanceof TLiteralFloat
                 && (string)$existing_var_atomic_type->value === $value
             ) {
@@ -1337,7 +1248,7 @@ private static function handleLiteralEqualityWithString(
         //here we'll accept non-literal type that *could* match on loose equality and return the original type
         foreach ($existing_var_atomic_types as $existing_var_atomic_type) {
             //here we'll accept non-literal type that *could* match on loose equality and return the original type
-            if ($is_loose_equality) {
+            if ($assertion instanceof IsLooselyEqual) {
                 if ($existing_var_atomic_type instanceof TInt
                     && !$existing_var_atomic_type instanceof TLiteralInt
                 ) {
@@ -1375,9 +1286,8 @@ private static function handleLiteralEqualityWithString(
      */
     private static function handleLiteralEqualityWithFloat(
         StatementsAnalyzer $statements_analyzer,
-        string             $assertion,
-        int                $bracket_pos,
-        bool               $is_loose_equality,
+        Assertion      $assertion,
+        TLiteralFloat      $assertion_type,
         Union              $existing_var_type,
         array              $existing_var_atomic_types,
         string             $old_var_type_string,
@@ -1386,7 +1296,7 @@ private static function handleLiteralEqualityWithFloat(
         ?CodeLocation      $code_location,
         array              $suppressed_issues
     ): Union {
-        $value = (float)substr($assertion, $bracket_pos + 1, -1);
+        $value = $assertion_type->value;
 
         // we create the literal that is being asserted. We'll return this when we're sure this is the resulting type
         $literal_asserted_type = new Union([new TLiteralFloat($value)]);
@@ -1395,8 +1305,8 @@ private static function handleLiteralEqualityWithFloat(
         $compatible_float_type = self::getCompatibleFloatType(
             $existing_var_type,
             $existing_var_atomic_types,
-            $value,
-            $is_loose_equality
+            $assertion_type,
+            $assertion instanceof IsLooselyEqual
         );
 
         if ($compatible_float_type !== null) {
@@ -1434,8 +1344,8 @@ private static function handleLiteralEqualityWithFloat(
                 $compatible_float_type = self::getCompatibleFloatType(
                     $existing_var_type,
                     $existing_var_atomic_type->as->getAtomicTypes(),
-                    $value,
-                    $is_loose_equality
+                    $assertion_type,
+                    $assertion instanceof IsLooselyEqual
                 );
                 if ($compatible_float_type !== null) {
                     return $compatible_float_type;
@@ -1450,8 +1360,7 @@ private static function handleLiteralEqualityWithFloat(
                 $existing_var_atomic_type->as = self::handleLiteralEquality(
                     $statements_analyzer,
                     $assertion,
-                    $bracket_pos,
-                    false,
+                    $assertion_type,
                     $existing_var_atomic_type->as,
                     $old_var_type_string,
                     $var_id,
@@ -1463,14 +1372,14 @@ private static function handleLiteralEqualityWithFloat(
                 return new Union([$existing_var_atomic_type]);
             }
 
-            if ($is_loose_equality
+            if ($assertion instanceof IsLooselyEqual
                 && $existing_var_atomic_type instanceof TLiteralInt
                 && (float)$existing_var_atomic_type->value === $value
             ) {
                 return new Union([$existing_var_atomic_type]);
             }
 
-            if ($is_loose_equality
+            if ($assertion instanceof IsLooselyEqual
                 && $existing_var_atomic_type instanceof TLiteralString
                 && (float)$existing_var_atomic_type->value === $value
             ) {
@@ -1480,7 +1389,7 @@ private static function handleLiteralEqualityWithFloat(
 
         //here we'll accept non-literal type that *could* match on loose equality and return the original type
         foreach ($existing_var_atomic_types as $existing_var_atomic_type) {
-            if ($is_loose_equality) {
+            if ($assertion instanceof IsLooselyEqual) {
                 if ($existing_var_atomic_type instanceof TInt
                     && !$existing_var_atomic_type instanceof TLiteralInt
                 ) {
@@ -1518,7 +1427,7 @@ private static function handleLiteralEqualityWithFloat(
     private static function getCompatibleIntType(
         Union $existing_var_type,
         array $existing_var_atomic_types,
-        int $value,
+        TLiteralInt $assertion_type,
         bool $is_loose_equality
     ): ?Union {
         foreach ($existing_var_atomic_types as $existing_var_atomic_type) {
@@ -1531,9 +1440,9 @@ private static function getCompatibleIntType(
                     return $existing_var_type;
                 }
 
-                $asserted_type = new Union([new TLiteralInt($value)]);
-                $asserted_type->from_docblock = $existing_var_type->from_docblock;
-                return $asserted_type;
+                $assertion_type = new Union([clone $assertion_type]);
+                $assertion_type->from_docblock = $existing_var_type->from_docblock;
+                return $assertion_type;
             }
         }
 
@@ -1546,8 +1455,7 @@ private static function getCompatibleIntType(
     private static function getCompatibleStringType(
         Union $existing_var_type,
         array $existing_var_atomic_types,
-        string $value,
-        string $scalar_type,
+        TLiteralString $assertion_type,
         bool $is_loose_equality
     ): ?Union {
         foreach ($existing_var_atomic_types as $existing_var_atomic_type) {
@@ -1559,18 +1467,15 @@ private static function getCompatibleStringType(
                     return $existing_var_type;
                 }
 
-                if ($scalar_type === 'class-string'
-                    || $scalar_type === 'interface-string'
-                    || $scalar_type === 'trait-string'
-                ) {
-                    $asserted_type = new Union([new TLiteralClassString($value)]);
-                    $asserted_type->from_docblock = $existing_var_type->from_docblock;
-                    return $asserted_type;
+                if ($assertion_type instanceof TLiteralClassString) {
+                    $assertion_type = new Union([clone $assertion_type]);
+                    $assertion_type->from_docblock = $existing_var_type->from_docblock;
+                    return $assertion_type;
                 }
 
-                $asserted_type = new Union([new TLiteralString($value)]);
-                $asserted_type->from_docblock = $existing_var_type->from_docblock;
-                return $asserted_type;
+                $assertion_type = new Union([clone $assertion_type]);
+                $assertion_type->from_docblock = $existing_var_type->from_docblock;
+                return $assertion_type;
             }
         }
 
@@ -1583,7 +1488,7 @@ private static function getCompatibleStringType(
     private static function getCompatibleFloatType(
         Union $existing_var_type,
         array $existing_var_atomic_types,
-        float $value,
+        TLiteralFloat $assertion_type,
         bool $is_loose_equality
     ): ?Union {
         foreach ($existing_var_atomic_types as $existing_var_atomic_type) {
@@ -1595,9 +1500,9 @@ private static function getCompatibleFloatType(
                     return $existing_var_type;
                 }
 
-                $asserted_type = new Union([new TLiteralFloat($value)]);
-                $asserted_type->from_docblock = $existing_var_type->from_docblock;
-                return $asserted_type;
+                $assertion_type = new Union([clone $assertion_type]);
+                $assertion_type->from_docblock = $existing_var_type->from_docblock;
+                return $assertion_type;
             }
         }
 
@@ -1605,51 +1510,52 @@ private static function getCompatibleFloatType(
     }
 
     /**
-     * @param array<string, array<string, Union>> $template_type_map
      * @param array<string>           $suppressed_issues
+     * @return non-empty-list<Atomic>
      */
     private static function handleIsA(
+        IsAClass $assertion,
         Codebase $codebase,
         Union $existing_var_type,
-        string &$assertion,
-        array $template_type_map,
         ?CodeLocation $code_location,
         ?string $key,
         array $suppressed_issues,
         bool &$should_return
-    ): Union {
-        $assertion = substr($assertion, 4);
+    ): array {
+        $allow_string_comparison = $assertion->allow_string;
 
-        $allow_string_comparison = false;
-
-        if (strpos($assertion, 'string-') === 0) {
-            $assertion = substr($assertion, 7);
-            $allow_string_comparison = true;
-        }
+        $assertion_type = $assertion->type;
 
         if ($existing_var_type->hasMixed()) {
-            $type = new Union([
-                new TNamedObject($assertion),
-            ]);
+            if (!$assertion_type instanceof TNamedObject) {
+                return [clone $assertion_type];
+            }
+
+            $types = [clone $assertion_type];
 
             if ($allow_string_comparison) {
-                $type->addType(
-                    new TClassString(
-                        $assertion,
-                        new TNamedObject($assertion)
-                    )
+                $types[] = new TClassString(
+                    $assertion_type->value,
+                    clone $assertion_type
                 );
             }
 
             $should_return = true;
-            return $type;
+            return $types;
         }
 
         $existing_has_object = $existing_var_type->hasObjectType();
         $existing_has_string = $existing_var_type->hasString();
 
         if ($existing_has_object && !$existing_has_string) {
-            return Type::parseString($assertion, null, $template_type_map);
+            if ($assertion_type instanceof TTemplateParamClass) {
+                return [new TTemplateParam(
+                    $assertion_type->param_name,
+                    new Union([$assertion_type->as_type ? clone $assertion_type->as_type : new TObject()]),
+                    $assertion_type->defining_class
+                )];
+            }
+            return [$assertion_type];
         }
 
         if ($existing_has_string && !$existing_has_object) {
@@ -1663,9 +1569,13 @@ private static function handleIsA(
                     $suppressed_issues
                 );
 
-                return Type::getMixed();
+                return [new TMixed()];
             } else {
-                $new_type_has_interface_string = $codebase->interfaceExists($assertion);
+                if (!$assertion_type instanceof TNamedObject) {
+                    return [clone $assertion_type];
+                }
+
+                $new_type_has_interface_string = $codebase->interfaceExists($assertion_type->value);
 
                 $old_type_has_interface_string = false;
 
@@ -1679,15 +1589,7 @@ private static function handleIsA(
                     }
                 }
 
-                if (isset($template_type_map[$assertion])) {
-                    $new_type = Type::parseString(
-                        'class-string<' . $assertion . '>',
-                        null,
-                        $template_type_map
-                    );
-                } else {
-                    $new_type = Type::getClassString($assertion);
-                }
+                $new_type = Type::getClassString($assertion_type->value);
 
                 if ((
                         $new_type_has_interface_string
@@ -1706,14 +1608,12 @@ private static function handleIsA(
                         )
                     )
                 ) {
-                    $new_type_part = Atomic::create($assertion, null, $template_type_map);
+                    $new_type_part = clone $assertion_type;
 
                     $acceptable_atomic_types = [];
 
                     foreach ($existing_var_type->getAtomicTypes() as $existing_var_type_part) {
-                        if (!$new_type_part instanceof TNamedObject
-                            || !$existing_var_type_part instanceof TClassString
-                        ) {
+                        if (!$existing_var_type_part instanceof TClassString) {
                             $acceptable_atomic_types = [];
 
                             break;
@@ -1748,16 +1648,14 @@ private static function handleIsA(
                     if (count($acceptable_atomic_types) === 1) {
                         $should_return = true;
 
-                        return new Union([
-                            new TClassString('object', $acceptable_atomic_types[0]),
-                        ]);
+                        return [new TClassString('object', $acceptable_atomic_types[0])];
                     }
                 }
             }
 
-            return $new_type;
+            return [$new_type->getSingleAtomic()];
         } else {
-            return Type::getMixed();
+            return [new TMixed()];
         }
     }
 }
diff --git a/src/Psalm/Internal/Type/NegatedAssertionReconciler.php b/src/Psalm/Internal/Type/NegatedAssertionReconciler.php
index 9d09707cda3..0092b093a6b 100644
--- a/src/Psalm/Internal/Type/NegatedAssertionReconciler.php
+++ b/src/Psalm/Internal/Type/NegatedAssertionReconciler.php
@@ -7,14 +7,25 @@
 use Psalm\Internal\Analyzer\TraitAnalyzer;
 use Psalm\Internal\Type\Comparator\AtomicTypeComparator;
 use Psalm\Internal\Type\Comparator\UnionTypeComparator;
+use Psalm\Storage\Assertion;
+use Psalm\Storage\Assertion\IsClassNotEqual;
+use Psalm\Storage\Assertion\IsNotCountable;
+use Psalm\Storage\Assertion\IsNotIdentical;
+use Psalm\Storage\Assertion\IsNotPositiveNumeric;
+use Psalm\Storage\Assertion\IsNotType;
 use Psalm\Type;
+use Psalm\Type\Atomic;
 use Psalm\Type\Atomic\TArray;
+use Psalm\Type\Atomic\TClassString;
 use Psalm\Type\Atomic\TEmptyMixed;
 use Psalm\Type\Atomic\TEnumCase;
 use Psalm\Type\Atomic\TFalse;
 use Psalm\Type\Atomic\TFloat;
 use Psalm\Type\Atomic\TInt;
 use Psalm\Type\Atomic\TIterable;
+use Psalm\Type\Atomic\TLiteralFloat;
+use Psalm\Type\Atomic\TLiteralInt;
+use Psalm\Type\Atomic\TLiteralString;
 use Psalm\Type\Atomic\TNamedObject;
 use Psalm\Type\Atomic\TNonEmptyString;
 use Psalm\Type\Atomic\TString;
@@ -23,11 +34,8 @@
 use Psalm\Type\Union;
 
 use function count;
-use function explode;
 use function get_class;
-use function strpos;
 use function strtolower;
-use function substr;
 
 /**
  * @internal
@@ -41,11 +49,8 @@ class NegatedAssertionReconciler extends Reconciler
      */
     public static function reconcile(
         StatementsAnalyzer $statements_analyzer,
-        string $assertion,
-        bool $is_strict_equality,
-        bool $is_loose_equality,
+        Assertion $assertion,
         Union $existing_var_type,
-        array $template_type_map,
         string $old_var_type_string,
         ?string $key,
         bool $negated,
@@ -54,10 +59,17 @@ public static function reconcile(
         int &$failed_reconciliation,
         bool $inside_loop
     ): Union {
-        $is_equality = $is_strict_equality || $is_loose_equality;
+        $is_equality = $assertion->hasEquality();
+
+        $assertion_type = $assertion->getAtomicType();
 
         // this is a specific value comparison type that cannot be negated
-        if ($is_equality && $bracket_pos = strpos($assertion, '(')) {
+        if ($is_equality
+            && ($assertion_type instanceof TLiteralFloat
+                || $assertion_type instanceof TLiteralInt
+                || $assertion_type instanceof TLiteralString
+                || $assertion_type instanceof TEnumCase)
+        ) {
             if ($existing_var_type->hasMixed()) {
                 return $existing_var_type;
             }
@@ -65,27 +77,26 @@ public static function reconcile(
             return self::handleLiteralNegatedEquality(
                 $statements_analyzer,
                 $assertion,
-                $bracket_pos,
+                $assertion_type,
                 $existing_var_type,
                 $old_var_type_string,
                 $key,
                 $negated,
                 $code_location,
-                $suppressed_issues,
-                $is_strict_equality
+                $suppressed_issues
             );
         }
 
-        if ($is_equality && $assertion === 'positive-numeric') {
+        if ($is_equality && $assertion instanceof IsNotPositiveNumeric) {
             return $existing_var_type;
         }
 
         $existing_var_atomic_types = $existing_var_type->getAtomicTypes();
 
-        if ($assertion === 'false' && isset($existing_var_atomic_types['bool'])) {
+        if ($assertion_type instanceof TFalse && isset($existing_var_atomic_types['bool'])) {
             $existing_var_type->removeType('bool');
             $existing_var_type->addType(new TTrue);
-        } elseif ($assertion === 'true' && isset($existing_var_atomic_types['bool'])) {
+        } elseif ($assertion_type instanceof TTrue && isset($existing_var_atomic_types['bool'])) {
             $existing_var_type->removeType('bool');
             $existing_var_type->addType(new TFalse);
         } else {
@@ -107,18 +118,24 @@ public static function reconcile(
             }
         }
 
-        if ($assertion === 'iterable' || $assertion === 'countable') {
+        $assertion_type = $assertion->getAtomicType();
+
+        if (($assertion instanceof IsNotType
+                && $assertion_type instanceof TIterable
+                && $assertion_type->type_params[1]->isMixed())
+            || $assertion instanceof IsNotCountable
+        ) {
             $existing_var_type->removeType('array');
         }
 
         if (!$is_equality
             && isset($existing_var_atomic_types['int'])
             && $existing_var_type->from_calculation
-            && ($assertion === 'int' || $assertion === 'float')
+            && ($assertion_type instanceof TInt || $assertion_type instanceof TFloat)
         ) {
-            $existing_var_type->removeType($assertion);
+            $existing_var_type->removeType($assertion_type->getKey());
 
-            if ($assertion === 'int') {
+            if ($assertion_type instanceof TInt) {
                 $existing_var_type->addType(new TFloat);
             } else {
                 $existing_var_type->addType(new TInt);
@@ -130,12 +147,13 @@ public static function reconcile(
         }
 
         if (!$is_equality
-            && ($assertion === 'DateTime' || $assertion === 'DateTimeImmutable')
+            && $assertion_type instanceof TNamedObject
+            && ($assertion_type->value === 'DateTime' || $assertion_type->value === 'DateTimeImmutable')
             && isset($existing_var_atomic_types['DateTimeInterface'])
         ) {
             $existing_var_type->removeType('DateTimeInterface');
 
-            if ($assertion === 'DateTime') {
+            if ($assertion_type->value === 'DateTime') {
                 $existing_var_type->addType(new TNamedObject('DateTimeImmutable'));
             } else {
                 $existing_var_type->addType(new TNamedObject('DateTime'));
@@ -144,7 +162,8 @@ public static function reconcile(
             return $existing_var_type;
         }
 
-        if (strtolower($assertion) === 'traversable'
+        if ($assertion_type instanceof TNamedObject
+            && strtolower($assertion_type->value) === 'traversable'
             && isset($existing_var_atomic_types['iterable'])
         ) {
             /** @var TIterable */
@@ -158,80 +177,76 @@ public static function reconcile(
                     clone $iterable->type_params[1],
                 ]
             ));
-        } elseif (strtolower($assertion) === 'int'
+        } elseif ($assertion_type instanceof TInt
             && isset($existing_var_type->getAtomicTypes()['array-key'])
         ) {
             $existing_var_type->removeType('array-key');
             $existing_var_type->addType(new TString);
-        } elseif (strpos($assertion, 'getclass-') === 0) {
-            $assertion = substr($assertion, 9);
+        } elseif ($assertion instanceof IsClassNotEqual) {
+            // do nothing
+        } elseif ($assertion_type instanceof TClassString && $assertion_type->is_loaded) {
+            // do nothing
         } elseif ($existing_var_type->isSingle()
             && $existing_var_type->hasNamedObjectType()
-            && isset($existing_var_type->getAtomicTypes()[$assertion])
+            && $assertion_type instanceof TNamedObject
+            && isset($existing_var_type->getAtomicTypes()[$assertion_type->getKey()])
         ) {
             // checking if two types share a common parent is not enough to guarantee childs are instanceof each other
             // fall through
         } elseif (!$is_equality) {
             $codebase = $statements_analyzer->getCodebase();
 
+            $assertion_type = $assertion->getAtomicType();
+
             // if there wasn't a direct hit, go deeper, eliminating subtypes
-            if (!$existing_var_type->removeType($assertion)) {
-                if (!strpos($assertion, '-')) {
-                    $assertion_type = Type::parseString($assertion, null, $template_type_map);
-
-                    if ($assertion_type->isSingle()) {
-                        $new_type_part = $assertion_type->getSingleAtomic();
-
-                        if ($new_type_part instanceof TNamedObject) {
-                            foreach ($existing_var_type->getAtomicTypes() as $part_name => $existing_var_type_part) {
-                                if (!$existing_var_type_part->isObjectType()) {
-                                    continue;
-                                }
-
-                                if (AtomicTypeComparator::isContainedBy(
-                                    $codebase,
-                                    $existing_var_type_part,
-                                    $new_type_part,
-                                    false,
-                                    false
-                                )) {
-                                    $existing_var_type->removeType($part_name);
-                                } elseif (AtomicTypeComparator::isContainedBy(
-                                    $codebase,
-                                    $new_type_part,
-                                    $existing_var_type_part,
-                                    false,
-                                    false
-                                )) {
-                                    $existing_var_type->different = true;
-                                }
-                            }
+            if ($assertion_type && !$existing_var_type->removeType($assertion_type->getKey())) {
+                if ($assertion_type instanceof TNamedObject) {
+                    foreach ($existing_var_type->getAtomicTypes() as $part_name => $existing_var_type_part) {
+                        if (!$existing_var_type_part->isObjectType()) {
+                            continue;
+                        }
+
+                        if (AtomicTypeComparator::isContainedBy(
+                            $codebase,
+                            $existing_var_type_part,
+                            $assertion_type,
+                            false,
+                            false
+                        )) {
+                            $existing_var_type->removeType($part_name);
+                        } elseif (AtomicTypeComparator::isContainedBy(
+                            $codebase,
+                            $assertion_type,
+                            $existing_var_type_part,
+                            false,
+                            false
+                        )) {
+                            $existing_var_type->different = true;
                         }
                     }
                 }
             }
         }
 
-        if ($is_strict_equality
-            && $assertion !== 'isset'
+        if ($assertion instanceof IsNotIdentical
             && ($key !== '$this'
                 || !($statements_analyzer->getSource()->getSource() instanceof TraitAnalyzer))
         ) {
-            $assertion = Type::parseString($assertion, null, $template_type_map);
+            $assertion_type = new Union([clone $assertion->type]);
 
             if ($key
                 && $code_location
                 && !UnionTypeComparator::canExpressionTypesBeIdentical(
                     $statements_analyzer->getCodebase(),
                     $existing_var_type,
-                    $assertion
+                    $assertion_type
                 )
             ) {
                 self::triggerIssueForImpossible(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!=' . $assertion,
+                    $assertion,
                     true,
                     $negated,
                     $code_location,
@@ -249,7 +264,7 @@ public static function reconcile(
                         $existing_var_type,
                         $old_var_type_string,
                         $key,
-                        '!' . $assertion,
+                        $assertion,
                         false,
                         $negated,
                         $code_location,
@@ -267,23 +282,21 @@ public static function reconcile(
     }
 
     /**
+     * @param  TLiteralInt|TLiteralString|TLiteralFloat|TEnumCase $assertion_type
      * @param  string[]   $suppressed_issues
      *
      */
     private static function handleLiteralNegatedEquality(
         StatementsAnalyzer $statements_analyzer,
-        string $assertion,
-        int $bracket_pos,
+        Assertion $assertion,
+        Atomic $assertion_type,
         Union $existing_var_type,
         string $old_var_type_string,
         ?string $key,
         bool $negated,
         ?CodeLocation $code_location,
-        array $suppressed_issues,
-        bool $is_strict_equality
+        array $suppressed_issues
     ): Union {
-        $scalar_type = substr($assertion, 0, $bracket_pos);
-
         $existing_var_atomic_types = $existing_var_type->getAtomicTypes();
 
         $did_remove_type = false;
@@ -291,62 +304,49 @@ private static function handleLiteralNegatedEquality(
 
         $scalar_var_type = null;
 
-        if ($scalar_type === 'int') {
+        if ($assertion_type instanceof TLiteralInt) {
             if ($existing_var_type->hasInt()) {
-                if ($existing_int_types = $existing_var_type->getLiteralInts()) {
+                if ($existing_var_type->getLiteralInts()) {
                     if (!$existing_var_type->hasPositiveInt()) {
                         $did_match_literal_type = true;
                     }
 
-                    if (isset($existing_int_types[$assertion])) {
-                        $existing_var_type->removeType($assertion);
-
+                    if ($existing_var_type->removeType($assertion_type->getKey())) {
                         $did_remove_type = true;
                     }
                 }
             } else {
-                $scalar_value = substr($assertion, $bracket_pos + 1, -1);
-                $scalar_var_type = Type::getInt(false, (int) $scalar_value);
+                $scalar_var_type = clone $assertion_type;
             }
-        } elseif ($scalar_type === 'string'
-            || $scalar_type === 'class-string'
-            || $scalar_type === 'interface-string'
-            || $scalar_type === 'trait-string'
-            || $scalar_type === 'callable-string'
-        ) {
+        } elseif ($assertion_type instanceof TLiteralString) {
             if ($existing_var_type->hasString()) {
-                if ($existing_string_types = $existing_var_type->getLiteralStrings()) {
+                if ($existing_var_type->getLiteralStrings()) {
                     $did_match_literal_type = true;
 
-                    if (isset($existing_string_types[$assertion])) {
-                        $existing_var_type->removeType($assertion);
-
+                    if ($existing_var_type->removeType($assertion_type->getKey())) {
                         $did_remove_type = true;
                     }
-                } elseif ($assertion === 'string()') {
+                } elseif ($assertion_type->value === "") {
                     $existing_var_type->addType(new TNonEmptyString());
                 }
-            } elseif ($scalar_type === 'string') {
-                $scalar_value = substr($assertion, $bracket_pos + 1, -1);
-                $scalar_var_type = Type::getString($scalar_value);
+            } elseif (get_class($assertion_type) === TLiteralString::class) {
+                $scalar_var_type = clone $assertion_type;
             }
-        } elseif ($scalar_type === 'float') {
+        } elseif ($assertion_type instanceof TLiteralFloat) {
             if ($existing_var_type->hasFloat()) {
-                if ($existing_float_types = $existing_var_type->getLiteralFloats()) {
+                if ($existing_var_type->getLiteralFloats()) {
                     $did_match_literal_type = true;
 
-                    if (isset($existing_float_types[$assertion])) {
-                        $existing_var_type->removeType($assertion);
-
+                    if ($existing_var_type->removeType($assertion_type->getKey())) {
                         $did_remove_type = true;
                     }
                 }
             } else {
-                $scalar_value = substr($assertion, $bracket_pos + 1, -1);
-                $scalar_var_type = Type::getFloat((float) $scalar_value);
+                $scalar_var_type = clone $assertion_type;
             }
-        } elseif ($scalar_type === 'enum') {
-            [$fq_enum_name, $case_name] = explode('::', substr($assertion, $bracket_pos + 1, -1));
+        } else {
+            $fq_enum_name = $assertion_type->value;
+            $case_name = $assertion_type->case_name;
 
             foreach ($existing_var_type->getAtomicTypes() as $atomic_key => $atomic_type) {
                 if (get_class($atomic_type) === TNamedObject::class
@@ -357,7 +357,7 @@ private static function handleLiteralNegatedEquality(
                     $enum_storage = $codebase->classlike_storage_provider->get($fq_enum_name);
 
                     if (!$enum_storage->is_enum || !$enum_storage->enum_cases) {
-                        $scalar_var_type = new Union([new TEnumCase($fq_enum_name, $case_name)]);
+                        $scalar_var_type = clone $assertion_type;
                     } else {
                         $existing_var_type->removeType($atomic_type->getKey());
                         $did_remove_type = true;
@@ -375,8 +375,8 @@ private static function handleLiteralNegatedEquality(
                     && $atomic_type->case_name !== $case_name
                 ) {
                     $did_match_literal_type = true;
-                } elseif ($atomic_key === $assertion) {
-                    $existing_var_type->removeType($assertion);
+                } elseif ($atomic_key === $assertion_type->getKey()) {
+                    $existing_var_type->removeType($assertion_type->getKey());
                     $did_remove_type = true;
                 }
             }
@@ -390,27 +390,27 @@ private static function handleLiteralNegatedEquality(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!' . $assertion,
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
                     $suppressed_issues
                 );
             } elseif ($scalar_var_type
-                && $is_strict_equality
+                && $assertion instanceof IsNotIdentical
                 && ($key !== '$this'
                     || !($statements_analyzer->getSource()->getSource() instanceof TraitAnalyzer))
             ) {
                 if (!UnionTypeComparator::canExpressionTypesBeIdentical(
                     $statements_analyzer->getCodebase(),
                     $existing_var_type,
-                    $scalar_var_type
+                    new Union([$scalar_var_type])
                 )) {
                     self::triggerIssueForImpossible(
                         $existing_var_type,
                         $old_var_type_string,
                         $key,
-                        '!=' . $assertion,
+                        $assertion,
                         true,
                         $negated,
                         $code_location,
diff --git a/src/Psalm/Internal/Type/SimpleAssertionReconciler.php b/src/Psalm/Internal/Type/SimpleAssertionReconciler.php
index e25e755a037..84d7eef7798 100644
--- a/src/Psalm/Internal/Type/SimpleAssertionReconciler.php
+++ b/src/Psalm/Internal/Type/SimpleAssertionReconciler.php
@@ -7,6 +7,27 @@
 use Psalm\Internal\Codebase\ClassConstantByWildcardResolver;
 use Psalm\Internal\Codebase\InternalCallMapHandler;
 use Psalm\Internal\Type\TypeCombiner;
+use Psalm\Storage\Assertion;
+use Psalm\Storage\Assertion\Any;
+use Psalm\Storage\Assertion\ArrayKeyExists;
+use Psalm\Storage\Assertion\HasArrayKey;
+use Psalm\Storage\Assertion\HasAtLeastCount;
+use Psalm\Storage\Assertion\HasExactCount;
+use Psalm\Storage\Assertion\HasIntOrStringArrayAccess;
+use Psalm\Storage\Assertion\HasMethod;
+use Psalm\Storage\Assertion\HasStringArrayAccess;
+use Psalm\Storage\Assertion\InArray;
+use Psalm\Storage\Assertion\IsCountable;
+use Psalm\Storage\Assertion\IsEqualIsset;
+use Psalm\Storage\Assertion\IsGreaterThan;
+use Psalm\Storage\Assertion\IsIsset;
+use Psalm\Storage\Assertion\IsLessThan;
+use Psalm\Storage\Assertion\IsLooselyEqual;
+use Psalm\Storage\Assertion\IsPositiveNumeric;
+use Psalm\Storage\Assertion\IsType;
+use Psalm\Storage\Assertion\NonEmpty;
+use Psalm\Storage\Assertion\NonEmptyCountable;
+use Psalm\Storage\Assertion\Truthy;
 use Psalm\Type;
 use Psalm\Type\Atomic\Scalar;
 use Psalm\Type\Atomic\TArray;
@@ -18,29 +39,31 @@
 use Psalm\Type\Atomic\TCallableList;
 use Psalm\Type\Atomic\TCallableObject;
 use Psalm\Type\Atomic\TCallableString;
+use Psalm\Type\Atomic\TClassConstant;
 use Psalm\Type\Atomic\TClassString;
-use Psalm\Type\Atomic\TEmptyMixed;
-use Psalm\Type\Atomic\TEmptyNumeric;
-use Psalm\Type\Atomic\TEmptyScalar;
 use Psalm\Type\Atomic\TFalse;
+use Psalm\Type\Atomic\TFloat;
 use Psalm\Type\Atomic\TGenericObject;
 use Psalm\Type\Atomic\TInt;
 use Psalm\Type\Atomic\TIntRange;
 use Psalm\Type\Atomic\TIterable;
 use Psalm\Type\Atomic\TKeyedArray;
 use Psalm\Type\Atomic\TList;
-use Psalm\Type\Atomic\TLiteralFloat;
 use Psalm\Type\Atomic\TLiteralInt;
 use Psalm\Type\Atomic\TLiteralString;
+use Psalm\Type\Atomic\TLowercaseString;
 use Psalm\Type\Atomic\TMixed;
 use Psalm\Type\Atomic\TNamedObject;
 use Psalm\Type\Atomic\TNever;
 use Psalm\Type\Atomic\TNonEmptyArray;
 use Psalm\Type\Atomic\TNonEmptyList;
 use Psalm\Type\Atomic\TNonEmptyLowercaseString;
+use Psalm\Type\Atomic\TNonEmptyMixed;
 use Psalm\Type\Atomic\TNonEmptyNonspecificLiteralString;
+use Psalm\Type\Atomic\TNonEmptyScalar;
 use Psalm\Type\Atomic\TNonEmptyString;
 use Psalm\Type\Atomic\TNonFalsyString;
+use Psalm\Type\Atomic\TNonspecificLiteralString;
 use Psalm\Type\Atomic\TNull;
 use Psalm\Type\Atomic\TNumeric;
 use Psalm\Type\Atomic\TNumericString;
@@ -51,6 +74,7 @@
 use Psalm\Type\Atomic\TScalar;
 use Psalm\Type\Atomic\TString;
 use Psalm\Type\Atomic\TTemplateParam;
+use Psalm\Type\Atomic\TTrue;
 use Psalm\Type\Reconciler;
 use Psalm\Type\Union;
 
@@ -61,7 +85,6 @@
 use function max;
 use function min;
 use function strpos;
-use function substr;
 
 /**
  * This class receives a known type and an assertion (probably coming from AssertionFinder). The goal is to refine
@@ -77,7 +100,7 @@ class SimpleAssertionReconciler extends Reconciler
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     public static function reconcile(
-        string $assertion,
+        Assertion $assertion,
         Codebase $codebase,
         Union $existing_var_type,
         ?string $key = null,
@@ -85,40 +108,41 @@ public static function reconcile(
         ?CodeLocation $code_location = null,
         array $suppressed_issues = [],
         int &$failed_reconciliation = Reconciler::RECONCILIATION_OK,
-        bool $is_equality = false,
-        bool $is_strict_equality = false,
         bool $inside_loop = false
     ): ?Union {
-        if ($assertion === 'mixed' && $existing_var_type->hasMixed()) {
+        if ($assertion instanceof Any && $existing_var_type->hasMixed()) {
             return $existing_var_type;
         }
 
         $old_var_type_string = $existing_var_type->getId();
 
-        if ($assertion === 'isset') {
+        $is_equality = $assertion->hasEquality();
+
+        if ($assertion instanceof IsIsset || $assertion instanceof IsEqualIsset) {
             return self::reconcileIsset(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $is_equality,
+                $assertion instanceof IsEqualIsset,
                 $inside_loop
             );
         }
 
-        if ($assertion === 'array-key-exists') {
+        if ($assertion instanceof ArrayKeyExists) {
             $existing_var_type->possibly_undefined = false;
 
             return $existing_var_type;
         }
 
-        if (strpos($assertion, 'in-array-') === 0) {
+        if ($assertion instanceof InArray) {
             return self::reconcileInArray(
+                $assertion,
                 $codebase,
                 $existing_var_type,
-                substr($assertion, 9),
                 $key,
                 $negated,
                 $code_location,
@@ -127,17 +151,17 @@ public static function reconcile(
             );
         }
 
-        if (strpos($assertion, 'has-array-key-') === 0) {
+        if ($assertion instanceof HasArrayKey) {
             return self::reconcileHasArrayKey(
                 $existing_var_type,
-                substr($assertion, 14)
+                $assertion
             );
         }
 
-        if ($assertion[0] === '>') {
+        if ($assertion instanceof IsGreaterThan) {
             return self::reconcileSuperiorTo(
-                $existing_var_type,
                 $assertion,
+                $existing_var_type,
                 $inside_loop,
                 $old_var_type_string,
                 $key,
@@ -147,10 +171,10 @@ public static function reconcile(
             );
         }
 
-        if ($assertion[0] === '<') {
+        if ($assertion instanceof IsLessThan) {
             return self::reconcileInferiorTo(
-                $existing_var_type,
                 $assertion,
+                $existing_var_type,
                 $inside_loop,
                 $old_var_type_string,
                 $key,
@@ -160,8 +184,8 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'falsy' || $assertion === 'empty') {
-            return self::reconcileFalsyOrEmpty(
+        if ($assertion instanceof Truthy || $assertion instanceof NonEmpty) {
+            return self::reconcileTruthyOrNonEmpty(
                 $assertion,
                 $existing_var_type,
                 $key,
@@ -173,8 +197,10 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'object') {
-            return self::reconcileObject(
+        if ($assertion instanceof IsCountable) {
+            return self::reconcileCountable(
+                $assertion,
+                $codebase,
                 $existing_var_type,
                 $key,
                 $negated,
@@ -185,20 +211,23 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'resource') {
-            return self::reconcileResource(
+        if ($assertion instanceof HasStringArrayAccess) {
+            return self::reconcileStringArrayAccess(
+                $assertion,
+                $codebase,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $is_equality
+                $inside_loop
             );
         }
 
-        if ($assertion === 'callable') {
-            return self::reconcileCallable(
+        if ($assertion instanceof HasIntOrStringArrayAccess) {
+            return self::reconcileIntArrayAccess(
+                $assertion,
                 $codebase,
                 $existing_var_type,
                 $key,
@@ -206,13 +235,13 @@ public static function reconcile(
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $is_equality
+                $inside_loop
             );
         }
 
-        if ($assertion === 'iterable') {
-            return self::reconcileIterable(
-                $codebase,
+        if ($assertion instanceof IsPositiveNumeric) {
+            return self::reconcilePositiveNumeric(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
@@ -223,8 +252,9 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'array') {
-            return self::reconcileArray(
+        if ($assertion instanceof NonEmptyCountable) {
+            return self::reconcileNonEmptyCountable(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
@@ -235,48 +265,44 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'list') {
-            return self::reconcileList(
+        if ($assertion instanceof HasAtLeastCount) {
+            return self::reconcileNonEmptyCountable(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $is_equality,
-                false
+                $is_equality
             );
         }
 
-        if ($assertion === 'non-empty-list') {
-            return self::reconcileList(
+        if ($assertion instanceof HasExactCount) {
+            return self::reconcileExactlyCountable(
                 $existing_var_type,
-                $key,
-                $negated,
-                $code_location,
-                $suppressed_issues,
-                $failed_reconciliation,
-                $is_equality,
-                true
+                $assertion->count
             );
         }
 
-        if ($assertion === 'Traversable') {
-            return self::reconcileTraversable(
+        if ($assertion instanceof HasMethod) {
+            return self::reconcileHasMethod(
+                $assertion,
                 $codebase,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
-                $failed_reconciliation,
-                $is_equality
+                $failed_reconciliation
             );
         }
 
-        if ($assertion === 'countable') {
-            return self::reconcileCountable(
-                $codebase,
+        $assertion_type = $assertion->getAtomicType();
+
+        if ($assertion_type instanceof TObject) {
+            return self::reconcileObject(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
@@ -287,21 +313,22 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'string-array-access') {
-            return self::reconcileStringArrayAccess(
-                $codebase,
+        if ($assertion_type instanceof TResource) {
+            return self::reconcileResource(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $inside_loop
+                $is_equality
             );
         }
 
-        if ($assertion === 'int-or-string-array-access') {
-            return self::reconcileIntArrayAccess(
+        if ($assertion_type instanceof TCallable) {
+            return self::reconcileCallable(
+                $assertion,
                 $codebase,
                 $existing_var_type,
                 $key,
@@ -309,12 +336,17 @@ public static function reconcile(
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $inside_loop
+                $is_equality
             );
         }
 
-        if ($assertion === 'numeric') {
-            return self::reconcileNumeric(
+        if ($assertion_type instanceof TIterable
+            && $assertion_type->type_params[0]->isMixed()
+            && $assertion_type->type_params[1]->isMixed()
+        ) {
+            return self::reconcileIterable(
+                $assertion,
+                $codebase,
                 $existing_var_type,
                 $key,
                 $negated,
@@ -325,8 +357,12 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'scalar') {
-            return self::reconcileScalar(
+        if ($assertion_type instanceof TArray
+            && $assertion_type->type_params[0]->isArrayKey()
+            && $assertion_type->type_params[1]->isMixed()
+        ) {
+            return self::reconcileArray(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
@@ -337,46 +373,54 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'bool') {
-            return self::reconcileBool(
+        if ($assertion_type instanceof TList
+            && $assertion_type->type_param->isMixed()
+        ) {
+            return self::reconcileList(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $is_equality
+                $is_equality,
+                $assertion_type instanceof TNonEmptyList
             );
         }
 
-        if ($assertion === 'string') {
-            return self::reconcileString(
+        if ($assertion_type instanceof TNamedObject
+            && $assertion_type->value === 'Traversable'
+        ) {
+            return self::reconcileTraversable(
+                $assertion,
+                $codebase,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $is_equality,
-                $is_strict_equality
+                $is_equality
             );
         }
 
-        if ($assertion === 'int') {
-            return self::reconcileInt(
+        if ($assertion_type instanceof TNumeric) {
+            return self::reconcileNumeric(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $is_equality,
-                $is_strict_equality
+                $is_equality
             );
         }
 
-        if ($assertion === 'positive-numeric') {
-            return self::reconcilePositiveNumeric(
+        if ($assertion_type instanceof TScalar) {
+            return self::reconcileScalar(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
@@ -387,55 +431,35 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'float'
-            && $existing_var_type->from_calculation
-            && $existing_var_type->hasInt()
-        ) {
-            return Type::getFloat();
-        }
-
-        if ($assertion === 'float' && $is_equality && !$is_strict_equality && $existing_var_type->isString()) {
-            return Type::getNumericString();
-        }
-
-        if ($assertion === 'non-empty-countable') {
-            return self::reconcileNonEmptyCountable(
+        if ($assertion_type && get_class($assertion_type) === TBool::class) {
+            return self::reconcileBool(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $is_equality,
-                null
+                $is_equality
             );
         }
 
-        if (strpos($assertion, 'has-at-least-') === 0) {
-            return self::reconcileNonEmptyCountable(
+        if ($assertion_type && get_class($assertion_type) === TString::class) {
+            return self::reconcileString(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $is_equality,
-                (int) substr($assertion, 13)
-            );
-        }
-
-        if (strpos($assertion, 'has-exactly-') === 0) {
-            /** @psalm-suppress ArgumentTypeCoercion */
-            return self::reconcileExactlyCountable(
-                $existing_var_type,
-                (int) substr($assertion, 12)
+                $is_equality
             );
         }
 
-        if (strpos($assertion, 'hasmethod-') === 0) {
-            return self::reconcileHasMethod(
-                $codebase,
-                substr($assertion, 10),
+        if ($assertion_type && get_class($assertion_type) === TInt::class) {
+            return self::reconcileInt(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
@@ -445,10 +469,22 @@ public static function reconcile(
             );
         }
 
-        if (substr($assertion, 0, 15) === 'class-constant(') {
+        if ($assertion_type instanceof TFloat) {
+            if ($existing_var_type->from_calculation
+                && $existing_var_type->hasInt()
+            ) {
+                return Type::getFloat();
+            }
+
+            if ($assertion instanceof IsLooselyEqual && $existing_var_type->isString()) {
+                return Type::getNumericString();
+            }
+        }
+
+        if ($assertion_type instanceof TClassConstant) {
             return self::reconcileClassConstant(
                 $codebase,
-                substr($assertion, 15, -1),
+                $assertion_type,
                 $existing_var_type,
                 $failed_reconciliation
             );
@@ -456,15 +492,13 @@ public static function reconcile(
 
         if ($existing_var_type->isSingle()
             && $existing_var_type->hasTemplate()
-            && strpos($assertion, '-') === false
-            && strpos($assertion, '(') === false
         ) {
             foreach ($existing_var_type->getAtomicTypes() as $atomic_type) {
-                if ($atomic_type instanceof TTemplateParam) {
+                if ($atomic_type instanceof TTemplateParam && $assertion_type) {
                     if ($atomic_type->as->hasMixed()
                         || $atomic_type->as->hasObject()
                     ) {
-                        $atomic_type->as = Type::parseString($assertion);
+                        $atomic_type->as = new Union([clone $assertion_type]);
 
                         return $existing_var_type;
                     }
@@ -480,6 +514,7 @@ public static function reconcile(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileIsset(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -513,7 +548,7 @@ private static function reconcileIsset(
                 $existing_var_type,
                 $old_var_type_string,
                 $key,
-                'isset',
+                $assertion,
                 !$did_remove_type,
                 $negated,
                 $code_location,
@@ -547,14 +582,14 @@ private static function reconcileIsset(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileNonEmptyCountable(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
         ?CodeLocation $code_location,
         array $suppressed_issues,
         int &$failed_reconciliation,
-        bool $is_equality,
-        ?int $min_count
+        bool $is_equality
     ): Union {
         $old_var_type_string = $existing_var_type->getId();
 
@@ -564,17 +599,18 @@ private static function reconcileNonEmptyCountable(
 
             if ($array_atomic_type instanceof TArray) {
                 if (!$array_atomic_type instanceof TNonEmptyArray
-                    || ($array_atomic_type->count < $min_count)
+                    || ($assertion instanceof HasAtLeastCount
+                        && $array_atomic_type->min_count < $assertion->count)
                 ) {
-                    if ($array_atomic_type->isEmptyArray()) {
+                    if ($array_atomic_type->getId() === 'array<empty, empty>') {
                         $existing_var_type->removeType('array');
                     } else {
                         $non_empty_array = new TNonEmptyArray(
                             $array_atomic_type->type_params
                         );
 
-                        if ($min_count) {
-                            $non_empty_array->count = $min_count;
+                        if ($assertion instanceof HasAtLeastCount) {
+                            $non_empty_array->min_count = $assertion->count;
                         }
 
                         $existing_var_type->addType($non_empty_array);
@@ -584,25 +620,51 @@ private static function reconcileNonEmptyCountable(
                 }
             } elseif ($array_atomic_type instanceof TList) {
                 if (!$array_atomic_type instanceof TNonEmptyList
-                    || ($array_atomic_type->count < $min_count)
+                    || ($assertion instanceof HasAtLeastCount
+                        && $array_atomic_type->count < $assertion->count)
                 ) {
                     $non_empty_list = new TNonEmptyList(
                         $array_atomic_type->type_param
                     );
 
-                    if ($min_count) {
-                        $non_empty_list->count = $min_count;
+                    if ($assertion instanceof HasAtLeastCount) {
+                        $non_empty_list->min_count = $assertion->count;
                     }
 
                     $did_remove_type = true;
                     $existing_var_type->addType($non_empty_list);
                 }
             } elseif ($array_atomic_type instanceof TKeyedArray) {
+                $prop_count = count($array_atomic_type->properties);
+                $min_count = 0;
                 foreach ($array_atomic_type->properties as $property_type) {
-                    if ($property_type->possibly_undefined) {
+                    if (!$property_type->possibly_undefined) {
+                        $min_count++;
+                    }
+                }
+
+                if ($assertion instanceof HasAtLeastCount) {
+                    if ($array_atomic_type->sealed && $assertion->count > $min_count) {
+                        $existing_var_type->removeType('array');
+                        $did_remove_type = true;
+                    } elseif (!$array_atomic_type->sealed
+                        && $array_atomic_type->is_list
+                        && $min_count === $prop_count
+                    ) {
+                        if ($assertion->count <= $min_count) {
+                            // this means a redundant condition
+                        } else {
+                            $did_remove_type = true;
+                            for ($i = $prop_count; $i < $assertion->count; $i++) {
+                                $array_atomic_type->properties[$i]
+                                    = clone ($array_atomic_type->previous_value_type ?: Type::getMixed());
+                            }
+                        }
+                    } else {
                         $did_remove_type = true;
-                        break;
                     }
+                } elseif ($min_count !== $prop_count) {
+                    $did_remove_type = true;
                 }
             }
 
@@ -615,7 +677,7 @@ private static function reconcileNonEmptyCountable(
                         $existing_var_type,
                         $old_var_type_string,
                         $key,
-                        'non-empty-countable',
+                        $assertion,
                         !$did_remove_type,
                         $negated,
                         $code_location,
@@ -669,6 +731,7 @@ private static function reconcileExactlyCountable(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcilePositiveNumeric(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -724,7 +787,7 @@ private static function reconcilePositiveNumeric(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'positive-numeric',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -747,8 +810,8 @@ private static function reconcilePositiveNumeric(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileHasMethod(
+        HasMethod $assertion,
         Codebase $codebase,
-        string $method_name,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -756,6 +819,7 @@ private static function reconcileHasMethod(
         array $suppressed_issues,
         int &$failed_reconciliation
     ): Union {
+        $method_name = $assertion->method;
         $old_var_type_string = $existing_var_type->getId();
         $existing_var_atomic_types = $existing_var_type->getAtomicTypes();
 
@@ -829,7 +893,7 @@ private static function reconcileHasMethod(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'object with method ' . $method_name,
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -852,20 +916,20 @@ private static function reconcileHasMethod(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileString(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
         ?CodeLocation $code_location,
         array $suppressed_issues,
         int &$failed_reconciliation,
-        bool $is_equality,
-        bool $is_strict_equality
+        bool $is_equality
     ): Union {
         $old_var_type_string = $existing_var_type->getId();
         $existing_var_atomic_types = $existing_var_type->getAtomicTypes();
 
         if ($existing_var_type->hasMixed()) {
-            if ($is_equality && !$is_strict_equality) {
+            if ($assertion instanceof IsLooselyEqual) {
                 return $existing_var_type;
             }
 
@@ -896,14 +960,14 @@ private static function reconcileString(
                     $type = clone $type;
 
                     $type->as = self::reconcileString(
+                        $assertion,
                         $type->as,
                         null,
                         false,
                         null,
                         $suppressed_issues,
                         $failed_reconciliation,
-                        $is_equality,
-                        $is_strict_equality
+                        $is_equality
                     );
 
                     $string_types[] = $type;
@@ -921,7 +985,7 @@ private static function reconcileString(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'string',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -946,17 +1010,16 @@ private static function reconcileString(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileInt(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
         ?CodeLocation $code_location,
         array $suppressed_issues,
-        int &$failed_reconciliation,
-        bool $is_equality,
-        bool $is_strict_equality
+        int &$failed_reconciliation
     ): Union {
         if ($existing_var_type->hasMixed()) {
-            if ($is_equality && !$is_strict_equality) {
+            if ($assertion instanceof IsLooselyEqual) {
                 return $existing_var_type;
             }
 
@@ -991,21 +1054,20 @@ private static function reconcileInt(
                     $type = clone $type;
 
                     $type->as = self::reconcileInt(
+                        $assertion,
                         $type->as,
                         null,
                         false,
                         null,
                         $suppressed_issues,
-                        $failed_reconciliation,
-                        $is_equality,
-                        $is_strict_equality
+                        $failed_reconciliation
                     );
 
                     $int_types[] = $type;
                 }
 
                 $did_remove_type = true;
-            } elseif ($type instanceof TString && $is_equality && !$is_strict_equality) {
+            } elseif ($type instanceof TString && $assertion instanceof IsLooselyEqual) {
                 $int_types[] = new TNumericString();
                 $did_remove_type = true;
             } else {
@@ -1013,13 +1075,13 @@ private static function reconcileInt(
             }
         }
 
-        if ((!$did_remove_type || !$int_types) && !$is_equality) {
+        if ((!$did_remove_type || !$int_types) && $assertion instanceof IsType) {
             if ($key && $code_location) {
                 self::triggerIssueForImpossible(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'int',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1044,6 +1106,7 @@ private static function reconcileInt(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileBool(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -1074,6 +1137,7 @@ private static function reconcileBool(
                     $type = clone $type;
 
                     $type->as = self::reconcileBool(
+                        $assertion,
                         $type->as,
                         null,
                         false,
@@ -1098,7 +1162,7 @@ private static function reconcileBool(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'bool',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1123,6 +1187,7 @@ private static function reconcileBool(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileScalar(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -1149,6 +1214,7 @@ private static function reconcileScalar(
                     $type = clone $type;
 
                     $type->as = self::reconcileScalar(
+                        $assertion,
                         $type->as,
                         null,
                         false,
@@ -1173,7 +1239,7 @@ private static function reconcileScalar(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'scalar',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1198,6 +1264,7 @@ private static function reconcileScalar(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileNumeric(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -1241,6 +1308,7 @@ private static function reconcileNumeric(
                     $type = clone $type;
 
                     $type->as = self::reconcileNumeric(
+                        $assertion,
                         $type->as,
                         null,
                         false,
@@ -1265,7 +1333,7 @@ private static function reconcileNumeric(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'numeric',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1290,6 +1358,7 @@ private static function reconcileNumeric(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileObject(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -1326,6 +1395,7 @@ private static function reconcileObject(
                     $type = clone $type;
 
                     $type->as = self::reconcileObject(
+                        $assertion,
                         $type->as,
                         null,
                         false,
@@ -1358,7 +1428,7 @@ private static function reconcileObject(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'object',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1383,6 +1453,7 @@ private static function reconcileObject(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileResource(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -1415,7 +1486,7 @@ private static function reconcileResource(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'resource',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1440,6 +1511,7 @@ private static function reconcileResource(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileCountable(
+        Assertion $assertion,
         Codebase $codebase,
         Union $existing_var_type,
         ?string $key,
@@ -1486,7 +1558,7 @@ private static function reconcileCountable(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'countable',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1509,6 +1581,7 @@ private static function reconcileCountable(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileIterable(
+        Assertion $assertion,
         Codebase $codebase,
         Union $existing_var_type,
         ?string $key,
@@ -1546,7 +1619,7 @@ private static function reconcileIterable(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'iterable',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1569,16 +1642,16 @@ private static function reconcileIterable(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileInArray(
+        InArray $assertion,
         Codebase $codebase,
         Union $existing_var_type,
-        string $assertion,
         ?string $key,
         bool $negated,
         ?CodeLocation $code_location,
         array $suppressed_issues,
         int &$failed_reconciliation
     ): Union {
-        $new_var_type = Type::parseString($assertion);
+        $new_var_type = clone $assertion->type;
 
         $intersection = Type::intersectUnionTypes($new_var_type, $existing_var_type, $codebase);
 
@@ -1588,7 +1661,7 @@ private static function reconcileInArray(
                     $existing_var_type,
                     $existing_var_type->getId(),
                     $key,
-                    '!' . $assertion,
+                    $assertion,
                     true,
                     $negated,
                     $code_location,
@@ -1606,8 +1679,9 @@ private static function reconcileInArray(
 
     private static function reconcileHasArrayKey(
         Union $existing_var_type,
-        string $assertion
+        HasArrayKey $assertion
     ): Union {
+        $assertion = $assertion->key;
         foreach ($existing_var_type->getAtomicTypes() as $atomic_type) {
             if ($atomic_type instanceof TKeyedArray) {
                 $is_class_string = false;
@@ -1636,8 +1710,8 @@ private static function reconcileHasArrayKey(
      * @param string[] $suppressed_issues
      */
     private static function reconcileSuperiorTo(
+        IsGreaterThan $assertion,
         Union         $existing_var_type,
-        string        $assertion,
         bool          $inside_loop,
         string        $old_var_type_string,
         ?string       $var_id,
@@ -1645,7 +1719,7 @@ private static function reconcileSuperiorTo(
         ?CodeLocation $code_location,
         array         $suppressed_issues
     ): Union {
-        $assertion_value = (int)substr($assertion, 1);
+        $assertion_value = $assertion->value;
 
         $did_remove_type = false;
 
@@ -1654,6 +1728,10 @@ private static function reconcileSuperiorTo(
                 continue;
             }
 
+            if ($assertion_value === null) {
+                continue;
+            }
+
             if ($atomic_type instanceof TIntRange) {
                 if ($atomic_type->contains($assertion_value)) {
                     // if the range contains the assertion, the range must be adapted
@@ -1741,8 +1819,8 @@ private static function reconcileSuperiorTo(
      * @param string[] $suppressed_issues
      */
     private static function reconcileInferiorTo(
+        IsLessThan    $assertion,
         Union         $existing_var_type,
-        string        $assertion,
         bool          $inside_loop,
         string        $old_var_type_string,
         ?string       $var_id,
@@ -1750,7 +1828,7 @@ private static function reconcileInferiorTo(
         ?CodeLocation $code_location,
         array         $suppressed_issues
     ): Union {
-        $assertion_value = (int)substr($assertion, 1);
+        $assertion_value = $assertion->value;
 
         $did_remove_type = false;
 
@@ -1759,6 +1837,10 @@ private static function reconcileInferiorTo(
                 continue;
             }
 
+            if ($assertion_value === null) {
+                continue;
+            }
+
             if ($atomic_type instanceof TIntRange) {
                 if ($atomic_type->contains($assertion_value)) {
                     // if the range contains the assertion, the range must be adapted
@@ -1844,6 +1926,7 @@ private static function reconcileInferiorTo(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileTraversable(
+        Assertion $assertion,
         Codebase $codebase,
         Union $existing_var_type,
         ?string $key,
@@ -1890,7 +1973,7 @@ private static function reconcileTraversable(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'Traversable',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1915,6 +1998,7 @@ private static function reconcileTraversable(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileArray(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -1957,6 +2041,7 @@ private static function reconcileArray(
                     $type = clone $type;
 
                     $type->as = self::reconcileArray(
+                        $assertion,
                         $type->as,
                         null,
                         false,
@@ -1981,7 +2066,7 @@ private static function reconcileArray(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'array',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -2010,6 +2095,7 @@ private static function reconcileArray(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileList(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -2084,7 +2170,7 @@ private static function reconcileList(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'array',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -2113,6 +2199,7 @@ private static function reconcileList(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileStringArrayAccess(
+        Assertion $assertion,
         Codebase $codebase,
         Union $existing_var_type,
         ?string $key,
@@ -2155,7 +2242,7 @@ private static function reconcileStringArrayAccess(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'string-array-access',
+                    $assertion,
                     true,
                     $negated,
                     $code_location,
@@ -2178,6 +2265,7 @@ private static function reconcileStringArrayAccess(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileIntArrayAccess(
+        Assertion $assertion,
         Codebase $codebase,
         Union $existing_var_type,
         ?string $key,
@@ -2215,7 +2303,7 @@ private static function reconcileIntArrayAccess(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'int-or-string-array-access',
+                    $assertion,
                     true,
                     $negated,
                     $code_location,
@@ -2238,6 +2326,7 @@ private static function reconcileIntArrayAccess(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileCallable(
+        Assertion $assertion,
         Codebase $codebase,
         Union $existing_var_type,
         ?string $key,
@@ -2300,6 +2389,7 @@ private static function reconcileCallable(
                     $type = clone $type;
 
                     $type->as = self::reconcileCallable(
+                        $assertion,
                         $codebase,
                         $type->as,
                         null,
@@ -2325,7 +2415,7 @@ private static function reconcileCallable(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    'callable',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -2344,11 +2434,12 @@ private static function reconcileCallable(
     }
 
     /**
+     * @param   Truthy|NonEmpty $assertion
      * @param   string[]  $suppressed_issues
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
-    private static function reconcileFalsyOrEmpty(
-        string $assertion,
+    private static function reconcileTruthyOrNonEmpty(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -2359,26 +2450,29 @@ private static function reconcileFalsyOrEmpty(
     ): Union {
         $old_var_type_string = $existing_var_type->getId();
 
+        //empty is used a lot to check for array offset existence, so we have to silent errors a lot
+        $is_empty_assertion = $assertion instanceof NonEmpty;
+
         $did_remove_type = $existing_var_type->possibly_undefined
             || $existing_var_type->possibly_undefined_from_try;
 
         foreach ($existing_var_type->getAtomicTypes() as $existing_var_type_key => $existing_var_type_part) {
-            //if any atomic in the union is either always truthy, we remove it. If not always falsy, we mark the check
+            //if any atomic in the union is either always falsy, we remove it. If not always truthy, we mark the check
             //as not redundant.
-            if (!$existing_var_type->possibly_undefined
-                && !$existing_var_type->possibly_undefined_from_try
-                && $existing_var_type_part->isTruthy()
-            ) {
+            if ($existing_var_type_part->isFalsy()) {
                 $did_remove_type = true;
                 $existing_var_type->removeType($existing_var_type_key);
-            } elseif (!$existing_var_type_part->isFalsy()) {
+            } elseif ($existing_var_type->possibly_undefined
+                || $existing_var_type->possibly_undefined_from_try
+                || !$existing_var_type_part->isTruthy()
+            ) {
                 $did_remove_type = true;
             }
         }
 
         if ($did_remove_type && $existing_var_type->isUnionEmpty()) {
             //every type was removed, this is an impossible assertion
-            if ($code_location && $key && !$recursive_check) {
+            if ($code_location && $key && !$is_empty_assertion && !$recursive_check) {
                 self::triggerIssueForImpossible(
                     $existing_var_type,
                     $old_var_type_string,
@@ -2397,8 +2491,7 @@ private static function reconcileFalsyOrEmpty(
         }
 
         if (!$did_remove_type) {
-            //nothing was removed, this is a redundant assertion
-            if ($code_location && $key && !$recursive_check) {
+            if ($code_location && $key && !$is_empty_assertion && !$recursive_check) {
                 self::triggerIssueForImpossible(
                     $existing_var_type,
                     $old_var_type_string,
@@ -2416,19 +2509,36 @@ private static function reconcileFalsyOrEmpty(
             return $existing_var_type;
         }
 
+        $existing_var_type->possibly_undefined = false;
+        $existing_var_type->possibly_undefined_from_try = false;
+
         if ($existing_var_type->hasType('bool')) {
             $existing_var_type->removeType('bool');
-            $existing_var_type->addType(new TFalse());
+            $existing_var_type->addType(new TTrue());
         }
 
         if ($existing_var_type->hasArray()) {
-            $existing_var_type->removeType('array');
-            $existing_var_type->addType(new TArray(
-                [
-                    new Union([new TNever()]),
-                    new Union([new TNever()]),
-                ]
-            ));
+            $array_atomic_type = $existing_var_type->getAtomicTypes()['array'];
+
+            if ($array_atomic_type instanceof TArray
+                && !$array_atomic_type instanceof TNonEmptyArray
+            ) {
+                $existing_var_type->removeType('array');
+                $existing_var_type->addType(
+                    new TNonEmptyArray(
+                        $array_atomic_type->type_params
+                    )
+                );
+            } elseif ($array_atomic_type instanceof TList
+                && !$array_atomic_type instanceof TNonEmptyList
+            ) {
+                $existing_var_type->removeType('array');
+                $existing_var_type->addType(
+                    new TNonEmptyList(
+                        $array_atomic_type->type_param
+                    )
+                );
+            }
         }
 
         if ($existing_var_type->hasMixed()) {
@@ -2436,7 +2546,7 @@ private static function reconcileFalsyOrEmpty(
 
             if (get_class($mixed_atomic_type) === TMixed::class) {
                 $existing_var_type->removeType('mixed');
-                $existing_var_type->addType(new TEmptyMixed());
+                $existing_var_type->addType(new TNonEmptyMixed());
             }
         }
 
@@ -2445,7 +2555,7 @@ private static function reconcileFalsyOrEmpty(
 
             if (get_class($scalar_atomic_type) === TScalar::class) {
                 $existing_var_type->removeType('scalar');
-                $existing_var_type->addType(new TEmptyScalar());
+                $existing_var_type->addType(new TNonEmptyScalar());
             }
         }
 
@@ -2454,17 +2564,16 @@ private static function reconcileFalsyOrEmpty(
 
             if (get_class($string_atomic_type) === TString::class) {
                 $existing_var_type->removeType('string');
-                $existing_var_type->addType(new TLiteralString(''));
-                $existing_var_type->addType(new TLiteralString('0'));
-            } elseif (get_class($string_atomic_type) === TNonEmptyString::class) {
+                $existing_var_type->addType(new TNonFalsyString());
+            } elseif (get_class($string_atomic_type) === TLowercaseString::class) {
                 $existing_var_type->removeType('string');
-                $existing_var_type->addType(new TLiteralString('0'));
-            } elseif (get_class($string_atomic_type) === TNonEmptyLowercaseString::class) {
+                $existing_var_type->addType(new TNonEmptyLowercaseString());
+            } elseif (get_class($string_atomic_type) === TNonspecificLiteralString::class) {
                 $existing_var_type->removeType('string');
-                $existing_var_type->addType(new TLiteralString('0'));
-            } elseif (get_class($string_atomic_type) === TNonEmptyNonspecificLiteralString::class) {
+                $existing_var_type->addType(new TNonEmptyNonspecificLiteralString());
+            } elseif (get_class($string_atomic_type) === TNonEmptyString::class) {
                 $existing_var_type->removeType('string');
-                $existing_var_type->addType(new TLiteralString('0'));
+                $existing_var_type->addType(new TNonFalsyString());
             }
         }
 
@@ -2475,23 +2584,19 @@ private static function reconcileFalsyOrEmpty(
                 foreach ($existing_range_types as $int_key => $literal_type) {
                     if ($literal_type->contains(0)) {
                         $existing_var_type->removeType($int_key);
-                        $existing_var_type->addType(new TLiteralInt(0));
+                        if ($literal_type->min_bound === null || $literal_type->min_bound <= -1) {
+                            $existing_var_type->addType(new TIntRange($literal_type->min_bound, -1));
+                        }
+                        if ($literal_type->max_bound === null || $literal_type->max_bound >= 1) {
+                            $existing_var_type->addType(new TIntRange(1, $literal_type->max_bound));
+                        }
                     }
                 }
-            } else {
-                $existing_var_type->removeType('int');
-                $existing_var_type->addType(new TLiteralInt(0));
             }
-        }
 
-        if ($existing_var_type->hasFloat()) {
-            $existing_var_type->removeType('float');
-            $existing_var_type->addType(new TLiteralFloat(0.0));
-        }
-
-        if ($existing_var_type->hasNumeric()) {
-            $existing_var_type->removeType('numeric');
-            $existing_var_type->addType(new TEmptyNumeric());
+            if ($existing_var_type->isSingle()) {
+                return $existing_var_type;
+            }
         }
 
         foreach ($existing_var_type->getAtomicTypes() as $type_key => $existing_var_atomic_type) {
@@ -2501,7 +2606,7 @@ private static function reconcileFalsyOrEmpty(
 
                     $existing_var_atomic_type = clone $existing_var_atomic_type;
 
-                    $existing_var_atomic_type->as = self::reconcileFalsyOrEmpty(
+                    $existing_var_atomic_type->as = self::reconcileTruthyOrNonEmpty(
                         $assertion,
                         $existing_var_atomic_type->as,
                         $key,
@@ -2509,7 +2614,7 @@ private static function reconcileFalsyOrEmpty(
                         $code_location,
                         $suppressed_issues,
                         $template_did_fail,
-                        $recursive_check
+                        true
                     );
 
                     if (!$template_did_fail) {
@@ -2529,15 +2634,12 @@ private static function reconcileFalsyOrEmpty(
      */
     private static function reconcileClassConstant(
         Codebase $codebase,
-        string $class_constant_expression,
+        TClassConstant $class_constant_expression,
         Union $existing_type,
         int &$failed_reconciliation
     ): Union {
-        if (strpos($class_constant_expression, '::') === false) {
-            return $existing_type;
-        }
-
-        [$class_name, $constant_pattern] = explode('::', $class_constant_expression, 2);
+        $class_name = $class_constant_expression->fq_classlike_name;
+        $constant_pattern = $class_constant_expression->const_name;
 
         $resolver = new ClassConstantByWildcardResolver($codebase);
         $matched_class_constant_types = $resolver->resolve($class_name, $constant_pattern);
diff --git a/src/Psalm/Internal/Type/SimpleNegatedAssertionReconciler.php b/src/Psalm/Internal/Type/SimpleNegatedAssertionReconciler.php
index 5d0bd93f0c9..37940d9dd20 100644
--- a/src/Psalm/Internal/Type/SimpleNegatedAssertionReconciler.php
+++ b/src/Psalm/Internal/Type/SimpleNegatedAssertionReconciler.php
@@ -9,6 +9,17 @@
 use Psalm\Issue\RedundantPropertyInitializationCheck;
 use Psalm\Issue\TypeDoesNotContainType;
 use Psalm\IssueBuffer;
+use Psalm\Storage\Assertion;
+use Psalm\Storage\Assertion\ArrayKeyDoesNotExist;
+use Psalm\Storage\Assertion\DoesNotHaveAtLeastCount;
+use Psalm\Storage\Assertion\DoesNotHaveExactCount;
+use Psalm\Storage\Assertion\Empty_;
+use Psalm\Storage\Assertion\Falsy;
+use Psalm\Storage\Assertion\IsGreaterThanOrEqualTo;
+use Psalm\Storage\Assertion\IsLessThanOrEqualTo;
+use Psalm\Storage\Assertion\IsNotIsset;
+use Psalm\Storage\Assertion\NotInArray;
+use Psalm\Storage\Assertion\NotNonEmptyCountable;
 use Psalm\Type;
 use Psalm\Type\Atomic\Scalar;
 use Psalm\Type\Atomic\TArray;
@@ -18,6 +29,10 @@
 use Psalm\Type\Atomic\TCallableArray;
 use Psalm\Type\Atomic\TCallableObject;
 use Psalm\Type\Atomic\TCallableString;
+use Psalm\Type\Atomic\TEmptyMixed;
+use Psalm\Type\Atomic\TEmptyNumeric;
+use Psalm\Type\Atomic\TEmptyScalar;
+use Psalm\Type\Atomic\TFalse;
 use Psalm\Type\Atomic\TFloat;
 use Psalm\Type\Atomic\TGenericObject;
 use Psalm\Type\Atomic\TInt;
@@ -25,27 +40,25 @@
 use Psalm\Type\Atomic\TIterable;
 use Psalm\Type\Atomic\TKeyedArray;
 use Psalm\Type\Atomic\TList;
+use Psalm\Type\Atomic\TLiteralFloat;
 use Psalm\Type\Atomic\TLiteralInt;
 use Psalm\Type\Atomic\TLiteralString;
-use Psalm\Type\Atomic\TLowercaseString;
 use Psalm\Type\Atomic\TMixed;
 use Psalm\Type\Atomic\TNamedObject;
 use Psalm\Type\Atomic\TNever;
 use Psalm\Type\Atomic\TNonEmptyArray;
 use Psalm\Type\Atomic\TNonEmptyList;
 use Psalm\Type\Atomic\TNonEmptyLowercaseString;
-use Psalm\Type\Atomic\TNonEmptyMixed;
 use Psalm\Type\Atomic\TNonEmptyNonspecificLiteralString;
-use Psalm\Type\Atomic\TNonEmptyScalar;
 use Psalm\Type\Atomic\TNonEmptyString;
-use Psalm\Type\Atomic\TNonFalsyString;
-use Psalm\Type\Atomic\TNonspecificLiteralString;
+use Psalm\Type\Atomic\TNull;
 use Psalm\Type\Atomic\TNumeric;
+use Psalm\Type\Atomic\TObject;
 use Psalm\Type\Atomic\TPositiveInt;
+use Psalm\Type\Atomic\TResource;
 use Psalm\Type\Atomic\TScalar;
 use Psalm\Type\Atomic\TString;
 use Psalm\Type\Atomic\TTemplateParam;
-use Psalm\Type\Atomic\TTrue;
 use Psalm\Type\Reconciler;
 use Psalm\Type\Union;
 
@@ -53,7 +66,6 @@
 use function get_class;
 use function max;
 use function strpos;
-use function substr;
 
 /**
  * @internal
@@ -66,7 +78,7 @@ class SimpleNegatedAssertionReconciler extends Reconciler
      */
     public static function reconcile(
         Codebase $codebase,
-        string $assertion,
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key = null,
         bool $negated = false,
@@ -78,7 +90,7 @@ public static function reconcile(
     ): ?Union {
         $old_var_type_string = $existing_var_type->getId();
 
-        if ($assertion === 'isset') {
+        if ($assertion instanceof IsNotIsset) {
             if ($existing_var_type->possibly_undefined) {
                 return Type::getNever();
             }
@@ -139,13 +151,12 @@ public static function reconcile(
             return Type::getNull();
         }
 
-        if ($assertion === 'array-key-exists') {
+        if ($assertion instanceof ArrayKeyDoesNotExist) {
             return Type::getNever();
         }
 
-        if (strpos($assertion, 'in-array-') === 0) {
-            $assertion = substr($assertion, 9);
-            $new_var_type = Type::parseString($assertion);
+        if ($assertion instanceof NotInArray) {
+            $new_var_type = clone $assertion->type;
 
             $intersection = Type::intersectUnionTypes(
                 $new_var_type,
@@ -159,7 +170,7 @@ public static function reconcile(
                         $existing_var_type,
                         $existing_var_type->getId(),
                         $key,
-                        '!' . $assertion,
+                        $assertion,
                         true,
                         $negated,
                         $code_location,
@@ -173,68 +184,82 @@ public static function reconcile(
             return $existing_var_type;
         }
 
-        if ($assertion === 'object' && !$existing_var_type->hasMixed()) {
-            return self::reconcileObject(
+        if ($assertion instanceof Falsy || $assertion instanceof Empty_) {
+            return self::reconcileFalsyOrEmpty(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $is_equality
+                false
             );
         }
 
-        if ($assertion === 'scalar' && !$existing_var_type->hasMixed()) {
-            return self::reconcileScalar(
+        if ($assertion instanceof NotNonEmptyCountable) {
+            return self::reconcileNotNonEmptyCountable(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $is_equality
+                $is_equality,
+                null
             );
         }
 
-        if ($assertion === 'resource' && !$existing_var_type->hasMixed()) {
-            return self::reconcileResource(
+        if ($assertion instanceof DoesNotHaveAtLeastCount) {
+            return self::reconcileNotNonEmptyCountable(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $is_equality
+                $is_equality,
+                $assertion->count
             );
         }
 
-        if ($assertion === 'bool' && !$existing_var_type->hasMixed()) {
-            return self::reconcileBool(
+        if ($assertion instanceof DoesNotHaveExactCount) {
+            return $existing_var_type;
+        }
+
+        if ($assertion instanceof IsLessThanOrEqualTo) {
+            return self::reconcileIsLessThanOrEqualTo(
+                $assertion,
                 $existing_var_type,
+                $inside_loop,
+                $old_var_type_string,
                 $key,
                 $negated,
                 $code_location,
-                $suppressed_issues,
-                $failed_reconciliation,
-                $is_equality
+                $suppressed_issues
             );
         }
 
-        if ($assertion === 'numeric' && !$existing_var_type->hasMixed()) {
-            return self::reconcileNumeric(
+        if ($assertion instanceof IsGreaterThanOrEqualTo) {
+            return self::reconcileIsGreaterThanOrEqualTo(
+                $assertion,
                 $existing_var_type,
+                $inside_loop,
+                $old_var_type_string,
                 $key,
                 $negated,
                 $code_location,
-                $suppressed_issues,
-                $failed_reconciliation,
-                $is_equality
+                $suppressed_issues
             );
         }
 
-        if ($assertion === 'float' && !$existing_var_type->hasMixed()) {
-            return self::reconcileFloat(
+        $assertion_type = $assertion->getAtomicType();
+
+        if ($assertion_type instanceof TObject && !$existing_var_type->hasMixed()) {
+            return self::reconcileObject(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
@@ -245,8 +270,9 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'int' && !$existing_var_type->hasMixed()) {
-            return self::reconcileInt(
+        if ($assertion_type instanceof TScalar && !$existing_var_type->hasMixed()) {
+            return self::reconcileScalar(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
@@ -257,8 +283,9 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'string' && !$existing_var_type->hasMixed()) {
-            return self::reconcileString(
+        if ($assertion_type instanceof TResource && !$existing_var_type->hasMixed()) {
+            return self::reconcileResource(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
@@ -269,8 +296,9 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'array' && !$existing_var_type->hasMixed()) {
-            return self::reconcileArray(
+        if ($assertion_type && get_class($assertion_type) === TBool::class && !$existing_var_type->hasMixed()) {
+            return self::reconcileBool(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
@@ -281,8 +309,8 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'falsy' || $assertion === 'empty') {
-            return self::reconcileFalsyOrEmpty(
+        if ($assertion_type instanceof TNumeric && !$existing_var_type->hasMixed()) {
+            return self::reconcileNumeric(
                 $assertion,
                 $existing_var_type,
                 $key,
@@ -290,12 +318,13 @@ public static function reconcile(
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                false
+                $is_equality
             );
         }
 
-        if ($assertion === 'null' && !$existing_var_type->hasMixed()) {
-            return self::reconcileNull(
+        if ($assertion_type instanceof TFloat && !$existing_var_type->hasMixed()) {
+            return self::reconcileFloat(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
@@ -306,8 +335,9 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'false' && !$existing_var_type->hasMixed()) {
-            return self::reconcileFalse(
+        if ($assertion_type && get_class($assertion_type) === TInt::class && !$existing_var_type->hasMixed()) {
+            return self::reconcileInt(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
@@ -318,65 +348,65 @@ public static function reconcile(
             );
         }
 
-        if ($assertion === 'non-empty-countable') {
-            return self::reconcileNonEmptyCountable(
+        if ($assertion_type && get_class($assertion_type) === TString::class && !$existing_var_type->hasMixed()) {
+            return self::reconcileString(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $is_equality,
-                null
-            );
-        }
-
-        if ($assertion === 'callable') {
-            return self::reconcileCallable(
-                $existing_var_type
+                $is_equality
             );
         }
 
-        if (strpos($assertion, 'has-at-least-') === 0) {
-            return self::reconcileNonEmptyCountable(
+        if ($assertion_type instanceof TArray
+            && !$existing_var_type->hasMixed()
+            && $assertion_type->type_params[0]->isArrayKey()
+            && $assertion_type->type_params[1]->isMixed()
+        ) {
+            return self::reconcileArray(
+                $assertion,
                 $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
                 $suppressed_issues,
                 $failed_reconciliation,
-                $is_equality,
-                (int) substr($assertion, 13)
+                $is_equality
             );
         }
 
-        if (strpos($assertion, 'has-exactly-') === 0) {
-            return $existing_var_type;
-        }
-
-        if ($assertion[0] === '>') {
-            return self::reconcileSuperiorTo(
-                $existing_var_type,
+        if ($assertion_type instanceof TNull && !$existing_var_type->hasMixed()) {
+            return self::reconcileNull(
                 $assertion,
-                $inside_loop,
-                $old_var_type_string,
+                $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
-                $suppressed_issues
+                $suppressed_issues,
+                $failed_reconciliation,
+                $is_equality
             );
         }
 
-        if ($assertion[0] === '<') {
-            return self::reconcileInferiorTo(
-                $existing_var_type,
+        if ($assertion_type instanceof TFalse && !$existing_var_type->hasMixed()) {
+            return self::reconcileFalse(
                 $assertion,
-                $inside_loop,
-                $old_var_type_string,
+                $existing_var_type,
                 $key,
                 $negated,
                 $code_location,
-                $suppressed_issues
+                $suppressed_issues,
+                $failed_reconciliation,
+                $is_equality
+            );
+        }
+
+        if ($assertion_type instanceof TCallable) {
+            return self::reconcileCallable(
+                $existing_var_type
             );
         }
 
@@ -406,6 +436,7 @@ private static function reconcileCallable(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileBool(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -447,7 +478,7 @@ private static function reconcileBool(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!bool',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -473,7 +504,8 @@ private static function reconcileBool(
      * @param   string[]  $suppressed_issues
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
-    private static function reconcileNonEmptyCountable(
+    private static function reconcileNotNonEmptyCountable(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -493,7 +525,8 @@ private static function reconcileNonEmptyCountable(
             if (($array_atomic_type instanceof TNonEmptyArray
                     || $array_atomic_type instanceof TNonEmptyList)
                 && ($min_count === null
-                    || $array_atomic_type->count >= $min_count)
+                    || $array_atomic_type->count >= $min_count
+                    || $array_atomic_type->min_count >= $min_count)
             ) {
                 $did_remove_type = true;
 
@@ -529,7 +562,7 @@ private static function reconcileNonEmptyCountable(
                         $existing_var_type,
                         $old_var_type_string,
                         $key,
-                        '!non-empty-countable',
+                        $assertion,
                         !$did_remove_type,
                         $negated,
                         $code_location,
@@ -547,6 +580,7 @@ private static function reconcileNonEmptyCountable(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileNull(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -566,6 +600,7 @@ private static function reconcileNull(
         foreach ($existing_var_type->getAtomicTypes() as $type) {
             if ($type instanceof TTemplateParam) {
                 $type->as = self::reconcileNull(
+                    $assertion,
                     $type->as,
                     null,
                     false,
@@ -586,7 +621,7 @@ private static function reconcileNull(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!null',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -613,6 +648,7 @@ private static function reconcileNull(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileFalse(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -632,6 +668,7 @@ private static function reconcileFalse(
         foreach ($existing_var_type->getAtomicTypes() as $type) {
             if ($type instanceof TTemplateParam) {
                 $type->as = self::reconcileFalse(
+                    $assertion,
                     $type->as,
                     null,
                     false,
@@ -652,7 +689,7 @@ private static function reconcileFalse(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!false',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -675,11 +712,12 @@ private static function reconcileFalse(
     }
 
     /**
+     * @param   Falsy|Empty_ $assertion
      * @param   string[]  $suppressed_issues
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileFalsyOrEmpty(
-        string $assertion,
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -690,34 +728,31 @@ private static function reconcileFalsyOrEmpty(
     ): Union {
         $old_var_type_string = $existing_var_type->getId();
 
-        //empty is used a lot to check for array offset existence, so we have to silent errors a lot
-        $is_empty_assertion = $assertion === 'empty';
-
         $did_remove_type = $existing_var_type->possibly_undefined
             || $existing_var_type->possibly_undefined_from_try;
 
         foreach ($existing_var_type->getAtomicTypes() as $existing_var_type_key => $existing_var_type_part) {
-            //if any atomic in the union is either always falsy, we remove it. If not always truthy, we mark the check
+            //if any atomic in the union is either always truthy, we remove it. If not always falsy, we mark the check
             //as not redundant.
-            if ($existing_var_type_part->isFalsy()) {
+            if (!$existing_var_type->possibly_undefined
+                && !$existing_var_type->possibly_undefined_from_try
+                && $existing_var_type_part->isTruthy()
+            ) {
                 $did_remove_type = true;
                 $existing_var_type->removeType($existing_var_type_key);
-            } elseif ($existing_var_type->possibly_undefined
-                || $existing_var_type->possibly_undefined_from_try
-                || !$existing_var_type_part->isTruthy()
-            ) {
+            } elseif (!$existing_var_type_part->isFalsy()) {
                 $did_remove_type = true;
             }
         }
 
         if ($did_remove_type && $existing_var_type->isUnionEmpty()) {
             //every type was removed, this is an impossible assertion
-            if ($code_location && $key && !$is_empty_assertion && !$recursive_check) {
+            if ($code_location && $key && !$recursive_check) {
                 self::triggerIssueForImpossible(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!' . $assertion,
+                    $assertion,
                     false,
                     $negated,
                     $code_location,
@@ -731,12 +766,13 @@ private static function reconcileFalsyOrEmpty(
         }
 
         if (!$did_remove_type) {
-            if ($code_location && $key && !$is_empty_assertion && !$recursive_check) {
+            //nothing was removed, this is a redundant assertion
+            if ($code_location && $key && !$recursive_check) {
                 self::triggerIssueForImpossible(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!' . $assertion,
+                    $assertion,
                     true,
                     $negated,
                     $code_location,
@@ -749,36 +785,19 @@ private static function reconcileFalsyOrEmpty(
             return $existing_var_type;
         }
 
-        $existing_var_type->possibly_undefined = false;
-        $existing_var_type->possibly_undefined_from_try = false;
-
         if ($existing_var_type->hasType('bool')) {
             $existing_var_type->removeType('bool');
-            $existing_var_type->addType(new TTrue());
+            $existing_var_type->addType(new TFalse());
         }
 
         if ($existing_var_type->hasArray()) {
-            $array_atomic_type = $existing_var_type->getAtomicTypes()['array'];
-
-            if ($array_atomic_type instanceof TArray
-                && !$array_atomic_type instanceof TNonEmptyArray
-            ) {
-                $existing_var_type->removeType('array');
-                $existing_var_type->addType(
-                    new TNonEmptyArray(
-                        $array_atomic_type->type_params
-                    )
-                );
-            } elseif ($array_atomic_type instanceof TList
-                && !$array_atomic_type instanceof TNonEmptyList
-            ) {
-                $existing_var_type->removeType('array');
-                $existing_var_type->addType(
-                    new TNonEmptyList(
-                        $array_atomic_type->type_param
-                    )
-                );
-            }
+            $existing_var_type->removeType('array');
+            $existing_var_type->addType(new TArray(
+                [
+                    new Union([new TNever()]),
+                    new Union([new TNever()]),
+                ]
+            ));
         }
 
         if ($existing_var_type->hasMixed()) {
@@ -786,7 +805,7 @@ private static function reconcileFalsyOrEmpty(
 
             if (get_class($mixed_atomic_type) === TMixed::class) {
                 $existing_var_type->removeType('mixed');
-                $existing_var_type->addType(new TNonEmptyMixed());
+                $existing_var_type->addType(new TEmptyMixed());
             }
         }
 
@@ -795,7 +814,7 @@ private static function reconcileFalsyOrEmpty(
 
             if (get_class($scalar_atomic_type) === TScalar::class) {
                 $existing_var_type->removeType('scalar');
-                $existing_var_type->addType(new TNonEmptyScalar());
+                $existing_var_type->addType(new TEmptyScalar());
             }
         }
 
@@ -804,16 +823,17 @@ private static function reconcileFalsyOrEmpty(
 
             if (get_class($string_atomic_type) === TString::class) {
                 $existing_var_type->removeType('string');
-                $existing_var_type->addType(new TNonFalsyString());
-            } elseif (get_class($string_atomic_type) === TLowercaseString::class) {
+                $existing_var_type->addType(new TLiteralString(''));
+                $existing_var_type->addType(new TLiteralString('0'));
+            } elseif (get_class($string_atomic_type) === TNonEmptyString::class) {
                 $existing_var_type->removeType('string');
-                $existing_var_type->addType(new TNonEmptyLowercaseString());
-            } elseif (get_class($string_atomic_type) === TNonspecificLiteralString::class) {
+                $existing_var_type->addType(new TLiteralString('0'));
+            } elseif (get_class($string_atomic_type) === TNonEmptyLowercaseString::class) {
                 $existing_var_type->removeType('string');
-                $existing_var_type->addType(new TNonEmptyNonspecificLiteralString());
-            } elseif (get_class($string_atomic_type) === TNonEmptyString::class) {
+                $existing_var_type->addType(new TLiteralString('0'));
+            } elseif (get_class($string_atomic_type) === TNonEmptyNonspecificLiteralString::class) {
                 $existing_var_type->removeType('string');
-                $existing_var_type->addType(new TNonFalsyString());
+                $existing_var_type->addType(new TLiteralString('0'));
             }
         }
 
@@ -824,19 +844,23 @@ private static function reconcileFalsyOrEmpty(
                 foreach ($existing_range_types as $int_key => $literal_type) {
                     if ($literal_type->contains(0)) {
                         $existing_var_type->removeType($int_key);
-                        if ($literal_type->min_bound === null || $literal_type->min_bound <= -1) {
-                            $existing_var_type->addType(new TIntRange($literal_type->min_bound, -1));
-                        }
-                        if ($literal_type->max_bound === null || $literal_type->max_bound >= 1) {
-                            $existing_var_type->addType(new TIntRange(1, $literal_type->max_bound));
-                        }
+                        $existing_var_type->addType(new TLiteralInt(0));
                     }
                 }
+            } else {
+                $existing_var_type->removeType('int');
+                $existing_var_type->addType(new TLiteralInt(0));
             }
+        }
 
-            if ($existing_var_type->isSingle()) {
-                return $existing_var_type;
-            }
+        if ($existing_var_type->hasFloat()) {
+            $existing_var_type->removeType('float');
+            $existing_var_type->addType(new TLiteralFloat(0.0));
+        }
+
+        if ($existing_var_type->hasNumeric()) {
+            $existing_var_type->removeType('numeric');
+            $existing_var_type->addType(new TEmptyNumeric());
         }
 
         foreach ($existing_var_type->getAtomicTypes() as $type_key => $existing_var_atomic_type) {
@@ -854,7 +878,7 @@ private static function reconcileFalsyOrEmpty(
                         $code_location,
                         $suppressed_issues,
                         $template_did_fail,
-                        true
+                        $recursive_check
                     );
 
                     if (!$template_did_fail) {
@@ -874,6 +898,7 @@ private static function reconcileFalsyOrEmpty(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileScalar(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -894,6 +919,7 @@ private static function reconcileScalar(
                     $type = clone $type;
 
                     $type->as = self::reconcileScalar(
+                        $assertion,
                         $type->as,
                         null,
                         false,
@@ -929,7 +955,7 @@ private static function reconcileScalar(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!scalar',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -960,6 +986,7 @@ private static function reconcileScalar(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileObject(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -980,6 +1007,7 @@ private static function reconcileObject(
                     $type = clone $type;
 
                     $type->as = self::reconcileObject(
+                        $assertion,
                         $type->as,
                         null,
                         false,
@@ -1030,7 +1058,7 @@ private static function reconcileObject(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!object',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1061,6 +1089,7 @@ private static function reconcileObject(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileNumeric(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -1082,6 +1111,7 @@ private static function reconcileNumeric(
                     $type = clone $type;
 
                     $type->as = self::reconcileNumeric(
+                        $assertion,
                         $type->as,
                         null,
                         false,
@@ -1120,7 +1150,7 @@ private static function reconcileNumeric(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!numeric',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1151,6 +1181,7 @@ private static function reconcileNumeric(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileInt(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -1171,6 +1202,7 @@ private static function reconcileInt(
                     $type = clone $type;
 
                     $type->as = self::reconcileInt(
+                        $assertion,
                         $type->as,
                         null,
                         false,
@@ -1220,7 +1252,7 @@ private static function reconcileInt(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!int',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1251,6 +1283,7 @@ private static function reconcileInt(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileFloat(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -1271,6 +1304,7 @@ private static function reconcileFloat(
                     $type = clone $type;
 
                     $type->as = self::reconcileFloat(
+                        $assertion,
                         $type->as,
                         null,
                         false,
@@ -1315,7 +1349,7 @@ private static function reconcileFloat(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!float',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1346,6 +1380,7 @@ private static function reconcileFloat(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileString(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -1366,6 +1401,7 @@ private static function reconcileString(
                     $type = clone $type;
 
                     $type->as = self::reconcileString(
+                        $assertion,
                         $type->as,
                         null,
                         false,
@@ -1419,7 +1455,7 @@ private static function reconcileString(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!string',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1450,6 +1486,7 @@ private static function reconcileString(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileArray(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -1470,6 +1507,7 @@ private static function reconcileArray(
                     $type = clone $type;
 
                     $type->as = self::reconcileArray(
+                        $assertion,
                         $type->as,
                         null,
                         false,
@@ -1520,7 +1558,7 @@ private static function reconcileArray(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!array',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1551,6 +1589,7 @@ private static function reconcileArray(
      * @param Reconciler::RECONCILIATION_* $failed_reconciliation
      */
     private static function reconcileResource(
+        Assertion $assertion,
         Union $existing_var_type,
         ?string $key,
         bool $negated,
@@ -1570,6 +1609,7 @@ private static function reconcileResource(
         foreach ($existing_var_type->getAtomicTypes() as $type) {
             if ($type instanceof TTemplateParam) {
                 $type->as = self::reconcileResource(
+                    $assertion,
                     $type->as,
                     null,
                     false,
@@ -1590,7 +1630,7 @@ private static function reconcileResource(
                     $existing_var_type,
                     $old_var_type_string,
                     $key,
-                    '!resource',
+                    $assertion,
                     !$did_remove_type,
                     $negated,
                     $code_location,
@@ -1615,9 +1655,9 @@ private static function reconcileResource(
     /**
      * @param string[] $suppressed_issues
      */
-    private static function reconcileSuperiorTo(
+    private static function reconcileIsLessThanOrEqualTo(
+        IsLessThanOrEqualTo $assertion,
         Union         $existing_var_type,
-        string        $assertion,
         bool          $inside_loop,
         string        $old_var_type_string,
         ?string       $var_id,
@@ -1625,7 +1665,11 @@ private static function reconcileSuperiorTo(
         ?CodeLocation $code_location,
         array         $suppressed_issues
     ): Union {
-        $assertion_value = (int)substr($assertion, 1) - 1;
+        if ($assertion->value === null) {
+            return $existing_var_type;
+        }
+
+        $assertion_value = $assertion->value - 1;
 
         $did_remove_type = false;
 
@@ -1690,7 +1734,7 @@ private static function reconcileSuperiorTo(
                 $existing_var_type,
                 $old_var_type_string,
                 $var_id,
-                '!'.$assertion,
+                $assertion,
                 true,
                 $negated,
                 $code_location,
@@ -1704,7 +1748,7 @@ private static function reconcileSuperiorTo(
                     $existing_var_type,
                     $old_var_type_string,
                     $var_id,
-                    '!'.$assertion,
+                    $assertion,
                     false,
                     $negated,
                     $code_location,
@@ -1720,9 +1764,9 @@ private static function reconcileSuperiorTo(
     /**
      * @param string[] $suppressed_issues
      */
-    private static function reconcileInferiorTo(
+    private static function reconcileIsGreaterThanOrEqualTo(
+        IsGreaterThanOrEqualTo $assertion,
         Union         $existing_var_type,
-        string        $assertion,
         bool          $inside_loop,
         string        $old_var_type_string,
         ?string       $var_id,
@@ -1730,7 +1774,11 @@ private static function reconcileInferiorTo(
         ?CodeLocation $code_location,
         array         $suppressed_issues
     ): Union {
-        $assertion_value = (int)substr($assertion, 1) + 1;
+        if ($assertion->value === null) {
+            return $existing_var_type;
+        }
+
+        $assertion_value = $assertion->value + 1;
 
         $did_remove_type = false;
 
@@ -1792,7 +1840,7 @@ private static function reconcileInferiorTo(
                 $existing_var_type,
                 $old_var_type_string,
                 $var_id,
-                '!'.$assertion,
+                $assertion,
                 true,
                 $negated,
                 $code_location,
@@ -1806,7 +1854,7 @@ private static function reconcileInferiorTo(
                     $existing_var_type,
                     $old_var_type_string,
                     $var_id,
-                    '!'.$assertion,
+                    $assertion,
                     false,
                     $negated,
                     $code_location,
diff --git a/src/Psalm/Internal/Type/TypeCombination.php b/src/Psalm/Internal/Type/TypeCombination.php
index d45af1cef99..c7770a32c26 100644
--- a/src/Psalm/Internal/Type/TypeCombination.php
+++ b/src/Psalm/Internal/Type/TypeCombination.php
@@ -38,6 +38,9 @@ class TypeCombination
     /** @var array<int, bool>|null */
     public $array_counts = [];
 
+    /** @var array<int, bool>|null */
+    public $array_min_counts = [];
+
     /** @var bool */
     public $array_sometimes_filled = false;
 
diff --git a/src/Psalm/Internal/Type/TypeCombiner.php b/src/Psalm/Internal/Type/TypeCombiner.php
index e0bab38aaea..bc3d5a29f50 100644
--- a/src/Psalm/Internal/Type/TypeCombiner.php
+++ b/src/Psalm/Internal/Type/TypeCombiner.php
@@ -66,6 +66,7 @@
 use function get_class;
 use function is_int;
 use function is_numeric;
+use function min;
 use function strpos;
 use function strtolower;
 use function substr;
@@ -545,6 +546,14 @@ private static function scrapeTypeProperties(
                     }
                 }
 
+                if ($combination->array_min_counts !== null) {
+                    if ($type->min_count === null) {
+                        $combination->array_min_counts = null;
+                    } else {
+                        $combination->array_min_counts[$type->min_count] = true;
+                    }
+                }
+
                 $combination->array_sometimes_filled = true;
             } else {
                 $combination->array_always_filled = false;
@@ -586,6 +595,14 @@ private static function scrapeTypeProperties(
                     }
                 }
 
+                if ($combination->array_min_counts !== null) {
+                    if ($type->min_count === null) {
+                        $combination->array_min_counts = null;
+                    } else {
+                        $combination->array_min_counts[$type->min_count] = true;
+                    }
+                }
+
                 $combination->array_sometimes_filled = true;
             } else {
                 $combination->array_always_filled = false;
@@ -717,6 +734,16 @@ private static function scrapeTypeProperties(
                 $combination->array_counts[count($type->properties)] = true;
             }
 
+            if ($combination->array_min_counts !== null) {
+                $min_prop_count = count(
+                    array_filter(
+                        $type->properties,
+                        fn($p) => $p->possibly_undefined
+                    )
+                );
+                $combination->array_min_counts[$min_prop_count] = true;
+            }
+
             foreach ($possibly_undefined_entries as $possibly_undefined_type) {
                 $possibly_undefined_type->possibly_undefined = true;
             }
@@ -1487,15 +1514,27 @@ private static function getArrayTypeFromGenericParams(
                     $array_type = new TNonEmptyList($generic_type_params[1]);
 
                     if ($combination->array_counts && count($combination->array_counts) === 1) {
+                        /** @psalm-suppress PropertyTypeCoercion */
                         $array_type->count = array_keys($combination->array_counts)[0];
                     }
+
+                    if ($combination->array_min_counts) {
+                        /** @psalm-suppress PropertyTypeCoercion */
+                        $array_type->min_count = min(array_keys($combination->array_min_counts));
+                    }
                 }
             } else {
                 $array_type = new TNonEmptyArray($generic_type_params);
 
                 if ($combination->array_counts && count($combination->array_counts) === 1) {
+                    /** @psalm-suppress PropertyTypeCoercion */
                     $array_type->count = array_keys($combination->array_counts)[0];
                 }
+
+                if ($combination->array_min_counts) {
+                    /** @psalm-suppress PropertyTypeCoercion */
+                    $array_type->min_count = min(array_keys($combination->array_min_counts));
+                }
             }
         } else {
             if ($combination->all_arrays_class_string_maps
diff --git a/src/Psalm/Internal/Type/TypeExpander.php b/src/Psalm/Internal/Type/TypeExpander.php
index e59b51c91c1..878da51cb5a 100644
--- a/src/Psalm/Internal/Type/TypeExpander.php
+++ b/src/Psalm/Internal/Type/TypeExpander.php
@@ -7,6 +7,7 @@
 use Psalm\Internal\Type\SimpleAssertionReconciler;
 use Psalm\Internal\Type\SimpleNegatedAssertionReconciler;
 use Psalm\Internal\Type\TypeParser;
+use Psalm\Storage\Assertion\IsType;
 use Psalm\Type\Atomic;
 use Psalm\Type\Atomic\TArray;
 use Psalm\Type\Atomic\TCallable;
@@ -714,7 +715,7 @@ private static function expandConditional(
                     );
 
                     if (count($candidate) === 1) {
-                        $assertion = $candidate[0]->getAssertionString();
+                        $assertion = new IsType($candidate[0]);
                     }
                 }
             }
diff --git a/src/Psalm/Internal/TypeVisitor/TypeChecker.php b/src/Psalm/Internal/TypeVisitor/TypeChecker.php
index 4eaaeb18987..af0ad30c33c 100644
--- a/src/Psalm/Internal/TypeVisitor/TypeChecker.php
+++ b/src/Psalm/Internal/TypeVisitor/TypeChecker.php
@@ -20,7 +20,6 @@
 use Psalm\StatementsSource;
 use Psalm\Storage\MethodStorage;
 use Psalm\Type\Atomic;
-use Psalm\Type\Atomic\TArray;
 use Psalm\Type\Atomic\TClassConstant;
 use Psalm\Type\Atomic\TGenericObject;
 use Psalm\Type\Atomic\TNamedObject;
@@ -127,16 +126,6 @@ protected function enterNode(TypeNode $type): ?int
             $this->checkTemplateParam($type);
         } elseif ($type instanceof TResource) {
             $this->checkResource($type);
-        } elseif ($type instanceof TArray) {
-            if (count($type->type_params) > 2) {
-                IssueBuffer::maybeAdd(
-                    new TooManyTemplateParams(
-                        $type->getId(). ' has too many template params, expecting 2',
-                        $this->code_location
-                    ),
-                    $this->suppressed_issues
-                );
-            }
         }
 
         $type->checked = true;
diff --git a/src/Psalm/IssueBuffer.php b/src/Psalm/IssueBuffer.php
index 49defb85280..a0978125587 100644
--- a/src/Psalm/IssueBuffer.php
+++ b/src/Psalm/IssueBuffer.php
@@ -824,7 +824,9 @@ public static function getOutput(
 
         $normalized_data = $issues_data === [] ? [] : array_merge(...array_values($issues_data));
 
-        switch ($report_options->format) {
+        $format = $report_options->format;
+
+        switch ($format) {
             case Report::TYPE_COMPACT:
                 $output = new CompactReport($normalized_data, self::$fixable_issue_counts, $report_options);
                 break;
diff --git a/src/Psalm/Storage/Assertion.php b/src/Psalm/Storage/Assertion.php
index 0cfa0255f22..ed7dca2542d 100644
--- a/src/Psalm/Storage/Assertion.php
+++ b/src/Psalm/Storage/Assertion.php
@@ -2,102 +2,36 @@
 
 namespace Psalm\Storage;
 
-use Psalm\Codebase;
-use Psalm\Internal\Type\TemplateBound;
-use Psalm\Internal\Type\TemplateStandinTypeReplacer;
-use Psalm\Internal\Type\TypeTokenizer;
-use Psalm\Type\Atomic\TTemplateParam;
+use Psalm\Type\Atomic;
 
-use function array_map;
-use function implode;
-use function is_string;
-use function str_replace;
-
-class Assertion
+abstract class Assertion
 {
-    /**
-     * @var array<int, array<int, string>> the rule being asserted
-     */
-    public $rule;
+    /** @psalm-mutation-free */
+    abstract public function getNegation(): Assertion;
+
+    /** @psalm-mutation-free */
+    abstract public function isNegationOf(self $assertion): bool;
 
-    /**
-     * @var int|string the id of the property/variable, or
-     *  the parameter offset of the affected arg
-     */
-    public $var_id;
+    abstract public function __toString(): string;
 
-    /**
-     * @param string|int $var_id
-     * @param array<int, array<int, string>> $rule
-     */
-    public function __construct($var_id, array $rule)
+    public function isNegation(): bool
     {
-        $this->rule = $rule;
-        $this->var_id = $var_id;
+        return false;
     }
 
-    /**
-     * @param array<string, array<string, non-empty-list<TemplateBound>>> $inferred_lower_bounds
-     */
-    public function getUntemplatedCopy(
-        array $inferred_lower_bounds,
-        ?string $this_var_id,
-        ?Codebase $codebase
-    ): self {
-        return new Assertion(
-            is_string($this->var_id) && $this_var_id
-                ? str_replace('$this->', $this_var_id . '->', $this->var_id)
-                : $this->var_id,
-            array_map(
-                /**
-                 * @param array<int, string> $rules
-                 *
-                 * @return array{0: string}
-                 */
-                function (array $rules) use ($inferred_lower_bounds, $codebase): array {
-                    $first_rule = $rules[0];
-
-                    if ($inferred_lower_bounds) {
-                        $rule_tokens = TypeTokenizer::tokenize($first_rule);
-
-                        $substitute = false;
-
-                        foreach ($rule_tokens as &$rule_token) {
-                            if (isset($inferred_lower_bounds[$rule_token[0]])) {
-                                foreach ($inferred_lower_bounds[$rule_token[0]] as $lower_bounds) {
-                                    $substitute = true;
-
-                                    $bound_type = TemplateStandinTypeReplacer::getMostSpecificTypeFromBounds(
-                                        $lower_bounds,
-                                        $codebase
-                                    );
-
-                                    $first_type = $bound_type->getSingleAtomic();
-
-                                    if ($first_type instanceof TTemplateParam) {
-                                        $rule_token[0] = $first_type->param_name;
-                                    } else {
-                                        $rule_token[0] = $first_type->getId();
-                                    }
-                                }
-                            }
-                        }
+    /** @psalm-mutation-free */
+    public function hasEquality(): bool
+    {
+        return false;
+    }
 
-                        if ($substitute) {
-                            return [implode(
-                                '',
-                                array_map(
-                                    fn($f) => $f[0],
-                                    $rule_tokens
-                                )
-                            )];
-                        }
-                    }
+    /** @psalm-mutation-free */
+    public function getAtomicType(): ?Atomic
+    {
+        return null;
+    }
 
-                    return [$first_rule];
-                },
-                $this->rule
-            )
-        );
+    public function setAtomicType(Atomic $type): void
+    {
     }
 }
diff --git a/src/Psalm/Storage/Assertion/Any.php b/src/Psalm/Storage/Assertion/Any.php
new file mode 100644
index 00000000000..6256e0a5f64
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/Any.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class Any extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return $this;
+    }
+
+    public function __toString(): string
+    {
+        return 'mixed';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return false;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/ArrayKeyDoesNotExist.php b/src/Psalm/Storage/Assertion/ArrayKeyDoesNotExist.php
new file mode 100644
index 00000000000..f174a7fea8e
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/ArrayKeyDoesNotExist.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class ArrayKeyDoesNotExist extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new ArrayKeyExists();
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    public function __toString(): string
+    {
+        return '!array-key-exists';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof ArrayKeyExists;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/ArrayKeyExists.php b/src/Psalm/Storage/Assertion/ArrayKeyExists.php
new file mode 100644
index 00000000000..598a5b9bd84
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/ArrayKeyExists.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class ArrayKeyExists extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new ArrayKeyDoesNotExist();
+    }
+
+    public function __toString(): string
+    {
+        return 'array-key-exists';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof ArrayKeyDoesNotExist;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/DoesNotHaveAtLeastCount.php b/src/Psalm/Storage/Assertion/DoesNotHaveAtLeastCount.php
new file mode 100644
index 00000000000..a64c52c509b
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/DoesNotHaveAtLeastCount.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class DoesNotHaveAtLeastCount extends Assertion
+{
+    /** @var positive-int */
+    public $count;
+
+    /** @param positive-int $count */
+    public function __construct(int $count)
+    {
+        $this->count = $count;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new HasAtLeastCount($this->count);
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    public function __toString(): string
+    {
+        return '!has-at-least-' . $this->count;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof HasAtLeastCount && $this->count === $assertion->count;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/DoesNotHaveExactCount.php b/src/Psalm/Storage/Assertion/DoesNotHaveExactCount.php
new file mode 100644
index 00000000000..4a4eb645f89
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/DoesNotHaveExactCount.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class DoesNotHaveExactCount extends Assertion
+{
+    /** @var positive-int */
+    public $count;
+
+    /** @param positive-int $count */
+    public function __construct(int $count)
+    {
+        $this->count = $count;
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new HasExactCount($this->count);
+    }
+
+    public function __toString(): string
+    {
+        return '!has-exact-count-' . $this->count;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof HasExactCount && $assertion->count === $this->count;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/DoesNotHaveMethod.php b/src/Psalm/Storage/Assertion/DoesNotHaveMethod.php
new file mode 100644
index 00000000000..1a80432ba5c
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/DoesNotHaveMethod.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class DoesNotHaveMethod extends Assertion
+{
+    public string $method;
+
+    public function __construct(string $method)
+    {
+        $this->method = $method;
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new HasMethod($this->method);
+    }
+
+    public function __toString(): string
+    {
+        return '!method-exists-' . $this->method;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof HasMethod && $assertion->method === $this->method;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/Empty_.php b/src/Psalm/Storage/Assertion/Empty_.php
new file mode 100644
index 00000000000..6dced7aa8f6
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/Empty_.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class Empty_ extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new NonEmpty();
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    public function __toString(): string
+    {
+        return '!non-empty';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof NonEmpty;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/Falsy.php b/src/Psalm/Storage/Assertion/Falsy.php
new file mode 100644
index 00000000000..81e139a0d86
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/Falsy.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class Falsy extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new Truthy();
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    public function __toString(): string
+    {
+        return 'falsy';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof Truthy;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/HasArrayKey.php b/src/Psalm/Storage/Assertion/HasArrayKey.php
new file mode 100644
index 00000000000..168357daca8
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/HasArrayKey.php
@@ -0,0 +1,33 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+use UnexpectedValueException;
+
+class HasArrayKey extends Assertion
+{
+    public $key;
+
+    public function __construct(string $key)
+    {
+        $this->key = $key;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        throw new UnexpectedValueException('This should never be called');
+    }
+
+    public function __toString(): string
+    {
+        return 'has-array-key-' . $this->key;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return false;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/HasAtLeastCount.php b/src/Psalm/Storage/Assertion/HasAtLeastCount.php
new file mode 100644
index 00000000000..699823a8302
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/HasAtLeastCount.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class HasAtLeastCount extends Assertion
+{
+    /** @var positive-int */
+    public $count;
+
+    /** @param positive-int $count */
+    public function __construct(int $count)
+    {
+        $this->count = $count;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new DoesNotHaveAtLeastCount($this->count);
+    }
+
+    public function __toString(): string
+    {
+        return 'has-at-least-' . $this->count;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof DoesNotHaveAtLeastCount && $this->count === $assertion->count;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/HasExactCount.php b/src/Psalm/Storage/Assertion/HasExactCount.php
new file mode 100644
index 00000000000..777e74fce95
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/HasExactCount.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class HasExactCount extends Assertion
+{
+    /** @var positive-int */
+    public $count;
+
+    /** @param positive-int $count */
+    public function __construct(int $count)
+    {
+        $this->count = $count;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new DoesNotHaveExactCount($this->count);
+    }
+
+    /** @psalm-mutation-free */
+    public function hasEquality(): bool
+    {
+        return true;
+    }
+
+    public function __toString(): string
+    {
+        return '=has-exact-count-' . $this->count;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof DoesNotHaveExactCount && $this->count === $assertion->count;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/HasIntOrStringArrayAccess.php b/src/Psalm/Storage/Assertion/HasIntOrStringArrayAccess.php
new file mode 100644
index 00000000000..63bd651e5d9
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/HasIntOrStringArrayAccess.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+use UnexpectedValueException;
+
+class HasIntOrStringArrayAccess extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        throw new UnexpectedValueException('This should never be called');
+    }
+
+    public function __toString(): string
+    {
+        return 'has-string-or-int-array-access';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return false;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/HasMethod.php b/src/Psalm/Storage/Assertion/HasMethod.php
new file mode 100644
index 00000000000..de99013a2e4
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/HasMethod.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class HasMethod extends Assertion
+{
+    public string $method;
+
+    public function __construct(string $method)
+    {
+        $this->method = $method;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new DoesNotHaveMethod($this->method);
+    }
+
+    public function __toString(): string
+    {
+        return 'method-exists-' . $this->method;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof DoesNotHaveMethod && $this->method === $assertion->method;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/HasStringArrayAccess.php b/src/Psalm/Storage/Assertion/HasStringArrayAccess.php
new file mode 100644
index 00000000000..b0251c026d8
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/HasStringArrayAccess.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+use UnexpectedValueException;
+
+class HasStringArrayAccess extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        throw new UnexpectedValueException('This should never be called');
+    }
+
+    public function __toString(): string
+    {
+        return 'has-string-array-access';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return false;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/InArray.php b/src/Psalm/Storage/Assertion/InArray.php
new file mode 100644
index 00000000000..fcc127e0347
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/InArray.php
@@ -0,0 +1,33 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+use Psalm\Type\Union;
+
+class InArray extends Assertion
+{
+    public Union $type;
+
+    public function __construct(Union $type)
+    {
+        $this->type = $type;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new NotInArray($this->type);
+    }
+
+    public function __toString(): string
+    {
+        return 'in-array-' . $this->type->getId();
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof NotInArray && $this->type->getId() === $assertion->type->getId();
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsAClass.php b/src/Psalm/Storage/Assertion/IsAClass.php
new file mode 100644
index 00000000000..83b056abbab
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsAClass.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+use Psalm\Type\Atomic;
+
+class IsAClass extends Assertion
+{
+    /** @var Atomic\TTemplateParamClass|Atomic\TNamedObject */
+    public Atomic $type;
+    public bool $allow_string;
+
+    /** @param Atomic\TTemplateParamClass|Atomic\TNamedObject $type */
+    public function __construct(Atomic $type, bool $allow_string)
+    {
+        $this->type = $type;
+        $this->allow_string = $allow_string;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsNotAClass($this->type, $this->allow_string);
+    }
+
+    /** @psalm-mutation-free */
+    public function getAtomicType(): ?Atomic
+    {
+        return $this->type;
+    }
+
+    public function __toString(): string
+    {
+        return 'isa-' . ($this->allow_string ? 'string-' : '') . $this->type;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsNotAClass
+            && $this->type === $assertion->type
+            && $this->allow_string === $assertion->allow_string;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsClassEqual.php b/src/Psalm/Storage/Assertion/IsClassEqual.php
new file mode 100644
index 00000000000..307b399b9e4
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsClassEqual.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class IsClassEqual extends Assertion
+{
+    public string $type;
+
+    public function __construct(string $type)
+    {
+        $this->type = $type;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsClassNotEqual($this->type);
+    }
+
+    /** @psalm-mutation-free */
+    public function hasEquality(): bool
+    {
+        return true;
+    }
+
+    public function __toString(): string
+    {
+        return '=get-class-' . $this->type;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsClassNotEqual && $this->type === $assertion->type;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsClassNotEqual.php b/src/Psalm/Storage/Assertion/IsClassNotEqual.php
new file mode 100644
index 00000000000..39241ac2508
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsClassNotEqual.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class IsClassNotEqual extends Assertion
+{
+    public string $type;
+
+    public function __construct(string $type)
+    {
+        $this->type = $type;
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsClassEqual($this->type);
+    }
+
+    public function __toString(): string
+    {
+        return '!=get-class-' . $this->type;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsClassEqual && $this->type === $assertion->type;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsCountable.php b/src/Psalm/Storage/Assertion/IsCountable.php
new file mode 100644
index 00000000000..543921d808c
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsCountable.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class IsCountable extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsNotCountable(true);
+    }
+
+    public function __toString(): string
+    {
+        return 'countable';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsNotCountable && $assertion->is_negatable;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsEqualIsset.php b/src/Psalm/Storage/Assertion/IsEqualIsset.php
new file mode 100644
index 00000000000..0ac2e9af920
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsEqualIsset.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class IsEqualIsset extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new Any();
+    }
+
+    public function __toString(): string
+    {
+        return '=isset';
+    }
+
+    /** @psalm-mutation-free */
+    public function hasEquality(): bool
+    {
+        return true;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return false;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsGreaterThan.php b/src/Psalm/Storage/Assertion/IsGreaterThan.php
new file mode 100644
index 00000000000..13d4c088f6c
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsGreaterThan.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class IsGreaterThan extends Assertion
+{
+    public ?int $value;
+
+    public function __construct(?int $value)
+    {
+        $this->value = $value;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsLessThanOrEqualTo($this->value);
+    }
+
+    public function __toString(): string
+    {
+        return '>' . $this->value;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsLessThanOrEqualTo && $this->value === $assertion->value;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsGreaterThanOrEqualTo.php b/src/Psalm/Storage/Assertion/IsGreaterThanOrEqualTo.php
new file mode 100644
index 00000000000..b0248d1f9a9
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsGreaterThanOrEqualTo.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class IsGreaterThanOrEqualTo extends Assertion
+{
+    public ?int $value;
+
+    public function __construct(?int $value)
+    {
+        $this->value = $value;
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsLessThan($this->value);
+    }
+
+    public function __toString(): string
+    {
+        return '!<' . $this->value;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsLessThan && $this->value === $assertion->value;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsIdentical.php b/src/Psalm/Storage/Assertion/IsIdentical.php
new file mode 100644
index 00000000000..b01b1751573
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsIdentical.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+use Psalm\Type\Atomic;
+
+class IsIdentical extends Assertion
+{
+    public Atomic $type;
+
+    public function __construct(Atomic $type)
+    {
+        $this->type = $type;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsNotIdentical($this->type);
+    }
+
+    public function __toString(): string
+    {
+        return '=' . $this->type->getAssertionString(true);
+    }
+
+    /** @psalm-mutation-free */
+    public function hasEquality(): bool
+    {
+        return true;
+    }
+
+    /** @psalm-mutation-free */
+    public function getAtomicType(): ?Atomic
+    {
+        return $this->type;
+    }
+
+    public function setAtomicType(Atomic $type): void
+    {
+        $this->type = $type;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsNotIdentical && $this->type->getId() === $assertion->type->getId();
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsIsset.php b/src/Psalm/Storage/Assertion/IsIsset.php
new file mode 100644
index 00000000000..dda04c24f32
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsIsset.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class IsIsset extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsNotIsset();
+    }
+
+    public function __toString(): string
+    {
+        return 'isset';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsNotIsset;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsLessThan.php b/src/Psalm/Storage/Assertion/IsLessThan.php
new file mode 100644
index 00000000000..24b3f628823
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsLessThan.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class IsLessThan extends Assertion
+{
+    public ?int $value;
+
+    public function __construct(?int $value)
+    {
+        $this->value = $value;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsGreaterThanOrEqualTo($this->value);
+    }
+
+    public function __toString(): string
+    {
+        return '<' . $this->value;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsGreaterThanOrEqualTo && $this->value === $assertion->value;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsLessThanOrEqualTo.php b/src/Psalm/Storage/Assertion/IsLessThanOrEqualTo.php
new file mode 100644
index 00000000000..c56a40e90ac
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsLessThanOrEqualTo.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class IsLessThanOrEqualTo extends Assertion
+{
+    public ?int $value;
+
+    public function __construct(?int $value)
+    {
+        $this->value = $value;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsGreaterThan($this->value);
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    public function __toString(): string
+    {
+        return '!>' . $this->value;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsGreaterThan && $this->value === $assertion->value;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsLooselyEqual.php b/src/Psalm/Storage/Assertion/IsLooselyEqual.php
new file mode 100644
index 00000000000..aa2912cac5e
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsLooselyEqual.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+use Psalm\Type\Atomic;
+
+class IsLooselyEqual extends Assertion
+{
+    public Atomic $type;
+
+    public function __construct(Atomic $type)
+    {
+        $this->type = $type;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsNotLooselyEqual($this->type);
+    }
+
+    public function __toString(): string
+    {
+        return '~' . $this->type->getAssertionString(true);
+    }
+
+    /** @psalm-mutation-free */
+    public function getAtomicType(): ?Atomic
+    {
+        return $this->type;
+    }
+
+    /** @psalm-mutation-free */
+    public function hasEquality(): bool
+    {
+        return true;
+    }
+
+    public function setAtomicType(Atomic $type): void
+    {
+        $this->type = $type;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsNotLooselyEqual && $this->type->getId() === $assertion->type->getId();
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsNotAClass.php b/src/Psalm/Storage/Assertion/IsNotAClass.php
new file mode 100644
index 00000000000..1ac2b5166ac
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsNotAClass.php
@@ -0,0 +1,44 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+use Psalm\Type\Atomic;
+
+class IsNotAClass extends Assertion
+{
+    /** @var Atomic\TTemplateParamClass|Atomic\TNamedObject */
+    public Atomic $type;
+    public bool $allow_string;
+
+    /** @param Atomic\TTemplateParamClass|Atomic\TNamedObject $type */
+    public function __construct(Atomic $type, bool $allow_string)
+    {
+        $this->type = $type;
+        $this->allow_string = $allow_string;
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsAClass($this->type, $this->allow_string);
+    }
+
+    public function __toString(): string
+    {
+        return 'isa-' . ($this->allow_string ? 'string-' : '') . $this->type;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsAClass
+            && $this->type === $assertion->type
+            && $this->allow_string === $assertion->allow_string;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsNotCountable.php b/src/Psalm/Storage/Assertion/IsNotCountable.php
new file mode 100644
index 00000000000..615269bbb36
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsNotCountable.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class IsNotCountable extends Assertion
+{
+    public $is_negatable;
+
+    public function __construct(bool $is_negatable)
+    {
+        $this->is_negatable = $is_negatable;
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsCountable();
+    }
+
+    public function __toString(): string
+    {
+        return '!countable';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsCountable;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsNotIdentical.php b/src/Psalm/Storage/Assertion/IsNotIdentical.php
new file mode 100644
index 00000000000..eb5391c30f9
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsNotIdentical.php
@@ -0,0 +1,55 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+use Psalm\Type\Atomic;
+
+class IsNotIdentical extends Assertion
+{
+    public Atomic $type;
+
+    public function __construct(Atomic $type)
+    {
+        $this->type = $type;
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsIdentical($this->type);
+    }
+
+    /** @psalm-mutation-free */
+    public function hasEquality(): bool
+    {
+        return true;
+    }
+
+    public function __toString(): string
+    {
+        return '!=' . $this->type->getAssertionString(true);
+    }
+
+    /** @psalm-mutation-free */
+    public function getAtomicType(): ?Atomic
+    {
+        return $this->type;
+    }
+
+    public function setAtomicType(Atomic $type): void
+    {
+        $this->type = $type;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsIdentical && $this->type->getId() === $assertion->type->getId();
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsNotIsset.php b/src/Psalm/Storage/Assertion/IsNotIsset.php
new file mode 100644
index 00000000000..4bb32b24cc1
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsNotIsset.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class IsNotIsset extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsIsset();
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    public function __toString(): string
+    {
+        return '!isset';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsNotIsset;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsNotLooselyEqual.php b/src/Psalm/Storage/Assertion/IsNotLooselyEqual.php
new file mode 100644
index 00000000000..0d61a076450
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsNotLooselyEqual.php
@@ -0,0 +1,55 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+use Psalm\Type\Atomic;
+
+class IsNotLooselyEqual extends Assertion
+{
+    public Atomic $type;
+
+    public function __construct(Atomic $type)
+    {
+        $this->type = $type;
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsLooselyEqual($this->type);
+    }
+
+    /** @psalm-mutation-free */
+    public function hasEquality(): bool
+    {
+        return true;
+    }
+
+    public function __toString(): string
+    {
+        return '!~' . $this->type->getAssertionString(true);
+    }
+
+    /** @psalm-mutation-free */
+    public function getAtomicType(): ?Atomic
+    {
+        return $this->type;
+    }
+
+    public function setAtomicType(Atomic $type): void
+    {
+        $this->type = $type;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsLooselyEqual && $this->type->getId() === $assertion->type->getId();
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsNotPositiveNumeric.php b/src/Psalm/Storage/Assertion/IsNotPositiveNumeric.php
new file mode 100644
index 00000000000..02016b095e1
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsNotPositiveNumeric.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class IsNotPositiveNumeric extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsPositiveNumeric(true);
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    public function __toString(): string
+    {
+        return '!positive-numeric';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsPositiveNumeric;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsNotType.php b/src/Psalm/Storage/Assertion/IsNotType.php
new file mode 100644
index 00000000000..ddad7757231
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsNotType.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+use Psalm\Type\Atomic;
+
+class IsNotType extends Assertion
+{
+    public Atomic $type;
+
+    public function __construct(Atomic $type)
+    {
+        $this->type = $type;
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsType($this->type);
+    }
+
+    public function __toString(): string
+    {
+        return '!' . $this->type->getId();
+    }
+
+    /** @psalm-mutation-free */
+    public function getAtomicType(): ?Atomic
+    {
+        return $this->type;
+    }
+
+    public function setAtomicType(Atomic $type): void
+    {
+        $this->type = $type;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsType && $this->type->getId() === $assertion->type->getId();
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsPositiveNumeric.php b/src/Psalm/Storage/Assertion/IsPositiveNumeric.php
new file mode 100644
index 00000000000..553dc775cb6
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsPositiveNumeric.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class IsPositiveNumeric extends Assertion
+{
+    public $is_negatable;
+
+    public function __construct(bool $is_negatable)
+    {
+        $this->is_negatable = $is_negatable;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return $this->is_negatable ? new IsNotPositiveNumeric() : new Any();
+    }
+
+    /** @psalm-mutation-free */
+    public function hasEquality(): bool
+    {
+        return !$this->is_negatable;
+    }
+
+    public function __toString(): string
+    {
+        return (!$this->is_negatable ? '=' : '') . 'positive-numeric';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsNotPositiveNumeric;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/IsType.php b/src/Psalm/Storage/Assertion/IsType.php
new file mode 100644
index 00000000000..3f305d548b1
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/IsType.php
@@ -0,0 +1,44 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+use Psalm\Type\Atomic;
+
+class IsType extends Assertion
+{
+    public Atomic $type;
+
+    public function __construct(Atomic $type)
+    {
+        $this->type = $type;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new IsNotType($this->type);
+    }
+
+    public function __toString(): string
+    {
+        return $this->type->getId();
+    }
+
+    /** @psalm-mutation-free */
+    public function getAtomicType(): ?Atomic
+    {
+        return $this->type;
+    }
+
+    public function setAtomicType(Atomic $type): void
+    {
+        $this->type = $type;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof IsNotType && $this->type->getId() === $assertion->type->getId();
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/NestedAssertions.php b/src/Psalm/Storage/Assertion/NestedAssertions.php
new file mode 100644
index 00000000000..9e74e04725b
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/NestedAssertions.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+use function json_encode;
+
+use const JSON_THROW_ON_ERROR;
+
+class NestedAssertions extends Assertion
+{
+    /** @var array<string, list<list<Assertion>>> */
+    public array $assertions;
+
+    /** @param array<string, list<list<Assertion>>> $assertions */
+    public function __construct(array $assertions)
+    {
+        $this->assertions = $assertions;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new NotNestedAssertions($this->assertions);
+    }
+
+    public function __toString(): string
+    {
+        return '@' . json_encode($this->assertions, JSON_THROW_ON_ERROR);
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return false;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/NonEmpty.php b/src/Psalm/Storage/Assertion/NonEmpty.php
new file mode 100644
index 00000000000..785c3388ee9
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/NonEmpty.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class NonEmpty extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new Empty_();
+    }
+
+    public function __toString(): string
+    {
+        return 'non-empty';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof Empty_;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/NonEmptyCountable.php b/src/Psalm/Storage/Assertion/NonEmptyCountable.php
new file mode 100644
index 00000000000..9990e348035
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/NonEmptyCountable.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class NonEmptyCountable extends Assertion
+{
+    public $is_negatable;
+
+    public function __construct(bool $is_negatable)
+    {
+        $this->is_negatable = $is_negatable;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return $this->is_negatable ? new NotNonEmptyCountable() : new Any();
+    }
+
+    /** @psalm-mutation-free */
+    public function hasEquality(): bool
+    {
+        return !$this->is_negatable;
+    }
+
+    public function __toString(): string
+    {
+        return ($this->is_negatable ? '' : '=') . 'non-empty-countable';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $this->is_negatable && $assertion instanceof NotNonEmptyCountable;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/NotInArray.php b/src/Psalm/Storage/Assertion/NotInArray.php
new file mode 100644
index 00000000000..138786bb02e
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/NotInArray.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+use Psalm\Type\Union;
+
+class NotInArray extends Assertion
+{
+    public Union $type;
+
+    public function __construct(Union $type)
+    {
+        $this->type = $type;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new InArray($this->type);
+    }
+
+    public function __toString(): string
+    {
+        return '!in-array-' . $this->type;
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof InArray && $this->type->getId() === $assertion->type->getId();
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/NotNestedAssertions.php b/src/Psalm/Storage/Assertion/NotNestedAssertions.php
new file mode 100644
index 00000000000..f594bd22ae6
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/NotNestedAssertions.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+use function json_encode;
+
+use const JSON_THROW_ON_ERROR;
+
+class NotNestedAssertions extends Assertion
+{
+    /** @var array<string, list<list<Assertion>>> */
+    public array $assertions;
+
+    /** @param array<string, list<list<Assertion>>> $assertions */
+    public function __construct(array $assertions)
+    {
+        $this->assertions = $assertions;
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new NestedAssertions($this->assertions);
+    }
+
+    public function __toString(): string
+    {
+        return '!@' . json_encode($this->assertions, JSON_THROW_ON_ERROR);
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return false;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/NotNonEmptyCountable.php b/src/Psalm/Storage/Assertion/NotNonEmptyCountable.php
new file mode 100644
index 00000000000..2e7cf3e8224
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/NotNonEmptyCountable.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class NotNonEmptyCountable extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new NonEmptyCountable(true);
+    }
+
+    public function isNegation(): bool
+    {
+        return true;
+    }
+
+    public function __toString(): string
+    {
+        return '!non-empty-countable';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof NonEmptyCountable && $assertion->is_negatable;
+    }
+}
diff --git a/src/Psalm/Storage/Assertion/Truthy.php b/src/Psalm/Storage/Assertion/Truthy.php
new file mode 100644
index 00000000000..78ba516899c
--- /dev/null
+++ b/src/Psalm/Storage/Assertion/Truthy.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace Psalm\Storage\Assertion;
+
+use Psalm\Storage\Assertion;
+
+class Truthy extends Assertion
+{
+    /** @psalm-mutation-free */
+    public function getNegation(): Assertion
+    {
+        return new Falsy();
+    }
+
+    public function __toString(): string
+    {
+        return '!falsy';
+    }
+
+    /** @psalm-mutation-free */
+    public function isNegationOf(Assertion $assertion): bool
+    {
+        return $assertion instanceof Falsy;
+    }
+}
diff --git a/src/Psalm/Storage/FunctionLikeStorage.php b/src/Psalm/Storage/FunctionLikeStorage.php
index c06a43dea24..b4614ad4607 100644
--- a/src/Psalm/Storage/FunctionLikeStorage.php
+++ b/src/Psalm/Storage/FunctionLikeStorage.php
@@ -122,17 +122,17 @@ abstract class FunctionLikeStorage
     public $template_types;
 
     /**
-     * @var array<int, Assertion>
+     * @var array<int, Possibilities>
      */
     public $assertions = [];
 
     /**
-     * @var array<int, Assertion>
+     * @var array<int, Possibilities>
      */
     public $if_true_assertions = [];
 
     /**
-     * @var array<int, Assertion>
+     * @var array<int, Possibilities>
      */
     public $if_false_assertions = [];
 
diff --git a/src/Psalm/Storage/Possibilities.php b/src/Psalm/Storage/Possibilities.php
new file mode 100644
index 00000000000..72a7a882ff9
--- /dev/null
+++ b/src/Psalm/Storage/Possibilities.php
@@ -0,0 +1,71 @@
+<?php
+
+namespace Psalm\Storage;
+
+use Psalm\Codebase;
+use Psalm\Internal\Type\TemplateInferredTypeReplacer;
+use Psalm\Internal\Type\TemplateResult;
+use Psalm\Type\Union;
+
+use function is_string;
+use function str_replace;
+
+class Possibilities
+{
+    /**
+     * @var list<Assertion> the rule being asserted
+     */
+    public $rule;
+
+    /**
+     * @var int|string the id of the property/variable, or
+     *  the parameter offset of the affected arg
+     */
+    public $var_id;
+
+    /**
+     * @param string|int $var_id
+     * @param list<Assertion> $rule
+     */
+    public function __construct($var_id, array $rule)
+    {
+        $this->rule = $rule;
+        $this->var_id = $var_id;
+    }
+
+    public function getUntemplatedCopy(
+        TemplateResult $template_result,
+        ?string $this_var_id,
+        ?Codebase $codebase
+    ): self {
+        $assertion_rules = [];
+
+        foreach ($this->rule as $assertion) {
+            $assertion_type = $assertion->getAtomicType();
+
+            if ($assertion_type) {
+                $union = new Union([clone $assertion_type]);
+                TemplateInferredTypeReplacer::replace(
+                    $union,
+                    $template_result,
+                    $codebase
+                );
+
+                foreach ($union->getAtomicTypes() as $atomic_type) {
+                    $assertion = clone $assertion;
+                    $assertion->setAtomicType($atomic_type);
+                    $assertion_rules[] = $assertion;
+                }
+            } else {
+                $assertion_rules[] = $assertion;
+            }
+        }
+
+        return new Possibilities(
+            is_string($this->var_id) && $this_var_id
+                ? str_replace('$this->', $this_var_id . '->', $this->var_id)
+                : $this->var_id,
+            $assertion_rules
+        );
+    }
+}
diff --git a/src/Psalm/Type/Atomic.php b/src/Psalm/Type/Atomic.php
index 0b9d0fa0d07..155b223a680 100644
--- a/src/Psalm/Type/Atomic.php
+++ b/src/Psalm/Type/Atomic.php
@@ -11,8 +11,6 @@
 use Psalm\Type;
 use Psalm\Type\Atomic\TArray;
 use Psalm\Type\Atomic\TArrayKey;
-use Psalm\Type\Atomic\TAssertionEmpty;
-use Psalm\Type\Atomic\TAssertionFalsy;
 use Psalm\Type\Atomic\TBool;
 use Psalm\Type\Atomic\TCallable;
 use Psalm\Type\Atomic\TCallableArray;
@@ -229,9 +227,6 @@ public static function create(
 
                 return new TNamedObject($value);
 
-            case 'empty':
-                return $analysis_php_version_id !== null ? new TNamedObject($value) : new TAssertionEmpty();
-
             case 'scalar':
                 return $analysis_php_version_id !== null ? new TNamedObject($value) : new TScalar();
 
@@ -277,9 +272,6 @@ public static function create(
             case 'literal-int':
                 return new TNonspecificLiteralInt();
 
-            case 'false-y':
-                return new TAssertionFalsy();
-
             case '$this':
                 return new TNamedObject('static');
 
diff --git a/src/Psalm/Type/Atomic/TAssertionEmpty.php b/src/Psalm/Type/Atomic/TAssertionEmpty.php
deleted file mode 100644
index c6a090836f0..00000000000
--- a/src/Psalm/Type/Atomic/TAssertionEmpty.php
+++ /dev/null
@@ -1,38 +0,0 @@
-<?php
-
-namespace Psalm\Type\Atomic;
-
-use Psalm\Type\Atomic;
-
-/**
- * Represents any value that returns true to empty(). This is used for assertions
- */
-class TAssertionEmpty extends Atomic
-{
-    public function __toString(): string
-    {
-        return 'empty';
-    }
-
-    public function getKey(bool $include_extra = true): string
-    {
-        return 'empty';
-    }
-
-    /**
-     * @param  array<lowercase-string, string> $aliased_classes
-     */
-    public function toPhpString(
-        ?string $namespace,
-        array $aliased_classes,
-        ?string $this_class,
-        int $analysis_php_version_id
-    ): ?string {
-        return null;
-    }
-
-    public function canBeFullyExpressedInPhp(int $analysis_php_version_id): bool
-    {
-        return false;
-    }
-}
diff --git a/src/Psalm/Type/Atomic/TAssertionFalsy.php b/src/Psalm/Type/Atomic/TAssertionFalsy.php
deleted file mode 100644
index 01ca6cc429c..00000000000
--- a/src/Psalm/Type/Atomic/TAssertionFalsy.php
+++ /dev/null
@@ -1,43 +0,0 @@
-<?php
-
-namespace Psalm\Type\Atomic;
-
-use Psalm\Type\Atomic;
-
-/**
- * Represents any value reduced to false when computed in boolean context. This is used for assertions
- */
-class TAssertionFalsy extends Atomic
-{
-    public function __toString(): string
-    {
-        return 'falsy';
-    }
-
-    public function getKey(bool $include_extra = true): string
-    {
-        return 'falsy';
-    }
-
-    public function getAssertionString(bool $exact = false): string
-    {
-        return 'falsy';
-    }
-
-    /**
-     * @param  array<lowercase-string, string> $aliased_classes
-     */
-    public function toPhpString(
-        ?string $namespace,
-        array $aliased_classes,
-        ?string $this_class,
-        int $analysis_php_version_id
-    ): ?string {
-        return null;
-    }
-
-    public function canBeFullyExpressedInPhp(int $analysis_php_version_id): bool
-    {
-        return false;
-    }
-}
diff --git a/src/Psalm/Type/Atomic/TClassString.php b/src/Psalm/Type/Atomic/TClassString.php
index e950b49111e..e46f031bcd4 100644
--- a/src/Psalm/Type/Atomic/TClassString.php
+++ b/src/Psalm/Type/Atomic/TClassString.php
@@ -33,6 +33,12 @@ class TClassString extends TString
      */
     public $as_type;
 
+    /** @var bool */
+    public $is_loaded = false;
+
+    /** @var bool */
+    public $is_interface = false;
+
     public function __construct(string $as = 'object', ?TNamedObject $as_type = null)
     {
         $this->as = $as;
@@ -41,7 +47,8 @@ public function __construct(string $as = 'object', ?TNamedObject $as_type = null
 
     public function getKey(bool $include_extra = true): string
     {
-        return 'class-string' . ($this->as === 'object' ? '' : '<' . $this->as_type . '>');
+        return ($this->is_interface ? 'interface' : 'class')
+            . '-string' . ($this->as === 'object' ? '' : '<' . $this->as_type . '>');
     }
 
     public function __toString(): string
@@ -51,7 +58,9 @@ public function __toString(): string
 
     public function getId(bool $nested = false): string
     {
-        return $this->getKey();
+        return ($this->is_loaded ? 'loaded-' : '')
+            . ($this->is_interface ? 'interface' : 'class')
+            . '-string' . ($this->as === 'object' ? '' : '<' . $this->as_type . '>');
     }
 
     public function getAssertionString(bool $exact = false): string
diff --git a/src/Psalm/Type/Atomic/TNonEmptyArray.php b/src/Psalm/Type/Atomic/TNonEmptyArray.php
index 8dce93d88f5..d81b5dfe9c8 100644
--- a/src/Psalm/Type/Atomic/TNonEmptyArray.php
+++ b/src/Psalm/Type/Atomic/TNonEmptyArray.php
@@ -9,10 +9,15 @@
 class TNonEmptyArray extends TArray
 {
     /**
-     * @var int|null
+     * @var positive-int|null
      */
     public $count;
 
+    /**
+     * @var positive-int|null
+     */
+    public $min_count;
+
     /**
      * @var string
      */
diff --git a/src/Psalm/Type/Atomic/TNonEmptyList.php b/src/Psalm/Type/Atomic/TNonEmptyList.php
index cf18019d6a1..2703e0bf160 100644
--- a/src/Psalm/Type/Atomic/TNonEmptyList.php
+++ b/src/Psalm/Type/Atomic/TNonEmptyList.php
@@ -8,10 +8,15 @@
 class TNonEmptyList extends TList
 {
     /**
-     * @var int|null
+     * @var positive-int|null
      */
     public $count;
 
+    /**
+     * @var positive-int|null
+     */
+    public $min_count;
+
     public const KEY = 'non-empty-list';
 
     public function getAssertionString(bool $exact = false): string
diff --git a/src/Psalm/Type/Reconciler.php b/src/Psalm/Type/Reconciler.php
index 727a05eacd4..28ca95c5fd6 100644
--- a/src/Psalm/Type/Reconciler.php
+++ b/src/Psalm/Type/Reconciler.php
@@ -19,9 +19,27 @@
 use Psalm\Issue\TypeDoesNotContainNull;
 use Psalm\Issue\TypeDoesNotContainType;
 use Psalm\IssueBuffer;
+use Psalm\Storage\Assertion;
+use Psalm\Storage\Assertion\ArrayKeyExists;
+use Psalm\Storage\Assertion\Empty_;
+use Psalm\Storage\Assertion\Falsy;
+use Psalm\Storage\Assertion\HasArrayKey;
+use Psalm\Storage\Assertion\HasIntOrStringArrayAccess;
+use Psalm\Storage\Assertion\HasStringArrayAccess;
+use Psalm\Storage\Assertion\IsEqualIsset;
+use Psalm\Storage\Assertion\IsIdentical;
+use Psalm\Storage\Assertion\IsIsset;
+use Psalm\Storage\Assertion\IsNotIsset;
+use Psalm\Storage\Assertion\IsNotLooselyEqual;
+use Psalm\Storage\Assertion\NestedAssertions;
+use Psalm\Storage\Assertion\NonEmpty;
+use Psalm\Storage\Assertion\NonEmptyCountable;
+use Psalm\Storage\Assertion\NotNestedAssertions;
+use Psalm\Storage\Assertion\Truthy;
 use Psalm\Type;
 use Psalm\Type\Atomic\TArray;
 use Psalm\Type\Atomic\TArrayKey;
+use Psalm\Type\Atomic\TBool;
 use Psalm\Type\Atomic\TClassStringMap;
 use Psalm\Type\Atomic\TFalse;
 use Psalm\Type\Atomic\TInt;
@@ -47,7 +65,6 @@
 use function explode;
 use function implode;
 use function is_numeric;
-use function json_decode;
 use function ksort;
 use function preg_match;
 use function preg_quote;
@@ -57,8 +74,6 @@
 use function strtolower;
 use function substr;
 
-use const JSON_THROW_ON_ERROR;
-
 class Reconciler
 {
     public const RECONCILIATION_OK = 0;
@@ -71,8 +86,8 @@ class Reconciler
     /**
      * Takes two arrays and consolidates them, removing null values from existing types where applicable
      *
-     * @param  array<string, array<array<int, string>>> $new_types
-     * @param  array<string, array<array<int, string>>> $active_new_types - types we can complain about
+     * @param  array<string, array<array<int, Assertion>>> $new_types
+     * @param  array<string, array<array<int, Assertion>>> $active_new_types - types we can complain about
      * @param  array<string, Union> $existing_types
      * @param  array<string, bool>       $changed_var_ids
      * @param  array<string, bool>       $referenced_var_ids
@@ -118,7 +133,7 @@ public static function reconcileKeyedTypes(
             $has_negation = false;
             $has_isset = false;
             $has_inverted_isset = false;
-            $has_falsyish = false;
+            $has_truthy_or_falsy_or_empty = false;
             $has_empty = false;
             $has_count_check = false;
             $is_real = ($old_new_types[$key] ?? null) === $new_type_parts;
@@ -126,30 +141,31 @@ public static function reconcileKeyedTypes(
 
             foreach ($new_type_parts as $new_type_part_parts) {
                 foreach ($new_type_part_parts as $new_type_part_part) {
-                    if ($new_type_part_part[0] === '!') {
+                    if ($new_type_part_part->isNegation()) {
                         $has_negation = true;
                     }
 
                     $has_isset = $has_isset
-                        || $new_type_part_part === 'isset'
-                        || $new_type_part_part === '=isset'
-                        || $new_type_part_part === 'array-key-exists'
-                        || $new_type_part_part === '=string-array-access';
+                        || $new_type_part_part instanceof IsIsset
+                        || $new_type_part_part instanceof IsEqualIsset
+                        || $new_type_part_part instanceof ArrayKeyExists
+                        || $new_type_part_part instanceof HasStringArrayAccess;
 
-                    $has_empty = $has_empty || $new_type_part_part === 'empty';
+                    $has_empty = $has_empty || $new_type_part_part instanceof Empty_;
 
-                    $has_falsyish = $has_falsyish
-                        || $new_type_part_part === 'empty'
-                        || $new_type_part_part === 'falsy';
+                    $has_truthy_or_falsy_or_empty = $has_truthy_or_falsy_or_empty
+                        || $new_type_part_part instanceof NonEmpty
+                        || $new_type_part_part instanceof Truthy
+                        || $new_type_part_part instanceof Empty_
+                        || $new_type_part_part instanceof Falsy;
 
                     $is_equality = $is_equality
-                        && $new_type_part_part[0] === '='
-                        && $new_type_part_part !== '=isset';
+                        && $new_type_part_part instanceof IsIdentical;
 
-                    $has_inverted_isset = $has_inverted_isset || $new_type_part_part === '!isset';
+                    $has_inverted_isset = $has_inverted_isset || $new_type_part_part instanceof IsNotIsset;
 
                     $has_count_check = $has_count_check
-                        || $new_type_part_part === 'non-empty-countable';
+                        || $new_type_part_part instanceof NonEmptyCountable;
                 }
             }
 
@@ -184,19 +200,15 @@ public static function reconcileKeyedTypes(
                 $orred_type = null;
 
                 foreach ($new_type_part_parts as $new_type_part_part) {
-                    if ($new_type_part_part[0] === '@'
-                        || ($new_type_part_part[0] === '!'
-                            && $new_type_part_part[1] === '@')
+                    if ($new_type_part_part instanceof NestedAssertions
+                        || $new_type_part_part instanceof NotNestedAssertions
                     ) {
-                        if ($new_type_part_part[0] === '!') {
-                            $nested_negated = !$negated;
+                        $data = $new_type_part_part->assertions;
 
-                            /** @var array<string, array<int, array<int, string>>> */
-                            $data = json_decode(substr($new_type_part_part, 2), true, 512, JSON_THROW_ON_ERROR);
+                        if ($new_type_part_part instanceof NotNestedAssertions) {
+                            $nested_negated = !$negated;
                         } else {
                             $nested_negated = $negated;
-                            /** @var array<string, array<int, array<int, string>>> */
-                            $data = json_decode(substr($new_type_part_part, 1), true, 512, JSON_THROW_ON_ERROR);
                         }
 
                         $existing_types = self::reconcileKeyedTypes(
@@ -212,7 +224,7 @@ public static function reconcileKeyedTypes(
                             $nested_negated
                         );
 
-                        $new_type_part_part = ($nested_negated ? '' : '!') . 'falsy';
+                        $new_type_part_part = $nested_negated ? new Falsy() : new Truthy();
                     }
 
                     $result_type_candidate = AssertionReconciler::reconcile(
@@ -299,7 +311,7 @@ public static function reconcileKeyedTypes(
                         }
                     }
                 }
-            } elseif (!$has_negation && !$has_falsyish && !$has_isset) {
+            } elseif (!$has_negation && !$has_truthy_or_falsy_or_empty && !$has_isset) {
                 $changed_var_ids[$key] = true;
             }
 
@@ -329,19 +341,18 @@ public static function reconcileKeyedTypes(
      *     '$a[0]->foo->bar' => 'isset' // original assertion
      * ]
      *
-     * @param array<string, array<array<int, string>>> $new_types
+     * @param array<string, array<array<int, Assertion>>> $new_types
      * @param array<string, Union> $existing_types
      *
-     * @return array<string, array<array<int, string>>>
+     * @return array<string, array<array<int, Assertion>>>
      */
     private static function addNestedAssertions(array $new_types, array $existing_types): array
     {
         foreach ($new_types as $nk => $type) {
             if (strpos($nk, '[') || strpos($nk, '->')) {
-                if ($type[0][0] === '=isset'
-                    //|| $type[0][0] === '!=empty'
-                    || $type[0][0] === 'isset'
-                    || $type[0][0] === '!empty'
+                if ($type[0][0] instanceof IsEqualIsset
+                    || $type[0][0] instanceof IsIsset
+                    || $type[0][0] instanceof NonEmpty
                 ) {
                     $key_parts = self::breakUpPathIntoParts($nk);
 
@@ -354,9 +365,9 @@ private static function addNestedAssertions(array $new_types, array $existing_ty
 
                     if (!isset($existing_types[$base_key]) || $existing_types[$base_key]->isNullable()) {
                         if (!isset($new_types[$base_key])) {
-                            $new_types[$base_key] = [['=isset']];
+                            $new_types[$base_key] = [[new IsEqualIsset()]];
                         } else {
-                            $new_types[$base_key][] = ['=isset'];
+                            $new_types[$base_key][] = [new IsEqualIsset()];
                         }
                     }
 
@@ -370,9 +381,9 @@ private static function addNestedAssertions(array $new_types, array $existing_ty
                             $new_base_key = $base_key . '[' . $array_key . ']';
 
                             if (strpos($array_key, '\'') !== false) {
-                                $new_types[$base_key][] = ['=string-array-access'];
+                                $new_types[$base_key][] = [new HasStringArrayAccess()];
                             } else {
-                                $new_types[$base_key][] = ['=int-or-string-array-access'];
+                                $new_types[$base_key][] = [new HasIntOrStringArrayAccess()];
                             }
 
                             $base_key = $new_base_key;
@@ -385,7 +396,7 @@ private static function addNestedAssertions(array $new_types, array $existing_ty
                             $new_base_key = $base_key . '->' . $property_name;
 
                             if (!isset($new_types[$base_key])) {
-                                $new_types[$base_key] = [['=isset']];
+                                $new_types[$base_key] = [[new IsEqualIsset()]];
                             }
 
                             $base_key = $new_base_key;
@@ -398,16 +409,20 @@ private static function addNestedAssertions(array $new_types, array $existing_ty
                         }
 
                         if (!isset($new_types[$base_key])) {
-                            $new_types[$base_key] = [['!~bool'], ['!~int'], ['=isset']];
+                            $new_types[$base_key] = [
+                                [new IsNotLooselyEqual(new TBool())],
+                                [new IsNotLooselyEqual(new TInt())],
+                                [new IsEqualIsset()]
+                            ];
                         } else {
-                            $new_types[$base_key][] = ['!~bool'];
-                            $new_types[$base_key][] = ['!~int'];
-                            $new_types[$base_key][] = ['=isset'];
+                            $new_types[$base_key][] = [new IsNotLooselyEqual(new TBool())];
+                            $new_types[$base_key][] = [new IsNotLooselyEqual(new TInt())];
+                            $new_types[$base_key][] = [new IsEqualIsset()];
                         }
                     }
                 }
 
-                if ($type[0][0] === 'array-key-exists') {
+                if ($type[0][0] instanceof ArrayKeyExists) {
                     $key_parts = self::breakUpPathIntoParts($nk);
 
                     if (count($key_parts) === 4
@@ -417,9 +432,9 @@ private static function addNestedAssertions(array $new_types, array $existing_ty
                     ) {
                         if ($key_parts[0][0] === '$') {
                             if (isset($new_types[$key_parts[0]])) {
-                                $new_types[$key_parts[0]][] = ['=has-array-key-' . $key_parts[2]];
+                                $new_types[$key_parts[0]][] = [new HasArrayKey($key_parts[2])];
                             } else {
-                                $new_types[$key_parts[0]] = [['=has-array-key-' . $key_parts[2]]];
+                                $new_types[$key_parts[0]] = [[new HasArrayKey($key_parts[2])]];
                             }
                         }
                     }
@@ -881,23 +896,24 @@ protected static function triggerIssueForImpossible(
         Union $existing_var_type,
         string $old_var_type_string,
         string $key,
-        string $assertion,
+        Assertion $assertion,
         bool $redundant,
         bool $negated,
         CodeLocation $code_location,
         array $suppressed_issues
     ): void {
-        $not = $assertion[0] === '!';
+        $assertion_string = (string)$assertion;
+        $not = $assertion_string[0] === '!';
 
         if ($not) {
-            $assertion = substr($assertion, 1);
+            $assertion_string = substr($assertion_string, 1);
         }
 
-        $operator = substr($assertion, 0, 1);
+        $operator = substr($assertion_string, 0, 1);
         if ($operator === '>') {
-            $assertion = '>= '.substr($assertion, 1);
+            $assertion_string = '>= '.substr($assertion_string, 1);
         } elseif ($operator === '<') {
-            $assertion = '<= '.substr($assertion, 1);
+            $assertion_string = '<= '.substr($assertion_string, 1);
         }
 
         if ($negated) {
@@ -908,11 +924,13 @@ protected static function triggerIssueForImpossible(
         $existing_var_atomic_types = $existing_var_type->getAtomicTypes();
 
         $from_docblock = $existing_var_type->from_docblock
-            || (isset($existing_var_atomic_types[$assertion])
-                && $existing_var_atomic_types[$assertion]->from_docblock);
+            || (isset($existing_var_atomic_types[$assertion_string])
+                && $existing_var_atomic_types[$assertion_string]->from_docblock);
 
         if ($redundant) {
-            if ($existing_var_type->from_property && $assertion === 'isset') {
+            if ($existing_var_type->from_property
+                && ($assertion instanceof IsIsset || $assertion instanceof IsNotIsset)
+            ) {
                 if ($existing_var_type->from_static_property) {
                     IssueBuffer::maybeAdd(
                         new RedundantPropertyInitializationCheck(
@@ -938,9 +956,9 @@ protected static function triggerIssueForImpossible(
                     new RedundantConditionGivenDocblockType(
                         'Docblock-defined type ' . $old_var_type_string
                         . ' for ' . $key
-                        . ' is ' . ($not ? 'never ' : 'always ') . $assertion,
+                        . ' is ' . ($not ? 'never ' : 'always ') . $assertion_string,
                         $code_location,
-                        $old_var_type_string . ' ' . $assertion
+                        $old_var_type_string . ' ' . $assertion_string
                     ),
                     $suppressed_issues
                 );
@@ -949,9 +967,9 @@ protected static function triggerIssueForImpossible(
                     new RedundantCondition(
                         'Type ' . $old_var_type_string
                         . ' for ' . $key
-                        . ' is ' . ($not ? 'never ' : 'always ') . $assertion,
+                        . ' is ' . ($not ? 'never ' : 'always ') . $assertion_string,
                         $code_location,
-                        $old_var_type_string . ' ' . $assertion
+                        $old_var_type_string . ' ' . $assertion_string
                     ),
                     $suppressed_issues
                 );
@@ -962,20 +980,20 @@ protected static function triggerIssueForImpossible(
                     new DocblockTypeContradiction(
                         'Docblock-defined type ' . $old_var_type_string
                             . ' for ' . $key
-                            . ' is ' . ($not ? 'always ' : 'never ') . $assertion,
+                            . ' is ' . ($not ? 'always ' : 'never ') . $assertion_string,
                         $code_location,
-                        $old_var_type_string . ' ' . $assertion
+                        $old_var_type_string . ' ' . $assertion_string
                     ),
                     $suppressed_issues
                 );
             } else {
-                if ($assertion === 'null' && !$not) {
+                if ($assertion_string === 'null' && !$not) {
                     $issue = new TypeDoesNotContainNull(
                         'Type ' . $old_var_type_string
                             . ' for ' . $key
-                            . ' is never ' . $assertion,
+                            . ' is never ' . $assertion_string,
                         $code_location,
-                        $old_var_type_string . ' ' . $assertion
+                        $old_var_type_string . ' ' . $assertion_string
                     );
                 } else {
                     $issue = new TypeDoesNotContainType(
diff --git a/src/Psalm/Type/Union.php b/src/Psalm/Type/Union.php
index 0388ca6e077..479bfbdd630 100644
--- a/src/Psalm/Type/Union.php
+++ b/src/Psalm/Type/Union.php
@@ -43,7 +43,6 @@
 use Psalm\Type\Atomic\TTemplateParam;
 use Psalm\Type\Atomic\TTemplateParamClass;
 use Psalm\Type\Atomic\TTrue;
-use UnexpectedValueException;
 
 use function array_filter;
 use function array_merge;
@@ -441,21 +440,6 @@ public function getId(): string
         return $id;
     }
 
-    public function getAssertionString(bool $exact = false): string
-    {
-        $assertions = [];
-        foreach ($this->types as $type) {
-            $assertions[] = $type->getAssertionString($exact);
-        }
-
-        $assertions = array_unique($assertions);
-        if (count($assertions) !== 1) {
-            throw new UnexpectedValueException('Should only be one type per assertion');
-        }
-
-        return reset($assertions);
-    }
-
     /**
      * @param  array<lowercase-string, string> $aliased_classes
      *
diff --git a/tests/AlgebraTest.php b/tests/AlgebraTest.php
index 2eb2f6b89d1..84f831773e4 100644
--- a/tests/AlgebraTest.php
+++ b/tests/AlgebraTest.php
@@ -11,6 +11,15 @@
 use Psalm\Internal\Clause;
 use Psalm\Internal\Provider\NodeDataProvider;
 use Psalm\Internal\Provider\StatementsProvider;
+use Psalm\Storage\Assertion\Falsy;
+use Psalm\Storage\Assertion\IsIdentical;
+use Psalm\Storage\Assertion\IsIsset;
+use Psalm\Storage\Assertion\IsType;
+use Psalm\Storage\Assertion\Truthy;
+use Psalm\Type;
+use Psalm\Type\Atomic\TArray;
+use Psalm\Type\Atomic\TInt;
+use Psalm\Type\Atomic\TString;
 
 use function spl_object_id;
 
@@ -19,57 +28,64 @@ class AlgebraTest extends TestCase
     public function testNegateFormula(): void
     {
         $formula = [
-            new Clause(['$a' => ['!falsy']], 1, 1),
+            new Clause(['$a' => [new Truthy()]], 1, 1),
         ];
 
         $negated_formula = Algebra::negateFormula($formula);
 
         $this->assertCount(1, $negated_formula);
-        $this->assertSame(['$a' => ['falsy']], $negated_formula[0]->possibilities);
+        $this->assertSame('!$a', (string)$negated_formula[0]);
 
         $formula = [
-            new Clause(['$a' => ['!falsy'], '$b' => ['!falsy']], 1, 1),
+            new Clause(['$a' => [new Truthy()], '$b' => [new Truthy()]], 1, 1),
         ];
 
         $negated_formula = Algebra::negateFormula($formula);
 
         $this->assertCount(2, $negated_formula);
-        $this->assertSame(['$a' => ['falsy']], $negated_formula[0]->possibilities);
-        $this->assertSame(['$b' => ['falsy']], $negated_formula[1]->possibilities);
+        $this->assertSame('!$a', (string)$negated_formula[0]);
+        $this->assertSame('!$b', (string)$negated_formula[1]);
 
         $formula = [
-            new Clause(['$a' => ['!falsy']], 1, 1),
-            new Clause(['$b' => ['!falsy']], 1, 2),
+            new Clause(['$a' => [new Truthy()]], 1, 1),
+            new Clause(['$b' => [new Truthy()]], 1, 2),
         ];
 
         $negated_formula = Algebra::negateFormula($formula);
 
         $this->assertCount(1, $negated_formula);
-        $this->assertSame(['$b' => ['falsy'], '$a' => ['falsy']], $negated_formula[0]->possibilities);
+        $this->assertSame('(!$a) || (!$b)', (string)$negated_formula[0]);
 
         $formula = [
-            new Clause(['$a' => ['int', 'string'], '$b' => ['!falsy']], 1, 1),
+            new Clause(
+                [
+                    '$a' => [new IsType(new TInt()), new IsType(new TString())],
+                    '$b' => [new Truthy()]
+                ],
+                1,
+                1
+            ),
         ];
 
         $negated_formula = Algebra::negateFormula($formula);
 
         $this->assertCount(3, $negated_formula);
-        $this->assertSame(['$a' => ['!int']], $negated_formula[0]->possibilities);
-        $this->assertSame(['$a' => ['!string']], $negated_formula[1]->possibilities);
-        $this->assertSame(['$b' => ['falsy']], $negated_formula[2]->possibilities);
+        $this->assertSame('$a is not string', (string)$negated_formula[0]);
+        $this->assertSame('$a is not int', (string)$negated_formula[1]);
+        $this->assertSame('!$b', (string)$negated_formula[2]);
     }
 
     public function testNegateFormulaWithUnreconcilableTerm(): void
     {
         $formula = [
-            new Clause(['$a' => ['int']], 1, 1),
-            new Clause(['$b' => ['int']], 1, 2, false, false),
+            new Clause(['$a' => [new IsType(new TInt())]], 1, 1),
+            new Clause(['$b' => [new IsType(new TInt())]], 1, 2, false, false),
         ];
 
         $negated_formula = Algebra::negateFormula($formula);
 
         $this->assertCount(1, $negated_formula);
-        $this->assertSame(['$a' => ['!int']], $negated_formula[0]->possibilities);
+        $this->assertSame('$a is not int', (string)$negated_formula[0]);
     }
 
     public function testCombinatorialExpansion(): void
@@ -113,15 +129,15 @@ public function testContainsClause(): void
         $this->assertTrue(
             (new Clause(
                 [
-                    '$a' => ['!falsy'],
-                    '$b' => ['!falsy'],
+                    '$a' => [new Truthy()],
+                    '$b' => [new Truthy()],
                 ],
                 1,
                 1
             ))->contains(
                 new Clause(
                     [
-                        '$a' => ['!falsy'],
+                        '$a' => [new Truthy()],
                     ],
                     1,
                     1
@@ -132,15 +148,15 @@ public function testContainsClause(): void
         $this->assertFalse(
             (new Clause(
                 [
-                    '$a' => ['!falsy'],
+                    '$a' => [new Truthy()],
                 ],
                 1,
                 1
             ))->contains(
                 new Clause(
                     [
-                        '$a' => ['!falsy'],
-                        '$b' => ['!falsy'],
+                        '$a' => [new Truthy()],
+                        '$b' => [new Truthy()],
                     ],
                     1,
                     1
@@ -149,66 +165,66 @@ public function testContainsClause(): void
         );
     }
 
-    public function testSimplifyCNF(): void
+    public function testSimplifySimpleCNF(): void
     {
         $formula = [
-            new Clause(['$a' => ['!falsy']], 1, 1),
-            new Clause(['$a' => ['falsy'], '$b' => ['falsy']], 1, 2),
+            new Clause(['$a' => [new Truthy()]], 1, 1),
+            new Clause(['$a' => [new Falsy()], '$b' => [new Falsy()]], 1, 2),
         ];
 
         $simplified_formula = Algebra::simplifyCNF($formula);
 
         $this->assertCount(2, $simplified_formula);
-        $this->assertSame(['$a' => ['!falsy']], $simplified_formula[0]->possibilities);
-        $this->assertSame(['$b' => ['falsy']], $simplified_formula[1]->possibilities);
+        $this->assertSame('$a', (string)$simplified_formula[0]);
+        $this->assertSame('!$b', (string)$simplified_formula[1]);
     }
 
     public function testSimplifyCNFWithOneUselessTerm(): void
     {
         $formula = [
-            new Clause(['$a' => ['!falsy'], '$b' => ['!falsy']], 1, 1),
-            new Clause(['$a' => ['falsy'], '$b' => ['!falsy']], 1, 2),
+            new Clause(['$a' => [new Truthy()], '$b' => [new Truthy()]], 1, 1),
+            new Clause(['$a' => [new Falsy()], '$b' => [new Truthy()]], 1, 2),
         ];
 
         $simplified_formula = Algebra::simplifyCNF($formula);
 
         $this->assertCount(1, $simplified_formula);
-        $this->assertSame(['$b' => ['!falsy']], $simplified_formula[0]->possibilities);
+        $this->assertSame('$b', (string)$simplified_formula[0]);
     }
 
     public function testSimplifyCNFWithNonUselessTerm(): void
     {
         $formula = [
-            new Clause(['$a' => ['!falsy'], '$b' => ['!falsy']], 1, 1),
-            new Clause(['$a' => ['falsy'], '$b' => ['falsy']], 1, 2),
+            new Clause(['$a' => [new Truthy()], '$b' => [new Truthy()]], 1, 1),
+            new Clause(['$a' => [new Falsy()], '$b' => [new Falsy()]], 1, 2),
         ];
 
         $simplified_formula = Algebra::simplifyCNF($formula);
 
         $this->assertCount(2, $simplified_formula);
-        $this->assertSame(['$a' => ['!falsy'], '$b' => ['!falsy']], $simplified_formula[0]->possibilities);
-        $this->assertSame(['$a' => ['falsy'], '$b' => ['falsy']], $simplified_formula[1]->possibilities);
+        $this->assertSame('($a) || ($b)', (string)$simplified_formula[0]);
+        $this->assertSame('(!$a) || (!$b)', (string)$simplified_formula[1]);
     }
 
     public function testSimplifyCNFWithUselessTermAndOneInMiddle(): void
     {
         $formula = [
-            new Clause(['$a' => ['!falsy'], '$b' => ['!falsy']], 1, 1),
-            new Clause(['$b' => ['!falsy']], 1, 2),
-            new Clause(['$a' => ['falsy'], '$b' => ['!falsy']], 1, 3),
+            new Clause(['$a' => [new Truthy()], '$b' => [new Truthy()]], 1, 1),
+            new Clause(['$b' => [new Truthy()]], 1, 2),
+            new Clause(['$a' => [new Falsy()], '$b' => [new Truthy()]], 1, 3),
         ];
 
         $simplified_formula = Algebra::simplifyCNF($formula);
 
         $this->assertCount(1, $simplified_formula);
-        $this->assertSame(['$b' => ['!falsy']], $simplified_formula[0]->possibilities);
+        $this->assertSame('$b', (string)$simplified_formula[0]);
     }
 
     public function testGroupImpossibilities(): void
     {
         $clause1 = (new Clause(
             [
-                '$a' => ['=array']
+                '$a' => [new IsIdentical(new TArray([Type::getArrayKey(), Type::getMixed()]))]
             ],
             1,
             2,
@@ -220,7 +236,7 @@ public function testGroupImpossibilities(): void
 
         $clause2 = (new Clause(
             [
-                '$b' => ['isset']
+                '$b' => [new IsIsset()]
             ],
             1,
             2,
diff --git a/tests/ArrayAccessTest.php b/tests/ArrayAccessTest.php
index 643915e0575..eef2404dd00 100644
--- a/tests/ArrayAccessTest.php
+++ b/tests/ArrayAccessTest.php
@@ -296,6 +296,75 @@ function takesList(array $arr) : void {
         $this->analyzeFile('somefile.php', new Context());
     }
 
+    public function testCountOnKeyedArrayInRange(): void
+    {
+        Config::getInstance()->ensure_array_int_offsets_exist = true;
+
+        $this->addFile(
+            'somefile.php',
+            '<?php
+                /** @param non-empty-list<string> $list */
+                function bar(array $list) : void {
+                    if (rand(0, 1)) {
+                        $list = ["a"];
+                    }
+                    if (count($list) > 1) {
+                        echo $list[1];
+                    }
+                }'
+        );
+
+        $this->analyzeFile('somefile.php', new Context());
+    }
+
+    public function testCountOnKeyedArrayInRangeWithUpdate(): void
+    {
+        Config::getInstance()->ensure_array_int_offsets_exist = true;
+
+        $this->addFile(
+            'somefile.php',
+            '<?php
+                /** @param non-empty-list<string> $list */
+                function bar(array $list) : void {
+                    if (rand(0, 1)) {
+                        $list = ["a"];
+                    }
+                    if (count($list) > 1) {
+                        if ($list[1][0] === "a") {
+                            $list[1] = "foo";
+                        }
+                        echo $list[1];
+                    }
+                }'
+        );
+
+        $this->analyzeFile('somefile.php', new Context());
+    }
+
+    public function testCountOnKeyedArrayOutOfRange(): void
+    {
+        Config::getInstance()->ensure_array_int_offsets_exist = true;
+
+        $this->expectException(CodeException::class);
+        $this->expectExceptionMessage('PossiblyUndefinedIntArrayOffset');
+
+        $this->addFile(
+            'somefile.php',
+            '<?php
+                /** @param non-empty-list<string> $list */
+                function bar(array $list) : void {
+                    if (rand(0, 1)) {
+                        $list = ["a"];
+                    }
+                    if (count($list) > 1) {
+                        echo $list[2];
+                    }
+                }'
+        );
+
+        $this->analyzeFile('somefile.php', new Context());
+    }
+
     public function testEnsureListOffsetExistsAfterCountValueOutOfRange(): void
     {
         Config::getInstance()->ensure_array_int_offsets_exist = true;
diff --git a/tests/ClassLikeStringTest.php b/tests/ClassLikeStringTest.php
index 1be529422eb..8541c05e746 100644
--- a/tests/ClassLikeStringTest.php
+++ b/tests/ClassLikeStringTest.php
@@ -811,6 +811,57 @@ function takesString(string $s) {
                         return new ReflectionClass($s);
                     }',
             ],
+            'checkDifferentSubclass' => [
+                'code' => '<?php
+                    class A {}
+                    class B {}
+                    
+                    /** @param class-string<A> $s */
+                    function takesAString(string $a): void {}
+                    /** @param class-string<B> $s */
+                    function takesBString(string $a): void {}
+                    
+                    /** @param class-string $s */
+                    function foo(string $s): void {
+                        if (is_subclass_of($s, A::class)) {
+                            takesAString($s);
+                        }
+                        if (is_subclass_of($s, B::class)) {
+                            takesBString($s);
+                        }
+                    }',
+            ],
+            'checkDifferentSubclassAfterNotClassExists' => [
+                'code' => '<?php
+                    class A {}
+                    class B {}
+
+                    /** @param class-string<A> $s */
+                    function takesAString(string $a): void {}
+                    /** @param class-string<B> $s */
+                    function takesBString(string $a): void {}
+                    
+                    function foo(string $s): void {
+                        if (!class_exists($s, false)) {
+                            return;
+                        }
+                        if (is_subclass_of($s, A::class)) {
+                            takesAString($s);
+                        }
+                        if (is_subclass_of($s, B::class)) {
+                            takesBString($s);
+                        }
+                    }',
+            ],
+            'compareGetClassToLiteralClass' => [
+                'code' => '<?php
+                    class A {}
+                    class B extends A {}
+
+                    function foo(A $a): void {
+                        if (get_class($a) === A::class) {}
+                    }',
+            ],
         ];
     }
 
diff --git a/tests/ClassTest.php b/tests/ClassTest.php
index 332f998c837..f0b0ef0ca9b 100644
--- a/tests/ClassTest.php
+++ b/tests/ClassTest.php
@@ -398,7 +398,7 @@ function foo(string $s) : void {
                         if (class_exists($s) || interface_exists($s)) {}
                     }',
             ],
-            'classExistsWithFalseArg' => [
+            'classExistsWithFalseArgRefinedAsString' => [
                 'code' => '<?php
                     /**
                      * @param class-string $class
diff --git a/tests/FunctionCallTest.php b/tests/FunctionCallTest.php
index 00fb3f40f4c..84c268fc1a2 100644
--- a/tests/FunctionCallTest.php
+++ b/tests/FunctionCallTest.php
@@ -191,6 +191,13 @@ class B extends A {
                         '$a' => 'array<never, never>',
                     ],
             ],
+            'countCheckOnNonEmptyArray' => [
+                'code' => '<?php
+                    /** @param non-empty-array<string> $arr */
+                    function foo(array $arr): void {
+                        if (count($arr) > 5) {}
+                    }',
+            ],
             'byRefAfterCallable' => [
                 'code' => '<?php
                     /**
diff --git a/tests/IntRangeTest.php b/tests/IntRangeTest.php
index 5cd10fcb112..4d5a0cba237 100644
--- a/tests/IntRangeTest.php
+++ b/tests/IntRangeTest.php
@@ -580,9 +580,10 @@ function getInt(): int{return 0;}
             ],
             'intersections' => [
                 'code' => '<?php
-                    function getInt(): int{return 0;}
+                    /** @return int<0, 10> */
+                    function getInt(): int{ return rand(0, 10); }
+                    
                     $a = getInt();
-                    /** @var int<0, 10> $a */
                     $b = -$a;
                     $c = null;
                     if($b === $a){
diff --git a/tests/Template/FunctionClassStringTemplateTest.php b/tests/Template/FunctionClassStringTemplateTest.php
index 55b83ba5609..fa7a6d41815 100644
--- a/tests/Template/FunctionClassStringTemplateTest.php
+++ b/tests/Template/FunctionClassStringTemplateTest.php
@@ -270,7 +270,7 @@ interface B {}
                      * @param interface-string<S> $type
                      * @return T&S
                      */
-                    function filter($item, string $type) {
+                    function filter(object $item, string $type) {
                         if (is_a($item, $type)) {
                             return $item;
                         };
diff --git a/tests/Template/FunctionTemplateAssertTest.php b/tests/Template/FunctionTemplateAssertTest.php
index 01034f84f67..9d2d20988e9 100644
--- a/tests/Template/FunctionTemplateAssertTest.php
+++ b/tests/Template/FunctionTemplateAssertTest.php
@@ -55,7 +55,7 @@ function getImplementationOfFoo(): Foo {
 
                     class C {
                         /**
-                         * @template T
+                         * @template T as object
                          * @param class-string<T> $expected
                          * @param mixed  $actual
                          * @psalm-assert T $actual
@@ -99,7 +99,7 @@ function bar(string $c, object $e) : void {
                     namespace Bar;
 
                     /**
-                     * @template T
+                     * @template T as object
                      * @param class-string<T> $expected
                      * @param mixed  $actual
                      * @psalm-assert T $actual
@@ -160,14 +160,14 @@ function bar(array $arr) : void {
             ],
             'assertTemplatedTypeString' => [
                 'code' => '<?php
-                    interface Foo {
-                        function bat() : void;
-                    }
+                    interface Foo {}
 
                     /**
+                     * @template T as object
+                     *
                      * @param mixed $value
                      * @param class-string<T> $type
-                     * @template T
+                     * 
                      * @psalm-assert T $value
                      */
                     function assertInstanceOf($value, string $type): void {
@@ -175,11 +175,7 @@ function assertInstanceOf($value, string $type): void {
                     }
 
                     function getFoo() : Foo {
-                        return new class implements Foo {
-                            public function bat(): void {
-                                echo "Hello";
-                            }
-                        };
+                        return new class implements Foo {};
                     }
 
                     $f = getFoo();
@@ -189,8 +185,7 @@ public function bat(): void {
                     $class = "hello";
 
                     /** @psalm-suppress MixedArgument */
-                    assertInstanceOf($f, $class);
-                    $f->bat();',
+                    assertInstanceOf($f, $class);',
                 'assertions' => [
                     '$f' => 'Foo',
                 ],
@@ -292,7 +287,7 @@ class Goodbye {}
                     $b = rand(0, 1) ? new Hello() : new Goodbye();
                     Assertion::assertSame($a, $b);',
             ],
-            'allowCanBeNotSameAfterAssertion' => [
+            'allowCanBeNotSameAfterAssertionReverseUnion' => [
                 'code' => '<?php
                     namespace Bar;
 
@@ -311,15 +306,63 @@ class Goodbye {}
 
                     $goodbye_or_hello = rand(0, 1) ? new Goodbye() : new Hello();
                     $hello_or_goodbye = rand(0, 1) ? new Hello() : new Goodbye();
-                    assertNotSame($goodbye_or_hello, $hello_or_goodbye);
+                    assertNotSame($goodbye_or_hello, $hello_or_goodbye);',
+            ],
+            'allowCanBeNotSameAfterAssertionAcmpAorB' => [
+                'code' => '<?php
+                    namespace Bar;
+
+                    /**
+                     * Asserts that two variables are the same.
+                     *
+                     * @template T
+                     * @param T      $expected
+                     * @param mixed  $actual
+                     * @psalm-assert !=T $actual
+                     */
+                    function assertNotSame($expected, $actual) : void {}
+
+                    class Hello {}
+                    class Goodbye {}
 
                     $hello = new Hello();
                     $hello_or_goodbye = rand(0, 1) ? new Hello() : new Goodbye();
-                    assertNotSame($hello, $hello_or_goodbye);
+                    assertNotSame($hello, $hello_or_goodbye);',
+            ],
+            'allowCanBeNotSameAfterAssertionAorBcmpA' => [
+                'code' => '<?php
+                    namespace Bar;
+
+                    /**
+                     * Asserts that two variables are the same.
+                     *
+                     * @template T
+                     * @param T      $expected
+                     * @param mixed  $actual
+                     * @psalm-assert !=T $actual
+                     */
+                    function assertNotSame($expected, $actual) : void {}
+
+                    class Hello {}
+                    class Goodbye {}
 
                     $hello = new Hello();
                     $hello_or_goodbye = rand(0, 1) ? new Hello() : new Goodbye();
-                    assertNotSame($hello_or_goodbye, $hello);
+                    assertNotSame($hello_or_goodbye, $hello);',
+            ],
+            'allowCanBeNotSameAfterAssertionScalar' => [
+                'code' => '<?php
+                    namespace Bar;
+
+                    /**
+                     * Asserts that two variables are the same.
+                     *
+                     * @template T
+                     * @param T      $expected
+                     * @param mixed  $actual
+                     * @psalm-assert !=T $actual
+                     */
+                    function assertNotSame($expected, $actual) : void {}
 
                     $c = 4;
                     $d = rand(0, 1) ? 4 : 5;
@@ -634,12 +677,15 @@ private function generateProxy(string $originalClass) : ?string {
                 'code' => '<?php
                     /**
                      * @psalm-template RequestedClass of object
-                     * @psalm-param class-string<RequestedClass> $expectedType
+                     * @psalm-param class-string<RequestedClass> $templated_class_string
                      * @psalm-return class-string<RequestedClass>
                      */
-                    function castStringToClassString(string $expectedType, string $anyString): string {
-                        \assert(\is_a($anyString, $expectedType, true));
-                        return $anyString;
+                    function castStringToClassString(
+                        string $templated_class_string,
+                        string $input_string
+                    ): string {
+                        \assert(\is_a($input_string, $templated_class_string, true));
+                        return $input_string;
                     }'
             ],
             'classTemplateAssert' => [
@@ -1006,7 +1052,8 @@ class Goodbye {}
                     assertEqual($c, $d);',
                 'error_message' => 'TypeDoesNotContainType',
             ],
-            'detectIntFloatNeverCanBeEqualAfterAssertion' => [
+            // Ignoring this to put the behaviour on par with regular equality checks
+            'SKIPPED-detectIntFloatNeverCanBeEqualAfterAssertion' => [
                 'code' => '<?php
 
                     /**
diff --git a/tests/TypeReconciliation/EmptyTest.php b/tests/TypeReconciliation/EmptyTest.php
index fe2d09ef33a..af9eddefaaa 100644
--- a/tests/TypeReconciliation/EmptyTest.php
+++ b/tests/TypeReconciliation/EmptyTest.php
@@ -473,19 +473,6 @@ function foo(array $r) {
                     }',
                 'error_message' => 'MixedReturnTypeCoercion'
             ],
-            'secondEmptyTwice' => [
-                'code' => '<?php
-                    /**
-                     * @param array{a?:int,b?:string} $p
-                     */
-                    function f(array $p) : void {
-                        if (empty($p)) {
-                            throw new RuntimeException("");
-                        }
-                        assert(!empty($p));
-                    }',
-                'error_message' => 'RedundantCondition'
-            ],
         ];
     }
 }
diff --git a/tests/TypeReconciliation/ReconcilerTest.php b/tests/TypeReconciliation/ReconcilerTest.php
index e5edec8d7f3..4b25ae69093 100644
--- a/tests/TypeReconciliation/ReconcilerTest.php
+++ b/tests/TypeReconciliation/ReconcilerTest.php
@@ -8,9 +8,30 @@
 use Psalm\Internal\Provider\NodeDataProvider;
 use Psalm\Internal\Type\AssertionReconciler;
 use Psalm\Internal\Type\Comparator\UnionTypeComparator;
+use Psalm\Storage\Assertion;
+use Psalm\Storage\Assertion\Falsy;
+use Psalm\Storage\Assertion\IsIdentical;
+use Psalm\Storage\Assertion\IsLooselyEqual;
+use Psalm\Storage\Assertion\IsNotIdentical;
+use Psalm\Storage\Assertion\IsNotType;
+use Psalm\Storage\Assertion\IsType;
+use Psalm\Storage\Assertion\NonEmpty;
+use Psalm\Storage\Assertion\Truthy;
 use Psalm\Tests\TestCase;
 use Psalm\Type;
+use Psalm\Type\Atomic\TArray;
+use Psalm\Type\Atomic\TClassConstant;
+use Psalm\Type\Atomic\TFalse;
+use Psalm\Type\Atomic\TFloat;
+use Psalm\Type\Atomic\TInt;
+use Psalm\Type\Atomic\TIterable;
+use Psalm\Type\Atomic\TKeyedArray;
 use Psalm\Type\Atomic\TLiteralString;
+use Psalm\Type\Atomic\TNamedObject;
+use Psalm\Type\Atomic\TNull;
+use Psalm\Type\Atomic\TNumeric;
+use Psalm\Type\Atomic\TObject;
+use Psalm\Type\Atomic\TTrue;
 use Psalm\Type\Union;
 
 class ReconcilerTest extends TestCase
@@ -46,7 +67,7 @@ interface SomeInterface {}
     /**
      * @dataProvider providerTestReconcilation
      */
-    public function testReconcilation(string $expected_type, string $assertion, string $original_type): void
+    public function testReconcilation(string $expected_type, Assertion $assertion, string $original_type): void
     {
         $reconciled = AssertionReconciler::reconcile(
             $assertion,
@@ -84,76 +105,80 @@ public function testTypeIsContainedBy($input, $container): void
     }
 
     /**
-     * @return array<string,array{string,string,string}>
+     * @return array<string,array{string,Assertion,string}>
      */
     public function providerTestReconcilation(): array
     {
         return [
-            'notNullWithObject' => ['SomeClass', '!null', 'SomeClass'],
-            'notNullWithObjectPipeNull' => ['SomeClass', '!null', 'SomeClass|null'],
-            'notNullWithSomeClassPipeFalse' => ['SomeClass|false', '!null', 'SomeClass|false'],
-            'notNullWithMixed' => ['mixed', '!null', 'mixed'],
+            'notNullWithObject' => ['SomeClass', new IsNotType(new TNull()), 'SomeClass'],
+            'notNullWithObjectPipeNull' => ['SomeClass', new IsNotType(new TNull()), 'SomeClass|null'],
+            'notNullWithSomeClassPipeFalse' => ['SomeClass|false', new IsNotType(new TNull()), 'SomeClass|false'],
+            'notNullWithMixed' => ['mixed', new IsNotType(new TNull()), 'mixed'],
 
-            'notEmptyWithSomeClass' => ['SomeClass', '!falsy', 'SomeClass'],
-            'notEmptyWithSomeClassPipeNull' => ['SomeClass', '!falsy', 'SomeClass|null'],
-            'notEmptyWithSomeClassPipeFalse' => ['SomeClass', '!falsy', 'SomeClass|false'],
-            'notEmptyWithMixed' => ['non-empty-mixed', '!falsy', 'mixed'],
+            'notEmptyWithSomeClass' => ['SomeClass', new Truthy(), 'SomeClass'],
+            'notEmptyWithSomeClassPipeNull' => ['SomeClass', new Truthy(), 'SomeClass|null'],
+            'notEmptyWithSomeClassPipeFalse' => ['SomeClass', new Truthy(), 'SomeClass|false'],
+            'notEmptyWithMixed' => ['non-empty-mixed', new Truthy(), 'mixed'],
             // @todo in the future this should also work
             //'notEmptyWithSomeClassFalseTrue' => ['SomeClass|true', '!falsy', 'SomeClass|bool'],
 
-            'nullWithSomeClassPipeNull' => ['null', 'null', 'SomeClass|null'],
-            'nullWithMixed' => ['null', 'null', 'mixed'],
+            'nullWithSomeClassPipeNull' => ['null', new IsType(new TNull()), 'SomeClass|null'],
+            'nullWithMixed' => ['null', new IsType(new TNull()), 'mixed'],
 
-            'falsyWithSomeClass' => ['never', 'falsy', 'SomeClass'],
-            'falsyWithSomeClassPipeFalse' => ['false', 'falsy', 'SomeClass|false'],
-            'falsyWithSomeClassPipeBool' => ['false', 'falsy', 'SomeClass|bool'],
-            'falsyWithMixed' => ['empty-mixed', 'falsy', 'mixed'],
-            'falsyWithBool' => ['false', 'falsy', 'bool'],
-            'falsyWithStringOrNull' => ['""|"0"|null', 'falsy', 'string|null'],
-            'falsyWithScalarOrNull' => ['empty-scalar', 'falsy', 'scalar'],
+            'falsyWithSomeClass' => ['never', new Falsy(), 'SomeClass'],
+            'falsyWithSomeClassPipeFalse' => ['false', new Falsy(), 'SomeClass|false'],
+            'falsyWithSomeClassPipeBool' => ['false', new Falsy(), 'SomeClass|bool'],
+            'falsyWithMixed' => ['empty-mixed', new Falsy(), 'mixed'],
+            'falsyWithBool' => ['false', new Falsy(), 'bool'],
+            'falsyWithStringOrNull' => ['""|"0"|null', new Falsy(), 'string|null'],
+            'falsyWithScalarOrNull' => ['empty-scalar', new Falsy(), 'scalar'],
+            'trueWithBool' => ['true', new IsType(new TTrue()), 'bool'],
+            'falseWithBool' => ['false', new IsType(new TFalse()), 'bool'],
+            'notTrueWithBool' => ['false', new IsNotIdentical(new TTrue()), 'bool'],
+            'notFalseWithBool' => ['true', new IsNotIdentical(new TFalse()), 'bool'],
 
-            'notSomeClassWithSomeClassPipeBool' => ['bool', '!SomeClass', 'SomeClass|bool'],
-            'notSomeClassWithSomeClassPipeNull' => ['null', '!SomeClass', 'SomeClass|null'],
-            'notSomeClassWithAPipeB' => ['B', '!A', 'A|B'],
-            'notDateTimeWithDateTimeInterface' => ['DateTimeImmutable', '!DateTime', 'DateTimeInterface'],
-            'notDateTimeImmutableWithDateTimeInterface' => ['DateTime', '!DateTimeImmutable', 'DateTimeInterface'],
+            'notSomeClassWithSomeClassPipeBool' => ['bool', new IsNotType(new TNamedObject('SomeClass')), 'SomeClass|bool'],
+            'notSomeClassWithSomeClassPipeNull' => ['null', new IsNotType(new TNamedObject('SomeClass')), 'SomeClass|null'],
+            'notSomeClassWithAPipeB' => ['B', new IsNotType(new TNamedObject('A')), 'A|B'],
+            'notDateTimeWithDateTimeInterface' => ['DateTimeImmutable', new IsNotType(new TNamedObject('DateTime')), 'DateTimeInterface'],
+            'notDateTimeImmutableWithDateTimeInterface' => ['DateTime', new IsNotType(new TNamedObject('DateTimeImmutable')), 'DateTimeInterface'],
 
-            'myObjectWithSomeClassPipeBool' => ['SomeClass', 'SomeClass', 'SomeClass|bool'],
-            'myObjectWithAPipeB' => ['A', 'A', 'A|B'],
+            'myObjectWithSomeClassPipeBool' => ['SomeClass', new IsType(new TNamedObject('SomeClass')), 'SomeClass|bool'],
+            'myObjectWithAPipeB' => ['A', new IsType(new TNamedObject('A')), 'A|B'],
 
-            'array' => ['array<array-key, mixed>', 'array', 'array|null'],
+            'array' => ['array<array-key, mixed>', new IsType(new TArray([Type::getArrayKey(), Type::getMixed()])), 'array|null'],
 
-            '2dArray' => ['array<array-key, array<array-key, string>>', 'array', 'array<array<string>>|null'],
+            '2dArray' => ['array<array-key, array<array-key, string>>', new IsType(new TArray([Type::getArrayKey(), Type::getMixed()])), 'array<array<string>>|null'],
 
-            'numeric' => ['numeric-string', 'numeric', 'string'],
+            'numeric' => ['numeric-string', new IsType(new TNumeric()), 'string'],
 
-            'nullableClassString' => ['null', 'falsy', '?class-string'],
-            'mixedOrNullNotFalsy' => ['non-empty-mixed', '!falsy', 'mixed|null'],
-            'mixedOrNullFalsy' => ['empty-mixed|null', 'falsy', 'mixed|null'],
-            'nullableClassStringFalsy' => ['null', 'falsy', 'class-string<SomeClass>|null'],
-            'nullableClassStringEqualsNull' => ['null', '=null', 'class-string<SomeClass>|null'],
-            'nullableClassStringTruthy' => ['class-string<SomeClass>', '!falsy', 'class-string<SomeClass>|null'],
-            'iterableToArray' => ['array<int, int>', 'array', 'iterable<int, int>'],
-            'iterableToTraversable' => ['Traversable<int, int>', 'Traversable', 'iterable<int, int>'],
-            'callableToCallableArray' => ['callable-array{0: class-string|object, 1: string}', 'array', 'callable'],
-            'SmallKeyedArrayAndCallable' => ['array{test: string}', 'array{test: string}', 'callable'],
-            'BigKeyedArrayAndCallable' => ['array{foo: string, test: string, thing: string}', 'array{foo: string, test: string, thing: string}', 'callable'],
-            'callableOrArrayToCallableArray' => ['array<array-key, mixed>', 'array', 'callable|array'],
-            'traversableToIntersection' => ['Countable&Traversable', 'Traversable', 'Countable'],
-            'iterableWithoutParamsToTraversableWithoutParams' => ['Traversable', '!array', 'iterable'],
-            'iterableWithParamsToTraversableWithParams' => ['Traversable<int, string>', '!array', 'iterable<int, string>'],
-            'iterableAndObject' => ['Traversable<int, string>', 'object', 'iterable<int, string>'],
-            'iterableAndNotObject' => ['array<int, string>', '!object', 'iterable<int, string>'],
-            'boolNotEmptyIsTrue' => ['true', '!empty', 'bool'],
-            'interfaceAssertionOnClassInterfaceUnion' => ['SomeInterface|SomeInterface&SomeClass', 'SomeInterface', 'SomeClass|SomeInterface'],
-            'classAssertionOnClassInterfaceUnion' => ['SomeClass|SomeClass&SomeInterface', 'SomeClass', 'SomeClass|SomeInterface'],
-            'stringToNumericStringWithInt' => ['numeric-string', '~int', 'string'],
-            'stringToNumericStringWithFloat' => ['numeric-string', '~float', 'string'],
-            'filterKeyedArrayWithIterable' => ['array{some: string}', 'iterable<string>', 'array{some: mixed}'],
-            'SimpleXMLElementNotAlwaysTruthy' => ['SimpleXMLElement', '!falsy', 'SimpleXMLElement'],
-            'SimpleXMLElementNotAlwaysTruthy2' => ['SimpleXMLElement', 'falsy', 'SimpleXMLElement'],
-            'SimpleXMLIteratorNotAlwaysTruthy' => ['SimpleXMLIterator', '!falsy', 'SimpleXMLIterator'],
-            'SimpleXMLIteratorNotAlwaysTruthy2' => ['SimpleXMLIterator', 'falsy', 'SimpleXMLIterator'],
+            'nullableClassString' => ['null', new Falsy(), '?class-string'],
+            'mixedOrNullNotFalsy' => ['non-empty-mixed', new Truthy(), 'mixed|null'],
+            'mixedOrNullFalsy' => ['empty-mixed|null', new Falsy(), 'mixed|null'],
+            'nullableClassStringFalsy' => ['null', new Falsy(), 'class-string<SomeClass>|null'],
+            'nullableClassStringEqualsNull' => ['null', new IsIdentical(new TNull()), 'class-string<SomeClass>|null'],
+            'nullableClassStringTruthy' => ['class-string<SomeClass>', new Truthy(), 'class-string<SomeClass>|null'],
+            'iterableToArray' => ['array<int, int>', new IsType(new TArray([Type::getArrayKey(), Type::getMixed()])), 'iterable<int, int>'],
+            'iterableToTraversable' => ['Traversable<int, int>', new IsType(new TNamedObject('Traversable')), 'iterable<int, int>'],
+            'callableToCallableArray' => ['callable-array{0: class-string|object, 1: string}', new IsType(new TArray([Type::getArrayKey(), Type::getMixed()])), 'callable'],
+            'SmallKeyedArrayAndCallable' => ['array{test: string}', new IsType(new TKeyedArray(['test' => Type::getString()])), 'callable'],
+            'BigKeyedArrayAndCallable' => ['array{foo: string, test: string, thing: string}', new IsType(new TKeyedArray(['foo' => Type::getString(), 'test' => Type::getString(), 'thing' => Type::getString()])), 'callable'],
+            'callableOrArrayToCallableArray' => ['array<array-key, mixed>', new IsType(new TArray([Type::getArrayKey(), Type::getMixed()])), 'callable|array'],
+            'traversableToIntersection' => ['Countable&Traversable', new IsType(new TNamedObject('Traversable')), 'Countable'],
+            'iterableWithoutParamsToTraversableWithoutParams' => ['Traversable', new IsNotType(new TArray([Type::getArrayKey(), Type::getMixed()])), 'iterable'],
+            'iterableWithParamsToTraversableWithParams' => ['Traversable<int, string>', new IsNotType(new TArray([Type::getArrayKey(), Type::getMixed()])), 'iterable<int, string>'],
+            'iterableAndObject' => ['Traversable<int, string>', new IsType(new TObject()), 'iterable<int, string>'],
+            'iterableAndNotObject' => ['array<int, string>', new IsNotType(new TObject()), 'iterable<int, string>'],
+            'boolNotEmptyIsTrue' => ['true', new NonEmpty(), 'bool'],
+            'interfaceAssertionOnClassInterfaceUnion' => ['SomeInterface|SomeInterface&SomeClass', new IsType(new TNamedObject('SomeInterface')), 'SomeClass|SomeInterface'],
+            'classAssertionOnClassInterfaceUnion' => ['SomeClass|SomeClass&SomeInterface', new IsType(new TNamedObject('SomeClass')), 'SomeClass|SomeInterface'],
+            'stringToNumericStringWithInt' => ['numeric-string', new IsLooselyEqual(new TInt()), 'string'],
+            'stringToNumericStringWithFloat' => ['numeric-string', new IsLooselyEqual(new TFloat()), 'string'],
+            'filterKeyedArrayWithIterable' => ['array{some: string}',new IsType(new TIterable([Type::getMixed(), Type::getString()])), 'array{some: mixed}'],
+            'SimpleXMLElementNotAlwaysTruthy' => ['SimpleXMLElement', new Truthy(), 'SimpleXMLElement'],
+            'SimpleXMLElementNotAlwaysTruthy2' => ['SimpleXMLElement', new Falsy(), 'SimpleXMLElement'],
+            'SimpleXMLIteratorNotAlwaysTruthy' => ['SimpleXMLIterator', new Truthy(), 'SimpleXMLIterator'],
+            'SimpleXMLIteratorNotAlwaysTruthy2' => ['SimpleXMLIterator', new Falsy(), 'SimpleXMLIterator'],
         ];
     }
 
@@ -194,7 +219,7 @@ public function providerTestTypeIsContainedBy(): array
     /**
      * @dataProvider constantAssertions
      */
-    public function testReconciliationOfClassConstantInAssertions(string $assertion, string $expected_type): void
+    public function testReconciliationOfClassConstantInAssertions(Assertion $assertion, string $expected_type): void
     {
         $this->addFile(
             'psalm-assert.php',
@@ -229,29 +254,29 @@ class Foo
     }
 
     /**
-     * @return array<non-empty-string,array{non-empty-string,string}>
+     * @return array<non-empty-string,array{Assertion,string}>
      */
     public function constantAssertions(): array
     {
         return [
             'constant-with-prefix' => [
-                'class-constant(ReconciliationTest\\Foo::PREFIX_*)',
+                new IsType(new TClassConstant('ReconciliationTest\\Foo', 'PREFIX_*')),
                 '"bar"|"baz"',
             ],
             'single-class-constant' => [
-                'class-constant(ReconciliationTest\\Foo::PREFIX_BAR)',
+                new IsType(new TClassConstant('ReconciliationTest\\Foo', 'PREFIX_BAR')),
                 '"bar"',
             ],
             'referencing-another-class-constant' => [
-                'class-constant(ReconciliationTest\\Foo::PREFIX_QOO)',
+                new IsType(new TClassConstant('ReconciliationTest\\Foo', 'PREFIX_QOO')),
                 '"bar"',
             ],
             'referencing-all-class-constants' => [
-                'class-constant(ReconciliationTest\\Foo::*)',
+                new IsType(new TClassConstant('ReconciliationTest\\Foo', '*')),
                 '"bar"|"baz"',
             ],
             'referencing-some-class-constants-with-wildcard' => [
-                'class-constant(ReconciliationTest\\Foo::PREFIX_B*)',
+                new IsType(new TClassConstant('ReconciliationTest\\Foo', 'PREFIX_B*')),
                 '"bar"|"baz"',
             ],
         ];
diff --git a/tests/TypeReconciliation/RedundantConditionTest.php b/tests/TypeReconciliation/RedundantConditionTest.php
index 84649c737a6..42fe6f5c7dd 100644
--- a/tests/TypeReconciliation/RedundantConditionTest.php
+++ b/tests/TypeReconciliation/RedundantConditionTest.php
@@ -885,6 +885,21 @@ public function get(): ?stdClass{ return new stdClass;}
                         }
                     }'
             ],
+            'secondFalsyTwiceWithChange' => [
+                'code' => '<?php
+                    /**
+                     * @param array{a?:int,b?:string} $p
+                     */
+                    function f(array $p) : void {
+                        if (!$p) {
+                            throw new RuntimeException("");
+                        }
+                        if (rand(0, 1)) {
+                            $p["a"] = 3;
+                        }
+                        assert(!!$p);
+                    }',
+            ],
         ];
     }
 
@@ -1493,6 +1508,19 @@ public function get(): stdClass{ return new stdClass;}
                     ',
                 'error_message' => 'RedundantCondition',
             ],
+            'secondFalsyTwiceWithoutChange' => [
+                'code' => '<?php
+                    /**
+                     * @param array{a?:int,b?:string} $p
+                     */
+                    function f(array $p) : void {
+                        if (!$p) {
+                            throw new RuntimeException("");
+                        }
+                        assert(!!$p);
+                    }',
+                'error_message' => 'RedundantCondition'
+            ],
         ];
     }
 }

From e4f7c8c7a56746ecf0fba4b8f5fe7a32b1a0ef0f Mon Sep 17 00:00:00 2001
From: Matthew Brown <github@muglug.com>
Date: Thu, 20 Jan 2022 17:01:02 -0500
Subject: [PATCH 2/5] Remove unnecessary param

---
 src/Psalm/Storage/Assertion/IsIdentical.php         | 2 +-
 src/Psalm/Storage/Assertion/IsLooselyEqual.php      | 2 +-
 src/Psalm/Storage/Assertion/IsNotIdentical.php      | 2 +-
 src/Psalm/Storage/Assertion/IsNotLooselyEqual.php   | 2 +-
 src/Psalm/Type/Atomic.php                           | 2 +-
 src/Psalm/Type/Atomic/TArray.php                    | 6 +++---
 src/Psalm/Type/Atomic/TCallableObject.php           | 4 +++-
 src/Psalm/Type/Atomic/TCallableString.php           | 4 +++-
 src/Psalm/Type/Atomic/TClassConstant.php            | 4 +++-
 src/Psalm/Type/Atomic/TClassString.php              | 4 +++-
 src/Psalm/Type/Atomic/TClassStringMap.php           | 4 +++-
 src/Psalm/Type/Atomic/TConditional.php              | 4 +++-
 src/Psalm/Type/Atomic/TDependentListKey.php         | 4 +++-
 src/Psalm/Type/Atomic/TGenericObject.php            | 4 +++-
 src/Psalm/Type/Atomic/TIterable.php                 | 4 +++-
 src/Psalm/Type/Atomic/TKeyOfClassConstant.php       | 4 +++-
 src/Psalm/Type/Atomic/TKeyedArray.php               | 4 +++-
 src/Psalm/Type/Atomic/TList.php                     | 6 +++---
 src/Psalm/Type/Atomic/TLiteralClassString.php       | 4 +++-
 src/Psalm/Type/Atomic/TLiteralInt.php               | 2 +-
 src/Psalm/Type/Atomic/TLiteralString.php            | 2 +-
 src/Psalm/Type/Atomic/TMixed.php                    | 2 +-
 src/Psalm/Type/Atomic/TNonEmptyList.php             | 2 +-
 src/Psalm/Type/Atomic/TNonspecificLiteralInt.php    | 2 +-
 src/Psalm/Type/Atomic/TNonspecificLiteralString.php | 2 +-
 src/Psalm/Type/Atomic/TNumericString.php            | 2 +-
 src/Psalm/Type/Atomic/TObjectWithProperties.php     | 2 +-
 src/Psalm/Type/Atomic/TScalar.php                   | 2 +-
 src/Psalm/Type/Atomic/TTemplateParam.php            | 2 +-
 src/Psalm/Type/Atomic/TTemplateParamClass.php       | 2 +-
 src/Psalm/Type/Atomic/TTypeAlias.php                | 2 +-
 src/Psalm/Type/Atomic/TValueOfClassConstant.php     | 2 +-
 32 files changed, 60 insertions(+), 36 deletions(-)

diff --git a/src/Psalm/Storage/Assertion/IsIdentical.php b/src/Psalm/Storage/Assertion/IsIdentical.php
index b01b1751573..9d29d5b59f7 100644
--- a/src/Psalm/Storage/Assertion/IsIdentical.php
+++ b/src/Psalm/Storage/Assertion/IsIdentical.php
@@ -22,7 +22,7 @@ public function getNegation(): Assertion
 
     public function __toString(): string
     {
-        return '=' . $this->type->getAssertionString(true);
+        return '=' . $this->type->getAssertionString();
     }
 
     /** @psalm-mutation-free */
diff --git a/src/Psalm/Storage/Assertion/IsLooselyEqual.php b/src/Psalm/Storage/Assertion/IsLooselyEqual.php
index aa2912cac5e..33cfccd9320 100644
--- a/src/Psalm/Storage/Assertion/IsLooselyEqual.php
+++ b/src/Psalm/Storage/Assertion/IsLooselyEqual.php
@@ -22,7 +22,7 @@ public function getNegation(): Assertion
 
     public function __toString(): string
     {
-        return '~' . $this->type->getAssertionString(true);
+        return '~' . $this->type->getAssertionString();
     }
 
     /** @psalm-mutation-free */
diff --git a/src/Psalm/Storage/Assertion/IsNotIdentical.php b/src/Psalm/Storage/Assertion/IsNotIdentical.php
index eb5391c30f9..9c9ab732eb5 100644
--- a/src/Psalm/Storage/Assertion/IsNotIdentical.php
+++ b/src/Psalm/Storage/Assertion/IsNotIdentical.php
@@ -33,7 +33,7 @@ public function hasEquality(): bool
 
     public function __toString(): string
     {
-        return '!=' . $this->type->getAssertionString(true);
+        return '!=' . $this->type->getAssertionString();
     }
 
     /** @psalm-mutation-free */
diff --git a/src/Psalm/Storage/Assertion/IsNotLooselyEqual.php b/src/Psalm/Storage/Assertion/IsNotLooselyEqual.php
index 0d61a076450..f1fd889a777 100644
--- a/src/Psalm/Storage/Assertion/IsNotLooselyEqual.php
+++ b/src/Psalm/Storage/Assertion/IsNotLooselyEqual.php
@@ -33,7 +33,7 @@ public function hasEquality(): bool
 
     public function __toString(): string
     {
-        return '!~' . $this->type->getAssertionString(true);
+        return '!~' . $this->type->getAssertionString();
     }
 
     /** @psalm-mutation-free */
diff --git a/src/Psalm/Type/Atomic.php b/src/Psalm/Type/Atomic.php
index 155b223a680..5ecaab4472a 100644
--- a/src/Psalm/Type/Atomic.php
+++ b/src/Psalm/Type/Atomic.php
@@ -568,7 +568,7 @@ public function getId(bool $nested = false): string
         return $this->__toString();
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
         return $this->getId();
     }
diff --git a/src/Psalm/Type/Atomic/TArray.php b/src/Psalm/Type/Atomic/TArray.php
index cf8ac756c7b..88041e209a8 100644
--- a/src/Psalm/Type/Atomic/TArray.php
+++ b/src/Psalm/Type/Atomic/TArray.php
@@ -83,13 +83,13 @@ public function equals(Atomic $other_type, bool $ensure_source_equality): bool
         return true;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
-        if (!$exact || $this->type_params[1]->isMixed()) {
+        if ($this->type_params[0]->isMixed() && $this->type_params[1]->isMixed()) {
             return 'array';
         }
 
-        return $this->toNamespacedString(null, [], null, false);
+        return $this->getId();
     }
 
     public function isEmptyArray(): bool
diff --git a/src/Psalm/Type/Atomic/TCallableObject.php b/src/Psalm/Type/Atomic/TCallableObject.php
index 086fc4140c5..78a50b72398 100644
--- a/src/Psalm/Type/Atomic/TCallableObject.php
+++ b/src/Psalm/Type/Atomic/TCallableObject.php
@@ -34,7 +34,9 @@ public function canBeFullyExpressedInPhp(int $analysis_php_version_id): bool
         return false;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString()
+
+    /** @psalm-mutation-free */: string
     {
         return 'object';
     }
diff --git a/src/Psalm/Type/Atomic/TCallableString.php b/src/Psalm/Type/Atomic/TCallableString.php
index 4ca934181ef..8e2458597e0 100644
--- a/src/Psalm/Type/Atomic/TCallableString.php
+++ b/src/Psalm/Type/Atomic/TCallableString.php
@@ -23,7 +23,9 @@ public function canBeFullyExpressedInPhp(int $analysis_php_version_id): bool
         return false;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString()
+
+    /** @psalm-mutation-free */: string
     {
         return 'string';
     }
diff --git a/src/Psalm/Type/Atomic/TClassConstant.php b/src/Psalm/Type/Atomic/TClassConstant.php
index 2b71c1ae33d..342d65ca765 100644
--- a/src/Psalm/Type/Atomic/TClassConstant.php
+++ b/src/Psalm/Type/Atomic/TClassConstant.php
@@ -37,7 +37,9 @@ public function getId(bool $nested = false): string
         return $this->fq_classlike_name . '::' . $this->const_name;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString()
+
+    /** @psalm-mutation-free */: string
     {
         return 'class-constant(' . $this->fq_classlike_name . '::' . $this->const_name . ')';
     }
diff --git a/src/Psalm/Type/Atomic/TClassString.php b/src/Psalm/Type/Atomic/TClassString.php
index e46f031bcd4..f511c43b5ed 100644
--- a/src/Psalm/Type/Atomic/TClassString.php
+++ b/src/Psalm/Type/Atomic/TClassString.php
@@ -63,7 +63,9 @@ public function getId(bool $nested = false): string
             . '-string' . ($this->as === 'object' ? '' : '<' . $this->as_type . '>');
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString()
+
+    /** @psalm-mutation-free */: string
     {
         return 'class-string';
     }
diff --git a/src/Psalm/Type/Atomic/TClassStringMap.php b/src/Psalm/Type/Atomic/TClassStringMap.php
index 69734476216..5cc06beaeec 100644
--- a/src/Psalm/Type/Atomic/TClassStringMap.php
+++ b/src/Psalm/Type/Atomic/TClassStringMap.php
@@ -231,7 +231,9 @@ public function equals(Atomic $other_type, bool $ensure_source_equality): bool
         return true;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString()
+
+    /** @psalm-mutation-free */: string
     {
         return $this->getKey();
     }
diff --git a/src/Psalm/Type/Atomic/TConditional.php b/src/Psalm/Type/Atomic/TConditional.php
index 496e1b3d492..886d4f33172 100644
--- a/src/Psalm/Type/Atomic/TConditional.php
+++ b/src/Psalm/Type/Atomic/TConditional.php
@@ -82,7 +82,9 @@ public function getKey(bool $include_extra = true): string
         return $this->__toString();
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString()
+
+    /** @psalm-mutation-free */: string
     {
         return '';
     }
diff --git a/src/Psalm/Type/Atomic/TDependentListKey.php b/src/Psalm/Type/Atomic/TDependentListKey.php
index 74f59173330..f84ec9ec779 100644
--- a/src/Psalm/Type/Atomic/TDependentListKey.php
+++ b/src/Psalm/Type/Atomic/TDependentListKey.php
@@ -34,7 +34,9 @@ public function getVarId(): string
         return $this->var_id;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString()
+
+    /** @psalm-mutation-free */: string
     {
         return 'int';
     }
diff --git a/src/Psalm/Type/Atomic/TGenericObject.php b/src/Psalm/Type/Atomic/TGenericObject.php
index 8b05040a4b9..fbd0907afcc 100644
--- a/src/Psalm/Type/Atomic/TGenericObject.php
+++ b/src/Psalm/Type/Atomic/TGenericObject.php
@@ -98,7 +98,9 @@ public function equals(Atomic $other_type, bool $ensure_source_equality): bool
         return true;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString()
+
+    /** @psalm-mutation-free */: string
     {
         return $this->value;
     }
diff --git a/src/Psalm/Type/Atomic/TIterable.php b/src/Psalm/Type/Atomic/TIterable.php
index c0c1970a614..c087b26af17 100644
--- a/src/Psalm/Type/Atomic/TIterable.php
+++ b/src/Psalm/Type/Atomic/TIterable.php
@@ -56,7 +56,9 @@ public function getKey(bool $include_extra = true): string
         return 'iterable';
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString()
+
+    /** @psalm-mutation-free */: string
     {
         return 'iterable';
     }
diff --git a/src/Psalm/Type/Atomic/TKeyOfClassConstant.php b/src/Psalm/Type/Atomic/TKeyOfClassConstant.php
index 189cda0df2a..d5b738a71c6 100644
--- a/src/Psalm/Type/Atomic/TKeyOfClassConstant.php
+++ b/src/Psalm/Type/Atomic/TKeyOfClassConstant.php
@@ -97,7 +97,9 @@ public function toNamespacedString(
         return 'key-of<\\' . $this->fq_classlike_name . '::' . $this->const_name . '>';
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString()
+
+    /** @psalm-mutation-free */: string
     {
         return 'mixed';
     }
diff --git a/src/Psalm/Type/Atomic/TKeyedArray.php b/src/Psalm/Type/Atomic/TKeyedArray.php
index 4c608fca927..93053235994 100644
--- a/src/Psalm/Type/Atomic/TKeyedArray.php
+++ b/src/Psalm/Type/Atomic/TKeyedArray.php
@@ -409,7 +409,9 @@ public function equals(Atomic $other_type, bool $ensure_source_equality): bool
         return true;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString()
+
+    /** @psalm-mutation-free */: string
     {
         return $this->getKey();
     }
diff --git a/src/Psalm/Type/Atomic/TList.php b/src/Psalm/Type/Atomic/TList.php
index 238c4fcac73..ebb3636f024 100644
--- a/src/Psalm/Type/Atomic/TList.php
+++ b/src/Psalm/Type/Atomic/TList.php
@@ -197,13 +197,13 @@ public function equals(Atomic $other_type, bool $ensure_source_equality): bool
         return true;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
-        if (!$exact || $this->type_param->isMixed()) {
+        if ($this->type_param->isMixed()) {
             return 'list';
         }
 
-        return $this->toNamespacedString(null, [], null, false);
+        return $this->getId();
     }
 
     public function getChildNodes(): array
diff --git a/src/Psalm/Type/Atomic/TLiteralClassString.php b/src/Psalm/Type/Atomic/TLiteralClassString.php
index 5cdb2125109..5e5b6806ce5 100644
--- a/src/Psalm/Type/Atomic/TLiteralClassString.php
+++ b/src/Psalm/Type/Atomic/TLiteralClassString.php
@@ -57,7 +57,9 @@ public function getId(bool $nested = false): string
         return $this->value . '::class';
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString()
+
+    /** @psalm-mutation-free */: string
     {
         return $this->getKey();
     }
diff --git a/src/Psalm/Type/Atomic/TLiteralInt.php b/src/Psalm/Type/Atomic/TLiteralInt.php
index 282dae12da1..d85ce02380b 100644
--- a/src/Psalm/Type/Atomic/TLiteralInt.php
+++ b/src/Psalm/Type/Atomic/TLiteralInt.php
@@ -25,7 +25,7 @@ public function getId(bool $nested = false): string
         return (string) $this->value;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
         return 'int(' . $this->value . ')';
     }
diff --git a/src/Psalm/Type/Atomic/TLiteralString.php b/src/Psalm/Type/Atomic/TLiteralString.php
index e19cfb8da2c..bb5c2b48baa 100644
--- a/src/Psalm/Type/Atomic/TLiteralString.php
+++ b/src/Psalm/Type/Atomic/TLiteralString.php
@@ -35,7 +35,7 @@ public function getId(bool $nested = false): string
         return '"' . $no_newline_value . '"';
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
         return 'string(' . $this->value . ')';
     }
diff --git a/src/Psalm/Type/Atomic/TMixed.php b/src/Psalm/Type/Atomic/TMixed.php
index b31dfe21e72..a2626a885f1 100644
--- a/src/Psalm/Type/Atomic/TMixed.php
+++ b/src/Psalm/Type/Atomic/TMixed.php
@@ -44,7 +44,7 @@ public function canBeFullyExpressedInPhp(int $analysis_php_version_id): bool
         return $analysis_php_version_id >= 8_00_00;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
         return 'mixed';
     }
diff --git a/src/Psalm/Type/Atomic/TNonEmptyList.php b/src/Psalm/Type/Atomic/TNonEmptyList.php
index 2703e0bf160..8b94f6e5a2a 100644
--- a/src/Psalm/Type/Atomic/TNonEmptyList.php
+++ b/src/Psalm/Type/Atomic/TNonEmptyList.php
@@ -19,7 +19,7 @@ class TNonEmptyList extends TList
 
     public const KEY = 'non-empty-list';
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
         return 'non-empty-list';
     }
diff --git a/src/Psalm/Type/Atomic/TNonspecificLiteralInt.php b/src/Psalm/Type/Atomic/TNonspecificLiteralInt.php
index ac920d5a68c..99da2397df4 100644
--- a/src/Psalm/Type/Atomic/TNonspecificLiteralInt.php
+++ b/src/Psalm/Type/Atomic/TNonspecificLiteralInt.php
@@ -18,7 +18,7 @@ public function canBeFullyExpressedInPhp(int $analysis_php_version_id): bool
         return false;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
         return 'int';
     }
diff --git a/src/Psalm/Type/Atomic/TNonspecificLiteralString.php b/src/Psalm/Type/Atomic/TNonspecificLiteralString.php
index fe4c46b57f0..e4ea460e2fa 100644
--- a/src/Psalm/Type/Atomic/TNonspecificLiteralString.php
+++ b/src/Psalm/Type/Atomic/TNonspecificLiteralString.php
@@ -18,7 +18,7 @@ public function canBeFullyExpressedInPhp(int $analysis_php_version_id): bool
         return false;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
         return 'string';
     }
diff --git a/src/Psalm/Type/Atomic/TNumericString.php b/src/Psalm/Type/Atomic/TNumericString.php
index 001eed685d0..b76081311c3 100644
--- a/src/Psalm/Type/Atomic/TNumericString.php
+++ b/src/Psalm/Type/Atomic/TNumericString.php
@@ -27,7 +27,7 @@ public function canBeFullyExpressedInPhp(int $analysis_php_version_id): bool
         return false;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
         return 'string';
     }
diff --git a/src/Psalm/Type/Atomic/TObjectWithProperties.php b/src/Psalm/Type/Atomic/TObjectWithProperties.php
index edbbe8fcb33..10f1480a62f 100644
--- a/src/Psalm/Type/Atomic/TObjectWithProperties.php
+++ b/src/Psalm/Type/Atomic/TObjectWithProperties.php
@@ -265,7 +265,7 @@ public function getChildNodes(): array
         return array_merge($this->properties, $this->extra_types !== null ? array_values($this->extra_types) : []);
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
         return $this->getKey();
     }
diff --git a/src/Psalm/Type/Atomic/TScalar.php b/src/Psalm/Type/Atomic/TScalar.php
index 5954a75e7f0..a9925e1fec5 100644
--- a/src/Psalm/Type/Atomic/TScalar.php
+++ b/src/Psalm/Type/Atomic/TScalar.php
@@ -35,7 +35,7 @@ public function canBeFullyExpressedInPhp(int $analysis_php_version_id): bool
         return false;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
         return 'scalar';
     }
diff --git a/src/Psalm/Type/Atomic/TTemplateParam.php b/src/Psalm/Type/Atomic/TTemplateParam.php
index 593a8ff3a6d..04d4da3b45a 100644
--- a/src/Psalm/Type/Atomic/TTemplateParam.php
+++ b/src/Psalm/Type/Atomic/TTemplateParam.php
@@ -53,7 +53,7 @@ public function getKey(bool $include_extra = true): string
         return $this->param_name . ':' . $this->defining_class;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
         return $this->as->getId();
     }
diff --git a/src/Psalm/Type/Atomic/TTemplateParamClass.php b/src/Psalm/Type/Atomic/TTemplateParamClass.php
index bd683122e8b..02bb55464a2 100644
--- a/src/Psalm/Type/Atomic/TTemplateParamClass.php
+++ b/src/Psalm/Type/Atomic/TTemplateParamClass.php
@@ -45,7 +45,7 @@ public function getId(bool $nested = false): string
             . ' as ' . ($this->as_type ? $this->as_type->getId() : $this->as) . '>';
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
         return 'class-string<' . $this->param_name . '>';
     }
diff --git a/src/Psalm/Type/Atomic/TTypeAlias.php b/src/Psalm/Type/Atomic/TTypeAlias.php
index c3ff90378f9..e90dc1271a9 100644
--- a/src/Psalm/Type/Atomic/TTypeAlias.php
+++ b/src/Psalm/Type/Atomic/TTypeAlias.php
@@ -78,7 +78,7 @@ public function canBeFullyExpressedInPhp(int $analysis_php_version_id): bool
         return false;
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
         return 'mixed';
     }
diff --git a/src/Psalm/Type/Atomic/TValueOfClassConstant.php b/src/Psalm/Type/Atomic/TValueOfClassConstant.php
index 6821650bae1..1c5c23834ab 100644
--- a/src/Psalm/Type/Atomic/TValueOfClassConstant.php
+++ b/src/Psalm/Type/Atomic/TValueOfClassConstant.php
@@ -72,7 +72,7 @@ public function toNamespacedString(
             . '>::' . $this->const_name . '>';
     }
 
-    public function getAssertionString(bool $exact = false): string
+    public function getAssertionString(): string
     {
         return 'mixed';
     }

From a72ab5c653e0802236924ab194ce96fe310c45d7 Mon Sep 17 00:00:00 2001
From: Matthew Brown <github@muglug.com>
Date: Thu, 20 Jan 2022 17:15:12 -0500
Subject: [PATCH 3/5] Remove some unnecessary checks

---
 src/Psalm/Internal/Type/AssertionReconciler.php | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/src/Psalm/Internal/Type/AssertionReconciler.php b/src/Psalm/Internal/Type/AssertionReconciler.php
index 8343e9e4f9e..6cf11b8c558 100644
--- a/src/Psalm/Internal/Type/AssertionReconciler.php
+++ b/src/Psalm/Internal/Type/AssertionReconciler.php
@@ -1143,10 +1143,8 @@ private static function handleLiteralEqualityWithString(
         $value = $assertion_type->value;
 
         // we create the literal that is being asserted. We'll return this when we're sure this is the resulting type
-        $literal_asserted_type_string = new Union([new TLiteralString($value)]);
+        $literal_asserted_type_string = new Union([clone $assertion_type]);
         $literal_asserted_type_string->from_docblock = $existing_var_type->from_docblock;
-        $literal_asserted_type_classstring = new Union([new TLiteralClassString($value)]);
-        $literal_asserted_type_classstring->from_docblock = $existing_var_type->from_docblock;
 
         $compatible_string_type = self::getCompatibleStringType(
             $existing_var_type,
@@ -1179,18 +1177,10 @@ private static function handleLiteralEqualityWithString(
                     return $existing_var_type;
                 }
 
-                if ($assertion_type instanceof TLiteralClassString) {
-                    return $literal_asserted_type_classstring;
-                }
-
                 return $literal_asserted_type_string;
             }
 
             if ($existing_var_atomic_type instanceof TString && !$existing_var_atomic_type instanceof TLiteralString) {
-                if ($assertion_type instanceof TLiteralClassString) {
-                    return $literal_asserted_type_classstring;
-                }
-
                 return $literal_asserted_type_string;
             }
 
@@ -1206,10 +1196,6 @@ private static function handleLiteralEqualityWithString(
                 }
 
                 if ($existing_var_atomic_type->as->hasString()) {
-                    if ($assertion_type instanceof TLiteralClassString) {
-                        return $literal_asserted_type_classstring;
-                    }
-
                     return $literal_asserted_type_string;
                 }
 

From 485e511582a1f8ab72f06e85e81c10d66c69f395 Mon Sep 17 00:00:00 2001
From: Matthew Brown <github@muglug.com>
Date: Thu, 20 Jan 2022 17:16:35 -0500
Subject: [PATCH 4/5] Fix bad find/replace

---
 src/Psalm/Type/Atomic/TCallableObject.php     | 4 +---
 src/Psalm/Type/Atomic/TCallableString.php     | 4 +---
 src/Psalm/Type/Atomic/TClassConstant.php      | 4 +---
 src/Psalm/Type/Atomic/TClassString.php        | 4 +---
 src/Psalm/Type/Atomic/TClassStringMap.php     | 4 +---
 src/Psalm/Type/Atomic/TConditional.php        | 4 +---
 src/Psalm/Type/Atomic/TDependentListKey.php   | 4 +---
 src/Psalm/Type/Atomic/TGenericObject.php      | 4 +---
 src/Psalm/Type/Atomic/TIterable.php           | 4 +---
 src/Psalm/Type/Atomic/TKeyOfClassConstant.php | 4 +---
 src/Psalm/Type/Atomic/TKeyedArray.php         | 4 +---
 src/Psalm/Type/Atomic/TLiteralClassString.php | 4 +---
 12 files changed, 12 insertions(+), 36 deletions(-)

diff --git a/src/Psalm/Type/Atomic/TCallableObject.php b/src/Psalm/Type/Atomic/TCallableObject.php
index 78a50b72398..ebbee0b3377 100644
--- a/src/Psalm/Type/Atomic/TCallableObject.php
+++ b/src/Psalm/Type/Atomic/TCallableObject.php
@@ -34,9 +34,7 @@ public function canBeFullyExpressedInPhp(int $analysis_php_version_id): bool
         return false;
     }
 
-    public function getAssertionString()
-
-    /** @psalm-mutation-free */: string
+    public function getAssertionString(): string
     {
         return 'object';
     }
diff --git a/src/Psalm/Type/Atomic/TCallableString.php b/src/Psalm/Type/Atomic/TCallableString.php
index 8e2458597e0..0b49ca93f96 100644
--- a/src/Psalm/Type/Atomic/TCallableString.php
+++ b/src/Psalm/Type/Atomic/TCallableString.php
@@ -23,9 +23,7 @@ public function canBeFullyExpressedInPhp(int $analysis_php_version_id): bool
         return false;
     }
 
-    public function getAssertionString()
-
-    /** @psalm-mutation-free */: string
+    public function getAssertionString(): string
     {
         return 'string';
     }
diff --git a/src/Psalm/Type/Atomic/TClassConstant.php b/src/Psalm/Type/Atomic/TClassConstant.php
index 342d65ca765..d93e076e407 100644
--- a/src/Psalm/Type/Atomic/TClassConstant.php
+++ b/src/Psalm/Type/Atomic/TClassConstant.php
@@ -37,9 +37,7 @@ public function getId(bool $nested = false): string
         return $this->fq_classlike_name . '::' . $this->const_name;
     }
 
-    public function getAssertionString()
-
-    /** @psalm-mutation-free */: string
+    public function getAssertionString(): string
     {
         return 'class-constant(' . $this->fq_classlike_name . '::' . $this->const_name . ')';
     }
diff --git a/src/Psalm/Type/Atomic/TClassString.php b/src/Psalm/Type/Atomic/TClassString.php
index f511c43b5ed..f34c5e603a4 100644
--- a/src/Psalm/Type/Atomic/TClassString.php
+++ b/src/Psalm/Type/Atomic/TClassString.php
@@ -63,9 +63,7 @@ public function getId(bool $nested = false): string
             . '-string' . ($this->as === 'object' ? '' : '<' . $this->as_type . '>');
     }
 
-    public function getAssertionString()
-
-    /** @psalm-mutation-free */: string
+    public function getAssertionString(): string
     {
         return 'class-string';
     }
diff --git a/src/Psalm/Type/Atomic/TClassStringMap.php b/src/Psalm/Type/Atomic/TClassStringMap.php
index 5cc06beaeec..3cfd43eea81 100644
--- a/src/Psalm/Type/Atomic/TClassStringMap.php
+++ b/src/Psalm/Type/Atomic/TClassStringMap.php
@@ -231,9 +231,7 @@ public function equals(Atomic $other_type, bool $ensure_source_equality): bool
         return true;
     }
 
-    public function getAssertionString()
-
-    /** @psalm-mutation-free */: string
+    public function getAssertionString(): string
     {
         return $this->getKey();
     }
diff --git a/src/Psalm/Type/Atomic/TConditional.php b/src/Psalm/Type/Atomic/TConditional.php
index 886d4f33172..559d0e12dce 100644
--- a/src/Psalm/Type/Atomic/TConditional.php
+++ b/src/Psalm/Type/Atomic/TConditional.php
@@ -82,9 +82,7 @@ public function getKey(bool $include_extra = true): string
         return $this->__toString();
     }
 
-    public function getAssertionString()
-
-    /** @psalm-mutation-free */: string
+    public function getAssertionString(): string
     {
         return '';
     }
diff --git a/src/Psalm/Type/Atomic/TDependentListKey.php b/src/Psalm/Type/Atomic/TDependentListKey.php
index f84ec9ec779..9037d627228 100644
--- a/src/Psalm/Type/Atomic/TDependentListKey.php
+++ b/src/Psalm/Type/Atomic/TDependentListKey.php
@@ -34,9 +34,7 @@ public function getVarId(): string
         return $this->var_id;
     }
 
-    public function getAssertionString()
-
-    /** @psalm-mutation-free */: string
+    public function getAssertionString(): string
     {
         return 'int';
     }
diff --git a/src/Psalm/Type/Atomic/TGenericObject.php b/src/Psalm/Type/Atomic/TGenericObject.php
index fbd0907afcc..e7fe236f413 100644
--- a/src/Psalm/Type/Atomic/TGenericObject.php
+++ b/src/Psalm/Type/Atomic/TGenericObject.php
@@ -98,9 +98,7 @@ public function equals(Atomic $other_type, bool $ensure_source_equality): bool
         return true;
     }
 
-    public function getAssertionString()
-
-    /** @psalm-mutation-free */: string
+    public function getAssertionString(): string
     {
         return $this->value;
     }
diff --git a/src/Psalm/Type/Atomic/TIterable.php b/src/Psalm/Type/Atomic/TIterable.php
index c087b26af17..d092da46681 100644
--- a/src/Psalm/Type/Atomic/TIterable.php
+++ b/src/Psalm/Type/Atomic/TIterable.php
@@ -56,9 +56,7 @@ public function getKey(bool $include_extra = true): string
         return 'iterable';
     }
 
-    public function getAssertionString()
-
-    /** @psalm-mutation-free */: string
+    public function getAssertionString(): string
     {
         return 'iterable';
     }
diff --git a/src/Psalm/Type/Atomic/TKeyOfClassConstant.php b/src/Psalm/Type/Atomic/TKeyOfClassConstant.php
index d5b738a71c6..621b010ff0a 100644
--- a/src/Psalm/Type/Atomic/TKeyOfClassConstant.php
+++ b/src/Psalm/Type/Atomic/TKeyOfClassConstant.php
@@ -97,9 +97,7 @@ public function toNamespacedString(
         return 'key-of<\\' . $this->fq_classlike_name . '::' . $this->const_name . '>';
     }
 
-    public function getAssertionString()
-
-    /** @psalm-mutation-free */: string
+    public function getAssertionString(): string
     {
         return 'mixed';
     }
diff --git a/src/Psalm/Type/Atomic/TKeyedArray.php b/src/Psalm/Type/Atomic/TKeyedArray.php
index 93053235994..1f41f32aad2 100644
--- a/src/Psalm/Type/Atomic/TKeyedArray.php
+++ b/src/Psalm/Type/Atomic/TKeyedArray.php
@@ -409,9 +409,7 @@ public function equals(Atomic $other_type, bool $ensure_source_equality): bool
         return true;
     }
 
-    public function getAssertionString()
-
-    /** @psalm-mutation-free */: string
+    public function getAssertionString(): string
     {
         return $this->getKey();
     }
diff --git a/src/Psalm/Type/Atomic/TLiteralClassString.php b/src/Psalm/Type/Atomic/TLiteralClassString.php
index 5e5b6806ce5..bbb5c5e941e 100644
--- a/src/Psalm/Type/Atomic/TLiteralClassString.php
+++ b/src/Psalm/Type/Atomic/TLiteralClassString.php
@@ -57,9 +57,7 @@ public function getId(bool $nested = false): string
         return $this->value . '::class';
     }
 
-    public function getAssertionString()
-
-    /** @psalm-mutation-free */: string
+    public function getAssertionString(): string
     {
         return $this->getKey();
     }

From e5b0c6fb4416453a97f668cd0b1e1d258d6d85be Mon Sep 17 00:00:00 2001
From: Matthew Brown <github@muglug.com>
Date: Thu, 20 Jan 2022 17:19:54 -0500
Subject: [PATCH 5/5] Add note about assertions no longer stored as strings in
 UPGRADING.md

---
 UPGRADING.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/UPGRADING.md b/UPGRADING.md
index 070a7f54607..5ddf250b0d1 100644
--- a/UPGRADING.md
+++ b/UPGRADING.md
@@ -19,7 +19,6 @@
     - `Psalm\Type\Atomic\Scalar`
     - `Psalm\Type\Atomic\TArray`
     - `Psalm\Type\Atomic\TArrayKey`
-    - `Psalm\Type\Atomic\TAssertionFalsy`
     - `Psalm\Type\Atomic\TCallable`
     - `Psalm\Type\Atomic\TCallableObject`
     - `Psalm\Type\Atomic\TCallableString`
@@ -77,7 +76,6 @@
     - `Psalm\Type\Atomic\TAnonymousClassInstance`
     - `Psalm\Type\Atomic\TArray`
     - `Psalm\Type\Atomic\TArrayKey`
-    - `Psalm\Type\Atomic\TAssertionFalsy`
     - `Psalm\Type\Atomic\TBool`
     - `Psalm\Type\Atomic\TCallable`
     - `Psalm\Type\Atomic\TCallableObject`
@@ -121,6 +119,7 @@
  - [BC] Property `Psalm\Type\Atomic\TNamedObject::$was_static` was renamed to `$is_static`
  - [BC] Method `Psalm\Type\Union::isFormerStaticObject()` was renamed to `isStaticObject()`
  - [BC] Method `Psalm\Type\Union::hasFormerStaticObject()` was renamed to `hasStaticObject()`
+ - [BC] Function assertions (from `@psalm-assert Foo $bar`) have been converted from strings to specific `Assertion` objects.
 
 ## Removed
  - [BC] Property `Psalm\Codebase::$php_major_version` was removed, use