diff --git a/conf/config.neon b/conf/config.neon
index 555e7ec53c..4d18b9552e 100644
--- a/conf/config.neon
+++ b/conf/config.neon
@@ -495,6 +495,7 @@ services:
 			implicitThrows: %exceptions.implicitThrows%
 			treatPhpDocTypesAsCertain: %treatPhpDocTypesAsCertain%
 			universalObjectCratesClasses: %universalObjectCratesClasses%
+			narrowMethodScopeFromConstructor: true
 
 	-
 		class: PHPStan\Analyser\ConstantResolver
diff --git a/src/Analyser/MutatingScope.php b/src/Analyser/MutatingScope.php
index 2d23a40665..42034f0ae3 100644
--- a/src/Analyser/MutatingScope.php
+++ b/src/Analyser/MutatingScope.php
@@ -294,6 +294,77 @@ public function enterDeclareStrictTypes(): self
 		);
 	}
 
+	/**
+	 * @param array<string, ExpressionTypeHolder> $currentExpressionTypes
+	 * @return array<string, ExpressionTypeHolder>
+	 */
+	private function rememberConstructorExpressions(array $currentExpressionTypes): array
+	{
+		$expressionTypes = [];
+		foreach ($currentExpressionTypes as $exprString => $expressionTypeHolder) {
+			$expr = $expressionTypeHolder->getExpr();
+			if ($expr instanceof FuncCall) {
+				if (
+					!$expr->name instanceof Name
+					|| !in_array($expr->name->name, ['class_exists', 'function_exists'], true)
+				) {
+					continue;
+				}
+			} elseif ($expr instanceof PropertyFetch) {
+				if (
+					!$expr->name instanceof Node\Identifier
+					|| !$expr->var instanceof Variable
+					|| $expr->var->name !== 'this'
+					|| !$this->phpVersion->supportsReadOnlyProperties()
+				) {
+					continue;
+				}
+
+				$propertyReflection = $this->propertyReflectionFinder->findPropertyReflectionFromNode($expr, $this);
+				if ($propertyReflection === null) {
+					continue;
+				}
+
+				$nativePropertyReflection = $propertyReflection->getNativeReflection();
+				if ($nativePropertyReflection === null || !$nativePropertyReflection->isReadOnly()) {
+						continue;
+				}
+			} elseif (!$expr instanceof ConstFetch && !$expr instanceof PropertyInitializationExpr) {
+				continue;
+			}
+
+			$expressionTypes[$exprString] = $expressionTypeHolder;
+		}
+
+		if (array_key_exists('$this', $currentExpressionTypes)) {
+			$expressionTypes['$this'] = $currentExpressionTypes['$this'];
+		}
+
+		return $expressionTypes;
+	}
+
+	public function rememberConstructorScope(): self
+	{
+		return $this->scopeFactory->create(
+			$this->context,
+			$this->isDeclareStrictTypes(),
+			$this->getFunction(),
+			$this->getNamespace(),
+			$this->rememberConstructorExpressions($this->expressionTypes),
+			$this->rememberConstructorExpressions($this->nativeExpressionTypes),
+			$this->conditionalExpressions,
+			$this->inClosureBindScopeClasses,
+			$this->anonymousFunctionReflection,
+			$this->inFirstLevelStatement,
+			[],
+			[],
+			$this->inFunctionCallsStack,
+			$this->afterExtractCall,
+			$this->parentScope,
+			$this->nativeTypesPromoted,
+		);
+	}
+
 	/** @api */
 	public function isInClass(): bool
 	{
@@ -3286,7 +3357,7 @@ public function enterFunction(
 
 	private function enterFunctionLike(
 		PhpFunctionFromParserNodeReflection $functionReflection,
-		bool $preserveThis,
+		bool $preserveConstructorScope,
 	): self
 	{
 		$parametersByName = [];
@@ -3298,6 +3369,12 @@ private function enterFunctionLike(
 		$expressionTypes = [];
 		$nativeExpressionTypes = [];
 		$conditionalTypes = [];
+
+		if ($preserveConstructorScope) {
+			$expressionTypes = $this->rememberConstructorExpressions($this->expressionTypes);
+			$nativeExpressionTypes = $this->rememberConstructorExpressions($this->nativeExpressionTypes);
+		}
+
 		foreach ($functionReflection->getParameters() as $parameter) {
 			$parameterType = $parameter->getType();
 
@@ -3348,13 +3425,6 @@ private function enterFunctionLike(
 			$nativeExpressionTypes[$parameterOriginalValueExprString] = ExpressionTypeHolder::createYes($parameterOriginalValueExpr, $nativeParameterType);
 		}
 
-		if ($preserveThis && array_key_exists('$this', $this->expressionTypes)) {
-			$expressionTypes['$this'] = $this->expressionTypes['$this'];
-		}
-		if ($preserveThis && array_key_exists('$this', $this->nativeExpressionTypes)) {
-			$nativeExpressionTypes['$this'] = $this->nativeExpressionTypes['$this'];
-		}
-
 		return $this->scopeFactory->create(
 			$this->context,
 			$this->isDeclareStrictTypes(),
diff --git a/src/Analyser/NodeScopeResolver.php b/src/Analyser/NodeScopeResolver.php
index 668c3aa9bd..e5cffa8560 100644
--- a/src/Analyser/NodeScopeResolver.php
+++ b/src/Analyser/NodeScopeResolver.php
@@ -218,6 +218,7 @@
 use function str_starts_with;
 use function strtolower;
 use function trim;
+use function usort;
 use const PHP_VERSION_ID;
 use const SORT_NUMERIC;
 
@@ -271,6 +272,7 @@ public function __construct(
 		private readonly array $universalObjectCratesClasses,
 		private readonly bool $implicitThrows,
 		private readonly bool $treatPhpDocTypesAsCertain,
+		private readonly bool $narrowMethodScopeFromConstructor,
 	)
 	{
 		$earlyTerminatingMethodNames = [];
@@ -791,6 +793,38 @@ private function processStmtNode(
 					$classReflection,
 					$methodReflection,
 				), $methodScope);
+
+				if ($isConstructor && $this->narrowMethodScopeFromConstructor) {
+					$finalScope = null;
+
+					foreach ($executionEnds as $executionEnd) {
+						if ($executionEnd->getStatementResult()->isAlwaysTerminating()) {
+							continue;
+						}
+
+						$endScope = $executionEnd->getStatementResult()->getScope();
+						if ($finalScope === null) {
+							$finalScope = $endScope;
+							continue;
+						}
+
+						$finalScope = $finalScope->mergeWith($endScope);
+					}
+
+					foreach ($gatheredReturnStatements as $statement) {
+						if ($finalScope === null) {
+							$finalScope = $statement->getScope();
+							continue;
+						}
+
+						$finalScope = $finalScope->mergeWith($statement->getScope());
+					}
+
+					if ($finalScope !== null) {
+						$scope = $finalScope->rememberConstructorScope();
+					}
+
+				}
 			}
 		} elseif ($stmt instanceof Echo_) {
 			$hasYield = false;
@@ -925,7 +959,26 @@ private function processStmtNode(
 			$classStatementsGatherer = new ClassStatementsGatherer($classReflection, $nodeCallback);
 			$this->processAttributeGroups($stmt, $stmt->attrGroups, $classScope, $classStatementsGatherer);
 
-			$this->processStmtNodes($stmt, $stmt->stmts, $classScope, $classStatementsGatherer, $context);
+			$classLikeStatements = $stmt->stmts;
+			if ($this->narrowMethodScopeFromConstructor) {
+				// analyze static methods first; constructor next; instance methods and property hooks last so we can carry over the scope
+				usort($classLikeStatements, static function ($a, $b) {
+					if ($a instanceof Node\Stmt\Property) {
+						return 1;
+					}
+					if ($b instanceof Node\Stmt\Property) {
+						return -1;
+					}
+
+					if (!$a instanceof Node\Stmt\ClassMethod || !$b instanceof Node\Stmt\ClassMethod) {
+						return 0;
+					}
+
+					return [!$a->isStatic(), $a->name->toLowerString() !== '__construct'] <=> [!$b->isStatic(), $b->name->toLowerString() !== '__construct'];
+				});
+			}
+
+			$this->processStmtNodes($stmt, $classLikeStatements, $classScope, $classStatementsGatherer, $context);
 			$nodeCallback(new ClassPropertiesNode($stmt, $this->readWritePropertiesExtensionProvider, $classStatementsGatherer->getProperties(), $classStatementsGatherer->getPropertyUsages(), $classStatementsGatherer->getMethodCalls(), $classStatementsGatherer->getReturnStatementsNodes(), $classStatementsGatherer->getPropertyAssigns(), $classReflection), $classScope);
 			$nodeCallback(new ClassMethodsNode($stmt, $classStatementsGatherer->getMethods(), $classStatementsGatherer->getMethodCalls(), $classReflection), $classScope);
 			$nodeCallback(new ClassConstantsNode($stmt, $classStatementsGatherer->getConstants(), $classStatementsGatherer->getConstantFetches(), $classReflection), $classScope);
diff --git a/src/Rules/IssetCheck.php b/src/Rules/IssetCheck.php
index 528f037f8b..303f0d2c0d 100644
--- a/src/Rules/IssetCheck.php
+++ b/src/Rules/IssetCheck.php
@@ -5,6 +5,7 @@
 use PhpParser\Node;
 use PhpParser\Node\Expr;
 use PHPStan\Analyser\Scope;
+use PHPStan\Node\Expr\PropertyInitializationExpr;
 use PHPStan\Rules\Properties\PropertyDescriptor;
 use PHPStan\Rules\Properties\PropertyReflectionFinder;
 use PHPStan\Type\NeverType;
@@ -143,6 +144,27 @@ public function check(Expr $expr, Scope $scope, string $operatorDescription, str
 			}
 
 			if ($propertyReflection->hasNativeType() && !$propertyReflection->isVirtual()->yes()) {
+				if (
+					$expr instanceof Node\Expr\PropertyFetch
+					&& $expr->name instanceof Node\Identifier
+					&& $expr->var instanceof Expr\Variable
+					&& $expr->var->name === 'this'
+					&& $propertyReflection->getNativeType()->isNull()->no()
+					&& $scope->hasExpressionType(new PropertyInitializationExpr($propertyReflection->getName()))->yes()
+				) {
+					return $this->generateError(
+						$propertyReflection->getNativeType(),
+						sprintf(
+							'%s %s',
+							$this->propertyDescriptor->describeProperty($propertyReflection, $scope, $expr),
+							$operatorDescription,
+						),
+						$typeMessageCallback,
+						$identifier,
+						'propertyNeverNullOrUninitialized',
+					);
+				}
+
 				if (!$scope->hasExpressionType($expr)->yes()) {
 					if ($expr instanceof Node\Expr\PropertyFetch) {
 						return $this->checkUndefined($expr->var, $scope, $operatorDescription, $identifier);
@@ -280,7 +302,7 @@ private function checkUndefined(Expr $expr, Scope $scope, string $operatorDescri
 	/**
 	 * @param callable(Type): ?string $typeMessageCallback
 	 * @param ErrorIdentifier $identifier
-	 * @param 'variable'|'offset'|'property'|'expr' $identifierSecondPart
+	 * @param 'variable'|'offset'|'property'|'expr'|'propertyNeverNullOrUninitialized' $identifierSecondPart
 	 */
 	private function generateError(Type $type, string $message, callable $typeMessageCallback, string $identifier, string $identifierSecondPart): ?IdentifierRuleError
 	{
diff --git a/src/Testing/RuleTestCase.php b/src/Testing/RuleTestCase.php
index cd0f52534e..e1e3cdb200 100644
--- a/src/Testing/RuleTestCase.php
+++ b/src/Testing/RuleTestCase.php
@@ -110,6 +110,7 @@ private function getAnalyser(DirectRuleRegistry $ruleRegistry): Analyser
 				self::getContainer()->getParameter('universalObjectCratesClasses'),
 				self::getContainer()->getParameter('exceptions')['implicitThrows'],
 				$this->shouldTreatPhpDocTypesAsCertain(),
+				$this->shouldNarrowMethodScopeFromConstructor(),
 			);
 			$fileAnalyser = new FileAnalyser(
 				$this->createScopeFactory($reflectionProvider, $typeSpecifier),
@@ -261,6 +262,11 @@ protected function shouldFailOnPhpErrors(): bool
 		return true;
 	}
 
+	protected function shouldNarrowMethodScopeFromConstructor(): bool
+	{
+		return false;
+	}
+
 	public static function getAdditionalConfigFiles(): array
 	{
 		return [
diff --git a/src/Testing/TypeInferenceTestCase.php b/src/Testing/TypeInferenceTestCase.php
index dc3e884c88..f693c1fe36 100644
--- a/src/Testing/TypeInferenceTestCase.php
+++ b/src/Testing/TypeInferenceTestCase.php
@@ -90,6 +90,7 @@ public static function processFile(
 			self::getContainer()->getParameter('universalObjectCratesClasses'),
 			self::getContainer()->getParameter('exceptions')['implicitThrows'],
 			self::getContainer()->getParameter('treatPhpDocTypesAsCertain'),
+			true,
 		);
 		$resolver->setAnalysedFiles(array_map(static fn (string $file): string => $fileHelper->normalizePath($file), array_merge([$file], static::getAdditionalAnalysedFiles())));
 
diff --git a/tests/PHPStan/Analyser/AnalyserTest.php b/tests/PHPStan/Analyser/AnalyserTest.php
index bacd85a967..78bfdfa4d7 100644
--- a/tests/PHPStan/Analyser/AnalyserTest.php
+++ b/tests/PHPStan/Analyser/AnalyserTest.php
@@ -733,6 +733,7 @@ private function createAnalyser(): Analyser
 			[stdClass::class],
 			true,
 			$this->shouldTreatPhpDocTypesAsCertain(),
+			true,
 		);
 		$lexer = new Lexer();
 		$fileAnalyser = new FileAnalyser(
diff --git a/tests/PHPStan/Analyser/nsrt/remember-readonly-constructor-narrowed-hooks.php b/tests/PHPStan/Analyser/nsrt/remember-readonly-constructor-narrowed-hooks.php
new file mode 100644
index 0000000000..8f03858767
--- /dev/null
+++ b/tests/PHPStan/Analyser/nsrt/remember-readonly-constructor-narrowed-hooks.php
@@ -0,0 +1,35 @@
+<?php // lint >= 8.4
+
+namespace RememberReadOnlyConstructorInPropertyHookBodies;
+
+use function PHPStan\Testing\assertType;
+
+class User
+{
+	public string $name {
+		get {
+			assertType('1|2', $this->type);
+			return $this->name ;
+		}
+		set {
+			if (strlen($value) === 0) {
+				throw new ValueError("Name must be non-empty");
+			}
+			assertType('1|2', $this->type);
+			$this->name = $value;
+		}
+	}
+
+	private readonly int $type;
+
+	public function __construct(
+		string $name
+	) {
+		$this->name = $name;
+		if (rand(0,1)) {
+			$this->type = 1;
+		} else {
+			$this->type = 2;
+		}
+	}
+}
diff --git a/tests/PHPStan/Analyser/nsrt/remember-readonly-constructor-narrowed.php b/tests/PHPStan/Analyser/nsrt/remember-readonly-constructor-narrowed.php
new file mode 100644
index 0000000000..7ab2ea364f
--- /dev/null
+++ b/tests/PHPStan/Analyser/nsrt/remember-readonly-constructor-narrowed.php
@@ -0,0 +1,109 @@
+<?php // lint >= 8.2
+
+namespace RememberReadOnlyConstructor;
+
+use function PHPStan\Testing\assertType;
+
+class HelloWorldReadonlyProperty {
+	private readonly int $i;
+
+	public function __construct()
+	{
+		if (rand(0,1)) {
+			$this->i = 4;
+		} else {
+			$this->i = 10;
+		}
+	}
+
+	public function doFoo() {
+		assertType('4|10', $this->i);
+	}
+}
+
+readonly class HelloWorldReadonlyClass {
+	private int $i;
+	private string $class;
+	private string $interface;
+	private string $enum;
+	private string $trait;
+
+	public function __construct(string $class, string $interface, string $enum, string $trait)
+	{
+		if (rand(0,1)) {
+			$this->i = 4;
+		} else {
+			$this->i = 10;
+		}
+
+		if (!class_exists($class)) {
+			throw new \LogicException();
+		}
+		$this->class = $class;
+
+		if (!interface_exists($interface)) {
+			throw new \LogicException();
+		}
+		$this->interface = $interface;
+
+		if (!enum_exists($enum)) {
+			throw new \LogicException();
+		}
+		$this->enum = $enum;
+
+		if (!trait_exists($trait)) {
+			throw new \LogicException();
+		}
+		$this->trait = $trait;
+	}
+
+	public function doFoo() {
+		assertType('4|10', $this->i);
+		assertType('class-string', $this->class);
+		assertType('class-string', $this->interface);
+		assertType('class-string<UnitEnum>', $this->enum);
+		assertType('class-string', $this->trait);
+	}
+}
+
+
+class HelloWorldRegular {
+	private int $i;
+
+	public function __construct()
+	{
+		if (rand(0,1)) {
+			$this->i = 4;
+		} else {
+			$this->i = 10;
+		}
+	}
+
+	public function doFoo() {
+		assertType('int', $this->i);
+	}
+}
+
+class HelloWorldReadonlyPropertySometimesThrowing {
+	private readonly int $i;
+
+	public function __construct()
+	{
+		if (rand(0,1)) {
+			$this->i = 4;
+
+			return;
+		} elseif (rand(10,100)) {
+			$this->i = 10;
+			return;
+		} else {
+			$this->i = 20;
+		}
+
+		throw new \LogicException();
+	}
+
+	public function doFoo() {
+		assertType('4|10', $this->i);
+	}
+}
diff --git a/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php
index 9841cd6ed4..4e026df3a6 100644
--- a/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php
+++ b/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php
@@ -15,6 +15,8 @@
 class ExistingClassInInstanceOfRuleTest extends RuleTestCase
 {
 
+	private bool $shouldNarrowMethodScopeFromConstructor = true;
+
 	protected function getRule(): Rule
 	{
 		$reflectionProvider = $this->createReflectionProvider();
@@ -29,6 +31,11 @@ protected function getRule(): Rule
 		);
 	}
 
+	public function shouldNarrowMethodScopeFromConstructor(): bool
+	{
+		return $this->shouldNarrowMethodScopeFromConstructor;
+	}
+
 	public function testClassDoesNotExist(): void
 	{
 		$this->analyse(
@@ -81,4 +88,27 @@ public function testBug7720(): void
 		]);
 	}
 
+	public function testRememberClassExistsFromConstructorDisabled(): void
+	{
+		$this->shouldNarrowMethodScopeFromConstructor = false;
+
+		$this->analyse([__DIR__ . '/data/remember-class-exists-from-constructor.php'], [
+			[
+				'Class SomeUnknownClass not found.',
+				19,
+				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
+			],
+			[
+				'Class SomeUnknownInterface not found.',
+				38,
+				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
+			],
+		]);
+	}
+
+	public function testRememberClassExistsFromConstructor(): void
+	{
+		$this->analyse([__DIR__ . '/data/remember-class-exists-from-constructor.php'], []);
+	}
+
 }
diff --git a/tests/PHPStan/Rules/Classes/data/remember-class-exists-from-constructor.php b/tests/PHPStan/Rules/Classes/data/remember-class-exists-from-constructor.php
new file mode 100644
index 0000000000..6c7b8cecbf
--- /dev/null
+++ b/tests/PHPStan/Rules/Classes/data/remember-class-exists-from-constructor.php
@@ -0,0 +1,44 @@
+<?php // lint >= 7.4
+
+namespace RememberClassExistsFromConstructor;
+
+use SomeUnknownClass;
+use SomeUnknownInterface;
+
+class UserWithClass
+{
+	public function __construct(
+	) {
+		if (!class_exists('SomeUnknownClass')) {
+			throw new \LogicException();
+		}
+	}
+
+	public function doFoo($m): bool
+	{
+		if ($m instanceof SomeUnknownClass) {
+			return false;
+		}
+		return true;
+	}
+
+}
+
+class UserWithInterface
+{
+	public function __construct(
+	) {
+		if (!interface_exists('SomeUnknownInterface')) {
+			throw new \LogicException();
+		}
+	}
+
+	public function doFoo($m): bool
+	{
+		if ($m instanceof SomeUnknownInterface) {
+			return false;
+		}
+		return true;
+	}
+
+}
diff --git a/tests/PHPStan/Rules/Constants/ConstantRuleTest.php b/tests/PHPStan/Rules/Constants/ConstantRuleTest.php
index d30fbcec67..0da9819e08 100644
--- a/tests/PHPStan/Rules/Constants/ConstantRuleTest.php
+++ b/tests/PHPStan/Rules/Constants/ConstantRuleTest.php
@@ -17,6 +17,11 @@ protected function getRule(): Rule
 		return new ConstantRule(true);
 	}
 
+	public function shouldNarrowMethodScopeFromConstructor(): bool
+	{
+		return true;
+	}
+
 	public function testConstants(): void
 	{
 		define('FOO_CONSTANT', 'foo');
@@ -80,4 +85,45 @@ public function testDefinedScopeMerge(): void
 		]);
 	}
 
+	public function testRememberedConstructorScope(): void
+	{
+		$this->analyse([__DIR__ . '/data/remembered-constructor-scope.php'], [
+			[
+				'Constant REMEMBERED_FOO not found.',
+				23,
+				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
+			],
+			[
+				'Constant REMEMBERED_FOO not found.',
+				38,
+				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
+			],
+			[
+				'Constant REMEMBERED_FOO not found.',
+				51,
+				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
+			],
+			[
+				'Constant REMEMBERED_FOO not found.',
+				65,
+				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
+			],
+			[
+				'Constant XYZ22 not found.',
+				87,
+				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
+			],
+			[
+				'Constant XYZ not found.',
+				88,
+				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
+			],
+			[
+				'Constant XYZ33 not found.',
+				98,
+				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
+			],
+		]);
+	}
+
 }
diff --git a/tests/PHPStan/Rules/Constants/data/remembered-constructor-scope.php b/tests/PHPStan/Rules/Constants/data/remembered-constructor-scope.php
new file mode 100644
index 0000000000..7be2b0bf7b
--- /dev/null
+++ b/tests/PHPStan/Rules/Constants/data/remembered-constructor-scope.php
@@ -0,0 +1,100 @@
+<?php declare(strict_types=1);
+
+namespace RememberedConstructorScope;
+
+use LogicException;
+
+class HelloWorld
+{
+	public function dooFoo(): void
+	{
+		if (REMEMBERED_FOO === '3') {
+
+		}
+	}
+
+	public function returnFoo(): string
+	{
+		return REMEMBERED_FOO;
+	}
+
+	static public function staticFoo(): void
+	{
+		echo REMEMBERED_FOO; // should error, as can be invoked without instantiation
+	}
+
+	public function __construct()
+	{
+		if (!defined('REMEMBERED_FOO')) {
+			throw new LogicException();
+		}
+		if (!is_string(REMEMBERED_FOO)) {
+			throw new LogicException();
+		}
+	}
+
+	static public function staticFoo2(): void
+	{
+		echo REMEMBERED_FOO; // should error, as can be invoked without instantiation
+	}
+
+	public function returnFoo2(): string
+	{
+		return REMEMBERED_FOO;
+	}
+}
+
+
+class AnotherClass {
+	public function myFoo(): string
+	{
+		return REMEMBERED_FOO; // should error, because this class should not share the __constructor() scope with HelloWorld-class above.
+	}
+}
+
+class AnotherClassWithOwnConstructor {
+	public function __construct()
+	{
+		if (!defined('ANOTHER_REMEMBERED_FOO')) {
+			throw new LogicException();
+		}
+	}
+
+	public function myFoo(): void
+	{
+		echo REMEMBERED_FOO; // should error, because this class should not share the __constructor() scope with HelloWorld-class above.
+
+		echo ANOTHER_REMEMBERED_FOO;
+	}
+}
+
+class MyClassWithDefine {
+	public function __construct() {
+		define('XYZ', '123');
+	}
+
+	public function doFoo(): void {
+		echo XYZ;
+	}
+}
+
+class StaticMethodScopeNotRemembered {
+	static public function init() {
+		define('XYZ22', '123');
+	}
+
+	public function doFoo(): void {
+		echo XYZ22; // error because defined in static method
+		echo XYZ; // error, because should not mix scope of __constructor() scope of different class
+	}
+}
+
+class InstanceMethodScopeNotRemembered {
+	public function init() {
+		define('XYZ33', '123');
+	}
+
+	public function doFoo(): void {
+		echo XYZ33; // error because defined in non-constructor method
+	}
+}
diff --git a/tests/PHPStan/Rules/Functions/CallToNonExistentFunctionRuleTest.php b/tests/PHPStan/Rules/Functions/CallToNonExistentFunctionRuleTest.php
index 4344c32b14..6707068e04 100644
--- a/tests/PHPStan/Rules/Functions/CallToNonExistentFunctionRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/CallToNonExistentFunctionRuleTest.php
@@ -17,6 +17,11 @@ protected function getRule(): Rule
 		return new CallToNonExistentFunctionRule($this->createReflectionProvider(), true, true);
 	}
 
+	public function shouldNarrowMethodScopeFromConstructor(): bool
+	{
+		return true;
+	}
+
 	public function testEmptyFile(): void
 	{
 		$this->analyse([__DIR__ . '/data/empty.php'], []);
@@ -258,4 +263,15 @@ public function testBug10003(): void
 		]);
 	}
 
+	public function testRememberFunctionExistsFromConstructor(): void
+	{
+		$this->analyse([__DIR__ . '/data/remember-function-exists-from-constructor.php'], [
+			[
+				'Function another_unknown_function not found.',
+				32,
+				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
+			],
+		]);
+	}
+
 }
diff --git a/tests/PHPStan/Rules/Functions/data/remember-function-exists-from-constructor.php b/tests/PHPStan/Rules/Functions/data/remember-function-exists-from-constructor.php
new file mode 100644
index 0000000000..1d8640a9ae
--- /dev/null
+++ b/tests/PHPStan/Rules/Functions/data/remember-function-exists-from-constructor.php
@@ -0,0 +1,35 @@
+<?php // lint >= 7.4
+
+namespace RememberFunctionExistsFromConstructor;
+
+class User
+{
+	public function __construct(
+	) {
+		if (!function_exists('some_unknown_function')) {
+			throw new \LogicException();
+		}
+	}
+
+	public function doFoo(): void
+	{
+		some_unknown_function();
+	}
+
+}
+
+class FooUser
+{
+	public function __construct(
+	) {
+		if (!function_exists('another_unknown_function')) {
+			echo 'Function another_unknown_function does not exist';
+		}
+	}
+
+	public function doFoo(): void
+	{
+		another_unknown_function();
+	}
+
+}
diff --git a/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php b/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php
index 3b481b8f14..f389c3f628 100644
--- a/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php
+++ b/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php
@@ -16,6 +16,8 @@
 class MissingReadOnlyPropertyAssignRuleTest extends RuleTestCase
 {
 
+	private bool $shouldNarrowMethodScopeFromConstructor = false;
+
 	protected function getRule(): Rule
 	{
 		return new MissingReadOnlyPropertyAssignRule(
@@ -31,6 +33,11 @@ protected function getRule(): Rule
 		);
 	}
 
+	public function shouldNarrowMethodScopeFromConstructor(): bool
+	{
+		return $this->shouldNarrowMethodScopeFromConstructor;
+	}
+
 	protected function getReadWritePropertiesExtensions(): array
 	{
 		return [
@@ -375,6 +382,26 @@ public function testBug9863(): void
 		]);
 	}
 
+	public function testBug10048(): void
+	{
+		if (PHP_VERSION_ID < 80100) {
+			$this->markTestSkipped('Test requires PHP 8.1.');
+		}
+
+		$this->shouldNarrowMethodScopeFromConstructor = true;
+		$this->analyse([__DIR__ . '/data/bug-10048.php'], []);
+	}
+
+	public function testBug11828(): void
+	{
+		if (PHP_VERSION_ID < 80100) {
+			$this->markTestSkipped('Test requires PHP 8.1.');
+		}
+
+		$this->shouldNarrowMethodScopeFromConstructor = true;
+		$this->analyse([__DIR__ . '/data/bug-11828.php'], []);
+	}
+
 	public function testBug9864(): void
 	{
 		if (PHP_VERSION_ID < 80100) {
diff --git a/tests/PHPStan/Rules/Properties/data/bug-10048.php b/tests/PHPStan/Rules/Properties/data/bug-10048.php
new file mode 100644
index 0000000000..d537fb6527
--- /dev/null
+++ b/tests/PHPStan/Rules/Properties/data/bug-10048.php
@@ -0,0 +1,26 @@
+<?php declare(strict_types = 1); // lint >= 8.1
+
+namespace Bug10048;
+
+class Foo {
+	private readonly string $bar;
+	private readonly \Closure $callback;
+	public function __construct() {
+		$this->bar = "hi";
+		$this->useBar();
+		echo $this->bar;
+		$this->callback = function() {
+			$this->useBar();
+		};
+	}
+
+	private function useBar(): void {
+		echo $this->bar;
+	}
+
+	public function useCallback(): void {
+		call_user_func($this->callback);
+	}
+}
+
+(new Foo())->useCallback();
diff --git a/tests/PHPStan/Rules/Properties/data/bug-11828.php b/tests/PHPStan/Rules/Properties/data/bug-11828.php
new file mode 100644
index 0000000000..0a030d7bd0
--- /dev/null
+++ b/tests/PHPStan/Rules/Properties/data/bug-11828.php
@@ -0,0 +1,31 @@
+<?php declare(strict_types = 1); // lint >= 8.1
+
+namespace Bug11828;
+
+class Dummy
+{
+	/**
+	 * @var callable
+	 */
+	private $callable;
+	private readonly int $foo;
+
+	public function __construct(int $foo)
+	{
+		$this->foo = $foo;
+
+		$this->callable = function () {
+			$foo = $this->getFoo();
+		};
+	}
+
+	public function getFoo(): int
+	{
+		return $this->foo;
+	}
+
+	public function getCallable(): callable
+	{
+		return $this->callable;
+	}
+}
diff --git a/tests/PHPStan/Rules/Variables/EmptyRuleTest.php b/tests/PHPStan/Rules/Variables/EmptyRuleTest.php
index f45e41b774..6e7a5f8181 100644
--- a/tests/PHPStan/Rules/Variables/EmptyRuleTest.php
+++ b/tests/PHPStan/Rules/Variables/EmptyRuleTest.php
@@ -32,6 +32,11 @@ protected function shouldTreatPhpDocTypesAsCertain(): bool
 		return $this->treatPhpDocTypesAsCertain;
 	}
 
+	public function shouldNarrowMethodScopeFromConstructor(): bool
+	{
+		return true;
+	}
+
 	public function testRule(): void
 	{
 		$this->treatPhpDocTypesAsCertain = true;
@@ -206,4 +211,24 @@ public function testBug12658(): void
 		$this->analyse([__DIR__ . '/data/bug-12658.php'], []);
 	}
 
+	public function testIssetAfterRememberedConstructor(): void
+	{
+		if (PHP_VERSION_ID < 80000) {
+			$this->markTestSkipped('Test requires PHP 8.0.');
+		}
+
+		$this->treatPhpDocTypesAsCertain = true;
+
+		$this->analyse([__DIR__ . '/data/isset-after-remembered-constructor.php'], [
+			[
+				'Property IssetOrCoalesceOnNonNullableInitializedProperty\MoreEmptyCases::$false in empty() is always falsy.',
+				93,
+			],
+			[
+				'Property IssetOrCoalesceOnNonNullableInitializedProperty\MoreEmptyCases::$true in empty() is not falsy.',
+				95,
+			],
+		]);
+	}
+
 }
diff --git a/tests/PHPStan/Rules/Variables/IssetRuleTest.php b/tests/PHPStan/Rules/Variables/IssetRuleTest.php
index f25e40b2d7..f92076b16a 100644
--- a/tests/PHPStan/Rules/Variables/IssetRuleTest.php
+++ b/tests/PHPStan/Rules/Variables/IssetRuleTest.php
@@ -32,6 +32,11 @@ protected function shouldTreatPhpDocTypesAsCertain(): bool
 		return $this->treatPhpDocTypesAsCertain;
 	}
 
+	public function shouldNarrowMethodScopeFromConstructor(): bool
+	{
+		return true;
+	}
+
 	public function testRule(): void
 	{
 		$this->treatPhpDocTypesAsCertain = true;
@@ -480,4 +485,16 @@ public function testBug12771(): void
 		$this->analyse([__DIR__ . '/data/bug-12771.php'], []);
 	}
 
+	public function testIssetAfterRememberedConstructor(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+
+		$this->analyse([__DIR__ . '/data/isset-after-remembered-constructor.php'], [
+			[
+				'Property IssetOrCoalesceOnNonNullableInitializedProperty\User::$string in isset() is not nullable.',
+				34,
+			],
+		]);
+	}
+
 }
diff --git a/tests/PHPStan/Rules/Variables/NullCoalesceRuleTest.php b/tests/PHPStan/Rules/Variables/NullCoalesceRuleTest.php
index 0745db66a6..0e849ab84e 100644
--- a/tests/PHPStan/Rules/Variables/NullCoalesceRuleTest.php
+++ b/tests/PHPStan/Rules/Variables/NullCoalesceRuleTest.php
@@ -32,6 +32,11 @@ protected function shouldTreatPhpDocTypesAsCertain(): bool
 		return $this->treatPhpDocTypesAsCertain;
 	}
 
+	public function shouldNarrowMethodScopeFromConstructor(): bool
+	{
+		return true;
+	}
+
 	public function testCoalesceRule(): void
 	{
 		$this->treatPhpDocTypesAsCertain = true;
@@ -356,4 +361,16 @@ public function testBug12553(): void
 		$this->analyse([__DIR__ . '/data/bug-12553.php'], []);
 	}
 
+	public function testIssetAfterRememberedConstructor(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+
+		$this->analyse([__DIR__ . '/data/isset-after-remembered-constructor.php'], [
+			[
+				'Property IssetOrCoalesceOnNonNullableInitializedProperty\User::$string on left side of ?? is not nullable.',
+				46,
+			],
+		]);
+	}
+
 }
diff --git a/tests/PHPStan/Rules/Variables/data/isset-after-remembered-constructor.php b/tests/PHPStan/Rules/Variables/data/isset-after-remembered-constructor.php
new file mode 100644
index 0000000000..2c48e6249d
--- /dev/null
+++ b/tests/PHPStan/Rules/Variables/data/isset-after-remembered-constructor.php
@@ -0,0 +1,98 @@
+<?php // lint >= 8.2
+
+namespace IssetOrCoalesceOnNonNullableInitializedProperty;
+
+class User
+{
+    private ?string $nullableString;
+    private string $maybeUninitializedString;
+    private string $string;
+
+    private $untyped;
+
+    public function __construct()
+    {
+        if (rand(0, 1)) {
+            $this->nullableString = 'hello';
+            $this->string = 'world';
+            $this->maybeUninitializedString = 'something';
+        } else {
+            $this->nullableString = null;
+            $this->string = 'world 2';
+            $this->untyped = 123;
+        }
+    }
+
+    public function doFoo(): void
+    {
+        if (isset($this->maybeUninitializedString)) {
+            echo $this->maybeUninitializedString;
+        }
+        if (isset($this->nullableString)) {
+            echo $this->nullableString;
+        }
+        if (isset($this->string)) {
+            echo $this->string;
+        }
+        if (isset($this->untyped)) {
+            echo $this->untyped;
+        }
+    }
+
+    public function doBar(): void
+    {
+        echo $this->maybeUninitializedString ?? 'default';
+        echo $this->nullableString ?? 'default';
+        echo $this->string ?? 'default';
+        echo $this->untyped ?? 'default';
+    }
+
+    public function doFooBar(): void
+    {
+        if (empty($this->maybeUninitializedString)) {
+            echo $this->maybeUninitializedString;
+        }
+        if (empty($this->nullableString)) {
+            echo $this->nullableString;
+        }
+        if (empty($this->string)) {
+            echo $this->string;
+        }
+        if (empty($this->untyped)) {
+            echo $this->untyped;
+        }
+    }
+}
+
+class MoreEmptyCases
+{
+    private false|string $union;
+    private false $false;
+    private true $true;
+    private bool $bool;
+
+    public function __construct()
+    {
+        if (rand(0, 1)) {
+            $this->union = 'nope';
+            $this->bool = true;
+        } elseif (rand(10, 20)) {
+            $this->union = false;
+            $this->bool = false;
+        }
+        $this->false = false;
+        $this->true = true;
+    }
+
+    public function doFoo(): void
+    {
+        if (empty($this->union)) {
+        }
+        if (empty($this->bool)) {
+        }
+        if (empty($this->false)) {
+        }
+        if (empty($this->true)) {
+        }
+    }
+}