diff --git a/src/Analyser/TypeSpecifier.php b/src/Analyser/TypeSpecifier.php
index 9f7a86eb4a..5701a80016 100644
--- a/src/Analyser/TypeSpecifier.php
+++ b/src/Analyser/TypeSpecifier.php
@@ -734,7 +734,16 @@ public function specifyTypesInCondition(
 			$leftTypes = $this->specifyTypesInCondition($scope, $expr->left, $context)->setRootExpr($expr);
 			$rightScope = $scope->filterByTruthyValue($expr->left);
 			$rightTypes = $this->specifyTypesInCondition($rightScope, $expr->right, $context)->setRootExpr($expr);
-			$types = $context->true() ? $leftTypes->unionWith($rightTypes) : $leftTypes->normalize($scope)->intersectWith($rightTypes->normalize($rightScope));
+			if ($context->true()) {
+				$types = $leftTypes->unionWith($rightTypes);
+			} else {
+				$leftNormalized = $leftTypes->normalize($scope);
+				$rightNormalized = $rightTypes->normalize($rightScope);
+				$types = $leftNormalized->intersectWith($rightNormalized);
+				$leftFalseyScope = $scope->filterByFalseyValue($expr->left);
+				$rightFalseyScope = $rightScope->filterByFalseyValue($expr->right);
+				$types = $this->augmentDisjunctionTypes($scope, $leftNormalized, $rightNormalized, $leftFalseyScope, $rightFalseyScope, $types);
+			}
 			if ($context->false()) {
 				$leftTypesForHolders = $leftTypes;
 				$rightTypesForHolders = $rightTypes;
@@ -788,8 +797,13 @@ public function specifyTypesInCondition(
 				) {
 					$types = $leftTypes->normalize($scope);
 				} else {
-					$types = $leftTypes->normalize($scope)->intersectWith($rightTypes->normalize($rightScope));
+					$leftNormalized = $leftTypes->normalize($scope);
+					$rightNormalized = $rightTypes->normalize($rightScope);
+					$types = $leftNormalized->intersectWith($rightNormalized);
 					$types = $this->augmentBooleanOrTruthyWithConditionalHolders($scope, $rightScope, $expr, $types);
+					$leftTruthyScopeForAugment = $scope->filterByTruthyValue($expr->left);
+					$rightTruthyScopeForAugment = $rightScope->filterByTruthyValue($expr->right);
+					$types = $this->augmentDisjunctionTypes($scope, $leftNormalized, $rightNormalized, $leftTruthyScopeForAugment, $rightTruthyScopeForAugment, $types);
 				}
 			} else {
 				$types = $leftTypes->unionWith($rightTypes);
@@ -2076,6 +2090,65 @@ private function augmentBooleanOrTruthyWithConditionalHolders(MutatingScope $sco
 		return $types;
 	}
 
+	private function augmentDisjunctionTypes(
+		MutatingScope $scope,
+		SpecifiedTypes $leftNormalized,
+		SpecifiedTypes $rightNormalized,
+		MutatingScope $leftFilteredScope,
+		MutatingScope $rightFilteredScope,
+		SpecifiedTypes $types,
+	): SpecifiedTypes
+	{
+		$candidateExprs = [];
+		foreach ($leftNormalized->getSureTypes() as $exprString => [$exprNode, $type]) {
+			$candidateExprs[$exprString] = $exprNode;
+		}
+		foreach ($rightNormalized->getSureTypes() as $exprString => [$exprNode, $type]) {
+			$candidateExprs[$exprString] = $exprNode;
+		}
+
+		$existingSureTypes = $types->getSureTypes();
+
+		foreach ($candidateExprs as $exprString => $targetExpr) {
+			if (isset($existingSureTypes[$exprString])) {
+				continue;
+			}
+
+			if (!$scope->hasExpressionType($targetExpr)->yes()) {
+				continue;
+			}
+			if (!$leftFilteredScope->hasExpressionType($targetExpr)->yes()) {
+				continue;
+			}
+			if (!$rightFilteredScope->hasExpressionType($targetExpr)->yes()) {
+				continue;
+			}
+
+			$originalType = $scope->getType($targetExpr);
+			$leftType = $leftFilteredScope->getType($targetExpr);
+			$rightType = $rightFilteredScope->getType($targetExpr);
+
+			if ($leftType->equals($originalType) || !$originalType->isSuperTypeOf($leftType)->yes()) {
+				continue;
+			}
+
+			if ($rightType->equals($originalType) || !$originalType->isSuperTypeOf($rightType)->yes()) {
+				continue;
+			}
+
+			$unionType = TypeCombinator::union($leftType, $rightType);
+			if ($unionType->equals($originalType)) {
+				continue;
+			}
+
+			$types = $types->unionWith(
+				$this->create($targetExpr, $unionType, TypeSpecifierContext::createTrue(), $scope),
+			);
+		}
+
+		return $types;
+	}
+
 	/**
 	 * @return array<string, ConditionalExpressionHolder[]>
 	 */
diff --git a/tests/PHPStan/Analyser/data/type-specifying-extensions-2-false.php b/tests/PHPStan/Analyser/data/type-specifying-extensions-2-false.php
index 8016cee235..c33f80b927 100644
--- a/tests/PHPStan/Analyser/data/type-specifying-extensions-2-false.php
+++ b/tests/PHPStan/Analyser/data/type-specifying-extensions-2-false.php
@@ -10,5 +10,5 @@
 if ((new \PHPStan\Tests\AssertionClass())->assertString($foo) && \PHPStan\Tests\AssertionClass::assertInt($bar)) {
 }
 
-assertType('string|null', $foo);
+assertType('string', $foo);
 assertType('int|null', $bar);
diff --git a/tests/PHPStan/Analyser/data/type-specifying-extensions-2-null.php b/tests/PHPStan/Analyser/data/type-specifying-extensions-2-null.php
index 8016cee235..c33f80b927 100644
--- a/tests/PHPStan/Analyser/data/type-specifying-extensions-2-null.php
+++ b/tests/PHPStan/Analyser/data/type-specifying-extensions-2-null.php
@@ -10,5 +10,5 @@
 if ((new \PHPStan\Tests\AssertionClass())->assertString($foo) && \PHPStan\Tests\AssertionClass::assertInt($bar)) {
 }
 
-assertType('string|null', $foo);
+assertType('string', $foo);
 assertType('int|null', $bar);
diff --git a/tests/PHPStan/Analyser/nsrt/bug-14566.php b/tests/PHPStan/Analyser/nsrt/bug-14566.php
new file mode 100644
index 0000000000..19ca598afe
--- /dev/null
+++ b/tests/PHPStan/Analyser/nsrt/bug-14566.php
@@ -0,0 +1,98 @@
+<?php declare(strict_types = 1);
+
+namespace Bug14566;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @param array{}|array{hi: 'hello'}|array{hi: array{0: 42, 1?: 42}} $test
+ */
+function fooNestedIfs(array $test): void {
+	if (isset($test['hi'])) {
+		if (is_string($test['hi'])) {
+			return;
+		}
+	}
+	assertType("array{}|array{hi: array{0: 42, 1?: 42}}", $test);
+}
+
+/**
+ * @param array{}|array{hi: 'hello'}|array{hi: array{0: 42, 1?: 42}} $test
+ */
+function fooCombinedAnd(array $test): void {
+	if (isset($test['hi']) && is_string($test['hi'])) {
+		return;
+	}
+	assertType("array{}|array{hi: array{0: 42, 1?: 42}}", $test);
+}
+
+/**
+ * @param array{}|array{hi: 'hello'}|array{hi: array{0: 42, 1?: 42}} $test
+ */
+function fooCombinedAndAssign(array $test): void {
+	if (isset($test['hi']) && is_string($test['hi'])) {
+		return;
+	}
+	$test['hi'][] = 42;
+}
+
+/**
+ * @param array{}|array{hi: 'hello'}|array{hi: array{0: 42, 1?: 42}} $test
+ */
+function fooBooleanOrDual(array $test): void {
+	if (!isset($test['hi']) || !is_string($test['hi'])) {
+		assertType("array{}|array{hi: array{0: 42, 1?: 42}}", $test);
+		return;
+	}
+	assertType("array{hi: 'hello'}", $test);
+}
+
+/**
+ * @param array{}|array{hi: 42}|array{hi: array{0: 42, 1?: 42}} $testIsArray
+ */
+function fooIsArray(array $testIsArray): void {
+	if (isset($testIsArray['hi']) && is_array($testIsArray['hi'])) {
+		return;
+	}
+	assertType("array{}|array{hi: 42}", $testIsArray);
+}
+
+/**
+ * @param array{}|array{hi: 42}|array{hi: 'hello'} $testIsInt
+ */
+function fooIsInt(array $testIsInt): void {
+	if (isset($testIsInt['hi']) && is_int($testIsInt['hi'])) {
+		return;
+	}
+	assertType("array{}|array{hi: 'hello'}", $testIsInt);
+}
+
+/**
+ * @param array{}|array{hi: 42}|array{hi: 1.5} $testIsFloat
+ */
+function fooIsFloat(array $testIsFloat): void {
+	if (isset($testIsFloat['hi']) && is_float($testIsFloat['hi'])) {
+		return;
+	}
+	assertType("array{}|array{hi: 42}", $testIsFloat);
+}
+
+/**
+ * @param array{}|array{hi: true}|array{hi: 'hello'} $testIsBool
+ */
+function fooIsBool(array $testIsBool): void {
+	if (isset($testIsBool['hi']) && is_bool($testIsBool['hi'])) {
+		return;
+	}
+	assertType("array{}|array{hi: 'hello'}", $testIsBool);
+}
+
+/**
+ * @param array{}|array{val: 'hello'}|array{val: array{0: 42}} $testArrayKeyExists
+ */
+function fooArrayKeyExists(array $testArrayKeyExists): void {
+	if (array_key_exists('val', $testArrayKeyExists) && is_string($testArrayKeyExists['val'])) {
+		return;
+	}
+	assertType("array{}|array{val: array{42}}", $testArrayKeyExists);
+}
diff --git a/tests/PHPStan/Rules/Classes/ImpossibleInstanceOfRuleTest.php b/tests/PHPStan/Rules/Classes/ImpossibleInstanceOfRuleTest.php
index 1e7a8a7d90..336dbd2b14 100644
--- a/tests/PHPStan/Rules/Classes/ImpossibleInstanceOfRuleTest.php
+++ b/tests/PHPStan/Rules/Classes/ImpossibleInstanceOfRuleTest.php
@@ -511,7 +511,10 @@ public function testBug3632(): void
 			[
 				'Instanceof between Bug3632\NiceClass and Bug3632\NiceClass will always evaluate to true.',
 				36,
-				$tipText,
+			],
+			[
+				'Instanceof between null and Bug3632\NiceClass will always evaluate to false.',
+				36,
 			],
 		]);
 	}
diff --git a/tests/PHPStan/Rules/Comparison/BooleanNotConstantConditionRuleTest.php b/tests/PHPStan/Rules/Comparison/BooleanNotConstantConditionRuleTest.php
index 3cf3f2a8bb..60a4dfa793 100644
--- a/tests/PHPStan/Rules/Comparison/BooleanNotConstantConditionRuleTest.php
+++ b/tests/PHPStan/Rules/Comparison/BooleanNotConstantConditionRuleTest.php
@@ -171,7 +171,6 @@ public function testBug11903(): void
 			[
 				'Negated boolean expression is always true.',
 				21,
-				'Because the type is coming from a PHPDoc, you can turn off this check by setting <fg=cyan>treatPhpDocTypesAsCertain: false</> in your <fg=cyan>%configurationFile%</>.',
 			],
 		]);
 	}