From 7ff11e64a4dd8fd1a17477e8544c2ccb372ca5b3 Mon Sep 17 00:00:00 2001
From: Patrik Foldes <studio22@mail.ru>
Date: Tue, 12 Nov 2019 12:31:47 +0300
Subject: [PATCH] Modernized remaining rules

---
 phpstan-baseline.neon                         | 1677 +----------------
 .../Arrays/AppendedArrayItemTypeRule.php      |   13 +-
 src/Rules/Arrays/AppendedArrayKeyTypeRule.php |   13 +-
 src/Rules/Arrays/DeadForeachRule.php          |   11 +-
 .../DuplicateKeysInLiteralArraysRule.php      |    9 +-
 .../Arrays/InvalidKeyInArrayDimFetchRule.php  |   17 +-
 .../Arrays/InvalidKeyInArrayItemRule.php      |   17 +-
 src/Rules/Arrays/IterableInForeachRule.php    |    9 +-
 .../NonexistentOffsetInArrayDimFetchRule.php  |    9 +-
 src/Rules/Arrays/OffsetAccessAssignOpRule.php |   31 +-
 .../Arrays/OffsetAccessAssignmentRule.php     |   31 +-
 .../OffsetAccessWithoutDimForReadingRule.php  |   13 +-
 .../Arrays/UnpackIterableInArrayRule.php      |    8 +-
 src/Rules/Cast/EchoRule.php                   |    9 +-
 src/Rules/Cast/InvalidCastRule.php            |    9 +-
 .../Cast/InvalidPartOfEncapsedStringRule.php  |    9 +-
 src/Rules/Cast/PrintRule.php                  |    9 +-
 .../Classes/ClassConstantDeclarationRule.php  |    8 +-
 src/Rules/Classes/ClassConstantRule.php       |   37 +-
 .../ExistingClassInClassExtendsRule.php       |    9 +-
 .../Classes/ExistingClassInInstanceOfRule.php |    9 +-
 .../Classes/ExistingClassInTraitUseRule.php   |    9 +-
 .../ExistingClassesInClassImplementsRule.php  |    9 +-
 .../ExistingClassesInInterfaceExtendsRule.php |    9 +-
 .../Classes/ImpossibleInstanceOfRule.php      |   21 +-
 src/Rules/Classes/InstantiationRule.php       |   40 +-
 src/Rules/Classes/NewStaticRule.php           |    2 +-
 .../UnusedConstructorParametersRule.php       |   13 +-
 .../BooleanAndConstantConditionRule.php       |    9 +-
 .../BooleanNotConstantConditionRule.php       |    9 +-
 .../BooleanOrConstantConditionRule.php        |    9 +-
 .../ElseIfConstantConditionRule.php           |    9 +-
 .../Comparison/IfConstantConditionRule.php    |    9 +-
 .../ImpossibleCheckTypeFunctionCallRule.php   |   33 +-
 .../ImpossibleCheckTypeMethodCallRule.php     |   37 +-
 ...mpossibleCheckTypeStaticMethodCallRule.php |   37 +-
 ...mparisonOperatorsConstantConditionRule.php |    9 +-
 .../StrictComparisonOfDifferentTypesRule.php  |   17 +-
 .../TernaryOperatorConstantConditionRule.php  |   13 +-
 .../Comparison/UnreachableIfBranchesRule.php  |    9 +-
 .../UnreachableTernaryElseBranchRule.php      |    9 +-
 src/Rules/Constants/ConstantRule.php          |   13 +-
 .../DeadCode/UnreachableStatementRule.php     |    9 +-
 .../CaughtExceptionExistenceRule.php          |    9 +-
 src/Rules/Exceptions/DeadCatchRule.php        |    9 +-
 src/Rules/FunctionCallParametersCheck.php     |   30 +-
 src/Rules/FunctionReturnTypeCheck.php         |   14 +-
 .../Functions/ArrowFunctionReturnTypeRule.php |    8 +-
 src/Rules/Functions/CallCallablesRule.php     |   21 +-
 .../CallToFunctionParametersRule.php          |    8 +-
 ...oFunctionStamentWithoutSideEffectsRule.php |   14 +-
 .../CallToNonExistentFunctionRule.php         |   21 +-
 src/Rules/Functions/ClosureReturnTypeRule.php |    8 +-
 ...ingClassesInArrowFunctionTypehintsRule.php |    9 +-
 .../ExistingClassesInClosureTypehintsRule.php |    9 +-
 .../ExistingClassesInTypehintsRule.php        |    9 +-
 .../IncompatibleDefaultParameterTypeRule.php  |    9 +-
 src/Rules/Functions/InnerFunctionRule.php     |   13 +-
 .../NonExistentDefinedFunctionRule.php        |   13 +-
 src/Rules/Functions/PrintfParametersRule.php  |   13 +-
 src/Rules/Functions/ReturnTypeRule.php        |    8 +-
 src/Rules/Functions/UnusedClosureUsesRule.php |    8 +-
 src/Rules/Generators/YieldFromTypeRule.php    |    9 +-
 src/Rules/Generators/YieldInGeneratorRule.php |    9 +-
 src/Rules/Generators/YieldTypeRule.php        |    9 +-
 src/Rules/Generics/ClassAncestorsRule.php     |    8 +-
 src/Rules/Generics/ClassTemplateTypeRule.php  |    8 +-
 .../Generics/FunctionTemplateTypeRule.php     |    8 +-
 src/Rules/Generics/InterfaceAncestorsRule.php |    8 +-
 .../Generics/InterfaceTemplateTypeRule.php    |    8 +-
 src/Rules/Generics/MethodTemplateTypeRule.php |    8 +-
 src/Rules/Generics/TraitTemplateTypeRule.php  |    8 +-
 src/Rules/Methods/CallMethodsRule.php         |   31 +-
 src/Rules/Methods/CallStaticMethodsRule.php   |   47 +-
 ...lToMethodStamentWithoutSideEffectsRule.php |   13 +-
 ...ticMethodStamentWithoutSideEffectsRule.php |   13 +-
 .../ExistingClassesInTypehintsRule.php        |    9 +-
 .../IncompatibleDefaultParameterTypeRule.php  |    9 +-
 src/Rules/Methods/MethodSignatureRule.php     |   17 +-
 src/Rules/Methods/ReturnTypeRule.php          |    8 +-
 ...MissingClosureNativeReturnTypehintRule.php |    9 +-
 src/Rules/Missing/MissingReturnRule.php       |    9 +-
 .../ExistingNamesInGroupUseRule.php           |    8 +-
 .../Namespaces/ExistingNamesInUseRule.php     |    8 +-
 .../Operators/InvalidBinaryOperationRule.php  |    9 +-
 .../InvalidComparisonOperationRule.php        |    9 +-
 .../Operators/InvalidIncDecOperationRule.php  |    9 +-
 .../Operators/InvalidUnaryOperationRule.php   |    9 +-
 .../PhpDoc/IncompatiblePhpDocTypeRule.php     |    8 +-
 .../IncompatiblePropertyPhpDocTypeRule.php    |    8 +-
 .../PhpDoc/InvalidPhpDocTagValueRule.php      |   13 +-
 .../PhpDoc/InvalidPhpDocVarTagTypeRule.php    |    8 +-
 .../PhpDoc/InvalidThrowsPhpDocValueRule.php   |   19 +-
 .../PhpDoc/WrongVariableNameInVarTagRule.php  |    8 +-
 .../AccessPropertiesInAssignRule.php          |    8 +-
 src/Rules/Properties/AccessPropertiesRule.php |   27 +-
 .../AccessStaticPropertiesInAssignRule.php    |    8 +-
 .../Properties/AccessStaticPropertiesRule.php |   43 +-
 ...aultValueTypesAssignedToPropertiesRule.php |   13 +-
 .../ExistingClassesInPropertiesRule.php       |    9 +-
 .../ReadingWriteOnlyPropertiesRule.php        |   13 +-
 .../TypesAssignedToPropertiesRule.php         |   13 +-
 .../WritingToReadOnlyPropertiesRule.php       |   13 +-
 .../Regexp/RegularExpressionPatternRule.php   |   11 +-
 .../TooWideClosureReturnTypehintRule.php      |   14 +-
 .../TooWideFunctionReturnTypehintRule.php     |   15 +-
 .../TooWideMethodReturnTypehintRule.php       |   16 +-
 src/Rules/UnusedFunctionParametersCheck.php   |    4 +-
 ...inedVariableInAnonymousFunctionUseRule.php |   13 +-
 src/Rules/Variables/DefinedVariableRule.php   |   13 +-
 src/Rules/Variables/ThisVariableRule.php      |   15 +-
 src/Rules/Variables/ThrowTypeRule.php         |   14 +-
 .../VariableCertaintyInIssetRule.php          |   24 +-
 src/Rules/Variables/VariableCloningRule.php   |   18 +-
 tests/PHPStan/Rules/AlwaysFailRule.php        |    3 +
 .../Arrays/AppendedArrayItemTypeRuleTest.php  |    3 +
 .../Arrays/AppendedArrayKeyTypeRuleTest.php   |    3 +
 .../Rules/Arrays/DeadForeachRuleTest.php      |    3 +
 .../DuplicateKeysInLiteralArraysRuleTest.php  |    3 +
 .../InvalidKeyInArrayDimFetchRuleTest.php     |    3 +
 .../Arrays/InvalidKeyInArrayItemRuleTest.php  |    3 +
 .../Arrays/IterableInForeachRuleTest.php      |    3 +
 ...nexistentOffsetInArrayDimFetchRuleTest.php |    3 +
 .../Arrays/OffsetAccessAssignOpRuleTest.php   |    3 +
 .../Arrays/OffsetAccessAssignmentRuleTest.php |    3 +
 ...fsetAccessWithoutDimForReadingRuleTest.php |    3 +
 .../Arrays/UnpackIterableInArrayRuleTest.php  |    3 +
 tests/PHPStan/Rules/Cast/EchoRuleTest.php     |    3 +
 .../Rules/Cast/InvalidCastRuleTest.php        |    3 +
 .../InvalidPartOfEncapsedStringRuleTest.php   |    3 +
 tests/PHPStan/Rules/Cast/PrintRuleTest.php    |    3 +
 .../Rules/Classes/ClassConstantRuleTest.php   |    3 +
 .../ExistingClassInClassExtendsRuleTest.php   |    3 +
 .../ExistingClassInInstanceOfRuleTest.php     |    3 +
 .../ExistingClassInTraitUseRuleTest.php       |    3 +
 ...istingClassesInClassImplementsRuleTest.php |    3 +
 ...stingClassesInInterfaceExtendsRuleTest.php |    3 +
 .../Classes/ImpossibleInstanceOfRuleTest.php  |    3 +
 .../Rules/Classes/InstantiationRuleTest.php   |    3 +
 .../UnusedConstructorParametersRuleTest.php   |    3 +
 .../BooleanAndConstantConditionRuleTest.php   |    3 +
 .../BooleanNotConstantConditionRuleTest.php   |    3 +
 .../BooleanOrConstantConditionRuleTest.php    |    3 +
 .../ElseIfConstantConditionRuleTest.php       |    3 +
 .../IfConstantConditionRuleTest.php           |    3 +
 ...mpossibleCheckTypeFunctionCallRuleTest.php |    3 +
 .../ImpossibleCheckTypeMethodCallRuleTest.php |    3 +
 ...sibleCheckTypeStaticMethodCallRuleTest.php |    3 +
 ...isonOperatorsConstantConditionRuleTest.php |    3 +
 ...rictComparisonOfDifferentTypesRuleTest.php |    3 +
 ...rnaryOperatorConstantConditionRuleTest.php |    3 +
 .../UnreachableIfBranchesRuleTest.php         |    3 +
 .../UnreachableTernaryElseBranchRuleTest.php  |    3 +
 .../Rules/Constants/ConstantRuleTest.php      |    3 +
 .../DeadCode/UnreachableStatementRuleTest.php |    3 +
 tests/PHPStan/Rules/DummyRule.php             |    8 +-
 .../CaughtExceptionExistenceRuleTest.php      |    3 +
 .../Rules/Exceptions/DeadCatchRuleTest.php    |    3 +
 .../ArrowFunctionReturnTypeRuleTest.php       |    3 +
 .../Rules/Functions/CallCallablesRuleTest.php |    3 +
 .../CallToFunctionParametersRuleTest.php      |    3 +
 ...ctionStamentWithoutSideEffectsRuleTest.php |    3 +
 .../CallToNonExistentFunctionRuleTest.php     |    3 +
 .../Functions/ClosureReturnTypeRuleTest.php   |    3 +
 ...lassesInArrowFunctionTypehintsRuleTest.php |    3 +
 ...stingClassesInClosureTypehintsRuleTest.php |    3 +
 .../ExistingClassesInTypehintsRuleTest.php    |    3 +
 ...compatibleDefaultParameterTypeRuleTest.php |    3 +
 .../Rules/Functions/InnerFunctionRuleTest.php |    3 +
 .../Functions/PrintfParametersRuleTest.php    |    3 +
 .../Rules/Functions/ReturnTypeRuleTest.php    |    3 +
 .../Functions/UnusedClosureUsesRuleTest.php   |    3 +
 .../Generators/YieldFromTypeRuleTest.php      |    3 +
 .../Generators/YieldInGeneratorRuleTest.php   |    3 +
 .../Rules/Generators/YieldTypeRuleTest.php    |    3 +
 .../Rules/Generics/ClassAncestorsRuleTest.php |    3 +
 .../Generics/ClassTemplateTypeRuleTest.php    |    3 +
 .../Generics/FunctionTemplateTypeRuleTest.php |    3 +
 .../Generics/InterfaceAncestorsRuleTest.php   |    3 +
 .../InterfaceTemplateTypeRuleTest.php         |    3 +
 .../Generics/MethodTemplateTypeRuleTest.php   |    3 +
 .../Generics/TraitTemplateTypeRuleTest.php    |    3 +
 .../Rules/Methods/CallMethodsRuleTest.php     |    3 +
 .../Methods/CallStaticMethodsRuleTest.php     |    3 +
 ...ethodStamentWithoutSideEffectsRuleTest.php |    3 +
 ...ethodStamentWithoutSideEffectsRuleTest.php |    3 +
 .../ExistingClassesInTypehintsRuleTest.php    |    3 +
 ...compatibleDefaultParameterTypeRuleTest.php |    3 +
 .../Rules/Methods/MethodSignatureRuleTest.php |    3 +
 .../Rules/Methods/ReturnTypeRuleTest.php      |    3 +
 ...ingClosureNativeReturnTypehintRuleTest.php |    3 +
 .../Rules/Missing/MissingReturnRuleTest.php   |    3 +
 .../ExistingNamesInGroupUseRuleTest.php       |    3 +
 .../Namespaces/ExistingNamesInUseRuleTest.php |    3 +
 .../InvalidBinaryOperationRuleTest.php        |    3 +
 .../InvalidComparisonOperationRuleTest.php    |    3 +
 .../InvalidIncDecOperationRuleTest.php        |    3 +
 .../InvalidUnaryOperationRuleTest.php         |    3 +
 .../PhpDoc/IncompatiblePhpDocTypeRuleTest.php |    3 +
 ...IncompatiblePropertyPhpDocTypeRuleTest.php |    3 +
 .../PhpDoc/InvalidPhpDocTagValueRuleTest.php  |    3 +
 .../InvalidPhpDocVarTagTypeRuleTest.php       |    3 +
 .../InvalidThrowsPhpDocValueRuleTest.php      |    3 +
 .../WrongVariableNameInVarTagRuleTest.php     |    3 +
 .../AccessPropertiesInAssignRuleTest.php      |    3 +
 .../Properties/AccessPropertiesRuleTest.php   |    3 +
 ...AccessStaticPropertiesInAssignRuleTest.php |    3 +
 .../AccessStaticPropertiesRuleTest.php        |    3 +
 ...ValueTypesAssignedToPropertiesRuleTest.php |    3 +
 .../ExistingClassesInPropertiesRuleTest.php   |    3 +
 .../ReadingWriteOnlyPropertiesRuleTest.php    |    3 +
 .../TypesAssignedToPropertiesRuleTest.php     |    3 +
 .../WritingToReadOnlyPropertiesRuleTest.php   |    3 +
 .../RegularExpressionPatternRuleTest.php      |    3 +
 .../TooWideClosureReturnTypehintRuleTest.php  |    3 +
 .../TooWideFunctionReturnTypehintRuleTest.php |    3 +
 .../TooWideMethodReturnTypehintRuleTest.php   |    3 +
 ...VariableInAnonymousFunctionUseRuleTest.php |    3 +
 .../Variables/DefinedVariableRuleTest.php     |    3 +
 .../Rules/Variables/ThisVariableRuleTest.php  |    3 +
 .../Rules/Variables/ThrowTypeRuleTest.php     |    3 +
 .../VariableCertaintyInIssetRuleTest.php      |    3 +
 222 files changed, 1066 insertions(+), 2455 deletions(-)

diff --git a/phpstan-baseline.neon b/phpstan-baseline.neon
index e371126854..d02ecc0e35 100644
--- a/phpstan-baseline.neon
+++ b/phpstan-baseline.neon
@@ -133,1693 +133,78 @@ parameters:
 			path: src/Reflection/Php/PhpClassReflectionExtension.php
 
 		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\AppendedArrayItemTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Arrays/AppendedArrayItemTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\AppendedArrayKeyTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Arrays/AppendedArrayKeyTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\DeadForeachRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Arrays/DeadForeachRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\DuplicateKeysInLiteralArraysRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Arrays/DuplicateKeysInLiteralArraysRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\InvalidKeyInArrayDimFetchRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Arrays/InvalidKeyInArrayDimFetchRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\InvalidKeyInArrayItemRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Arrays/InvalidKeyInArrayItemRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\IterableInForeachRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Arrays/IterableInForeachRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\NonexistentOffsetInArrayDimFetchRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Arrays/NonexistentOffsetInArrayDimFetchRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\OffsetAccessAssignOpRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Arrays/OffsetAccessAssignOpRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\OffsetAccessAssignmentRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Arrays/OffsetAccessAssignmentRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\OffsetAccessWithoutDimForReadingRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Arrays/OffsetAccessWithoutDimForReadingRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\UnpackIterableInArrayRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Arrays/UnpackIterableInArrayRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Cast\\\\EchoRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Cast/EchoRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Cast\\\\InvalidCastRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Cast/InvalidCastRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Cast\\\\InvalidPartOfEncapsedStringRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Cast/InvalidPartOfEncapsedStringRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Cast\\\\PrintRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Cast/PrintRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ClassConstantDeclarationRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Classes/ClassConstantDeclarationRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ClassConstantRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Classes/ClassConstantRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ExistingClassInClassExtendsRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Classes/ExistingClassInClassExtendsRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ExistingClassInInstanceOfRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Classes/ExistingClassInInstanceOfRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ExistingClassInTraitUseRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Classes/ExistingClassInTraitUseRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ExistingClassesInClassImplementsRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Classes/ExistingClassesInClassImplementsRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ExistingClassesInInterfaceExtendsRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Classes/ExistingClassesInInterfaceExtendsRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ImpossibleInstanceOfRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Classes/ImpossibleInstanceOfRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\InstantiationRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Classes/InstantiationRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\UnusedConstructorParametersRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Classes/UnusedConstructorParametersRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\BooleanAndConstantConditionRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Comparison/BooleanAndConstantConditionRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\BooleanNotConstantConditionRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Comparison/BooleanNotConstantConditionRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\BooleanOrConstantConditionRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Comparison/BooleanOrConstantConditionRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\ElseIfConstantConditionRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Comparison/ElseIfConstantConditionRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\IfConstantConditionRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Comparison/IfConstantConditionRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\ImpossibleCheckTypeFunctionCallRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Comparison/ImpossibleCheckTypeFunctionCallRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\ImpossibleCheckTypeMethodCallRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Comparison/ImpossibleCheckTypeMethodCallRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\ImpossibleCheckTypeStaticMethodCallRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\NumberComparisonOperatorsConstantConditionRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Comparison/NumberComparisonOperatorsConstantConditionRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\StrictComparisonOfDifferentTypesRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Comparison/StrictComparisonOfDifferentTypesRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\TernaryOperatorConstantConditionRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Comparison/TernaryOperatorConstantConditionRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\UnreachableIfBranchesRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Comparison/UnreachableIfBranchesRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\UnreachableTernaryElseBranchRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Comparison/UnreachableTernaryElseBranchRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Constants\\\\ConstantRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Constants/ConstantRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\DeadCode\\\\UnreachableStatementRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/DeadCode/UnreachableStatementRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Exceptions\\\\CaughtExceptionExistenceRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Exceptions/CaughtExceptionExistenceRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Exceptions\\\\DeadCatchRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Exceptions/DeadCatchRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\ArrowFunctionReturnTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/ArrowFunctionReturnTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\CallCallablesRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/CallCallablesRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\CallToFunctionParametersRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/CallToFunctionParametersRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\CallToFunctionStamentWithoutSideEffectsRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/CallToFunctionStamentWithoutSideEffectsRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\CallToNonExistentFunctionRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/CallToNonExistentFunctionRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\ClosureReturnTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/ClosureReturnTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\ExistingClassesInArrowFunctionTypehintsRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\ExistingClassesInClosureTypehintsRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/ExistingClassesInClosureTypehintsRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\ExistingClassesInTypehintsRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/ExistingClassesInTypehintsRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\IncompatibleDefaultParameterTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/IncompatibleDefaultParameterTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\InnerFunctionRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/InnerFunctionRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\NonExistentDefinedFunctionRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/NonExistentDefinedFunctionRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\PrintfParametersRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/PrintfParametersRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\ReturnTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/ReturnTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\UnusedClosureUsesRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Functions/UnusedClosureUsesRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generators\\\\YieldFromTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Generators/YieldFromTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generators\\\\YieldInGeneratorRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Generators/YieldInGeneratorRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generators\\\\YieldTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Generators/YieldTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generics\\\\ClassAncestorsRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Generics/ClassAncestorsRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generics\\\\ClassTemplateTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Generics/ClassTemplateTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generics\\\\FunctionTemplateTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Generics/FunctionTemplateTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generics\\\\InterfaceAncestorsRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Generics/InterfaceAncestorsRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generics\\\\InterfaceTemplateTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Generics/InterfaceTemplateTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generics\\\\MethodTemplateTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Generics/MethodTemplateTypeRule.php
-
-		-
-			message: "#^Cannot call method toString\\(\\) on PhpParser\\\\Node\\\\Identifier\\|null\\.$#"
-			count: 1
-			path: src/Rules/Generics/MethodTemplateTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generics\\\\TraitTemplateTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Generics/TraitTemplateTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\CallMethodsRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Methods/CallMethodsRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\CallToMethodStamentWithoutSideEffectsRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Methods/CallToMethodStamentWithoutSideEffectsRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\CallToStaticMethodStamentWithoutSideEffectsRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Methods/CallToStaticMethodStamentWithoutSideEffectsRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\ExistingClassesInTypehintsRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Methods/ExistingClassesInTypehintsRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\IncompatibleDefaultParameterTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Methods/IncompatibleDefaultParameterTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\MethodSignatureRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Methods/MethodSignatureRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\ReturnTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Methods/ReturnTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Missing\\\\MissingClosureNativeReturnTypehintRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Missing/MissingClosureNativeReturnTypehintRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Missing\\\\MissingReturnRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Missing/MissingReturnRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Namespaces\\\\ExistingNamesInGroupUseRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Namespaces/ExistingNamesInGroupUseRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Namespaces\\\\ExistingNamesInUseRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Namespaces/ExistingNamesInUseRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Operators\\\\InvalidBinaryOperationRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Operators/InvalidBinaryOperationRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Operators\\\\InvalidComparisonOperationRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Operators/InvalidComparisonOperationRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Operators\\\\InvalidIncDecOperationRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Operators/InvalidIncDecOperationRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Operators\\\\InvalidUnaryOperationRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Operators/InvalidUnaryOperationRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\PhpDoc\\\\IncompatiblePhpDocTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/PhpDoc/IncompatiblePhpDocTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\PhpDoc\\\\IncompatiblePropertyPhpDocTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\PhpDoc\\\\InvalidPhpDocTagValueRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/PhpDoc/InvalidPhpDocTagValueRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\PhpDoc\\\\InvalidPhpDocVarTagTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/PhpDoc/InvalidPhpDocVarTagTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\PhpDoc\\\\InvalidThrowsPhpDocValueRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/PhpDoc/InvalidThrowsPhpDocValueRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\PhpDoc\\\\WrongVariableNameInVarTagRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/PhpDoc/WrongVariableNameInVarTagRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\AccessPropertiesInAssignRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Properties/AccessPropertiesInAssignRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\AccessPropertiesRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Properties/AccessPropertiesRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\AccessStaticPropertiesInAssignRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Properties/AccessStaticPropertiesInAssignRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\AccessStaticPropertiesRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Properties/AccessStaticPropertiesRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\DefaultValueTypesAssignedToPropertiesRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Properties/DefaultValueTypesAssignedToPropertiesRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\ExistingClassesInPropertiesRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Properties/ExistingClassesInPropertiesRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\ReadingWriteOnlyPropertiesRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Properties/ReadingWriteOnlyPropertiesRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\TypesAssignedToPropertiesRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Properties/TypesAssignedToPropertiesRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\WritingToReadOnlyPropertiesRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Properties/WritingToReadOnlyPropertiesRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Regexp\\\\RegularExpressionPatternRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Regexp/RegularExpressionPatternRule.php
-
-		-
-			message: "#^Property PHPStan\\\\Rules\\\\Registry\\:\\:\\$rules with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Registry.php
-
-		-
-			message: "#^Property PHPStan\\\\Rules\\\\Registry\\:\\:\\$cache with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Registry.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Registry\\:\\:__construct\\(\\) has parameter \\$rules with generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Registry.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\TooWideTypehints\\\\TooWideClosureReturnTypehintRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/TooWideTypehints/TooWideClosureReturnTypehintRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\TooWideTypehints\\\\TooWideFunctionReturnTypehintRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\TooWideTypehints\\\\TooWideMethodReturnTypehintRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/TooWideTypehints/TooWideMethodReturnTypehintRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Variables\\\\DefinedVariableInAnonymousFunctionUseRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Variables/DefinedVariableInAnonymousFunctionUseRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Variables\\\\DefinedVariableRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Variables/DefinedVariableRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Variables\\\\ThisVariableRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Variables/ThisVariableRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Variables\\\\ThrowTypeRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Variables/ThrowTypeRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Variables\\\\VariableCertaintyInIssetRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Variables/VariableCertaintyInIssetRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Variables\\\\VariableCloningRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Rules/Variables/VariableCloningRule.php
-
-		-
-			message: "#^Method PHPStan\\\\Testing\\\\RuleTestCase\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: src/Testing/RuleTestCase.php
-
-		-
-			message: "#^Parameter \\#1 \\$rules of class PHPStan\\\\Rules\\\\Registry constructor expects array\\<PHPStan\\\\Rules\\\\Rule\\>, array\\<int, TRule of PHPStan\\\\Rules\\\\Rule\\> given\\.$#"
-			count: 1
-			path: src/Testing/RuleTestCase.php
-
-		-
-			message: "#^Cannot call method getActiveTemplateTypeMap\\(\\) on PHPStan\\\\Reflection\\\\ClassReflection\\|null\\.$#"
-			count: 2
-			path: src/Type/Generic/GenericObjectType.php
-
-		-
-			message: "#^Class PHPStan\\\\Analyser\\\\AnonymousClassNameRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Analyser/AnonymousClassNameRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Analyser\\\\AnonymousClassNameRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Analyser/AnonymousClassNameRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Analyser\\\\AnonymousClassNameRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Analyser/AnonymousClassNameRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Analyser\\\\EvaluationOrderRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Analyser/EvaluationOrderRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Analyser\\\\EvaluationOrderTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Analyser/EvaluationOrderTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Analyser\\\\EvaluationOrderTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Analyser/EvaluationOrderTest.php
-
-		-
-			message: "#^Constant SOME_CONSTANT_IN_AUTOLOAD_FILE not found\\.$#"
-			count: 1
-			path: tests/PHPStan/Command/AnalyseCommandTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Node\\\\FileNodeTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Node/FileNodeTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Node\\\\FileNodeTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Node/FileNodeTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\AlwaysFailRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/AlwaysFailRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\AppendedArrayItemTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/AppendedArrayItemTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Arrays\\\\AppendedArrayItemTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/AppendedArrayItemTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\AppendedArrayKeyTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/AppendedArrayKeyTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Arrays\\\\AppendedArrayKeyTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/AppendedArrayKeyTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\DeadForeachRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/DeadForeachRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Arrays\\\\DeadForeachRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/DeadForeachRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\DuplicateKeysInLiteralArraysRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/DuplicateKeysInLiteralArraysRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Arrays\\\\DuplicateKeysInLiteralArraysRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/DuplicateKeysInLiteralArraysRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\InvalidKeyInArrayDimFetchRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/InvalidKeyInArrayDimFetchRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Arrays\\\\InvalidKeyInArrayDimFetchRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/InvalidKeyInArrayDimFetchRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\InvalidKeyInArrayItemRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/InvalidKeyInArrayItemRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Arrays\\\\InvalidKeyInArrayItemRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/InvalidKeyInArrayItemRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\IterableInForeachRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/IterableInForeachRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Arrays\\\\IterableInForeachRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/IterableInForeachRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\NonexistentOffsetInArrayDimFetchRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/NonexistentOffsetInArrayDimFetchRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Arrays\\\\NonexistentOffsetInArrayDimFetchRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/NonexistentOffsetInArrayDimFetchRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\OffsetAccessAssignOpRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/OffsetAccessAssignOpRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Arrays\\\\OffsetAccessAssignOpRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/OffsetAccessAssignOpRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\OffsetAccessAssignmentRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/OffsetAccessAssignmentRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Arrays\\\\OffsetAccessAssignmentRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/OffsetAccessAssignmentRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\OffsetAccessWithoutDimForReadingRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/OffsetAccessWithoutDimForReadingRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Arrays\\\\OffsetAccessWithoutDimForReadingRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/OffsetAccessWithoutDimForReadingRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Arrays\\\\UnpackIterableInArrayRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/UnpackIterableInArrayRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Arrays\\\\UnpackIterableInArrayRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Arrays/UnpackIterableInArrayRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Cast\\\\EchoRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Cast/EchoRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Cast\\\\EchoRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Cast/EchoRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Cast\\\\InvalidCastRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Cast/InvalidCastRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Cast\\\\InvalidCastRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Cast/InvalidCastRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Cast\\\\InvalidPartOfEncapsedStringRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Cast/InvalidPartOfEncapsedStringRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Cast\\\\InvalidPartOfEncapsedStringRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Cast/InvalidPartOfEncapsedStringRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Cast\\\\PrintRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Cast/PrintRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Cast\\\\PrintRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Cast/PrintRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ClassConstantRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Classes\\\\ClassConstantRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ExistingClassInClassExtendsRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Classes\\\\ExistingClassInClassExtendsRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ExistingClassInInstanceOfRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Classes\\\\ExistingClassInInstanceOfRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ExistingClassInTraitUseRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Classes\\\\ExistingClassInTraitUseRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ExistingClassesInClassImplementsRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Classes\\\\ExistingClassesInClassImplementsRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ExistingClassesInInterfaceExtendsRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Classes\\\\ExistingClassesInInterfaceExtendsRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\ImpossibleInstanceOfRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/ImpossibleInstanceOfRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Classes\\\\ImpossibleInstanceOfRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/ImpossibleInstanceOfRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\InstantiationRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/InstantiationRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Classes\\\\InstantiationRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/InstantiationRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Classes\\\\UnusedConstructorParametersRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/UnusedConstructorParametersRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Classes\\\\UnusedConstructorParametersRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Classes/UnusedConstructorParametersRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\BooleanAndConstantConditionRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/BooleanAndConstantConditionRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Comparison\\\\BooleanAndConstantConditionRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/BooleanAndConstantConditionRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\BooleanNotConstantConditionRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/BooleanNotConstantConditionRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Comparison\\\\BooleanNotConstantConditionRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/BooleanNotConstantConditionRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\BooleanOrConstantConditionRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/BooleanOrConstantConditionRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Comparison\\\\BooleanOrConstantConditionRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/BooleanOrConstantConditionRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\ElseIfConstantConditionRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/ElseIfConstantConditionRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Comparison\\\\ElseIfConstantConditionRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/ElseIfConstantConditionRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\IfConstantConditionRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/IfConstantConditionRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Comparison\\\\IfConstantConditionRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/IfConstantConditionRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\ImpossibleCheckTypeFunctionCallRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeFunctionCallRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Comparison\\\\ImpossibleCheckTypeFunctionCallRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeFunctionCallRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\ImpossibleCheckTypeMethodCallRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeMethodCallRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Comparison\\\\ImpossibleCheckTypeMethodCallRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeMethodCallRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\ImpossibleCheckTypeStaticMethodCallRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Comparison\\\\ImpossibleCheckTypeStaticMethodCallRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\NumberComparisonOperatorsConstantConditionRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/NumberComparisonOperatorsConstantConditionRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Comparison\\\\NumberComparisonOperatorsConstantConditionRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/NumberComparisonOperatorsConstantConditionRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\StrictComparisonOfDifferentTypesRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/StrictComparisonOfDifferentTypesRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Comparison\\\\StrictComparisonOfDifferentTypesRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/StrictComparisonOfDifferentTypesRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\TernaryOperatorConstantConditionRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/TernaryOperatorConstantConditionRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Comparison\\\\TernaryOperatorConstantConditionRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/TernaryOperatorConstantConditionRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\UnreachableIfBranchesRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/UnreachableIfBranchesRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Comparison\\\\UnreachableIfBranchesRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/UnreachableIfBranchesRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Comparison\\\\UnreachableTernaryElseBranchRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/UnreachableTernaryElseBranchRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Comparison\\\\UnreachableTernaryElseBranchRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Comparison/UnreachableTernaryElseBranchRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Constants\\\\ConstantRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Constants/ConstantRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Constants\\\\ConstantRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Constants/ConstantRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\DeadCode\\\\UnreachableStatementRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/DeadCode/UnreachableStatementRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\DeadCode\\\\UnreachableStatementRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/DeadCode/UnreachableStatementRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\DummyRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/DummyRule.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Exceptions\\\\CaughtExceptionExistenceRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Exceptions\\\\CaughtExceptionExistenceRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Exceptions\\\\DeadCatchRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Exceptions/DeadCatchRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Exceptions\\\\DeadCatchRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Exceptions/DeadCatchRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\ArrowFunctionReturnTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/ArrowFunctionReturnTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Functions\\\\ArrowFunctionReturnTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/ArrowFunctionReturnTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\CallCallablesRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/CallCallablesRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Functions\\\\CallCallablesRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/CallCallablesRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\CallToFunctionParametersRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/CallToFunctionParametersRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Functions\\\\CallToFunctionParametersRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/CallToFunctionParametersRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\CallToFunctionStamentWithoutSideEffectsRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/CallToFunctionStamentWithoutSideEffectsRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Functions\\\\CallToFunctionStamentWithoutSideEffectsRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/CallToFunctionStamentWithoutSideEffectsRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\CallToNonExistentFunctionRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/CallToNonExistentFunctionRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Functions\\\\CallToNonExistentFunctionRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/CallToNonExistentFunctionRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\ClosureReturnTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/ClosureReturnTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Functions\\\\ClosureReturnTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/ClosureReturnTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\ExistingClassesInArrowFunctionTypehintsRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Functions\\\\ExistingClassesInArrowFunctionTypehintsRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\ExistingClassesInClosureTypehintsRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Functions\\\\ExistingClassesInClosureTypehintsRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\ExistingClassesInTypehintsRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Functions\\\\ExistingClassesInTypehintsRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\IncompatibleDefaultParameterTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/IncompatibleDefaultParameterTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Functions\\\\IncompatibleDefaultParameterTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/IncompatibleDefaultParameterTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\InnerFunctionRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/InnerFunctionRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Functions\\\\InnerFunctionRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/InnerFunctionRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\PrintfParametersRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/PrintfParametersRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Functions\\\\PrintfParametersRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/PrintfParametersRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\ReturnTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/ReturnTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Functions\\\\ReturnTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/ReturnTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Functions\\\\UnusedClosureUsesRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/UnusedClosureUsesRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Functions\\\\UnusedClosureUsesRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Functions/UnusedClosureUsesRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generators\\\\YieldFromTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generators/YieldFromTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Generators\\\\YieldFromTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generators/YieldFromTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generators\\\\YieldInGeneratorRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generators/YieldInGeneratorRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Generators\\\\YieldInGeneratorRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generators/YieldInGeneratorRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generators\\\\YieldTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generators/YieldTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Generators\\\\YieldTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generators/YieldTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generics\\\\ClassAncestorsRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generics/ClassAncestorsRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Generics\\\\ClassAncestorsRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generics/ClassAncestorsRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generics\\\\ClassTemplateTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Generics\\\\ClassTemplateTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generics\\\\FunctionTemplateTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Generics\\\\FunctionTemplateTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generics\\\\InterfaceAncestorsRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generics/InterfaceAncestorsRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Generics\\\\InterfaceAncestorsRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generics/InterfaceAncestorsRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generics\\\\InterfaceTemplateTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Generics\\\\InterfaceTemplateTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generics\\\\MethodTemplateTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Generics\\\\MethodTemplateTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Generics\\\\TraitTemplateTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Generics\\\\TraitTemplateTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\CallMethodsRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/CallMethodsRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Methods\\\\CallMethodsRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/CallMethodsRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\CallStaticMethodsRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Methods\\\\CallStaticMethodsRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\CallToMethodStamentWithoutSideEffectsRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/CallToMethodStamentWithoutSideEffectsRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Methods\\\\CallToMethodStamentWithoutSideEffectsRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/CallToMethodStamentWithoutSideEffectsRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\CallToStaticMethodStamentWithoutSideEffectsRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/CallToStaticMethodStamentWithoutSideEffectsRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Methods\\\\CallToStaticMethodStamentWithoutSideEffectsRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/CallToStaticMethodStamentWithoutSideEffectsRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\ExistingClassesInTypehintsRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Methods\\\\ExistingClassesInTypehintsRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\IncompatibleDefaultParameterTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/IncompatibleDefaultParameterTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Methods\\\\IncompatibleDefaultParameterTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/IncompatibleDefaultParameterTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\MethodSignatureRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/MethodSignatureRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Methods\\\\MethodSignatureRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/MethodSignatureRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Methods\\\\ReturnTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/ReturnTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Methods\\\\ReturnTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Methods/ReturnTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Missing\\\\MissingClosureNativeReturnTypehintRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Missing/MissingClosureNativeReturnTypehintRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Missing\\\\MissingClosureNativeReturnTypehintRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Missing/MissingClosureNativeReturnTypehintRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Missing\\\\MissingReturnRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Missing/MissingReturnRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Missing\\\\MissingReturnRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Missing/MissingReturnRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Namespaces\\\\ExistingNamesInGroupUseRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Namespaces\\\\ExistingNamesInGroupUseRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Namespaces\\\\ExistingNamesInUseRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Namespaces\\\\ExistingNamesInUseRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Operators\\\\InvalidBinaryOperationRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Operators/InvalidBinaryOperationRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Operators\\\\InvalidBinaryOperationRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Operators/InvalidBinaryOperationRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Operators\\\\InvalidComparisonOperationRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Operators/InvalidComparisonOperationRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Operators\\\\InvalidComparisonOperationRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Operators/InvalidComparisonOperationRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Operators\\\\InvalidIncDecOperationRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Operators/InvalidIncDecOperationRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Operators\\\\InvalidIncDecOperationRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Operators/InvalidIncDecOperationRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Operators\\\\InvalidUnaryOperationRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Operators/InvalidUnaryOperationRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Operators\\\\InvalidUnaryOperationRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Operators/InvalidUnaryOperationRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\PhpDoc\\\\IncompatiblePhpDocTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\PhpDoc\\\\IncompatiblePhpDocTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\PhpDoc\\\\IncompatiblePropertyPhpDocTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\PhpDoc\\\\IncompatiblePropertyPhpDocTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\PhpDoc\\\\InvalidPhpDocTagValueRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/PhpDoc/InvalidPhpDocTagValueRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\PhpDoc\\\\InvalidPhpDocTagValueRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/PhpDoc/InvalidPhpDocTagValueRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\PhpDoc\\\\InvalidPhpDocVarTagTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\PhpDoc\\\\InvalidPhpDocVarTagTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\PhpDoc\\\\InvalidThrowsPhpDocValueRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/PhpDoc/InvalidThrowsPhpDocValueRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\PhpDoc\\\\InvalidThrowsPhpDocValueRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/PhpDoc/InvalidThrowsPhpDocValueRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\PhpDoc\\\\WrongVariableNameInVarTagRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/PhpDoc/WrongVariableNameInVarTagRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\PhpDoc\\\\WrongVariableNameInVarTagRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/PhpDoc/WrongVariableNameInVarTagRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\AccessPropertiesInAssignRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/AccessPropertiesInAssignRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Properties\\\\AccessPropertiesInAssignRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/AccessPropertiesInAssignRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\AccessPropertiesRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/AccessPropertiesRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Properties\\\\AccessPropertiesRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/AccessPropertiesRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\AccessStaticPropertiesInAssignRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Properties\\\\AccessStaticPropertiesInAssignRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\AccessStaticPropertiesRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Properties\\\\AccessStaticPropertiesRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\DefaultValueTypesAssignedToPropertiesRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/DefaultValueTypesAssignedToPropertiesRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Properties\\\\DefaultValueTypesAssignedToPropertiesRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/DefaultValueTypesAssignedToPropertiesRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\ExistingClassesInPropertiesRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Properties\\\\ExistingClassesInPropertiesRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\ReadingWriteOnlyPropertiesRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/ReadingWriteOnlyPropertiesRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Properties\\\\ReadingWriteOnlyPropertiesRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/ReadingWriteOnlyPropertiesRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\TypesAssignedToPropertiesRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/TypesAssignedToPropertiesRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Properties\\\\TypesAssignedToPropertiesRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/TypesAssignedToPropertiesRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Properties\\\\WritingToReadOnlyPropertiesRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/WritingToReadOnlyPropertiesRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Properties\\\\WritingToReadOnlyPropertiesRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Properties/WritingToReadOnlyPropertiesRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\Regexp\\\\RegularExpressionPatternRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Regexp/RegularExpressionPatternRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\Regexp\\\\RegularExpressionPatternRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
-			count: 1
-			path: tests/PHPStan/Rules/Regexp/RegularExpressionPatternRuleTest.php
-
-		-
-			message: "#^Class PHPStan\\\\Rules\\\\TooWideTypehints\\\\TooWideClosureReturnTypehintRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/TooWideTypehints/TooWideClosureReturnTypehintRuleTest.php
-
-		-
-			message: "#^Method PHPStan\\\\Rules\\\\TooWideTypehints\\\\TooWideClosureReturnTypehintRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
+			message: "#^Property PHPStan\\\\Rules\\\\Registry\\:\\:\\$rules with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
 			count: 1
-			path: tests/PHPStan/Rules/TooWideTypehints/TooWideClosureReturnTypehintRuleTest.php
+			path: src/Rules/Registry.php
 
 		-
-			message: "#^Class PHPStan\\\\Rules\\\\TooWideTypehints\\\\TooWideFunctionReturnTypehintRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
+			message: "#^Property PHPStan\\\\Rules\\\\Registry\\:\\:\\$cache with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
 			count: 1
-			path: tests/PHPStan/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRuleTest.php
+			path: src/Rules/Registry.php
 
 		-
-			message: "#^Method PHPStan\\\\Rules\\\\TooWideTypehints\\\\TooWideFunctionReturnTypehintRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
+			message: "#^Method PHPStan\\\\Rules\\\\Registry\\:\\:__construct\\(\\) has parameter \\$rules with generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
 			count: 1
-			path: tests/PHPStan/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRuleTest.php
+			path: src/Rules/Registry.php
 
 		-
-			message: "#^Class PHPStan\\\\Rules\\\\TooWideTypehints\\\\TooWideMethodReturnTypehintRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
+			message: "#^Method PHPStan\\\\Testing\\\\RuleTestCase\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
 			count: 1
-			path: tests/PHPStan/Rules/TooWideTypehints/TooWideMethodReturnTypehintRuleTest.php
+			path: src/Testing/RuleTestCase.php
 
 		-
-			message: "#^Method PHPStan\\\\Rules\\\\TooWideTypehints\\\\TooWideMethodReturnTypehintRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
+			message: "#^Parameter \\#1 \\$rules of class PHPStan\\\\Rules\\\\Registry constructor expects array\\<PHPStan\\\\Rules\\\\Rule\\>, array\\<int, TRule of PHPStan\\\\Rules\\\\Rule\\> given\\.$#"
 			count: 1
-			path: tests/PHPStan/Rules/TooWideTypehints/TooWideMethodReturnTypehintRuleTest.php
+			path: src/Testing/RuleTestCase.php
 
 		-
-			message: "#^Class PHPStan\\\\Rules\\\\Variables\\\\DefinedVariableInAnonymousFunctionUseRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
-			count: 1
-			path: tests/PHPStan/Rules/Variables/DefinedVariableInAnonymousFunctionUseRuleTest.php
+			message: "#^Cannot call method getActiveTemplateTypeMap\\(\\) on PHPStan\\\\Reflection\\\\ClassReflection\\|null\\.$#"
+			count: 2
+			path: src/Type/Generic/GenericObjectType.php
 
 		-
-			message: "#^Method PHPStan\\\\Rules\\\\Variables\\\\DefinedVariableInAnonymousFunctionUseRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
+			message: "#^Class PHPStan\\\\Analyser\\\\AnonymousClassNameRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
 			count: 1
-			path: tests/PHPStan/Rules/Variables/DefinedVariableInAnonymousFunctionUseRuleTest.php
+			path: tests/PHPStan/Analyser/AnonymousClassNameRule.php
 
 		-
-			message: "#^Class PHPStan\\\\Rules\\\\Variables\\\\DefinedVariableRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
+			message: "#^Class PHPStan\\\\Analyser\\\\AnonymousClassNameRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
 			count: 1
-			path: tests/PHPStan/Rules/Variables/DefinedVariableRuleTest.php
+			path: tests/PHPStan/Analyser/AnonymousClassNameRuleTest.php
 
 		-
-			message: "#^Method PHPStan\\\\Rules\\\\Variables\\\\DefinedVariableRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
+			message: "#^Method PHPStan\\\\Analyser\\\\AnonymousClassNameRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
 			count: 1
-			path: tests/PHPStan/Rules/Variables/DefinedVariableRuleTest.php
+			path: tests/PHPStan/Analyser/AnonymousClassNameRuleTest.php
 
 		-
-			message: "#^Class PHPStan\\\\Rules\\\\Variables\\\\ThisVariableRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
+			message: "#^Class PHPStan\\\\Analyser\\\\EvaluationOrderRule implements generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
 			count: 1
-			path: tests/PHPStan/Rules/Variables/ThisVariableRuleTest.php
+			path: tests/PHPStan/Analyser/EvaluationOrderRule.php
 
 		-
-			message: "#^Method PHPStan\\\\Rules\\\\Variables\\\\ThisVariableRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
+			message: "#^Class PHPStan\\\\Analyser\\\\EvaluationOrderTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
 			count: 1
-			path: tests/PHPStan/Rules/Variables/ThisVariableRuleTest.php
+			path: tests/PHPStan/Analyser/EvaluationOrderTest.php
 
 		-
-			message: "#^Class PHPStan\\\\Rules\\\\Variables\\\\ThrowTypeRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
+			message: "#^Method PHPStan\\\\Analyser\\\\EvaluationOrderTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
 			count: 1
-			path: tests/PHPStan/Rules/Variables/ThrowTypeRuleTest.php
+			path: tests/PHPStan/Analyser/EvaluationOrderTest.php
 
 		-
-			message: "#^Method PHPStan\\\\Rules\\\\Variables\\\\ThrowTypeRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
+			message: "#^Constant SOME_CONSTANT_IN_AUTOLOAD_FILE not found\\.$#"
 			count: 1
-			path: tests/PHPStan/Rules/Variables/ThrowTypeRuleTest.php
+			path: tests/PHPStan/Command/AnalyseCommandTest.php
 
 		-
-			message: "#^Class PHPStan\\\\Rules\\\\Variables\\\\VariableCertaintyInIssetRuleTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
+			message: "#^Class PHPStan\\\\Node\\\\FileNodeTest extends generic class PHPStan\\\\Testing\\\\RuleTestCase but does not specify its types\\: TRule$#"
 			count: 1
-			path: tests/PHPStan/Rules/Variables/VariableCertaintyInIssetRuleTest.php
+			path: tests/PHPStan/Node/FileNodeTest.php
 
 		-
-			message: "#^Method PHPStan\\\\Rules\\\\Variables\\\\VariableCertaintyInIssetRuleTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
+			message: "#^Method PHPStan\\\\Node\\\\FileNodeTest\\:\\:getRule\\(\\) return type with generic interface PHPStan\\\\Rules\\\\Rule does not specify its types\\: TNodeType$#"
 			count: 1
-			path: tests/PHPStan/Rules/Variables/VariableCertaintyInIssetRuleTest.php
+			path: tests/PHPStan/Node/FileNodeTest.php
 
 
diff --git a/src/Rules/Arrays/AppendedArrayItemTypeRule.php b/src/Rules/Arrays/AppendedArrayItemTypeRule.php
index 614ff13aeb..e31fd14864 100644
--- a/src/Rules/Arrays/AppendedArrayItemTypeRule.php
+++ b/src/Rules/Arrays/AppendedArrayItemTypeRule.php
@@ -7,10 +7,14 @@
 use PhpParser\Node\Expr\AssignOp;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Properties\PropertyReflectionFinder;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr>
+ */
 class AppendedArrayItemTypeRule implements \PHPStan\Rules\Rule
 {
 
@@ -34,11 +38,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(\PhpParser\Node $node, Scope $scope): array
 	{
 		if (
@@ -79,11 +78,11 @@ public function processNode(\PhpParser\Node $node, Scope $scope): array
 		if (!$this->ruleLevelHelper->accepts($itemType, $assignedValueType, $scope->isDeclareStrictTypes())) {
 			$verbosityLevel = $itemType->isCallable()->and($assignedValueType->isCallable())->yes() ? VerbosityLevel::value() : VerbosityLevel::typeOnly();
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Array (%s) does not accept %s.',
 					$assignedToType->describe($verbosityLevel),
 					$assignedValueType->describe($verbosityLevel)
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Arrays/AppendedArrayKeyTypeRule.php b/src/Rules/Arrays/AppendedArrayKeyTypeRule.php
index 1f2f029dd3..b62950653d 100644
--- a/src/Rules/Arrays/AppendedArrayKeyTypeRule.php
+++ b/src/Rules/Arrays/AppendedArrayKeyTypeRule.php
@@ -6,11 +6,15 @@
 use PhpParser\Node\Expr\Assign;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Properties\PropertyReflectionFinder;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\IntegerType;
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Assign>
+ */
 class AppendedArrayKeyTypeRule implements \PHPStan\Rules\Rule
 {
 
@@ -34,11 +38,6 @@ public function getNodeType(): string
 		return Assign::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Assign $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(\PhpParser\Node $node, Scope $scope): array
 	{
 		if (!($node->var instanceof ArrayDimFetch)) {
@@ -80,11 +79,11 @@ public function processNode(\PhpParser\Node $node, Scope $scope): array
 
 		if (!$arrayType->getIterableKeyType()->isSuperTypeOf($keyType)->yes()) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Array (%s) does not accept key %s.',
 					$arrayType->describe(VerbosityLevel::typeOnly()),
 					$keyType->describe(VerbosityLevel::value())
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Arrays/DeadForeachRule.php b/src/Rules/Arrays/DeadForeachRule.php
index afc7d04be4..f24d930be3 100644
--- a/src/Rules/Arrays/DeadForeachRule.php
+++ b/src/Rules/Arrays/DeadForeachRule.php
@@ -5,7 +5,11 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Foreach_>
+ */
 class DeadForeachRule implements Rule
 {
 
@@ -14,11 +18,6 @@ public function getNodeType(): string
 		return Node\Stmt\Foreach_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Foreach_ $node
-	 * @param Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$iterableType = $scope->getType($node->expr);
@@ -31,7 +30,7 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		return [
-			'Empty array passed to foreach.',
+			RuleErrorBuilder::message('Empty array passed to foreach.')->build(),
 		];
 	}
 
diff --git a/src/Rules/Arrays/DuplicateKeysInLiteralArraysRule.php b/src/Rules/Arrays/DuplicateKeysInLiteralArraysRule.php
index 09d1557045..c735306fa3 100644
--- a/src/Rules/Arrays/DuplicateKeysInLiteralArraysRule.php
+++ b/src/Rules/Arrays/DuplicateKeysInLiteralArraysRule.php
@@ -4,10 +4,12 @@
 
 use PHPStan\Analyser\Scope;
 use PHPStan\Node\LiteralArrayNode;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\ConstantScalarType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PHPStan\Node\LiteralArrayNode>
+ */
 class DuplicateKeysInLiteralArraysRule implements \PHPStan\Rules\Rule
 {
 
@@ -26,11 +28,6 @@ public function getNodeType(): string
 		return LiteralArrayNode::class;
 	}
 
-	/**
-	 * @param LiteralArrayNode $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(\PhpParser\Node $node, Scope $scope): array
 	{
 		$values = [];
diff --git a/src/Rules/Arrays/InvalidKeyInArrayDimFetchRule.php b/src/Rules/Arrays/InvalidKeyInArrayDimFetchRule.php
index eae58ddde9..073d9f2504 100644
--- a/src/Rules/Arrays/InvalidKeyInArrayDimFetchRule.php
+++ b/src/Rules/Arrays/InvalidKeyInArrayDimFetchRule.php
@@ -3,10 +3,14 @@
 namespace PHPStan\Rules\Arrays;
 
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\TypeUtils;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\ArrayDimFetch>
+ */
 class InvalidKeyInArrayDimFetchRule implements \PHPStan\Rules\Rule
 {
 
@@ -23,11 +27,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\ArrayDimFetch::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\ArrayDimFetch $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(\PhpParser\Node $node, Scope $scope): array
 	{
 		if ($node->dim === null) {
@@ -43,11 +42,15 @@ public function processNode(\PhpParser\Node $node, Scope $scope): array
 		$isSuperType = AllowedArrayKeysTypes::getType()->isSuperTypeOf($dimensionType);
 		if ($isSuperType->no()) {
 			return [
-				sprintf('Invalid array key type %s.', $dimensionType->describe(VerbosityLevel::typeOnly())),
+				RuleErrorBuilder::message(
+					sprintf('Invalid array key type %s.', $dimensionType->describe(VerbosityLevel::typeOnly()))
+				)->build(),
 			];
 		} elseif ($this->reportMaybes && $isSuperType->maybe() && !$dimensionType instanceof MixedType) {
 			return [
-				sprintf('Possibly invalid array key type %s.', $dimensionType->describe(VerbosityLevel::typeOnly())),
+				RuleErrorBuilder::message(
+					sprintf('Possibly invalid array key type %s.', $dimensionType->describe(VerbosityLevel::typeOnly()))
+				)->build(),
 			];
 		}
 
diff --git a/src/Rules/Arrays/InvalidKeyInArrayItemRule.php b/src/Rules/Arrays/InvalidKeyInArrayItemRule.php
index 3e4aba0fd3..93bc328572 100644
--- a/src/Rules/Arrays/InvalidKeyInArrayItemRule.php
+++ b/src/Rules/Arrays/InvalidKeyInArrayItemRule.php
@@ -3,9 +3,13 @@
 namespace PHPStan\Rules\Arrays;
 
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\ArrayItem>
+ */
 class InvalidKeyInArrayItemRule implements \PHPStan\Rules\Rule
 {
 
@@ -22,11 +26,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\ArrayItem::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\ArrayItem $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(\PhpParser\Node $node, Scope $scope): array
 	{
 		if ($node->key === null) {
@@ -37,11 +36,15 @@ public function processNode(\PhpParser\Node $node, Scope $scope): array
 		$isSuperType = AllowedArrayKeysTypes::getType()->isSuperTypeOf($dimensionType);
 		if ($isSuperType->no()) {
 			return [
-				sprintf('Invalid array key type %s.', $dimensionType->describe(VerbosityLevel::typeOnly())),
+				RuleErrorBuilder::message(
+					sprintf('Invalid array key type %s.', $dimensionType->describe(VerbosityLevel::typeOnly()))
+				)->build(),
 			];
 		} elseif ($this->reportMaybes && $isSuperType->maybe() && !$dimensionType instanceof MixedType) {
 			return [
-				sprintf('Possibly invalid array key type %s.', $dimensionType->describe(VerbosityLevel::typeOnly())),
+				RuleErrorBuilder::message(
+					sprintf('Possibly invalid array key type %s.', $dimensionType->describe(VerbosityLevel::typeOnly()))
+				)->build(),
 			];
 		}
 
diff --git a/src/Rules/Arrays/IterableInForeachRule.php b/src/Rules/Arrays/IterableInForeachRule.php
index c402bcc3aa..c1c8b304f1 100644
--- a/src/Rules/Arrays/IterableInForeachRule.php
+++ b/src/Rules/Arrays/IterableInForeachRule.php
@@ -4,13 +4,15 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Foreach_>
+ */
 class IterableInForeachRule implements \PHPStan\Rules\Rule
 {
 
@@ -27,11 +29,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Stmt\Foreach_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Foreach_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$typeResult = $this->ruleLevelHelper->findTypeToCheck(
diff --git a/src/Rules/Arrays/NonexistentOffsetInArrayDimFetchRule.php b/src/Rules/Arrays/NonexistentOffsetInArrayDimFetchRule.php
index 2dc7c7663f..d6f35f66f7 100644
--- a/src/Rules/Arrays/NonexistentOffsetInArrayDimFetchRule.php
+++ b/src/Rules/Arrays/NonexistentOffsetInArrayDimFetchRule.php
@@ -3,7 +3,6 @@
 namespace PHPStan\Rules\Arrays;
 
 use PHPStan\Analyser\Scope;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
@@ -12,6 +11,9 @@
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\ArrayDimFetch>
+ */
 class NonexistentOffsetInArrayDimFetchRule implements \PHPStan\Rules\Rule
 {
 
@@ -35,11 +37,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\ArrayDimFetch::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\ArrayDimFetch $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(\PhpParser\Node $node, Scope $scope): array
 	{
 		if ($node->dim !== null) {
diff --git a/src/Rules/Arrays/OffsetAccessAssignOpRule.php b/src/Rules/Arrays/OffsetAccessAssignOpRule.php
index ebff85e049..e9d276a0e9 100644
--- a/src/Rules/Arrays/OffsetAccessAssignOpRule.php
+++ b/src/Rules/Arrays/OffsetAccessAssignOpRule.php
@@ -4,12 +4,16 @@
 
 use PhpParser\Node\Expr\ArrayDimFetch;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\AssignOp>
+ */
 class OffsetAccessAssignOpRule implements \PHPStan\Rules\Rule
 {
 
@@ -26,11 +30,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\AssignOp::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\AssignOp $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(\PhpParser\Node $node, Scope $scope): array
 	{
 		if (!$node->var instanceof ArrayDimFetch) {
@@ -79,17 +78,21 @@ static function (Type $dimType) use ($varType): bool {
 		}
 
 		if ($dimType === null) {
-			return [sprintf(
-				'Cannot assign new offset to %s.',
-				$varType->describe(VerbosityLevel::typeOnly())
-			)];
+			return [
+				RuleErrorBuilder::message(sprintf(
+					'Cannot assign new offset to %s.',
+					$varType->describe(VerbosityLevel::typeOnly())
+				))->build(),
+			];
 		}
 
-		return [sprintf(
-			'Cannot assign offset %s to %s.',
-			$dimType->describe(VerbosityLevel::value()),
-			$varType->describe(VerbosityLevel::typeOnly())
-		)];
+		return [
+			RuleErrorBuilder::message(sprintf(
+				'Cannot assign offset %s to %s.',
+				$dimType->describe(VerbosityLevel::value()),
+				$varType->describe(VerbosityLevel::typeOnly())
+			))->build(),
+		];
 	}
 
 }
diff --git a/src/Rules/Arrays/OffsetAccessAssignmentRule.php b/src/Rules/Arrays/OffsetAccessAssignmentRule.php
index ee1050a59a..400b2df6be 100644
--- a/src/Rules/Arrays/OffsetAccessAssignmentRule.php
+++ b/src/Rules/Arrays/OffsetAccessAssignmentRule.php
@@ -3,12 +3,16 @@
 namespace PHPStan\Rules\Arrays;
 
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\ArrayDimFetch>
+ */
 class OffsetAccessAssignmentRule implements \PHPStan\Rules\Rule
 {
 
@@ -25,11 +29,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\ArrayDimFetch::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\ArrayDimFetch $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(\PhpParser\Node $node, Scope $scope): array
 	{
 		if (!$scope->isInExpressionAssign($node)) {
@@ -73,17 +72,21 @@ static function (Type $dimType) use ($varType): bool {
 		}
 
 		if ($dimType === null) {
-			return [sprintf(
-				'Cannot assign new offset to %s.',
-				$varType->describe(VerbosityLevel::typeOnly())
-			)];
+			return [
+				RuleErrorBuilder::message(sprintf(
+					'Cannot assign new offset to %s.',
+					$varType->describe(VerbosityLevel::typeOnly())
+				))->build(),
+			];
 		}
 
-		return [sprintf(
-			'Cannot assign offset %s to %s.',
-			$dimType->describe(VerbosityLevel::value()),
-			$varType->describe(VerbosityLevel::typeOnly())
-		)];
+		return [
+			RuleErrorBuilder::message(sprintf(
+				'Cannot assign offset %s to %s.',
+				$dimType->describe(VerbosityLevel::value()),
+				$varType->describe(VerbosityLevel::typeOnly())
+			))->build(),
+		];
 	}
 
 }
diff --git a/src/Rules/Arrays/OffsetAccessWithoutDimForReadingRule.php b/src/Rules/Arrays/OffsetAccessWithoutDimForReadingRule.php
index f7a015cf16..5a19af0357 100644
--- a/src/Rules/Arrays/OffsetAccessWithoutDimForReadingRule.php
+++ b/src/Rules/Arrays/OffsetAccessWithoutDimForReadingRule.php
@@ -3,7 +3,11 @@
 namespace PHPStan\Rules\Arrays;
 
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\ArrayDimFetch>
+ */
 class OffsetAccessWithoutDimForReadingRule implements \PHPStan\Rules\Rule
 {
 
@@ -12,11 +16,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\ArrayDimFetch::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\ArrayDimFetch $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(\PhpParser\Node $node, Scope $scope): array
 	{
 		if ($scope->isInExpressionAssign($node)) {
@@ -27,7 +26,9 @@ public function processNode(\PhpParser\Node $node, Scope $scope): array
 			return [];
 		}
 
-		return ['Cannot use [] for reading.'];
+		return [
+			RuleErrorBuilder::message('Cannot use [] for reading.')->build(),
+		];
 	}
 
 }
diff --git a/src/Rules/Arrays/UnpackIterableInArrayRule.php b/src/Rules/Arrays/UnpackIterableInArrayRule.php
index dc59fb25c1..496d4a6a7b 100644
--- a/src/Rules/Arrays/UnpackIterableInArrayRule.php
+++ b/src/Rules/Arrays/UnpackIterableInArrayRule.php
@@ -12,6 +12,9 @@
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PHPStan\Node\LiteralArrayNode>
+ */
 class UnpackIterableInArrayRule implements Rule
 {
 
@@ -30,11 +33,6 @@ public function getNodeType(): string
 		return LiteralArrayNode::class;
 	}
 
-	/**
-	 * @param \PHPStan\Node\LiteralArrayNode $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return \PHPStan\Rules\RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$errors = [];
diff --git a/src/Rules/Cast/EchoRule.php b/src/Rules/Cast/EchoRule.php
index 0b2ec11374..0db3df952a 100644
--- a/src/Rules/Cast/EchoRule.php
+++ b/src/Rules/Cast/EchoRule.php
@@ -5,13 +5,15 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Echo_>
+ */
 class EchoRule implements Rule
 {
 
@@ -28,11 +30,6 @@ public function getNodeType(): string
 		return Node\Stmt\Echo_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Echo_ $node
-	 * @param Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$messages = [];
diff --git a/src/Rules/Cast/InvalidCastRule.php b/src/Rules/Cast/InvalidCastRule.php
index 355822137e..0d0279a5f3 100644
--- a/src/Rules/Cast/InvalidCastRule.php
+++ b/src/Rules/Cast/InvalidCastRule.php
@@ -5,13 +5,15 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Broker\Broker;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Cast>
+ */
 class InvalidCastRule implements \PHPStan\Rules\Rule
 {
 
@@ -35,11 +37,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\Cast::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Cast $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$castTypeCallback = static function (Type $type) use ($node): ?Type {
diff --git a/src/Rules/Cast/InvalidPartOfEncapsedStringRule.php b/src/Rules/Cast/InvalidPartOfEncapsedStringRule.php
index d8a2f00025..f8625e3e3e 100644
--- a/src/Rules/Cast/InvalidPartOfEncapsedStringRule.php
+++ b/src/Rules/Cast/InvalidPartOfEncapsedStringRule.php
@@ -4,13 +4,15 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Scalar\Encapsed>
+ */
 class InvalidPartOfEncapsedStringRule implements \PHPStan\Rules\Rule
 {
 
@@ -34,11 +36,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Scalar\Encapsed::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Scalar\Encapsed $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$messages = [];
diff --git a/src/Rules/Cast/PrintRule.php b/src/Rules/Cast/PrintRule.php
index b600d51d83..b619d70f92 100644
--- a/src/Rules/Cast/PrintRule.php
+++ b/src/Rules/Cast/PrintRule.php
@@ -5,13 +5,15 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Print_>
+ */
 class PrintRule implements Rule
 {
 
@@ -28,11 +30,6 @@ public function getNodeType(): string
 		return Node\Expr\Print_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Print_ $node
-	 * @param Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$typeResult = $this->ruleLevelHelper->findTypeToCheck(
diff --git a/src/Rules/Classes/ClassConstantDeclarationRule.php b/src/Rules/Classes/ClassConstantDeclarationRule.php
index 0e2c9c7b7a..a43c6085aa 100644
--- a/src/Rules/Classes/ClassConstantDeclarationRule.php
+++ b/src/Rules/Classes/ClassConstantDeclarationRule.php
@@ -6,6 +6,9 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\ClassConst>
+ */
 class ClassConstantDeclarationRule implements Rule
 {
 
@@ -14,11 +17,6 @@ public function getNodeType(): string
 		return Node\Stmt\ClassConst::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\ClassConst $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$scope->isInClass()) {
diff --git a/src/Rules/Classes/ClassConstantRule.php b/src/Rules/Classes/ClassConstantRule.php
index 684b4ddaff..0998ce780b 100644
--- a/src/Rules/Classes/ClassConstantRule.php
+++ b/src/Rules/Classes/ClassConstantRule.php
@@ -8,6 +8,7 @@
 use PHPStan\Broker\Broker;
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\ClassNameNodePair;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\ObjectType;
@@ -16,6 +17,9 @@
 use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\ClassConstFetch>
+ */
 class ClassConstantRule implements \PHPStan\Rules\Rule
 {
 
@@ -44,11 +48,6 @@ public function getNodeType(): string
 		return ClassConstFetch::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\ClassConstFetch $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return (string|\PHPStan\Rules\RuleError)[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$node->name instanceof Node\Identifier) {
@@ -64,7 +63,7 @@ public function processNode(Node $node, Scope $scope): array
 			if (in_array($lowercasedClassName, ['self', 'static'], true)) {
 				if (!$scope->isInClass()) {
 					return [
-						sprintf('Using %s outside of class scope.', $className),
+						RuleErrorBuilder::message(sprintf('Using %s outside of class scope.', $className))->build(),
 					];
 				}
 
@@ -72,17 +71,17 @@ public function processNode(Node $node, Scope $scope): array
 			} elseif ($lowercasedClassName === 'parent') {
 				if (!$scope->isInClass()) {
 					return [
-						sprintf('Using %s outside of class scope.', $className),
+						RuleErrorBuilder::message(sprintf('Using %s outside of class scope.', $className))->build(),
 					];
 				}
 				$currentClassReflection = $scope->getClassReflection();
 				if ($currentClassReflection->getParentClass() === false) {
 					return [
-						sprintf(
+						RuleErrorBuilder::message(sprintf(
 							'Access to parent::%s but %s does not extend any class.',
 							$constantName,
 							$currentClassReflection->getDisplayName()
-						),
+						))->build(),
 					];
 				}
 				$className = $currentClassReflection->getParentClass()->getName();
@@ -90,12 +89,14 @@ public function processNode(Node $node, Scope $scope): array
 				if (!$this->broker->hasClass($className)) {
 					if (strtolower($constantName) === 'class') {
 						return [
-							sprintf('Class %s not found.', $className),
+							RuleErrorBuilder::message(sprintf('Class %s not found.', $className))->build(),
 						];
 					}
 
 					return [
-						sprintf('Access to constant %s on an unknown class %s.', $constantName, $className),
+						RuleErrorBuilder::message(
+							sprintf('Access to constant %s on an unknown class %s.', $constantName, $className)
+						)->build(),
 					];
 				} else {
 					$messages = $this->classCaseSensitivityCheck->checkClassNames([new ClassNameNodePair($className, $class)]);
@@ -129,7 +130,11 @@ static function (Type $type) use ($constantName): bool {
 
 		if (!$classType->canAccessConstants()->yes()) {
 			return array_merge($messages, [
-				sprintf('Cannot access constant %s on %s.', $constantName, $typeForDescribe->describe(VerbosityLevel::typeOnly())),
+				RuleErrorBuilder::message(sprintf(
+					'Cannot access constant %s on %s.',
+					$constantName,
+					$typeForDescribe->describe(VerbosityLevel::typeOnly())
+				))->build(),
 			]);
 		}
 
@@ -139,23 +144,23 @@ static function (Type $type) use ($constantName): bool {
 
 		if (!$classType->hasConstant($constantName)->yes()) {
 			return array_merge($messages, [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Access to undefined constant %s::%s.',
 					$typeForDescribe->describe(VerbosityLevel::typeOnly()),
 					$constantName
-				),
+				))->build(),
 			]);
 		}
 
 		$constantReflection = $classType->getConstant($constantName);
 		if (!$scope->canAccessConstant($constantReflection)) {
 			return array_merge($messages, [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Access to %s constant %s of class %s.',
 					$constantReflection->isPrivate() ? 'private' : 'protected',
 					$constantName,
 					$constantReflection->getDeclaringClass()->getDisplayName()
-				),
+				))->build(),
 			]);
 		}
 
diff --git a/src/Rules/Classes/ExistingClassInClassExtendsRule.php b/src/Rules/Classes/ExistingClassInClassExtendsRule.php
index 0aebdb83c3..e4572b1bf5 100644
--- a/src/Rules/Classes/ExistingClassInClassExtendsRule.php
+++ b/src/Rules/Classes/ExistingClassInClassExtendsRule.php
@@ -6,8 +6,10 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\ClassNameNodePair;
-use PHPStan\Rules\RuleError;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Class_>
+ */
 class ExistingClassInClassExtendsRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +26,6 @@ public function getNodeType(): string
 		return Node\Stmt\Class_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Class_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if ($node->extends === null) {
diff --git a/src/Rules/Classes/ExistingClassInInstanceOfRule.php b/src/Rules/Classes/ExistingClassInInstanceOfRule.php
index 63e969b72d..77f38f1355 100644
--- a/src/Rules/Classes/ExistingClassInInstanceOfRule.php
+++ b/src/Rules/Classes/ExistingClassInInstanceOfRule.php
@@ -8,9 +8,11 @@
 use PHPStan\Broker\Broker;
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\ClassNameNodePair;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Instanceof_>
+ */
 class ExistingClassInInstanceOfRule implements \PHPStan\Rules\Rule
 {
 
@@ -39,11 +41,6 @@ public function getNodeType(): string
 		return Instanceof_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Instanceof_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$class = $node->class;
diff --git a/src/Rules/Classes/ExistingClassInTraitUseRule.php b/src/Rules/Classes/ExistingClassInTraitUseRule.php
index e845487033..a9de3cf55a 100644
--- a/src/Rules/Classes/ExistingClassInTraitUseRule.php
+++ b/src/Rules/Classes/ExistingClassInTraitUseRule.php
@@ -6,8 +6,10 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\ClassNameNodePair;
-use PHPStan\Rules\RuleError;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\TraitUse>
+ */
 class ExistingClassInTraitUseRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +26,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Stmt\TraitUse::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\TraitUse $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		return $this->classCaseSensitivityCheck->checkClassNames(
diff --git a/src/Rules/Classes/ExistingClassesInClassImplementsRule.php b/src/Rules/Classes/ExistingClassesInClassImplementsRule.php
index 642c50da40..1eb0460f03 100644
--- a/src/Rules/Classes/ExistingClassesInClassImplementsRule.php
+++ b/src/Rules/Classes/ExistingClassesInClassImplementsRule.php
@@ -6,8 +6,10 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\ClassNameNodePair;
-use PHPStan\Rules\RuleError;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Class_>
+ */
 class ExistingClassesInClassImplementsRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +26,6 @@ public function getNodeType(): string
 		return Node\Stmt\Class_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Class_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		return $this->classCaseSensitivityCheck->checkClassNames(
diff --git a/src/Rules/Classes/ExistingClassesInInterfaceExtendsRule.php b/src/Rules/Classes/ExistingClassesInInterfaceExtendsRule.php
index 6001e3665b..2119227c22 100644
--- a/src/Rules/Classes/ExistingClassesInInterfaceExtendsRule.php
+++ b/src/Rules/Classes/ExistingClassesInInterfaceExtendsRule.php
@@ -6,8 +6,10 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\ClassNameNodePair;
-use PHPStan\Rules\RuleError;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Interface_>
+ */
 class ExistingClassesInInterfaceExtendsRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +26,6 @@ public function getNodeType(): string
 		return Node\Stmt\Interface_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Interface_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		return $this->classCaseSensitivityCheck->checkClassNames(
diff --git a/src/Rules/Classes/ImpossibleInstanceOfRule.php b/src/Rules/Classes/ImpossibleInstanceOfRule.php
index 33f1748338..1e86bd9e95 100644
--- a/src/Rules/Classes/ImpossibleInstanceOfRule.php
+++ b/src/Rules/Classes/ImpossibleInstanceOfRule.php
@@ -4,6 +4,7 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\ObjectWithoutClassType;
@@ -11,6 +12,9 @@
 use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Instanceof_>
+ */
 class ImpossibleInstanceOfRule implements \PHPStan\Rules\Rule
 {
 
@@ -27,11 +31,6 @@ public function getNodeType(): string
 		return Node\Expr\Instanceof_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Instanceof_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$instanceofType = $scope->getType($node);
@@ -48,11 +47,11 @@ public function processNode(Node $node, Scope $scope): array
 			);
 			if (!$allowed->accepts($classType, true)->yes()) {
 				return [
-					sprintf(
+					RuleErrorBuilder::message(sprintf(
 						'Instanceof between %s and %s results in an error.',
 						$expressionType->describe(VerbosityLevel::typeOnly()),
 						$classType->describe(VerbosityLevel::typeOnly())
-					),
+					))->build(),
 				];
 			}
 		}
@@ -63,19 +62,19 @@ public function processNode(Node $node, Scope $scope): array
 
 		if (!$instanceofType->getValue()) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Instanceof between %s and %s will always evaluate to false.',
 					$expressionType->describe(VerbosityLevel::typeOnly()),
 					$classType->describe(VerbosityLevel::typeOnly())
-				),
+				))->build(),
 			];
 		} elseif ($this->checkAlwaysTrueInstanceof) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Instanceof between %s and %s will always evaluate to true.',
 					$expressionType->describe(VerbosityLevel::typeOnly()),
 					$classType->describe(VerbosityLevel::typeOnly())
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Classes/InstantiationRule.php b/src/Rules/Classes/InstantiationRule.php
index 33dca6f158..45a26e5ef0 100644
--- a/src/Rules/Classes/InstantiationRule.php
+++ b/src/Rules/Classes/InstantiationRule.php
@@ -11,10 +11,15 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\ClassNameNodePair;
 use PHPStan\Rules\FunctionCallParametersCheck;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\TypeUtils;
 use PHPStan\Type\TypeWithClassName;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\New_>
+ */
 class InstantiationRule implements \PHPStan\Rules\Rule
 {
 
@@ -43,11 +48,6 @@ public function getNodeType(): string
 		return New_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\New_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return (string|\PHPStan\Rules\RuleError)[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$errors = [];
@@ -61,7 +61,7 @@ public function processNode(Node $node, Scope $scope): array
 	 * @param string $class
 	 * @param \PhpParser\Node\Expr\New_ $node
 	 * @param Scope $scope
-	 * @return (string|\PHPStan\Rules\RuleError)[]
+	 * @return RuleError[]
 	 */
 	private function checkClassName(string $class, Node $node, Scope $scope): array
 	{
@@ -71,7 +71,7 @@ private function checkClassName(string $class, Node $node, Scope $scope): array
 		if ($lowercasedClass === 'static') {
 			if (!$scope->isInClass()) {
 				return [
-					sprintf('Using %s outside of class scope.', $class),
+					RuleErrorBuilder::message(sprintf('Using %s outside of class scope.', $class))->build(),
 				];
 			}
 
@@ -95,31 +95,31 @@ private function checkClassName(string $class, Node $node, Scope $scope): array
 		} elseif ($lowercasedClass === 'self') {
 			if (!$scope->isInClass()) {
 				return [
-					sprintf('Using %s outside of class scope.', $class),
+					RuleErrorBuilder::message(sprintf('Using %s outside of class scope.', $class))->build(),
 				];
 			}
 			$classReflection = $scope->getClassReflection();
 		} elseif ($lowercasedClass === 'parent') {
 			if (!$scope->isInClass()) {
 				return [
-					sprintf('Using %s outside of class scope.', $class),
+					RuleErrorBuilder::message(sprintf('Using %s outside of class scope.', $class))->build(),
 				];
 			}
 			if ($scope->getClassReflection()->getParentClass() === false) {
 				return [
-					sprintf(
+					RuleErrorBuilder::message(sprintf(
 						'%s::%s() calls new parent but %s does not extend any class.',
 						$scope->getClassReflection()->getDisplayName(),
 						$scope->getFunctionName(),
 						$scope->getClassReflection()->getDisplayName()
-					),
+					))->build(),
 				];
 			}
 			$classReflection = $scope->getClassReflection()->getParentClass();
 		} else {
 			if (!$this->broker->hasClass($class)) {
 				return [
-					sprintf('Instantiated class %s not found.', $class),
+					RuleErrorBuilder::message(sprintf('Instantiated class %s not found.', $class))->build(),
 				];
 			} else {
 				$messages = $this->classCaseSensitivityCheck->checkClassNames([
@@ -132,23 +132,27 @@ private function checkClassName(string $class, Node $node, Scope $scope): array
 
 		if (!$isStatic && $classReflection->isInterface()) {
 			return [
-				sprintf('Cannot instantiate interface %s.', $classReflection->getDisplayName()),
+				RuleErrorBuilder::message(
+					sprintf('Cannot instantiate interface %s.', $classReflection->getDisplayName())
+				)->build(),
 			];
 		}
 
 		if (!$isStatic && $classReflection->isAbstract()) {
 			return [
-				sprintf('Instantiated class %s is abstract.', $classReflection->getDisplayName()),
+				RuleErrorBuilder::message(
+					sprintf('Instantiated class %s is abstract.', $classReflection->getDisplayName())
+				)->build(),
 			];
 		}
 
 		if (!$classReflection->hasConstructor()) {
 			if (count($node->args) > 0) {
 				return array_merge($messages, [
-					sprintf(
+					RuleErrorBuilder::message(sprintf(
 						'Class %s does not have a constructor and must be instantiated without any parameters.',
 						$classReflection->getDisplayName()
-					),
+					))->build(),
 				]);
 			}
 
@@ -157,13 +161,13 @@ private function checkClassName(string $class, Node $node, Scope $scope): array
 
 		$constructorReflection = $classReflection->getConstructor();
 		if (!$scope->canCallMethod($constructorReflection)) {
-			$messages[] = sprintf(
+			$messages[] = RuleErrorBuilder::message(sprintf(
 				'Cannot instantiate class %s via %s constructor %s::%s().',
 				$classReflection->getDisplayName(),
 				$constructorReflection->isPrivate() ? 'private' : 'protected',
 				$constructorReflection->getDeclaringClass()->getDisplayName(),
 				$constructorReflection->getName()
-			);
+			))->build();
 		}
 
 		return array_merge($messages, $this->check->check(
diff --git a/src/Rules/Classes/NewStaticRule.php b/src/Rules/Classes/NewStaticRule.php
index d8c071f78b..f77485cad8 100644
--- a/src/Rules/Classes/NewStaticRule.php
+++ b/src/Rules/Classes/NewStaticRule.php
@@ -9,7 +9,7 @@
 use PHPStan\Rules\RuleErrorBuilder;
 
 /**
- * @implements Rule<Node\Expr\New_>
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\New_>
  */
 class NewStaticRule implements Rule
 {
diff --git a/src/Rules/Classes/UnusedConstructorParametersRule.php b/src/Rules/Classes/UnusedConstructorParametersRule.php
index 37699502e0..832f7c9b9c 100644
--- a/src/Rules/Classes/UnusedConstructorParametersRule.php
+++ b/src/Rules/Classes/UnusedConstructorParametersRule.php
@@ -9,6 +9,9 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\UnusedFunctionParametersCheck;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\ClassMethod>
+ */
 class UnusedConstructorParametersRule implements \PHPStan\Rules\Rule
 {
 
@@ -25,11 +28,6 @@ public function getNodeType(): string
 		return ClassMethod::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\ClassMethod $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$scope->isInClass()) {
@@ -44,7 +42,10 @@ public function processNode(Node $node, Scope $scope): array
 			return [];
 		}
 
-		$message = sprintf('Constructor of class %s has an unused parameter $%%s.', $scope->getClassReflection()->getDisplayName());
+		$message = sprintf(
+			'Constructor of class %s has an unused parameter $%%s.',
+			$scope->getClassReflection()->getDisplayName()
+		);
 		if ($scope->getClassReflection()->isAnonymous()) {
 			$message = 'Constructor of an anonymous class has an unused parameter $%s.';
 		}
diff --git a/src/Rules/Comparison/BooleanAndConstantConditionRule.php b/src/Rules/Comparison/BooleanAndConstantConditionRule.php
index c08c5cadc2..82ec16f7a6 100644
--- a/src/Rules/Comparison/BooleanAndConstantConditionRule.php
+++ b/src/Rules/Comparison/BooleanAndConstantConditionRule.php
@@ -2,10 +2,12 @@
 
 namespace PHPStan\Rules\Comparison;
 
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Constant\ConstantBooleanType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\BinaryOp\BooleanAnd>
+ */
 class BooleanAndConstantConditionRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +26,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\BinaryOp\BooleanAnd::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\BinaryOp\BooleanAnd $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(
 		\PhpParser\Node $node,
 		\PHPStan\Analyser\Scope $scope
diff --git a/src/Rules/Comparison/BooleanNotConstantConditionRule.php b/src/Rules/Comparison/BooleanNotConstantConditionRule.php
index dd3344e227..64560df896 100644
--- a/src/Rules/Comparison/BooleanNotConstantConditionRule.php
+++ b/src/Rules/Comparison/BooleanNotConstantConditionRule.php
@@ -2,10 +2,12 @@
 
 namespace PHPStan\Rules\Comparison;
 
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Constant\ConstantBooleanType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\BooleanNot>
+ */
 class BooleanNotConstantConditionRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +26,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\BooleanNot::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\BooleanNot $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(
 		\PhpParser\Node $node,
 		\PHPStan\Analyser\Scope $scope
diff --git a/src/Rules/Comparison/BooleanOrConstantConditionRule.php b/src/Rules/Comparison/BooleanOrConstantConditionRule.php
index 26c449eee0..11a0974526 100644
--- a/src/Rules/Comparison/BooleanOrConstantConditionRule.php
+++ b/src/Rules/Comparison/BooleanOrConstantConditionRule.php
@@ -2,10 +2,12 @@
 
 namespace PHPStan\Rules\Comparison;
 
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Constant\ConstantBooleanType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\BinaryOp\BooleanOr>
+ */
 class BooleanOrConstantConditionRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +26,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\BinaryOp\BooleanOr::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\BinaryOp\BooleanOr $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(
 		\PhpParser\Node $node,
 		\PHPStan\Analyser\Scope $scope
diff --git a/src/Rules/Comparison/ElseIfConstantConditionRule.php b/src/Rules/Comparison/ElseIfConstantConditionRule.php
index 62590d1cb6..ba2cb31aad 100644
--- a/src/Rules/Comparison/ElseIfConstantConditionRule.php
+++ b/src/Rules/Comparison/ElseIfConstantConditionRule.php
@@ -2,10 +2,12 @@
 
 namespace PHPStan\Rules\Comparison;
 
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Constant\ConstantBooleanType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\ElseIf_>
+ */
 class ElseIfConstantConditionRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +26,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Stmt\ElseIf_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\ElseIf_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(
 		\PhpParser\Node $node,
 		\PHPStan\Analyser\Scope $scope
diff --git a/src/Rules/Comparison/IfConstantConditionRule.php b/src/Rules/Comparison/IfConstantConditionRule.php
index d9fd5d80fa..216541cf4c 100644
--- a/src/Rules/Comparison/IfConstantConditionRule.php
+++ b/src/Rules/Comparison/IfConstantConditionRule.php
@@ -2,10 +2,12 @@
 
 namespace PHPStan\Rules\Comparison;
 
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Constant\ConstantBooleanType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\If_>
+ */
 class IfConstantConditionRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +26,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Stmt\If_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\If_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(
 		\PhpParser\Node $node,
 		\PHPStan\Analyser\Scope $scope
diff --git a/src/Rules/Comparison/ImpossibleCheckTypeFunctionCallRule.php b/src/Rules/Comparison/ImpossibleCheckTypeFunctionCallRule.php
index b058e1d1f6..f21750c483 100644
--- a/src/Rules/Comparison/ImpossibleCheckTypeFunctionCallRule.php
+++ b/src/Rules/Comparison/ImpossibleCheckTypeFunctionCallRule.php
@@ -4,7 +4,11 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\FuncCall>
+ */
 class ImpossibleCheckTypeFunctionCallRule implements \PHPStan\Rules\Rule
 {
 
@@ -28,11 +32,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\FuncCall::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\FuncCall $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[] errors
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$node->name instanceof Node\Name) {
@@ -49,17 +48,21 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		if (!$isAlways) {
-			return [sprintf(
-				'Call to function %s()%s will always evaluate to false.',
-				$functionName,
-				$this->impossibleCheckTypeHelper->getArgumentsDescription($scope, $node->args)
-			)];
+			return [
+				RuleErrorBuilder::message(sprintf(
+					'Call to function %s()%s will always evaluate to false.',
+					$functionName,
+					$this->impossibleCheckTypeHelper->getArgumentsDescription($scope, $node->args)
+				))->build(),
+			];
 		} elseif ($this->checkAlwaysTrueCheckTypeFunctionCall) {
-			return [sprintf(
-				'Call to function %s()%s will always evaluate to true.',
-				$functionName,
-				$this->impossibleCheckTypeHelper->getArgumentsDescription($scope, $node->args)
-			)];
+			return [
+				RuleErrorBuilder::message(sprintf(
+					'Call to function %s()%s will always evaluate to true.',
+					$functionName,
+					$this->impossibleCheckTypeHelper->getArgumentsDescription($scope, $node->args)
+				))->build(),
+			];
 		}
 
 		return [];
diff --git a/src/Rules/Comparison/ImpossibleCheckTypeMethodCallRule.php b/src/Rules/Comparison/ImpossibleCheckTypeMethodCallRule.php
index b90f6e86c9..e0349001ac 100644
--- a/src/Rules/Comparison/ImpossibleCheckTypeMethodCallRule.php
+++ b/src/Rules/Comparison/ImpossibleCheckTypeMethodCallRule.php
@@ -6,7 +6,11 @@
 use PhpParser\Node\Expr;
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\MethodReflection;
+use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\MethodCall>
+ */
 class ImpossibleCheckTypeMethodCallRule implements \PHPStan\Rules\Rule
 {
 
@@ -30,11 +34,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\MethodCall::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\MethodCall $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[] errors
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$node->name instanceof Node\Identifier) {
@@ -48,20 +47,24 @@ public function processNode(Node $node, Scope $scope): array
 
 		if (!$isAlways) {
 			$method = $this->getMethod($node->var, $node->name->name, $scope);
-			return [sprintf(
-				'Call to method %s::%s()%s will always evaluate to false.',
-				$method->getDeclaringClass()->getDisplayName(),
-				$method->getName(),
-				$this->impossibleCheckTypeHelper->getArgumentsDescription($scope, $node->args)
-			)];
+			return [
+				RuleErrorBuilder::message(sprintf(
+					'Call to method %s::%s()%s will always evaluate to false.',
+					$method->getDeclaringClass()->getDisplayName(),
+					$method->getName(),
+					$this->impossibleCheckTypeHelper->getArgumentsDescription($scope, $node->args)
+				))->build(),
+			];
 		} elseif ($this->checkAlwaysTrueCheckTypeFunctionCall) {
 			$method = $this->getMethod($node->var, $node->name->name, $scope);
-			return [sprintf(
-				'Call to method %s::%s()%s will always evaluate to true.',
-				$method->getDeclaringClass()->getDisplayName(),
-				$method->getName(),
-				$this->impossibleCheckTypeHelper->getArgumentsDescription($scope, $node->args)
-			)];
+			return [
+				RuleErrorBuilder::message(sprintf(
+					'Call to method %s::%s()%s will always evaluate to true.',
+					$method->getDeclaringClass()->getDisplayName(),
+					$method->getName(),
+					$this->impossibleCheckTypeHelper->getArgumentsDescription($scope, $node->args)
+				))->build(),
+			];
 		}
 
 		return [];
diff --git a/src/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRule.php b/src/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRule.php
index 6b7bb7f0f1..9fbd694aa7 100644
--- a/src/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRule.php
+++ b/src/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRule.php
@@ -6,8 +6,12 @@
 use PhpParser\Node\Expr;
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\MethodReflection;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\ObjectType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\StaticCall>
+ */
 class ImpossibleCheckTypeStaticMethodCallRule implements \PHPStan\Rules\Rule
 {
 
@@ -31,11 +35,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\StaticCall::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\StaticCall $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[] errors
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$node->name instanceof Node\Identifier) {
@@ -50,21 +49,25 @@ public function processNode(Node $node, Scope $scope): array
 		if (!$isAlways) {
 			$method = $this->getMethod($node->class, $node->name->name, $scope);
 
-			return [sprintf(
-				'Call to static method %s::%s()%s will always evaluate to false.',
-				$method->getDeclaringClass()->getDisplayName(),
-				$method->getName(),
-				$this->impossibleCheckTypeHelper->getArgumentsDescription($scope, $node->args)
-			)];
+			return [
+				RuleErrorBuilder::message(sprintf(
+					'Call to static method %s::%s()%s will always evaluate to false.',
+					$method->getDeclaringClass()->getDisplayName(),
+					$method->getName(),
+					$this->impossibleCheckTypeHelper->getArgumentsDescription($scope, $node->args)
+				))->build(),
+			];
 		} elseif ($this->checkAlwaysTrueCheckTypeFunctionCall) {
 			$method = $this->getMethod($node->class, $node->name->name, $scope);
 
-			return [sprintf(
-				'Call to static method %s::%s()%s will always evaluate to true.',
-				$method->getDeclaringClass()->getDisplayName(),
-				$method->getName(),
-				$this->impossibleCheckTypeHelper->getArgumentsDescription($scope, $node->args)
-			)];
+			return [
+				RuleErrorBuilder::message(sprintf(
+					'Call to static method %s::%s()%s will always evaluate to true.',
+					$method->getDeclaringClass()->getDisplayName(),
+					$method->getName(),
+					$this->impossibleCheckTypeHelper->getArgumentsDescription($scope, $node->args)
+				))->build(),
+			];
 		}
 
 		return [];
diff --git a/src/Rules/Comparison/NumberComparisonOperatorsConstantConditionRule.php b/src/Rules/Comparison/NumberComparisonOperatorsConstantConditionRule.php
index cba9ab0d24..de0ebaf218 100644
--- a/src/Rules/Comparison/NumberComparisonOperatorsConstantConditionRule.php
+++ b/src/Rules/Comparison/NumberComparisonOperatorsConstantConditionRule.php
@@ -3,11 +3,13 @@
 namespace PHPStan\Rules\Comparison;
 
 use PhpParser\Node\Expr\BinaryOp;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\BinaryOp>
+ */
 class NumberComparisonOperatorsConstantConditionRule implements \PHPStan\Rules\Rule
 {
 
@@ -16,11 +18,6 @@ public function getNodeType(): string
 		return BinaryOp::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\BinaryOp $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(
 		\PhpParser\Node $node,
 		\PHPStan\Analyser\Scope $scope
diff --git a/src/Rules/Comparison/StrictComparisonOfDifferentTypesRule.php b/src/Rules/Comparison/StrictComparisonOfDifferentTypesRule.php
index 87b6436756..6424b5db7d 100644
--- a/src/Rules/Comparison/StrictComparisonOfDifferentTypesRule.php
+++ b/src/Rules/Comparison/StrictComparisonOfDifferentTypesRule.php
@@ -4,9 +4,13 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\BinaryOp>
+ */
 class StrictComparisonOfDifferentTypesRule implements \PHPStan\Rules\Rule
 {
 
@@ -23,11 +27,6 @@ public function getNodeType(): string
 		return Node\Expr\BinaryOp::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\BinaryOp $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[] errors
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$node instanceof Node\Expr\BinaryOp\Identical && !$node instanceof Node\Expr\BinaryOp\NotIdentical) {
@@ -44,21 +43,21 @@ public function processNode(Node $node, Scope $scope): array
 
 		if (!$nodeType->getValue()) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Strict comparison using %s between %s and %s will always evaluate to false.',
 					$node instanceof Node\Expr\BinaryOp\Identical ? '===' : '!==',
 					$leftType->describe(VerbosityLevel::value()),
 					$rightType->describe(VerbosityLevel::value())
-				),
+				))->build(),
 			];
 		} elseif ($this->checkAlwaysTrueStrictComparison) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Strict comparison using %s between %s and %s will always evaluate to true.',
 					$node instanceof Node\Expr\BinaryOp\Identical ? '===' : '!==',
 					$leftType->describe(VerbosityLevel::value()),
 					$rightType->describe(VerbosityLevel::value())
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Comparison/TernaryOperatorConstantConditionRule.php b/src/Rules/Comparison/TernaryOperatorConstantConditionRule.php
index 34390c6650..e85463e10a 100644
--- a/src/Rules/Comparison/TernaryOperatorConstantConditionRule.php
+++ b/src/Rules/Comparison/TernaryOperatorConstantConditionRule.php
@@ -2,8 +2,12 @@
 
 namespace PHPStan\Rules\Comparison;
 
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Constant\ConstantBooleanType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Ternary>
+ */
 class TernaryOperatorConstantConditionRule implements \PHPStan\Rules\Rule
 {
 
@@ -22,11 +26,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\Ternary::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Ternary $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(
 		\PhpParser\Node $node,
 		\PHPStan\Analyser\Scope $scope
@@ -35,10 +34,10 @@ public function processNode(
 		$exprType = $this->helper->getBooleanType($scope, $node->cond);
 		if ($exprType instanceof ConstantBooleanType) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Ternary operator condition is always %s.',
 					$exprType->getValue() ? 'true' : 'false'
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Comparison/UnreachableIfBranchesRule.php b/src/Rules/Comparison/UnreachableIfBranchesRule.php
index b0ced8ebf6..765df42758 100644
--- a/src/Rules/Comparison/UnreachableIfBranchesRule.php
+++ b/src/Rules/Comparison/UnreachableIfBranchesRule.php
@@ -4,10 +4,12 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Constant\ConstantBooleanType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\If_>
+ */
 class UnreachableIfBranchesRule implements \PHPStan\Rules\Rule
 {
 
@@ -26,11 +28,6 @@ public function getNodeType(): string
 		return Node\Stmt\If_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\If_ $node
-	 * @param Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$errors = [];
diff --git a/src/Rules/Comparison/UnreachableTernaryElseBranchRule.php b/src/Rules/Comparison/UnreachableTernaryElseBranchRule.php
index c6e052afac..1e52fed07a 100644
--- a/src/Rules/Comparison/UnreachableTernaryElseBranchRule.php
+++ b/src/Rules/Comparison/UnreachableTernaryElseBranchRule.php
@@ -5,10 +5,12 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Constant\ConstantBooleanType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Ternary>
+ */
 class UnreachableTernaryElseBranchRule implements Rule
 {
 
@@ -27,11 +29,6 @@ public function getNodeType(): string
 		return Node\Expr\Ternary::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Ternary $node
-	 * @param Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$conditionType = $scope->getType($node->cond)->toBoolean();
diff --git a/src/Rules/Constants/ConstantRule.php b/src/Rules/Constants/ConstantRule.php
index b8a359f488..d380317484 100644
--- a/src/Rules/Constants/ConstantRule.php
+++ b/src/Rules/Constants/ConstantRule.php
@@ -4,7 +4,11 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\ConstFetch>
+ */
 class ConstantRule implements \PHPStan\Rules\Rule
 {
 
@@ -13,19 +17,14 @@ public function getNodeType(): string
 		return Node\Expr\ConstFetch::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\ConstFetch $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$scope->hasConstant($node->name)) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Constant %s not found.',
 					(string) $node->name
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/DeadCode/UnreachableStatementRule.php b/src/Rules/DeadCode/UnreachableStatementRule.php
index c52851f06b..25819da0bf 100644
--- a/src/Rules/DeadCode/UnreachableStatementRule.php
+++ b/src/Rules/DeadCode/UnreachableStatementRule.php
@@ -6,9 +6,11 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Node\UnreachableStatementNode;
 use PHPStan\Rules\Rule;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PHPStan\Node\UnreachableStatementNode>
+ */
 class UnreachableStatementRule implements Rule
 {
 
@@ -17,11 +19,6 @@ public function getNodeType(): string
 		return UnreachableStatementNode::class;
 	}
 
-	/**
-	 * @param UnreachableStatementNode $node
-	 * @param Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if ($node->getOriginalStatement() instanceof Node\Stmt\Nop) {
diff --git a/src/Rules/Exceptions/CaughtExceptionExistenceRule.php b/src/Rules/Exceptions/CaughtExceptionExistenceRule.php
index 759aa31970..92c6077863 100644
--- a/src/Rules/Exceptions/CaughtExceptionExistenceRule.php
+++ b/src/Rules/Exceptions/CaughtExceptionExistenceRule.php
@@ -8,9 +8,11 @@
 use PHPStan\Broker\Broker;
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\ClassNameNodePair;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Catch_>
+ */
 class CaughtExceptionExistenceRule implements \PHPStan\Rules\Rule
 {
 
@@ -39,11 +41,6 @@ public function getNodeType(): string
 		return Catch_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Catch_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$errors = [];
diff --git a/src/Rules/Exceptions/DeadCatchRule.php b/src/Rules/Exceptions/DeadCatchRule.php
index 6364958746..88438b0689 100644
--- a/src/Rules/Exceptions/DeadCatchRule.php
+++ b/src/Rules/Exceptions/DeadCatchRule.php
@@ -5,13 +5,15 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\TryCatch>
+ */
 class DeadCatchRule implements Rule
 {
 
@@ -20,11 +22,6 @@ public function getNodeType(): string
 		return Node\Stmt\TryCatch::class;
 	}
 
-	/**
-	 * @param Node\Stmt\TryCatch $node
-	 * @param Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$catchTypes = array_map(static function (Node\Stmt\Catch_ $catch): Type {
diff --git a/src/Rules/FunctionCallParametersCheck.php b/src/Rules/FunctionCallParametersCheck.php
index 024dae5664..73742c90fe 100644
--- a/src/Rules/FunctionCallParametersCheck.php
+++ b/src/Rules/FunctionCallParametersCheck.php
@@ -47,7 +47,7 @@ public function __construct(
 	 * @param \PHPStan\Analyser\Scope $scope
 	 * @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\New_ $funcCall
 	 * @param string[] $messages Nine message templates
-	 * @return string[]
+	 * @return RuleError[]
 	 */
 	public function check(
 		ParametersAcceptor $parametersAcceptor,
@@ -84,24 +84,24 @@ public function check(
 			|| ($this->checkExtraArguments && $invokedParametersCount > $functionParametersMaxCount)
 		) {
 			if ($functionParametersMinCount === $functionParametersMaxCount) {
-				$errors[] = sprintf(
+				$errors[] = RuleErrorBuilder::message(sprintf(
 					$invokedParametersCount === 1 ? $messages[0] : $messages[1],
 					$invokedParametersCount,
 					$functionParametersMinCount
-				);
+				))->build();
 			} elseif ($functionParametersMaxCount === -1 && $invokedParametersCount < $functionParametersMinCount) {
-				$errors[] = sprintf(
+				$errors[] = RuleErrorBuilder::message(sprintf(
 					$invokedParametersCount === 1 ? $messages[2] : $messages[3],
 					$invokedParametersCount,
 					$functionParametersMinCount
-				);
+				))->build();
 			} elseif ($functionParametersMaxCount !== -1) {
-				$errors[] = sprintf(
+				$errors[] = RuleErrorBuilder::message(sprintf(
 					$invokedParametersCount === 1 ? $messages[4] : $messages[5],
 					$invokedParametersCount,
 					$functionParametersMinCount,
 					$functionParametersMaxCount
-				);
+				))->build();
 			}
 		}
 
@@ -110,7 +110,7 @@ public function check(
 			&& !$scope->isInFirstLevelStatement()
 			&& !$funcCall instanceof \PhpParser\Node\Expr\New_
 		) {
-			$errors[] = $messages[7];
+			$errors[] = RuleErrorBuilder::message($messages[7])->build();
 		}
 
 		if (!$this->checkArgumentTypes && !$this->checkArgumentsPassedByReference) {
@@ -136,11 +136,11 @@ static function (Type $type): bool {
 					!$iterableTypeResultType instanceof ErrorType
 					&& !$iterableTypeResultType->isIterable()->yes()
 				) {
-					$errors[] = sprintf(
+					$errors[] = RuleErrorBuilder::message(sprintf(
 						'Only iterables can be unpacked, %s given in argument #%d.',
 						$iterableTypeResultType->describe(VerbosityLevel::typeOnly()),
 						$i + 1
-					);
+					))->build();
 				}
 			}
 
@@ -192,13 +192,13 @@ static function (Type $type): bool {
 				$verbosityLevel = TypeUtils::containsCallable($parameterType) || count(TypeUtils::getConstantArrays($parameterType)) > 0
 					? VerbosityLevel::value()
 					: VerbosityLevel::typeOnly();
-				$errors[] = sprintf(
+				$errors[] = RuleErrorBuilder::message(sprintf(
 					$messages[6],
 					$i + 1,
 					sprintf('%s$%s', $parameter->isVariadic() ? '...' : '', $parameter->getName()),
 					$parameterType->describe($verbosityLevel),
 					$argumentValueType->describe($verbosityLevel)
-				);
+				))->build();
 			}
 
 			if (
@@ -212,11 +212,11 @@ static function (Type $type): bool {
 				continue;
 			}
 
-			$errors[] = sprintf(
+			$errors[] = RuleErrorBuilder::message(sprintf(
 				$messages[8],
 				$i + 1,
 				sprintf('%s$%s', $parameter->isVariadic() ? '...' : '', $parameter->getName())
-			);
+			))->build();
 		}
 
 		foreach ($parametersAcceptor->getResolvedTemplateTypeMap()->getTypes() as $name => $type) {
@@ -224,7 +224,7 @@ static function (Type $type): bool {
 				continue;
 			}
 
-			$errors[] = sprintf($messages[9], $name);
+			$errors[] = RuleErrorBuilder::message(sprintf($messages[9], $name))->build();
 		}
 
 		return $errors;
diff --git a/src/Rules/FunctionReturnTypeCheck.php b/src/Rules/FunctionReturnTypeCheck.php
index ffce920287..9449de9b9f 100644
--- a/src/Rules/FunctionReturnTypeCheck.php
+++ b/src/Rules/FunctionReturnTypeCheck.php
@@ -30,7 +30,7 @@ public function __construct(RuleLevelHelper $ruleLevelHelper)
 	 * @param string $voidMessage
 	 * @param string $typeMismatchMessage
 	 * @param bool $isGenerator
-	 * @return string[]
+	 * @return RuleError[]
 	 */
 	public function checkReturnType(
 		Scope $scope,
@@ -67,10 +67,10 @@ public function checkReturnType(
 			}
 
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					$emptyReturnStatementMessage,
 					$returnType->describe($verbosityLevel)
-				),
+				))->build(),
 			];
 		}
 
@@ -78,20 +78,20 @@ public function checkReturnType(
 
 		if ($isVoidSuperType->yes()) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					$voidMessage,
 					$returnValueType->describe($verbosityLevel)
-				),
+				))->build(),
 			];
 		}
 
 		if (!$this->ruleLevelHelper->accepts($returnType, $returnValueType, $scope->isDeclareStrictTypes())) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					$typeMismatchMessage,
 					$returnType->describe($verbosityLevel),
 					$returnValueType->describe($verbosityLevel)
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Functions/ArrowFunctionReturnTypeRule.php b/src/Rules/Functions/ArrowFunctionReturnTypeRule.php
index eeb52f7762..6933156657 100644
--- a/src/Rules/Functions/ArrowFunctionReturnTypeRule.php
+++ b/src/Rules/Functions/ArrowFunctionReturnTypeRule.php
@@ -8,6 +8,9 @@
 use PHPStan\Rules\FunctionReturnTypeCheck;
 use PHPStan\Type\ObjectType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PHPStan\Node\InArrowFunctionNode>
+ */
 class ArrowFunctionReturnTypeRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +27,6 @@ public function getNodeType(): string
 		return InArrowFunctionNode::class;
 	}
 
-	/**
-	 * @param \PHPStan\Node\InArrowFunctionNode $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$scope->isInAnonymousFunction()) {
diff --git a/src/Rules/Functions/CallCallablesRule.php b/src/Rules/Functions/CallCallablesRule.php
index 2bc5a40357..776a6726c6 100644
--- a/src/Rules/Functions/CallCallablesRule.php
+++ b/src/Rules/Functions/CallCallablesRule.php
@@ -6,12 +6,16 @@
 use PHPStan\Reflection\InaccessibleMethod;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\FunctionCallParametersCheck;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ClosureType;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\FuncCall>
+ */
 class CallCallablesRule implements \PHPStan\Rules\Rule
 {
 
@@ -40,11 +44,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr\FuncCall::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\FuncCall $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return (string|\PHPStan\Rules\RuleError)[]
-	 */
 	public function processNode(
 		\PhpParser\Node $node,
 		Scope $scope
@@ -70,12 +69,16 @@ static function (Type $type): bool {
 		$isCallable = $type->isCallable();
 		if ($isCallable->no()) {
 			return [
-				sprintf('Trying to invoke %s but it\'s not a callable.', $type->describe(VerbosityLevel::value())),
+				RuleErrorBuilder::message(
+					sprintf('Trying to invoke %s but it\'s not a callable.', $type->describe(VerbosityLevel::value()))
+				)->build(),
 			];
 		}
 		if ($this->reportMaybes && $isCallable->maybe()) {
 			return [
-				sprintf('Trying to invoke %s but it might not be a callable.', $type->describe(VerbosityLevel::value())),
+				RuleErrorBuilder::message(
+					sprintf('Trying to invoke %s but it might not be a callable.', $type->describe(VerbosityLevel::value()))
+				)->build(),
 			];
 		}
 
@@ -87,12 +90,12 @@ static function (Type $type): bool {
 			&& $parametersAcceptors[0] instanceof InaccessibleMethod
 		) {
 			$method = $parametersAcceptors[0]->getMethod();
-			$messages[] = sprintf(
+			$messages[] = RuleErrorBuilder::message(sprintf(
 				'Call to %s method %s() of class %s.',
 				$method->isPrivate() ? 'private' : 'protected',
 				$method->getName(),
 				$method->getDeclaringClass()->getDisplayName()
-			);
+			))->build();
 		}
 
 		$parametersAcceptor = ParametersAcceptorSelector::selectFromArgs(
diff --git a/src/Rules/Functions/CallToFunctionParametersRule.php b/src/Rules/Functions/CallToFunctionParametersRule.php
index e311e0204a..e81f4e80e2 100644
--- a/src/Rules/Functions/CallToFunctionParametersRule.php
+++ b/src/Rules/Functions/CallToFunctionParametersRule.php
@@ -9,6 +9,9 @@
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\FunctionCallParametersCheck;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\FuncCall>
+ */
 class CallToFunctionParametersRule implements \PHPStan\Rules\Rule
 {
 
@@ -29,11 +32,6 @@ public function getNodeType(): string
 		return FuncCall::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\FuncCall $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!($node->name instanceof \PhpParser\Node\Name)) {
diff --git a/src/Rules/Functions/CallToFunctionStamentWithoutSideEffectsRule.php b/src/Rules/Functions/CallToFunctionStamentWithoutSideEffectsRule.php
index a406c9d100..c18a244424 100644
--- a/src/Rules/Functions/CallToFunctionStamentWithoutSideEffectsRule.php
+++ b/src/Rules/Functions/CallToFunctionStamentWithoutSideEffectsRule.php
@@ -6,7 +6,11 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Broker\Broker;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Expression>
+ */
 class CallToFunctionStamentWithoutSideEffectsRule implements Rule
 {
 
@@ -23,11 +27,6 @@ public function getNodeType(): string
 		return Node\Stmt\Expression::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Expression $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$node->expr instanceof Node\Expr\FuncCall) {
@@ -46,7 +45,10 @@ public function processNode(Node $node, Scope $scope): array
 		$function = $this->broker->getFunction($funcCall->name, $scope);
 		if ($function->hasSideEffects()->no()) {
 			return [
-				sprintf('Call to function %s() on a separate line has no effect.', $function->getName()),
+				RuleErrorBuilder::message(sprintf(
+					'Call to function %s() on a separate line has no effect.',
+					$function->getName()
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Functions/CallToNonExistentFunctionRule.php b/src/Rules/Functions/CallToNonExistentFunctionRule.php
index 47557d2fd2..730255b36b 100644
--- a/src/Rules/Functions/CallToNonExistentFunctionRule.php
+++ b/src/Rules/Functions/CallToNonExistentFunctionRule.php
@@ -6,7 +6,11 @@
 use PhpParser\Node\Expr\FuncCall;
 use PHPStan\Analyser\Scope;
 use PHPStan\Broker\Broker;
+use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\FuncCall>
+ */
 class CallToNonExistentFunctionRule implements \PHPStan\Rules\Rule
 {
 
@@ -30,11 +34,6 @@ public function getNodeType(): string
 		return FuncCall::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\FuncCall $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!($node->name instanceof \PhpParser\Node\Name)) {
@@ -42,7 +41,9 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		if (!$this->broker->hasFunction($node->name, $scope)) {
-			return [sprintf('Function %s not found.', (string) $node->name)];
+			return [
+				RuleErrorBuilder::message(sprintf('Function %s not found.', (string) $node->name))->build(),
+			];
 		}
 
 		$function = $this->broker->getFunction($node->name, $scope);
@@ -55,7 +56,13 @@ public function processNode(Node $node, Scope $scope): array
 				strtolower($function->getName()) === strtolower($calledFunctionName)
 				&& $function->getName() !== $calledFunctionName
 			) {
-				return [sprintf('Call to function %s() with incorrect case: %s', $function->getName(), $name)];
+				return [
+					RuleErrorBuilder::message(sprintf(
+						'Call to function %s() with incorrect case: %s',
+						$function->getName(),
+						$name
+					))->build(),
+				];
 			}
 		}
 
diff --git a/src/Rules/Functions/ClosureReturnTypeRule.php b/src/Rules/Functions/ClosureReturnTypeRule.php
index 8d77ad6683..4a8ea3a73c 100644
--- a/src/Rules/Functions/ClosureReturnTypeRule.php
+++ b/src/Rules/Functions/ClosureReturnTypeRule.php
@@ -8,6 +8,9 @@
 use PHPStan\Rules\FunctionReturnTypeCheck;
 use PHPStan\Type\ObjectType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Return_>
+ */
 class ClosureReturnTypeRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +27,6 @@ public function getNodeType(): string
 		return Return_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Return_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$scope->isInAnonymousFunction()) {
diff --git a/src/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRule.php b/src/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRule.php
index 059b23fc26..6b3b522a7e 100644
--- a/src/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRule.php
+++ b/src/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRule.php
@@ -5,8 +5,10 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\FunctionDefinitionCheck;
-use PHPStan\Rules\RuleError;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\ArrowFunction>
+ */
 class ExistingClassesInArrowFunctionTypehintsRule implements \PHPStan\Rules\Rule
 {
 
@@ -23,11 +25,6 @@ public function getNodeType(): string
 		return Node\Expr\ArrowFunction::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\ArrowFunction $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		return $this->check->checkAnonymousFunction(
diff --git a/src/Rules/Functions/ExistingClassesInClosureTypehintsRule.php b/src/Rules/Functions/ExistingClassesInClosureTypehintsRule.php
index 228151369b..88005e65f6 100644
--- a/src/Rules/Functions/ExistingClassesInClosureTypehintsRule.php
+++ b/src/Rules/Functions/ExistingClassesInClosureTypehintsRule.php
@@ -6,8 +6,10 @@
 use PhpParser\Node\Expr\Closure;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\FunctionDefinitionCheck;
-use PHPStan\Rules\RuleError;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Closure>
+ */
 class ExistingClassesInClosureTypehintsRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +26,6 @@ public function getNodeType(): string
 		return Closure::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Closure $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		return $this->check->checkAnonymousFunction(
diff --git a/src/Rules/Functions/ExistingClassesInTypehintsRule.php b/src/Rules/Functions/ExistingClassesInTypehintsRule.php
index 2386636ccc..eab699fa50 100644
--- a/src/Rules/Functions/ExistingClassesInTypehintsRule.php
+++ b/src/Rules/Functions/ExistingClassesInTypehintsRule.php
@@ -6,8 +6,10 @@
 use PhpParser\Node\Stmt\Function_;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\FunctionDefinitionCheck;
-use PHPStan\Rules\RuleError;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Function_>
+ */
 class ExistingClassesInTypehintsRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +26,6 @@ public function getNodeType(): string
 		return Function_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Function_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		return $this->check->checkFunction(
diff --git a/src/Rules/Functions/IncompatibleDefaultParameterTypeRule.php b/src/Rules/Functions/IncompatibleDefaultParameterTypeRule.php
index ef9d31947e..e88b6b8ad4 100644
--- a/src/Rules/Functions/IncompatibleDefaultParameterTypeRule.php
+++ b/src/Rules/Functions/IncompatibleDefaultParameterTypeRule.php
@@ -9,10 +9,12 @@
 use PHPStan\Broker\Broker;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\Rule;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\FunctionLike>
+ */
 class IncompatibleDefaultParameterTypeRule implements Rule
 {
 
@@ -29,11 +31,6 @@ public function getNodeType(): string
 		return FunctionLike::class;
 	}
 
-	/**
-	 * @param FunctionLike $node
-	 * @param Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!($node instanceof Function_)) {
diff --git a/src/Rules/Functions/InnerFunctionRule.php b/src/Rules/Functions/InnerFunctionRule.php
index fc43ab613c..5d0c0cfe93 100644
--- a/src/Rules/Functions/InnerFunctionRule.php
+++ b/src/Rules/Functions/InnerFunctionRule.php
@@ -5,7 +5,11 @@
 use PhpParser\Node;
 use PhpParser\Node\Stmt\Function_;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Function_>
+ */
 class InnerFunctionRule implements \PHPStan\Rules\Rule
 {
 
@@ -14,11 +18,6 @@ public function getNodeType(): string
 		return Function_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Function_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if ($scope->getFunction() === null) {
@@ -26,7 +25,9 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		return [
-			'Inner named functions are not supported by PHPStan. Consider refactoring to an anonymous function, class method, or a top-level-defined function. See issue #165 (https://github.com/phpstan/phpstan/issues/165) for more details.',
+			RuleErrorBuilder::message(
+				'Inner named functions are not supported by PHPStan. Consider refactoring to an anonymous function, class method, or a top-level-defined function. See issue #165 (https://github.com/phpstan/phpstan/issues/165) for more details.'
+			)->build(),
 		];
 	}
 
diff --git a/src/Rules/Functions/NonExistentDefinedFunctionRule.php b/src/Rules/Functions/NonExistentDefinedFunctionRule.php
index 4f99bbfdd0..ae78a2b9cb 100644
--- a/src/Rules/Functions/NonExistentDefinedFunctionRule.php
+++ b/src/Rules/Functions/NonExistentDefinedFunctionRule.php
@@ -7,7 +7,11 @@
 use PhpParser\Node\Stmt\Function_;
 use PHPStan\Analyser\Scope;
 use PHPStan\Broker\Broker;
+use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Function_>
+ */
 class NonExistentDefinedFunctionRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +28,6 @@ public function getNodeType(): string
 		return Function_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Function_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$functionName = $node->name->name;
@@ -41,10 +40,10 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		return [
-			sprintf(
+			RuleErrorBuilder::message(sprintf(
 				'Function %s not found while trying to analyse it - autoloading is probably not configured properly.',
 				$functionName
-			),
+			))->build(),
 		];
 	}
 
diff --git a/src/Rules/Functions/PrintfParametersRule.php b/src/Rules/Functions/PrintfParametersRule.php
index 9ad60f6967..2b6bc3aeb5 100644
--- a/src/Rules/Functions/PrintfParametersRule.php
+++ b/src/Rules/Functions/PrintfParametersRule.php
@@ -5,8 +5,12 @@
 use PhpParser\Node;
 use PhpParser\Node\Expr\FuncCall;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\TypeUtils;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\FuncCall>
+ */
 class PrintfParametersRule implements \PHPStan\Rules\Rule
 {
 
@@ -15,11 +19,6 @@ public function getNodeType(): string
 		return FuncCall::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\FuncCall $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!($node->name instanceof \PhpParser\Node\Name)) {
@@ -77,7 +76,7 @@ public function processNode(Node $node, Scope $scope): array
 
 		if ($argsCount !== $placeHoldersCount + 1) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					sprintf(
 						'%s, %s.',
 						$placeHoldersCount === 1 ? 'Call to %s contains %d placeholder' : 'Call to %s contains %d placeholders',
@@ -86,7 +85,7 @@ public function processNode(Node $node, Scope $scope): array
 					$name,
 					$placeHoldersCount,
 					$argsCount - 1
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Functions/ReturnTypeRule.php b/src/Rules/Functions/ReturnTypeRule.php
index 5d6f841979..7d9f27c992 100644
--- a/src/Rules/Functions/ReturnTypeRule.php
+++ b/src/Rules/Functions/ReturnTypeRule.php
@@ -10,6 +10,9 @@
 use PHPStan\Reflection\Php\PhpMethodFromParserNodeReflection;
 use PHPStan\Rules\FunctionReturnTypeCheck;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Return_>
+ */
 class ReturnTypeRule implements \PHPStan\Rules\Rule
 {
 
@@ -26,11 +29,6 @@ public function getNodeType(): string
 		return Return_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Return_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if ($scope->getFunction() === null) {
diff --git a/src/Rules/Functions/UnusedClosureUsesRule.php b/src/Rules/Functions/UnusedClosureUsesRule.php
index 2c2aa2fc33..99d77a2812 100644
--- a/src/Rules/Functions/UnusedClosureUsesRule.php
+++ b/src/Rules/Functions/UnusedClosureUsesRule.php
@@ -6,6 +6,9 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\UnusedFunctionParametersCheck;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Closure>
+ */
 class UnusedClosureUsesRule implements \PHPStan\Rules\Rule
 {
 
@@ -22,11 +25,6 @@ public function getNodeType(): string
 		return Node\Expr\Closure::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Closure $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (count($node->uses) === 0) {
diff --git a/src/Rules/Generators/YieldFromTypeRule.php b/src/Rules/Generators/YieldFromTypeRule.php
index ee1e134e85..ab30bc2f4b 100644
--- a/src/Rules/Generators/YieldFromTypeRule.php
+++ b/src/Rules/Generators/YieldFromTypeRule.php
@@ -7,7 +7,6 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\Rule;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\GenericTypeVariableResolver;
@@ -15,6 +14,9 @@
 use PHPStan\Type\TypeWithClassName;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\YieldFrom>
+ */
 class YieldFromTypeRule implements Rule
 {
 
@@ -38,11 +40,6 @@ public function getNodeType(): string
 		return YieldFrom::class;
 	}
 
-	/**
-	 * @param YieldFrom $node
-	 * @param Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$exprType = $scope->getType($node->expr);
diff --git a/src/Rules/Generators/YieldInGeneratorRule.php b/src/Rules/Generators/YieldInGeneratorRule.php
index 6e4ac51503..ddfaab3e09 100644
--- a/src/Rules/Generators/YieldInGeneratorRule.php
+++ b/src/Rules/Generators/YieldInGeneratorRule.php
@@ -6,12 +6,14 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\Rule;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\MixedType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr>
+ */
 class YieldInGeneratorRule implements Rule
 {
 
@@ -28,11 +30,6 @@ public function getNodeType(): string
 		return Node\Expr::class;
 	}
 
-	/**
-	 * @param Node\Expr $node
-	 * @param Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$node instanceof Node\Expr\Yield_ && !$node instanceof Node\Expr\YieldFrom) {
diff --git a/src/Rules/Generators/YieldTypeRule.php b/src/Rules/Generators/YieldTypeRule.php
index 59bdc966cd..8059b02fd3 100644
--- a/src/Rules/Generators/YieldTypeRule.php
+++ b/src/Rules/Generators/YieldTypeRule.php
@@ -6,7 +6,6 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\Rule;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\IntegerType;
@@ -14,6 +13,9 @@
 use PHPStan\Type\NullType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Yield_>
+ */
 class YieldTypeRule implements Rule
 {
 
@@ -32,11 +34,6 @@ public function getNodeType(): string
 		return Node\Expr\Yield_::class;
 	}
 
-	/**
-	 * @param Node\Expr\Yield_ $node
-	 * @param Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$anonymousFunctionReturnType = $scope->getAnonymousFunctionReturnType();
diff --git a/src/Rules/Generics/ClassAncestorsRule.php b/src/Rules/Generics/ClassAncestorsRule.php
index 03fea134a6..a9dfa3ce81 100644
--- a/src/Rules/Generics/ClassAncestorsRule.php
+++ b/src/Rules/Generics/ClassAncestorsRule.php
@@ -10,6 +10,9 @@
 use PHPStan\Type\FileTypeMapper;
 use PHPStan\Type\Type;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Class_>
+ */
 class ClassAncestorsRule implements Rule
 {
 
@@ -33,11 +36,6 @@ public function getNodeType(): string
 		return Node\Stmt\Class_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Class_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return \PHPStan\Rules\RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!isset($node->namespacedName)) {
diff --git a/src/Rules/Generics/ClassTemplateTypeRule.php b/src/Rules/Generics/ClassTemplateTypeRule.php
index b5ae95553f..762c2712dd 100644
--- a/src/Rules/Generics/ClassTemplateTypeRule.php
+++ b/src/Rules/Generics/ClassTemplateTypeRule.php
@@ -8,6 +8,9 @@
 use PHPStan\Type\FileTypeMapper;
 use PHPStan\Type\Generic\TemplateTypeScope;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Class_>
+ */
 class ClassTemplateTypeRule implements Rule
 {
 
@@ -31,11 +34,6 @@ public function getNodeType(): string
 		return Node\Stmt\Class_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Class_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return \PHPStan\Rules\RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$docComment = $node->getDocComment();
diff --git a/src/Rules/Generics/FunctionTemplateTypeRule.php b/src/Rules/Generics/FunctionTemplateTypeRule.php
index 4c16b55068..54f445283c 100644
--- a/src/Rules/Generics/FunctionTemplateTypeRule.php
+++ b/src/Rules/Generics/FunctionTemplateTypeRule.php
@@ -8,6 +8,9 @@
 use PHPStan\Type\FileTypeMapper;
 use PHPStan\Type\Generic\TemplateTypeScope;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Function_>
+ */
 class FunctionTemplateTypeRule implements Rule
 {
 
@@ -31,11 +34,6 @@ public function getNodeType(): string
 		return Node\Stmt\Function_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Function_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return \PHPStan\Rules\RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$docComment = $node->getDocComment();
diff --git a/src/Rules/Generics/InterfaceAncestorsRule.php b/src/Rules/Generics/InterfaceAncestorsRule.php
index cc2bab1c56..fdebc862a0 100644
--- a/src/Rules/Generics/InterfaceAncestorsRule.php
+++ b/src/Rules/Generics/InterfaceAncestorsRule.php
@@ -10,6 +10,9 @@
 use PHPStan\Type\FileTypeMapper;
 use PHPStan\Type\Type;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Interface_>
+ */
 class InterfaceAncestorsRule implements Rule
 {
 
@@ -33,11 +36,6 @@ public function getNodeType(): string
 		return Node\Stmt\Interface_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Interface_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return \PHPStan\Rules\RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!isset($node->namespacedName)) {
diff --git a/src/Rules/Generics/InterfaceTemplateTypeRule.php b/src/Rules/Generics/InterfaceTemplateTypeRule.php
index 77a624f505..ad4adc4afd 100644
--- a/src/Rules/Generics/InterfaceTemplateTypeRule.php
+++ b/src/Rules/Generics/InterfaceTemplateTypeRule.php
@@ -8,6 +8,9 @@
 use PHPStan\Type\FileTypeMapper;
 use PHPStan\Type\Generic\TemplateTypeScope;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Interface_>
+ */
 class InterfaceTemplateTypeRule implements Rule
 {
 
@@ -31,11 +34,6 @@ public function getNodeType(): string
 		return Node\Stmt\Interface_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Interface_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return \PHPStan\Rules\RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$docComment = $node->getDocComment();
diff --git a/src/Rules/Generics/MethodTemplateTypeRule.php b/src/Rules/Generics/MethodTemplateTypeRule.php
index 83c9434aa9..fc6ac03ffa 100644
--- a/src/Rules/Generics/MethodTemplateTypeRule.php
+++ b/src/Rules/Generics/MethodTemplateTypeRule.php
@@ -10,6 +10,9 @@
 use PHPStan\Type\Generic\TemplateTypeScope;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\ClassMethod>
+ */
 class MethodTemplateTypeRule implements Rule
 {
 
@@ -33,11 +36,6 @@ public function getNodeType(): string
 		return Node\Stmt\ClassMethod::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Interface_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return \PHPStan\Rules\RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$docComment = $node->getDocComment();
diff --git a/src/Rules/Generics/TraitTemplateTypeRule.php b/src/Rules/Generics/TraitTemplateTypeRule.php
index 13ad842c47..b8386e97aa 100644
--- a/src/Rules/Generics/TraitTemplateTypeRule.php
+++ b/src/Rules/Generics/TraitTemplateTypeRule.php
@@ -8,6 +8,9 @@
 use PHPStan\Type\FileTypeMapper;
 use PHPStan\Type\Generic\TemplateTypeScope;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Trait_>
+ */
 class TraitTemplateTypeRule implements Rule
 {
 
@@ -31,11 +34,6 @@ public function getNodeType(): string
 		return Node\Stmt\Trait_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Trait_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return \PHPStan\Rules\RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$docComment = $node->getDocComment();
diff --git a/src/Rules/Methods/CallMethodsRule.php b/src/Rules/Methods/CallMethodsRule.php
index cead610e27..523e5a3c26 100644
--- a/src/Rules/Methods/CallMethodsRule.php
+++ b/src/Rules/Methods/CallMethodsRule.php
@@ -8,11 +8,15 @@
 use PHPStan\Broker\Broker;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\FunctionCallParametersCheck;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\MethodCall>
+ */
 class CallMethodsRule implements \PHPStan\Rules\Rule
 {
 
@@ -51,11 +55,6 @@ public function getNodeType(): string
 		return MethodCall::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\MethodCall $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return (string|\PHPStan\Rules\RuleError)[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$node->name instanceof Node\Identifier) {
@@ -77,7 +76,11 @@ static function (Type $type) use ($name): bool {
 		}
 		if (!$type->canCallMethods()->yes()) {
 			return [
-				sprintf('Cannot call method %s() on %s.', $name, $type->describe(VerbosityLevel::typeOnly())),
+				RuleErrorBuilder::message(sprintf(
+					'Cannot call method %s() on %s.',
+					$name,
+					$type->describe(VerbosityLevel::typeOnly())
+				))->build(),
 			];
 		}
 
@@ -103,11 +106,11 @@ static function (Type $type) use ($name): bool {
 				while ($parentClassReflection !== false) {
 					if ($parentClassReflection->hasMethod($name)) {
 						return [
-							sprintf(
+							RuleErrorBuilder::message(sprintf(
 								'Call to private method %s() of parent class %s.',
 								$parentClassReflection->getMethod($name, $scope)->getName(),
 								$parentClassReflection->getDisplayName()
-							),
+							))->build(),
 						];
 					}
 
@@ -116,11 +119,11 @@ static function (Type $type) use ($name): bool {
 			}
 
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Call to an undefined method %s::%s().',
 					$type->describe(VerbosityLevel::typeOnly()),
 					$name
-				),
+				))->build(),
 			];
 		}
 
@@ -128,12 +131,12 @@ static function (Type $type) use ($name): bool {
 		$messagesMethodName = $methodReflection->getDeclaringClass()->getDisplayName() . '::' . $methodReflection->getName() . '()';
 		$errors = [];
 		if (!$scope->canCallMethod($methodReflection)) {
-			$errors[] = sprintf(
+			$errors[] = RuleErrorBuilder::message(sprintf(
 				'Call to %s method %s() of class %s.',
 				$methodReflection->isPrivate() ? 'private' : 'protected',
 				$methodReflection->getName(),
 				$methodReflection->getDeclaringClass()->getDisplayName()
-			);
+			))->build();
 		}
 
 		$errors = array_merge($errors, $this->check->check(
@@ -163,7 +166,9 @@ static function (Type $type) use ($name): bool {
 			&& strtolower($methodReflection->getName()) === strtolower($name)
 			&& $methodReflection->getName() !== $name
 		) {
-			$errors[] = sprintf('Call to method %s with incorrect case: %s', $messagesMethodName, $name);
+			$errors[] = RuleErrorBuilder::message(
+				sprintf('Call to method %s with incorrect case: %s', $messagesMethodName, $name)
+			)->build();
 		}
 
 		return $errors;
diff --git a/src/Rules/Methods/CallStaticMethodsRule.php b/src/Rules/Methods/CallStaticMethodsRule.php
index 4df0f5228c..e1ff374b05 100644
--- a/src/Rules/Methods/CallStaticMethodsRule.php
+++ b/src/Rules/Methods/CallStaticMethodsRule.php
@@ -12,6 +12,7 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\ClassNameNodePair;
 use PHPStan\Rules\FunctionCallParametersCheck;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\ObjectType;
@@ -84,34 +85,34 @@ public function processNode(Node $node, Scope $scope): array
 			if (in_array($lowercasedClassName, ['self', 'static'], true)) {
 				if (!$scope->isInClass()) {
 					return [
-						sprintf(
+						RuleErrorBuilder::message(sprintf(
 							'Calling %s::%s() outside of class scope.',
 							$className,
 							$methodName
-						),
+						))->build(),
 					];
 				}
 				$className = $scope->getClassReflection()->getName();
 			} elseif ($lowercasedClassName === 'parent') {
 				if (!$scope->isInClass()) {
 					return [
-						sprintf(
+						RuleErrorBuilder::message(sprintf(
 							'Calling %s::%s() outside of class scope.',
 							$className,
 							$methodName
-						),
+						))->build(),
 					];
 				}
 				$currentClassReflection = $scope->getClassReflection();
 				if ($currentClassReflection->getParentClass() === false) {
 					return [
-						sprintf(
+						RuleErrorBuilder::message(sprintf(
 							'%s::%s() calls parent::%s() but %s does not extend any class.',
 							$scope->getClassReflection()->getDisplayName(),
 							$scope->getFunctionName(),
 							$methodName,
 							$scope->getClassReflection()->getDisplayName()
-						),
+						))->build(),
 					];
 				}
 
@@ -123,7 +124,11 @@ public function processNode(Node $node, Scope $scope): array
 			} else {
 				if (!$this->broker->hasClass($className)) {
 					return [
-						sprintf('Call to static method %s() on an unknown class %s.', $methodName, $className),
+						RuleErrorBuilder::message(sprintf(
+							'Call to static method %s() on an unknown class %s.',
+							$methodName,
+							$className
+						))->build(),
 					];
 				} else {
 					$errors = $this->classCaseSensitivityCheck->checkClassNames([new ClassNameNodePair($className, $class)]);
@@ -159,7 +164,11 @@ static function (Type $type) use ($methodName): bool {
 
 		if (!$classType->canCallMethods()->yes()) {
 			return array_merge($errors, [
-				sprintf('Cannot call static method %s() on %s.', $methodName, $typeForDescribe->describe(VerbosityLevel::typeOnly())),
+				RuleErrorBuilder::message(sprintf(
+					'Cannot call static method %s() on %s.',
+					$methodName,
+					$typeForDescribe->describe(VerbosityLevel::typeOnly())
+				))->build(),
 			]);
 		}
 
@@ -179,11 +188,11 @@ static function (Type $type) use ($methodName): bool {
 			}
 
 			return array_merge($errors, [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Call to an undefined static method %s::%s().',
 					$typeForDescribe->describe(VerbosityLevel::typeOnly()),
 					$methodName
-				),
+				))->build(),
 			]);
 		}
 
@@ -201,34 +210,34 @@ static function (Type $type) use ($methodName): bool {
 				)
 			) {
 				return array_merge($errors, [
-					sprintf(
+					RuleErrorBuilder::message(sprintf(
 						'Static call to instance method %s::%s().',
 						$method->getDeclaringClass()->getDisplayName(),
 						$method->getName()
-					),
+					))->build(),
 				]);
 			}
 		}
 
 		if (!$scope->canCallMethod($method)) {
 			$errors = array_merge($errors, [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Call to %s %s %s() of class %s.',
 					$method->isPrivate() ? 'private' : 'protected',
 					$method->isStatic() ? 'static method' : 'method',
 					$method->getName(),
 					$method->getDeclaringClass()->getDisplayName()
-				),
+				))->build(),
 			]);
 		}
 
 		if ($isInterface && $method->isStatic()) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Cannot call static method %s() on interface %s.',
 					$method->getName(),
 					$classType->describe(VerbosityLevel::typeOnly())
-				),
+				))->build(),
 			];
 		}
 
@@ -269,7 +278,11 @@ static function (Type $type) use ($methodName): bool {
 			$this->checkFunctionNameCase
 			&& $method->getName() !== $methodName
 		) {
-			$errors[] = sprintf('Call to %s with incorrect case: %s', $lowercasedMethodName, $methodName);
+			$errors[] = RuleErrorBuilder::message(sprintf(
+				'Call to %s with incorrect case: %s',
+				$lowercasedMethodName,
+				$methodName
+			))->build();
 		}
 
 		return $errors;
diff --git a/src/Rules/Methods/CallToMethodStamentWithoutSideEffectsRule.php b/src/Rules/Methods/CallToMethodStamentWithoutSideEffectsRule.php
index 3bae41df09..cb3941fef5 100644
--- a/src/Rules/Methods/CallToMethodStamentWithoutSideEffectsRule.php
+++ b/src/Rules/Methods/CallToMethodStamentWithoutSideEffectsRule.php
@@ -5,10 +5,14 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\Type;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Expression>
+ */
 class CallToMethodStamentWithoutSideEffectsRule implements Rule
 {
 
@@ -25,11 +29,6 @@ public function getNodeType(): string
 		return Node\Stmt\Expression::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Expression $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$node->expr instanceof Node\Expr\MethodCall) {
@@ -65,12 +64,12 @@ static function (Type $type) use ($methodName): bool {
 		$method = $calledOnType->getMethod($methodName, $scope);
 		if ($method->hasSideEffects()->no()) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Call to %s %s::%s() on a separate line has no effect.',
 					$method->isStatic() ? 'static method' : 'method',
 					$method->getDeclaringClass()->getDisplayName(),
 					$method->getName()
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Methods/CallToStaticMethodStamentWithoutSideEffectsRule.php b/src/Rules/Methods/CallToStaticMethodStamentWithoutSideEffectsRule.php
index 0fa698f748..3fcddb3d76 100644
--- a/src/Rules/Methods/CallToStaticMethodStamentWithoutSideEffectsRule.php
+++ b/src/Rules/Methods/CallToStaticMethodStamentWithoutSideEffectsRule.php
@@ -6,11 +6,15 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Broker\Broker;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Expression>
+ */
 class CallToStaticMethodStamentWithoutSideEffectsRule implements Rule
 {
 
@@ -34,11 +38,6 @@ public function getNodeType(): string
 		return Node\Stmt\Expression::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Expression $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$node->expr instanceof Node\Expr\StaticCall) {
@@ -84,12 +83,12 @@ static function (Type $type) use ($methodName): bool {
 		$method = $calledOnType->getMethod($methodName, $scope);
 		if ($method->hasSideEffects()->no()) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Call to %s %s::%s() on a separate line has no effect.',
 					$method->isStatic() ? 'static method' : 'method',
 					$method->getDeclaringClass()->getDisplayName(),
 					$method->getName()
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Methods/ExistingClassesInTypehintsRule.php b/src/Rules/Methods/ExistingClassesInTypehintsRule.php
index 9cffefc6a8..330ebe0ab5 100644
--- a/src/Rules/Methods/ExistingClassesInTypehintsRule.php
+++ b/src/Rules/Methods/ExistingClassesInTypehintsRule.php
@@ -7,8 +7,10 @@
 use PHPStan\Node\InClassMethodNode;
 use PHPStan\Reflection\Php\PhpMethodFromParserNodeReflection;
 use PHPStan\Rules\FunctionDefinitionCheck;
-use PHPStan\Rules\RuleError;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PHPStan\Node\InClassMethodNode>
+ */
 class ExistingClassesInTypehintsRule implements \PHPStan\Rules\Rule
 {
 
@@ -25,11 +27,6 @@ public function getNodeType(): string
 		return InClassMethodNode::class;
 	}
 
-	/**
-	 * @param \PHPStan\Node\InClassMethodNode $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$methodReflection = $scope->getFunction();
diff --git a/src/Rules/Methods/IncompatibleDefaultParameterTypeRule.php b/src/Rules/Methods/IncompatibleDefaultParameterTypeRule.php
index 1115ec4f0a..eaade51b60 100644
--- a/src/Rules/Methods/IncompatibleDefaultParameterTypeRule.php
+++ b/src/Rules/Methods/IncompatibleDefaultParameterTypeRule.php
@@ -8,10 +8,12 @@
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Reflection\Php\PhpMethodFromParserNodeReflection;
 use PHPStan\Rules\Rule;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PHPStan\Node\InClassMethodNode>
+ */
 class IncompatibleDefaultParameterTypeRule implements Rule
 {
 
@@ -20,11 +22,6 @@ public function getNodeType(): string
 		return InClassMethodNode::class;
 	}
 
-	/**
-	 * @param InClassMethodNode $node
-	 * @param Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$method = $scope->getFunction();
diff --git a/src/Rules/Methods/MethodSignatureRule.php b/src/Rules/Methods/MethodSignatureRule.php
index d62acd1d79..91cd3052a2 100644
--- a/src/Rules/Methods/MethodSignatureRule.php
+++ b/src/Rules/Methods/MethodSignatureRule.php
@@ -8,12 +8,16 @@
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\ParameterReflection;
 use PHPStan\Reflection\ParametersAcceptorSelector;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 use PHPStan\Type\VoidType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\ClassMethod>
+ */
 class MethodSignatureRule implements \PHPStan\Rules\Rule
 {
 
@@ -37,11 +41,6 @@ public function getNodeType(): string
 		return ClassMethod::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\ClassMethod $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$methodName = (string) $node->name;
@@ -71,7 +70,7 @@ public function processNode(Node $node, Scope $scope): array
 
 			$returnTypeCompatibility = $this->checkReturnTypeCompatibility($parameters->getReturnType(), $parentParameters->getReturnType());
 			if ($returnTypeCompatibility->no() || (!$returnTypeCompatibility->yes() && $this->reportMaybes)) {
-				$errors[] = sprintf(
+				$errors[] = RuleErrorBuilder::message(sprintf(
 					'Return type (%s) of method %s::%s() should be %s with return type (%s) of method %s::%s()',
 					$parameters->getReturnType()->describe(VerbosityLevel::typeOnly()),
 					$method->getDeclaringClass()->getDisplayName(),
@@ -80,7 +79,7 @@ public function processNode(Node $node, Scope $scope): array
 					$parentParameters->getReturnType()->describe(VerbosityLevel::typeOnly()),
 					$parentMethod->getDeclaringClass()->getDisplayName(),
 					$parentMethod->getName()
-				);
+				))->build();
 			}
 
 			$parameterResults = $this->checkParameterTypeCompatibility($parameters->getParameters(), $parentParameters->getParameters());
@@ -93,7 +92,7 @@ public function processNode(Node $node, Scope $scope): array
 				}
 				$parameter = $parameters->getParameters()[$parameterIndex];
 				$parentParameter = $parentParameters->getParameters()[$parameterIndex];
-				$errors[] = sprintf(
+				$errors[] = RuleErrorBuilder::message(sprintf(
 					'Parameter #%d $%s (%s) of method %s::%s() should be %s with parameter $%s (%s) of method %s::%s()',
 					$parameterIndex + 1,
 					$parameter->getName(),
@@ -105,7 +104,7 @@ public function processNode(Node $node, Scope $scope): array
 					$parentParameter->getType()->describe(VerbosityLevel::typeOnly()),
 					$parentMethod->getDeclaringClass()->getDisplayName(),
 					$parentMethod->getName()
-				);
+				))->build();
 			}
 		}
 
diff --git a/src/Rules/Methods/ReturnTypeRule.php b/src/Rules/Methods/ReturnTypeRule.php
index 2c68c20977..1f7c5d7eed 100644
--- a/src/Rules/Methods/ReturnTypeRule.php
+++ b/src/Rules/Methods/ReturnTypeRule.php
@@ -9,6 +9,9 @@
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\FunctionReturnTypeCheck;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Return_>
+ */
 class ReturnTypeRule implements \PHPStan\Rules\Rule
 {
 
@@ -25,11 +28,6 @@ public function getNodeType(): string
 		return Return_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Return_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if ($scope->getFunction() === null) {
diff --git a/src/Rules/Missing/MissingClosureNativeReturnTypehintRule.php b/src/Rules/Missing/MissingClosureNativeReturnTypehintRule.php
index 164102c528..eb7a41732c 100644
--- a/src/Rules/Missing/MissingClosureNativeReturnTypehintRule.php
+++ b/src/Rules/Missing/MissingClosureNativeReturnTypehintRule.php
@@ -6,7 +6,6 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Node\ClosureReturnStatementsNode;
 use PHPStan\Rules\Rule;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\IntersectionType;
@@ -20,6 +19,9 @@
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PHPStan\Node\ClosureReturnStatementsNode>
+ */
 class MissingClosureNativeReturnTypehintRule implements Rule
 {
 
@@ -36,11 +38,6 @@ public function getNodeType(): string
 		return ClosureReturnStatementsNode::class;
 	}
 
-	/**
-	 * @param \PHPStan\Node\ClosureReturnStatementsNode $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[] errors
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$closure = $node->getClosureExpr();
diff --git a/src/Rules/Missing/MissingReturnRule.php b/src/Rules/Missing/MissingReturnRule.php
index 74fe4da12b..635b74ef03 100644
--- a/src/Rules/Missing/MissingReturnRule.php
+++ b/src/Rules/Missing/MissingReturnRule.php
@@ -8,7 +8,6 @@
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\Rule;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Generic\TemplateMixedType;
 use PHPStan\Type\GenericTypeVariableResolver;
@@ -17,6 +16,9 @@
 use PHPStan\Type\VerbosityLevel;
 use PHPStan\Type\VoidType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PHPStan\Node\ExecutionEndNode>
+ */
 class MissingReturnRule implements Rule
 {
 
@@ -40,11 +42,6 @@ public function getNodeType(): string
 		return ExecutionEndNode::class;
 	}
 
-	/**
-	 * @param ExecutionEndNode $node
-	 * @param Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$statementResult = $node->getStatementResult();
diff --git a/src/Rules/Namespaces/ExistingNamesInGroupUseRule.php b/src/Rules/Namespaces/ExistingNamesInGroupUseRule.php
index 828e653658..eb01d6156e 100644
--- a/src/Rules/Namespaces/ExistingNamesInGroupUseRule.php
+++ b/src/Rules/Namespaces/ExistingNamesInGroupUseRule.php
@@ -11,6 +11,9 @@
 use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\GroupUse>
+ */
 class ExistingNamesInGroupUseRule implements \PHPStan\Rules\Rule
 {
 
@@ -39,11 +42,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Stmt\GroupUse::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\GroupUse $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$errors = [];
diff --git a/src/Rules/Namespaces/ExistingNamesInUseRule.php b/src/Rules/Namespaces/ExistingNamesInUseRule.php
index a1b8ba2b4a..841346906c 100644
--- a/src/Rules/Namespaces/ExistingNamesInUseRule.php
+++ b/src/Rules/Namespaces/ExistingNamesInUseRule.php
@@ -10,6 +10,9 @@
 use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Use_>
+ */
 class ExistingNamesInUseRule implements \PHPStan\Rules\Rule
 {
 
@@ -38,11 +41,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Stmt\Use_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Use_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if ($node->type === Node\Stmt\Use_::TYPE_UNKNOWN) {
diff --git a/src/Rules/Operators/InvalidBinaryOperationRule.php b/src/Rules/Operators/InvalidBinaryOperationRule.php
index a85bd416b6..929ab0e88d 100644
--- a/src/Rules/Operators/InvalidBinaryOperationRule.php
+++ b/src/Rules/Operators/InvalidBinaryOperationRule.php
@@ -5,13 +5,15 @@
 use PhpParser\Node;
 use PHPStan\Analyser\MutatingScope;
 use PHPStan\Analyser\Scope;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr>
+ */
 class InvalidBinaryOperationRule implements \PHPStan\Rules\Rule
 {
 
@@ -35,11 +37,6 @@ public function getNodeType(): string
 		return Node\Expr::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(\PhpParser\Node $node, Scope $scope): array
 	{
 		if (
diff --git a/src/Rules/Operators/InvalidComparisonOperationRule.php b/src/Rules/Operators/InvalidComparisonOperationRule.php
index 824a1bd129..c97f4053b2 100644
--- a/src/Rules/Operators/InvalidComparisonOperationRule.php
+++ b/src/Rules/Operators/InvalidComparisonOperationRule.php
@@ -4,7 +4,6 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
@@ -15,6 +14,9 @@
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\BinaryOp>
+ */
 class InvalidComparisonOperationRule implements \PHPStan\Rules\Rule
 {
 
@@ -31,11 +33,6 @@ public function getNodeType(): string
 		return Node\Expr\BinaryOp::class;
 	}
 
-	/**
-	 * @param Node $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (
diff --git a/src/Rules/Operators/InvalidIncDecOperationRule.php b/src/Rules/Operators/InvalidIncDecOperationRule.php
index 61af85194e..06137ef4b1 100644
--- a/src/Rules/Operators/InvalidIncDecOperationRule.php
+++ b/src/Rules/Operators/InvalidIncDecOperationRule.php
@@ -2,11 +2,13 @@
 
 namespace PHPStan\Rules\Operators;
 
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr>
+ */
 class InvalidIncDecOperationRule implements \PHPStan\Rules\Rule
 {
 
@@ -23,11 +25,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(\PhpParser\Node $node, \PHPStan\Analyser\Scope $scope): array
 	{
 		if (
diff --git a/src/Rules/Operators/InvalidUnaryOperationRule.php b/src/Rules/Operators/InvalidUnaryOperationRule.php
index fc4206a147..5ddeda862a 100644
--- a/src/Rules/Operators/InvalidUnaryOperationRule.php
+++ b/src/Rules/Operators/InvalidUnaryOperationRule.php
@@ -3,11 +3,13 @@
 namespace PHPStan\Rules\Operators;
 
 use PHPStan\Analyser\Scope;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr>
+ */
 class InvalidUnaryOperationRule implements \PHPStan\Rules\Rule
 {
 
@@ -16,11 +18,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(\PhpParser\Node $node, Scope $scope): array
 	{
 		if (
diff --git a/src/Rules/PhpDoc/IncompatiblePhpDocTypeRule.php b/src/Rules/PhpDoc/IncompatiblePhpDocTypeRule.php
index 5b5a2bd2aa..2ed5bdec1c 100644
--- a/src/Rules/PhpDoc/IncompatiblePhpDocTypeRule.php
+++ b/src/Rules/PhpDoc/IncompatiblePhpDocTypeRule.php
@@ -15,6 +15,9 @@
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\FunctionLike>
+ */
 class IncompatiblePhpDocTypeRule implements \PHPStan\Rules\Rule
 {
 
@@ -38,11 +41,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\FunctionLike::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\FunctionLike $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return \PHPStan\Rules\RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$docComment = $node->getDocComment();
diff --git a/src/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRule.php b/src/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRule.php
index f98d8e2e74..4b01b78381 100644
--- a/src/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRule.php
+++ b/src/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRule.php
@@ -11,6 +11,9 @@
 use PHPStan\Type\NeverType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\PropertyProperty>
+ */
 class IncompatiblePropertyPhpDocTypeRule implements Rule
 {
 
@@ -27,11 +30,6 @@ public function getNodeType(): string
 		return Node\Stmt\PropertyProperty::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\PropertyProperty $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return \PHPStan\Rules\RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$scope->isInClass()) {
diff --git a/src/Rules/PhpDoc/InvalidPhpDocTagValueRule.php b/src/Rules/PhpDoc/InvalidPhpDocTagValueRule.php
index 5d645827f8..8be7189f55 100644
--- a/src/Rules/PhpDoc/InvalidPhpDocTagValueRule.php
+++ b/src/Rules/PhpDoc/InvalidPhpDocTagValueRule.php
@@ -8,7 +8,11 @@
 use PHPStan\PhpDocParser\Lexer\Lexer;
 use PHPStan\PhpDocParser\Parser\PhpDocParser;
 use PHPStan\PhpDocParser\Parser\TokenIterator;
+use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node>
+ */
 class InvalidPhpDocTagValueRule implements \PHPStan\Rules\Rule
 {
 
@@ -29,11 +33,6 @@ public function getNodeType(): string
 		return \PhpParser\Node::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (
@@ -62,12 +61,12 @@ public function processNode(Node $node, Scope $scope): array
 				continue;
 			}
 
-			$errors[] = sprintf(
+			$errors[] = RuleErrorBuilder::message(sprintf(
 				'PHPDoc tag %s has invalid value (%s): %s',
 				$phpDocTag->name,
 				$phpDocTag->value->value,
 				$phpDocTag->value->exception->getMessage()
-			);
+			))->build();
 		}
 
 		return $errors;
diff --git a/src/Rules/PhpDoc/InvalidPhpDocVarTagTypeRule.php b/src/Rules/PhpDoc/InvalidPhpDocVarTagTypeRule.php
index 4472ecd13c..7f76347dd0 100644
--- a/src/Rules/PhpDoc/InvalidPhpDocVarTagTypeRule.php
+++ b/src/Rules/PhpDoc/InvalidPhpDocVarTagTypeRule.php
@@ -17,6 +17,9 @@
 use PHPStan\Type\VerbosityLevel;
 use function sprintf;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node>
+ */
 class InvalidPhpDocVarTagTypeRule implements Rule
 {
 
@@ -65,11 +68,6 @@ public function getNodeType(): string
 		return \PhpParser\Node::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return \PHPStan\Rules\RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (
diff --git a/src/Rules/PhpDoc/InvalidThrowsPhpDocValueRule.php b/src/Rules/PhpDoc/InvalidThrowsPhpDocValueRule.php
index d0530a016d..c47ccb27b3 100644
--- a/src/Rules/PhpDoc/InvalidThrowsPhpDocValueRule.php
+++ b/src/Rules/PhpDoc/InvalidThrowsPhpDocValueRule.php
@@ -4,11 +4,15 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\FileTypeMapper;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\VerbosityLevel;
 use PHPStan\Type\VoidType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\FunctionLike>
+ */
 class InvalidThrowsPhpDocValueRule implements \PHPStan\Rules\Rule
 {
 
@@ -25,11 +29,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\FunctionLike::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\FunctionLike $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$docComment = $node->getDocComment();
@@ -66,10 +65,12 @@ public function processNode(Node $node, Scope $scope): array
 			return [];
 		}
 
-		return [sprintf(
-			'PHPDoc tag @throws with type %s is not subtype of Throwable',
-			$phpDocThrowsType->describe(VerbosityLevel::typeOnly())
-		)];
+		return [
+			RuleErrorBuilder::message(sprintf(
+				'PHPDoc tag @throws with type %s is not subtype of Throwable',
+				$phpDocThrowsType->describe(VerbosityLevel::typeOnly())
+			))->build(),
+		];
 	}
 
 }
diff --git a/src/Rules/PhpDoc/WrongVariableNameInVarTagRule.php b/src/Rules/PhpDoc/WrongVariableNameInVarTagRule.php
index 2e90a2c53c..df7f150bd2 100644
--- a/src/Rules/PhpDoc/WrongVariableNameInVarTagRule.php
+++ b/src/Rules/PhpDoc/WrongVariableNameInVarTagRule.php
@@ -9,6 +9,9 @@
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\FileTypeMapper;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node>
+ */
 class WrongVariableNameInVarTagRule implements Rule
 {
 
@@ -25,11 +28,6 @@ public function getNodeType(): string
 		return \PhpParser\Node::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return \PHPStan\Rules\RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (
diff --git a/src/Rules/Properties/AccessPropertiesInAssignRule.php b/src/Rules/Properties/AccessPropertiesInAssignRule.php
index 4641ed109a..739e0a8337 100644
--- a/src/Rules/Properties/AccessPropertiesInAssignRule.php
+++ b/src/Rules/Properties/AccessPropertiesInAssignRule.php
@@ -6,6 +6,9 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Assign>
+ */
 class AccessPropertiesInAssignRule implements Rule
 {
 
@@ -22,11 +25,6 @@ public function getNodeType(): string
 		return Node\Expr\Assign::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Assign $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return (string|\PHPStan\Rules\RuleError)[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$node->var instanceof Node\Expr\PropertyFetch) {
diff --git a/src/Rules/Properties/AccessPropertiesRule.php b/src/Rules/Properties/AccessPropertiesRule.php
index a8ff004c20..b0dd9646e5 100644
--- a/src/Rules/Properties/AccessPropertiesRule.php
+++ b/src/Rules/Properties/AccessPropertiesRule.php
@@ -5,11 +5,15 @@
 use PhpParser\Node\Expr\PropertyFetch;
 use PHPStan\Analyser\Scope;
 use PHPStan\Broker\Broker;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\PropertyFetch>
+ */
 class AccessPropertiesRule implements \PHPStan\Rules\Rule
 {
 
@@ -38,11 +42,6 @@ public function getNodeType(): string
 		return PropertyFetch::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\PropertyFetch $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return (string|\PHPStan\Rules\RuleError)[]
-	 */
 	public function processNode(\PhpParser\Node $node, Scope $scope): array
 	{
 		if (!$node->name instanceof \PhpParser\Node\Identifier) {
@@ -69,7 +68,11 @@ static function (Type $type) use ($name): bool {
 
 		if (!$type->canAccessProperties()->yes()) {
 			return [
-				sprintf('Cannot access property $%s on %s.', $name, $type->describe(VerbosityLevel::typeOnly())),
+				RuleErrorBuilder::message(sprintf(
+					'Cannot access property $%s on %s.',
+					$name,
+					$type->describe(VerbosityLevel::typeOnly())
+				))->build(),
 			];
 		}
 
@@ -102,11 +105,11 @@ static function (Type $type) use ($name): bool {
 				while ($parentClassReflection !== false) {
 					if ($parentClassReflection->hasProperty($name)) {
 						return [
-							sprintf(
+							RuleErrorBuilder::message(sprintf(
 								'Access to private property $%s of parent class %s.',
 								$name,
 								$parentClassReflection->getDisplayName()
-							),
+							))->build(),
 						];
 					}
 
@@ -115,23 +118,23 @@ static function (Type $type) use ($name): bool {
 			}
 
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Access to an undefined property %s::$%s.',
 					$type->describe(VerbosityLevel::typeOnly()),
 					$name
-				),
+				))->build(),
 			];
 		}
 
 		$propertyReflection = $type->getProperty($name, $scope);
 		if (!$scope->canAccessProperty($propertyReflection)) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Access to %s property %s::$%s.',
 					$propertyReflection->isPrivate() ? 'private' : 'protected',
 					$type->describe(VerbosityLevel::typeOnly()),
 					$name
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Properties/AccessStaticPropertiesInAssignRule.php b/src/Rules/Properties/AccessStaticPropertiesInAssignRule.php
index b54e6e5650..5ad4382de5 100644
--- a/src/Rules/Properties/AccessStaticPropertiesInAssignRule.php
+++ b/src/Rules/Properties/AccessStaticPropertiesInAssignRule.php
@@ -6,6 +6,9 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Assign>
+ */
 class AccessStaticPropertiesInAssignRule implements Rule
 {
 
@@ -22,11 +25,6 @@ public function getNodeType(): string
 		return Node\Expr\Assign::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Assign $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return (string|\PHPStan\Rules\RuleError)[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$node->var instanceof Node\Expr\StaticPropertyFetch) {
diff --git a/src/Rules/Properties/AccessStaticPropertiesRule.php b/src/Rules/Properties/AccessStaticPropertiesRule.php
index 1b47e62922..5ec4eb51e5 100644
--- a/src/Rules/Properties/AccessStaticPropertiesRule.php
+++ b/src/Rules/Properties/AccessStaticPropertiesRule.php
@@ -9,6 +9,7 @@
 use PHPStan\Broker\Broker;
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\ClassNameNodePair;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\ObjectType;
@@ -18,6 +19,9 @@
 use PHPStan\Type\TypeUtils;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\StaticPropertyFetch>
+ */
 class AccessStaticPropertiesRule implements \PHPStan\Rules\Rule
 {
 
@@ -46,11 +50,6 @@ public function getNodeType(): string
 		return StaticPropertyFetch::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\StaticPropertyFetch $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return (string|\PHPStan\Rules\RuleError)[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$node->name instanceof Node\VarLikeIdentifier) {
@@ -65,33 +64,33 @@ public function processNode(Node $node, Scope $scope): array
 			if (in_array($lowercasedClass, ['self', 'static'], true)) {
 				if (!$scope->isInClass()) {
 					return [
-						sprintf(
+						RuleErrorBuilder::message(sprintf(
 							'Accessing %s::$%s outside of class scope.',
 							$class,
 							$name
-						),
+						))->build(),
 					];
 				}
 				$className = $scope->getClassReflection()->getName();
 			} elseif ($lowercasedClass === 'parent') {
 				if (!$scope->isInClass()) {
 					return [
-						sprintf(
+						RuleErrorBuilder::message(sprintf(
 							'Accessing %s::$%s outside of class scope.',
 							$class,
 							$name
-						),
+						))->build(),
 					];
 				}
 				if ($scope->getClassReflection()->getParentClass() === false) {
 					return [
-						sprintf(
+						RuleErrorBuilder::message(sprintf(
 							'%s::%s() accesses parent::$%s but %s does not extend any class.',
 							$scope->getClassReflection()->getDisplayName(),
 							$scope->getFunctionName(),
 							$name,
 							$scope->getClassReflection()->getDisplayName()
-						),
+						))->build(),
 					];
 				}
 
@@ -109,11 +108,11 @@ public function processNode(Node $node, Scope $scope): array
 			} else {
 				if (!$this->broker->hasClass($class)) {
 					return [
-						sprintf(
+						RuleErrorBuilder::message(sprintf(
 							'Access to static property $%s on an unknown class %s.',
 							$name,
 							$class
-						),
+						))->build(),
 					];
 				} else {
 					$messages = $this->classCaseSensitivityCheck->checkClassNames([new ClassNameNodePair($class, $node->class)]);
@@ -150,7 +149,11 @@ static function (Type $type) use ($name): bool {
 
 		if (!$classType->canAccessProperties()->yes()) {
 			return array_merge($messages, [
-				sprintf('Cannot access static property $%s on %s.', $name, $typeForDescribe->describe(VerbosityLevel::typeOnly())),
+				RuleErrorBuilder::message(sprintf(
+					'Cannot access static property $%s on %s.',
+					$name,
+					$typeForDescribe->describe(VerbosityLevel::typeOnly())
+				))->build(),
 			]);
 		}
 
@@ -160,11 +163,11 @@ static function (Type $type) use ($name): bool {
 			}
 
 			return array_merge($messages, [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Access to an undefined static property %s::$%s.',
 					$typeForDescribe->describe(VerbosityLevel::typeOnly()),
 					$name
-				),
+				))->build(),
 			]);
 		}
 
@@ -178,22 +181,22 @@ static function (Type $type) use ($name): bool {
 			}
 
 			return array_merge($messages, [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Static access to instance property %s::$%s.',
 					$property->getDeclaringClass()->getDisplayName(),
 					$name
-				),
+				))->build(),
 			]);
 		}
 
 		if (!$scope->canAccessProperty($property)) {
 			return array_merge($messages, [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Access to %s property $%s of class %s.',
 					$property->isPrivate() ? 'private' : 'protected',
 					$name,
 					$property->getDeclaringClass()->getDisplayName()
-				),
+				))->build(),
 			]);
 		}
 
diff --git a/src/Rules/Properties/DefaultValueTypesAssignedToPropertiesRule.php b/src/Rules/Properties/DefaultValueTypesAssignedToPropertiesRule.php
index 8f59dbe538..5d0a1dae1f 100644
--- a/src/Rules/Properties/DefaultValueTypesAssignedToPropertiesRule.php
+++ b/src/Rules/Properties/DefaultValueTypesAssignedToPropertiesRule.php
@@ -5,9 +5,13 @@
 use PhpParser\Node;
 use PhpParser\Node\Stmt\Property;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Property>
+ */
 class DefaultValueTypesAssignedToPropertiesRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +28,6 @@ public function getNodeType(): string
 		return Property::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Property $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$scope->isInClass()) {
@@ -54,14 +53,14 @@ public function processNode(Node $node, Scope $scope): array
 				continue;
 			}
 
-			$errors[] = sprintf(
+			$errors[] = RuleErrorBuilder::message(sprintf(
 				'%s %s::$%s (%s) does not accept default value of type %s.',
 				$node->isStatic() ? 'Static property' : 'Property',
 				$classReflection->getDisplayName(),
 				$property->name->name,
 				$propertyType->describe(VerbosityLevel::typeOnly()),
 				$defaultValueType->describe(VerbosityLevel::typeOnly())
-			);
+			))->build();
 		}
 
 		return $errors;
diff --git a/src/Rules/Properties/ExistingClassesInPropertiesRule.php b/src/Rules/Properties/ExistingClassesInPropertiesRule.php
index 31b535f461..a3d1830468 100644
--- a/src/Rules/Properties/ExistingClassesInPropertiesRule.php
+++ b/src/Rules/Properties/ExistingClassesInPropertiesRule.php
@@ -8,9 +8,11 @@
 use PHPStan\Broker\Broker;
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\ClassNameNodePair;
-use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\PropertyProperty>
+ */
 class ExistingClassesInPropertiesRule implements \PHPStan\Rules\Rule
 {
 
@@ -44,11 +46,6 @@ public function getNodeType(): string
 		return PropertyProperty::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\PropertyProperty $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return RuleError[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!$scope->isInClass()) {
diff --git a/src/Rules/Properties/ReadingWriteOnlyPropertiesRule.php b/src/Rules/Properties/ReadingWriteOnlyPropertiesRule.php
index 0c2307b7ee..f01b16aa2a 100644
--- a/src/Rules/Properties/ReadingWriteOnlyPropertiesRule.php
+++ b/src/Rules/Properties/ReadingWriteOnlyPropertiesRule.php
@@ -4,8 +4,12 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr>
+ */
 class ReadingWriteOnlyPropertiesRule implements \PHPStan\Rules\Rule
 {
 
@@ -39,11 +43,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr $node
-	 * @param Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (
@@ -77,10 +76,10 @@ public function processNode(Node $node, Scope $scope): array
 			$propertyDescription = $this->propertyDescriptor->describeProperty($propertyReflection, $node);
 
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'%s is not readable.',
 					$propertyDescription
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Properties/TypesAssignedToPropertiesRule.php b/src/Rules/Properties/TypesAssignedToPropertiesRule.php
index 26979917d2..de2331958b 100644
--- a/src/Rules/Properties/TypesAssignedToPropertiesRule.php
+++ b/src/Rules/Properties/TypesAssignedToPropertiesRule.php
@@ -4,9 +4,13 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr>
+ */
 class TypesAssignedToPropertiesRule implements \PHPStan\Rules\Rule
 {
 
@@ -35,11 +39,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (
@@ -74,12 +73,12 @@ public function processNode(Node $node, Scope $scope): array
 			$propertyDescription = $this->propertyDescriptor->describeProperty($propertyReflection, $propertyFetch);
 
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'%s (%s) does not accept %s.',
 					$propertyDescription,
 					$propertyType->describe(VerbosityLevel::typeOnly()),
 					$assignedValueType->describe(VerbosityLevel::typeOnly())
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Properties/WritingToReadOnlyPropertiesRule.php b/src/Rules/Properties/WritingToReadOnlyPropertiesRule.php
index 0feea7e02c..1076fad2db 100644
--- a/src/Rules/Properties/WritingToReadOnlyPropertiesRule.php
+++ b/src/Rules/Properties/WritingToReadOnlyPropertiesRule.php
@@ -4,8 +4,12 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr>
+ */
 class WritingToReadOnlyPropertiesRule implements \PHPStan\Rules\Rule
 {
 
@@ -39,11 +43,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Expr::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (
@@ -83,10 +82,10 @@ public function processNode(Node $node, Scope $scope): array
 			$propertyDescription = $this->propertyDescriptor->describeProperty($propertyReflection, $propertyFetch);
 
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'%s is not writable.',
 					$propertyDescription
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Regexp/RegularExpressionPatternRule.php b/src/Rules/Regexp/RegularExpressionPatternRule.php
index d9451b6ecc..b1548f40b7 100644
--- a/src/Rules/Regexp/RegularExpressionPatternRule.php
+++ b/src/Rules/Regexp/RegularExpressionPatternRule.php
@@ -5,9 +5,13 @@
 use PhpParser\Node;
 use PhpParser\Node\Expr\FuncCall;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\TypeUtils;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\FuncCall>
+ */
 class RegularExpressionPatternRule implements \PHPStan\Rules\Rule
 {
 
@@ -16,11 +20,6 @@ public function getNodeType(): string
 		return FuncCall::class;
 	}
 
-	/**
-	 * @param FuncCall $node
-	 * @param Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$patterns = $this->extractPatterns($node, $scope);
@@ -32,7 +31,7 @@ public function processNode(Node $node, Scope $scope): array
 				continue;
 			}
 
-			$errors[] = sprintf('Regex pattern is invalid: %s', $errorMessage);
+			$errors[] = RuleErrorBuilder::message(sprintf('Regex pattern is invalid: %s', $errorMessage))->build();
 		}
 
 		return $errors;
diff --git a/src/Rules/TooWideTypehints/TooWideClosureReturnTypehintRule.php b/src/Rules/TooWideTypehints/TooWideClosureReturnTypehintRule.php
index d8b832f4b7..d688d93508 100644
--- a/src/Rules/TooWideTypehints/TooWideClosureReturnTypehintRule.php
+++ b/src/Rules/TooWideTypehints/TooWideClosureReturnTypehintRule.php
@@ -6,10 +6,14 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Node\ClosureReturnStatementsNode;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PHPStan\Node\ClosureReturnStatementsNode>
+ */
 class TooWideClosureReturnTypehintRule implements Rule
 {
 
@@ -18,11 +22,6 @@ public function getNodeType(): string
 		return ClosureReturnStatementsNode::class;
 	}
 
-	/**
-	 * @param \PHPStan\Node\ClosureReturnStatementsNode $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$closureReturnType = $scope->getAnonymousFunctionReturnType();
@@ -61,7 +60,10 @@ public function processNode(Node $node, Scope $scope): array
 				continue;
 			}
 
-			$messages[] = sprintf('Anonymous function never returns %s so it can be removed from the return typehint.', $type->describe(VerbosityLevel::typeOnly()));
+			$messages[] = RuleErrorBuilder::message(sprintf(
+				'Anonymous function never returns %s so it can be removed from the return typehint.',
+				$type->describe(VerbosityLevel::typeOnly())
+			))->build();
 		}
 
 		return $messages;
diff --git a/src/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRule.php b/src/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRule.php
index 6fd9d7e435..747685bc9e 100644
--- a/src/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRule.php
+++ b/src/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRule.php
@@ -8,10 +8,14 @@
 use PHPStan\Reflection\FunctionReflection;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PHPStan\Node\FunctionReturnStatementsNode>
+ */
 class TooWideFunctionReturnTypehintRule implements Rule
 {
 
@@ -20,11 +24,6 @@ public function getNodeType(): string
 		return FunctionReturnStatementsNode::class;
 	}
 
-	/**
-	 * @param \PHPStan\Node\FunctionReturnStatementsNode $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$function = $scope->getFunction();
@@ -68,7 +67,11 @@ public function processNode(Node $node, Scope $scope): array
 				continue;
 			}
 
-			$messages[] = sprintf('Function %s() never returns %s so it can be removed from the return typehint.', $function->getName(), $type->describe(VerbosityLevel::typeOnly()));
+			$messages[] = RuleErrorBuilder::message(sprintf(
+				'Function %s() never returns %s so it can be removed from the return typehint.',
+				$function->getName(),
+				$type->describe(VerbosityLevel::typeOnly())
+			))->build();
 		}
 
 		return $messages;
diff --git a/src/Rules/TooWideTypehints/TooWideMethodReturnTypehintRule.php b/src/Rules/TooWideTypehints/TooWideMethodReturnTypehintRule.php
index aee54e99d2..10420c37f7 100644
--- a/src/Rules/TooWideTypehints/TooWideMethodReturnTypehintRule.php
+++ b/src/Rules/TooWideTypehints/TooWideMethodReturnTypehintRule.php
@@ -8,10 +8,14 @@
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PHPStan\Node\MethodReturnStatementsNode>
+ */
 class TooWideMethodReturnTypehintRule implements Rule
 {
 
@@ -20,11 +24,6 @@ public function getNodeType(): string
 		return MethodReturnStatementsNode::class;
 	}
 
-	/**
-	 * @param \PHPStan\Node\MethodReturnStatementsNode $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$method = $scope->getFunction();
@@ -72,7 +71,12 @@ public function processNode(Node $node, Scope $scope): array
 				continue;
 			}
 
-			$messages[] = sprintf('Method %s::%s() never returns %s so it can be removed from the return typehint.', $method->getDeclaringClass()->getDisplayName(), $method->getName(), $type->describe(VerbosityLevel::typeOnly()));
+			$messages[] = RuleErrorBuilder::message(sprintf(
+				'Method %s::%s() never returns %s so it can be removed from the return typehint.',
+				$method->getDeclaringClass()->getDisplayName(),
+				$method->getName(),
+				$type->describe(VerbosityLevel::typeOnly())
+			))->build();
 		}
 
 		return $messages;
diff --git a/src/Rules/UnusedFunctionParametersCheck.php b/src/Rules/UnusedFunctionParametersCheck.php
index 5154500a43..42c31ab618 100644
--- a/src/Rules/UnusedFunctionParametersCheck.php
+++ b/src/Rules/UnusedFunctionParametersCheck.php
@@ -14,7 +14,7 @@ class UnusedFunctionParametersCheck
 	 * @param string[] $parameterNames
 	 * @param \PhpParser\Node[] $statements
 	 * @param string $unusedParameterMessage
-	 * @return string[]
+	 * @return RuleError[]
 	 */
 	public function getUnusedParameters(
 		Scope $scope,
@@ -33,7 +33,7 @@ public function getUnusedParameters(
 		}
 		$errors = [];
 		foreach (array_keys($unusedParameters) as $name) {
-			$errors[] = sprintf($unusedParameterMessage, $name);
+			$errors[] = RuleErrorBuilder::message(sprintf($unusedParameterMessage, $name))->build();
 		}
 
 		return $errors;
diff --git a/src/Rules/Variables/DefinedVariableInAnonymousFunctionUseRule.php b/src/Rules/Variables/DefinedVariableInAnonymousFunctionUseRule.php
index cacd4f6808..aaad13d03e 100644
--- a/src/Rules/Variables/DefinedVariableInAnonymousFunctionUseRule.php
+++ b/src/Rules/Variables/DefinedVariableInAnonymousFunctionUseRule.php
@@ -5,7 +5,11 @@
 use PhpParser\Node;
 use PhpParser\Node\Expr\ClosureUse;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\ClosureUse>
+ */
 class DefinedVariableInAnonymousFunctionUseRule implements \PHPStan\Rules\Rule
 {
 
@@ -24,11 +28,6 @@ public function getNodeType(): string
 		return ClosureUse::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\ClosureUse $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if ($node->byRef || !is_string($node->var->name)) {
@@ -37,14 +36,14 @@ public function processNode(Node $node, Scope $scope): array
 
 		if ($scope->hasVariableType($node->var->name)->no()) {
 			return [
-				sprintf('Undefined variable: $%s', $node->var->name),
+				RuleErrorBuilder::message(sprintf('Undefined variable: $%s', $node->var->name))->build(),
 			];
 		} elseif (
 			$this->checkMaybeUndefinedVariables
 			&& !$scope->hasVariableType($node->var->name)->yes()
 		) {
 			return [
-				sprintf('Variable $%s might not be defined.', $node->var->name),
+				RuleErrorBuilder::message(sprintf('Variable $%s might not be defined.', $node->var->name))->build(),
 			];
 		}
 
diff --git a/src/Rules/Variables/DefinedVariableRule.php b/src/Rules/Variables/DefinedVariableRule.php
index 25932a2d25..251217d760 100644
--- a/src/Rules/Variables/DefinedVariableRule.php
+++ b/src/Rules/Variables/DefinedVariableRule.php
@@ -5,7 +5,11 @@
 use PhpParser\Node;
 use PhpParser\Node\Expr\Variable;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Variable>
+ */
 class DefinedVariableRule implements \PHPStan\Rules\Rule
 {
 
@@ -29,11 +33,6 @@ public function getNodeType(): string
 		return Variable::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Variable $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!is_string($node->name)) {
@@ -56,14 +55,14 @@ public function processNode(Node $node, Scope $scope): array
 
 		if ($scope->hasVariableType($node->name)->no()) {
 			return [
-				sprintf('Undefined variable: $%s', $node->name),
+				RuleErrorBuilder::message(sprintf('Undefined variable: $%s', $node->name))->build(),
 			];
 		} elseif (
 			$this->checkMaybeUndefinedVariables
 			&& !$scope->hasVariableType($node->name)->yes()
 		) {
 			return [
-				sprintf('Variable $%s might not be defined.', $node->name),
+				RuleErrorBuilder::message(sprintf('Variable $%s might not be defined.', $node->name))->build(),
 			];
 		}
 
diff --git a/src/Rules/Variables/ThisVariableRule.php b/src/Rules/Variables/ThisVariableRule.php
index c68ff4af80..95c32ca77b 100644
--- a/src/Rules/Variables/ThisVariableRule.php
+++ b/src/Rules/Variables/ThisVariableRule.php
@@ -6,7 +6,11 @@
 use PhpParser\Node\Expr\Variable;
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\MethodReflection;
+use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Variable>
+ */
 class ThisVariableRule implements \PHPStan\Rules\Rule
 {
 
@@ -15,11 +19,6 @@ public function getNodeType(): string
 		return Variable::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Variable $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		if (!is_string($node->name) || $node->name !== 'this') {
@@ -32,7 +31,7 @@ public function processNode(Node $node, Scope $scope): array
 
 		if (!$scope->isInClass()) {
 			return [
-				'Using $this outside a class.',
+				RuleErrorBuilder::message('Using $this outside a class.')->build(),
 			];
 		}
 
@@ -43,11 +42,11 @@ public function processNode(Node $node, Scope $scope): array
 
 		if ($function->isStatic()) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Using $this in static method %s::%s().',
 					$scope->getClassReflection()->getDisplayName(),
 					$function->getName()
-				),
+				))->build(),
 			];
 		}
 
diff --git a/src/Rules/Variables/ThrowTypeRule.php b/src/Rules/Variables/ThrowTypeRule.php
index 65dbe25a45..e162a238cd 100644
--- a/src/Rules/Variables/ThrowTypeRule.php
+++ b/src/Rules/Variables/ThrowTypeRule.php
@@ -4,12 +4,16 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Throw_>
+ */
 class ThrowTypeRule implements \PHPStan\Rules\Rule
 {
 
@@ -28,11 +32,6 @@ public function getNodeType(): string
 		return \PhpParser\Node\Stmt\Throw_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Stmt\Throw_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return (string|\PHPStan\Rules\RuleError)[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$throwableType = new ObjectType(\Throwable::class);
@@ -56,7 +55,10 @@ static function (Type $type) use ($throwableType): bool {
 		}
 
 		return [
-			sprintf('Invalid type %s to throw.', $foundType->describe(VerbosityLevel::typeOnly())),
+			RuleErrorBuilder::message(sprintf(
+				'Invalid type %s to throw.',
+				$foundType->describe(VerbosityLevel::typeOnly())
+			))->build(),
 		];
 	}
 
diff --git a/src/Rules/Variables/VariableCertaintyInIssetRule.php b/src/Rules/Variables/VariableCertaintyInIssetRule.php
index 5fd2916902..e08221bcad 100644
--- a/src/Rules/Variables/VariableCertaintyInIssetRule.php
+++ b/src/Rules/Variables/VariableCertaintyInIssetRule.php
@@ -4,8 +4,12 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\NullType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Isset_>
+ */
 class VariableCertaintyInIssetRule implements \PHPStan\Rules\Rule
 {
 
@@ -14,11 +18,6 @@ public function getNodeType(): string
 		return Node\Expr\Isset_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Isset_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$messages = [];
@@ -50,14 +49,23 @@ public function processNode(Node $node, Scope $scope): array
 					$scope->getFunction() !== null
 					|| $scope->isInAnonymousFunction()
 				) {
-					$messages[] = sprintf('Variable $%s in isset() is never defined.', $var->name);
+					$messages[] = RuleErrorBuilder::message(sprintf(
+						'Variable $%s in isset() is never defined.',
+						$var->name
+					))->build();
 				}
 			} elseif ($certainty->yes() && !$isSubNode) {
 				$variableType = $scope->getVariableType($var->name);
 				if ($variableType->isSuperTypeOf(new NullType())->no()) {
-					$messages[] = sprintf('Variable $%s in isset() always exists and is not nullable.', $var->name);
+					$messages[] = RuleErrorBuilder::message(sprintf(
+						'Variable $%s in isset() always exists and is not nullable.',
+						$var->name
+					))->build();
 				} elseif ((new NullType())->isSuperTypeOf($variableType)->yes()) {
-					$messages[] = sprintf('Variable $%s in isset() is always null.', $var->name);
+					$messages[] = RuleErrorBuilder::message(sprintf(
+						'Variable $%s in isset() is always null.',
+						$var->name
+					))->build();
 				}
 			}
 		}
diff --git a/src/Rules/Variables/VariableCloningRule.php b/src/Rules/Variables/VariableCloningRule.php
index 0da080b04e..0977fe52f3 100644
--- a/src/Rules/Variables/VariableCloningRule.php
+++ b/src/Rules/Variables/VariableCloningRule.php
@@ -6,11 +6,15 @@
 use PhpParser\Node\Expr\Clone_;
 use PhpParser\Node\Expr\Variable;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\Clone_>
+ */
 class VariableCloningRule implements \PHPStan\Rules\Rule
 {
 
@@ -27,11 +31,6 @@ public function getNodeType(): string
 		return Clone_::class;
 	}
 
-	/**
-	 * @param \PhpParser\Node\Expr\Clone_ $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return (string|\PHPStan\Rules\RuleError)[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$typeResult = $this->ruleLevelHelper->findTypeToCheck(
@@ -52,16 +51,19 @@ static function (Type $type): bool {
 
 		if ($node->expr instanceof Variable && is_string($node->expr->name)) {
 			return [
-				sprintf(
+				RuleErrorBuilder::message(sprintf(
 					'Cannot clone non-object variable $%s of type %s.',
 					$node->expr->name,
 					$type->describe(VerbosityLevel::typeOnly())
-				),
+				))->build(),
 			];
 		}
 
 		return [
-			sprintf('Cannot clone %s.', $type->describe(VerbosityLevel::typeOnly())),
+			RuleErrorBuilder::message(sprintf(
+				'Cannot clone %s.',
+				$type->describe(VerbosityLevel::typeOnly())
+			))->build(),
 		];
 	}
 
diff --git a/tests/PHPStan/Rules/AlwaysFailRule.php b/tests/PHPStan/Rules/AlwaysFailRule.php
index 8139a08f85..b6320727d6 100644
--- a/tests/PHPStan/Rules/AlwaysFailRule.php
+++ b/tests/PHPStan/Rules/AlwaysFailRule.php
@@ -5,6 +5,9 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\FuncCall>
+ */
 class AlwaysFailRule implements \PHPStan\Rules\Rule
 {
 
diff --git a/tests/PHPStan/Rules/Arrays/AppendedArrayItemTypeRuleTest.php b/tests/PHPStan/Rules/Arrays/AppendedArrayItemTypeRuleTest.php
index 9c16562afc..fff590bcc4 100644
--- a/tests/PHPStan/Rules/Arrays/AppendedArrayItemTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Arrays/AppendedArrayItemTypeRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Properties\PropertyReflectionFinder;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<AppendedArrayItemTypeRule>
+ */
 class AppendedArrayItemTypeRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Arrays/AppendedArrayKeyTypeRuleTest.php b/tests/PHPStan/Rules/Arrays/AppendedArrayKeyTypeRuleTest.php
index 0af61cdd73..502df29bc4 100644
--- a/tests/PHPStan/Rules/Arrays/AppendedArrayKeyTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Arrays/AppendedArrayKeyTypeRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\Properties\PropertyReflectionFinder;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<AppendedArrayKeyTypeRule>
+ */
 class AppendedArrayKeyTypeRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Arrays/DeadForeachRuleTest.php b/tests/PHPStan/Rules/Arrays/DeadForeachRuleTest.php
index b5280b3569..d8b999e8e6 100644
--- a/tests/PHPStan/Rules/Arrays/DeadForeachRuleTest.php
+++ b/tests/PHPStan/Rules/Arrays/DeadForeachRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<DeadForeachRule>
+ */
 class DeadForeachRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Arrays/DuplicateKeysInLiteralArraysRuleTest.php b/tests/PHPStan/Rules/Arrays/DuplicateKeysInLiteralArraysRuleTest.php
index 2ff2fba54e..28e7898337 100644
--- a/tests/PHPStan/Rules/Arrays/DuplicateKeysInLiteralArraysRuleTest.php
+++ b/tests/PHPStan/Rules/Arrays/DuplicateKeysInLiteralArraysRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Arrays;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<DuplicateKeysInLiteralArraysRule>
+ */
 class DuplicateKeysInLiteralArraysRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Arrays/InvalidKeyInArrayDimFetchRuleTest.php b/tests/PHPStan/Rules/Arrays/InvalidKeyInArrayDimFetchRuleTest.php
index 010704ae48..e1cc3685d0 100644
--- a/tests/PHPStan/Rules/Arrays/InvalidKeyInArrayDimFetchRuleTest.php
+++ b/tests/PHPStan/Rules/Arrays/InvalidKeyInArrayDimFetchRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Arrays;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InvalidKeyInArrayDimFetchRule>
+ */
 class InvalidKeyInArrayDimFetchRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Arrays/InvalidKeyInArrayItemRuleTest.php b/tests/PHPStan/Rules/Arrays/InvalidKeyInArrayItemRuleTest.php
index a2e6d3189c..7bb10e9e47 100644
--- a/tests/PHPStan/Rules/Arrays/InvalidKeyInArrayItemRuleTest.php
+++ b/tests/PHPStan/Rules/Arrays/InvalidKeyInArrayItemRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Arrays;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InvalidKeyInArrayItemRule>
+ */
 class InvalidKeyInArrayItemRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Arrays/IterableInForeachRuleTest.php b/tests/PHPStan/Rules/Arrays/IterableInForeachRuleTest.php
index bcc640879f..c0ec34ef0e 100644
--- a/tests/PHPStan/Rules/Arrays/IterableInForeachRuleTest.php
+++ b/tests/PHPStan/Rules/Arrays/IterableInForeachRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<IterableInForeachRule>
+ */
 class IterableInForeachRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Arrays/NonexistentOffsetInArrayDimFetchRuleTest.php b/tests/PHPStan/Rules/Arrays/NonexistentOffsetInArrayDimFetchRuleTest.php
index 4659087a8c..37f6b41bd2 100644
--- a/tests/PHPStan/Rules/Arrays/NonexistentOffsetInArrayDimFetchRuleTest.php
+++ b/tests/PHPStan/Rules/Arrays/NonexistentOffsetInArrayDimFetchRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<NonexistentOffsetInArrayDimFetchRule>
+ */
 class NonexistentOffsetInArrayDimFetchRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Arrays/OffsetAccessAssignOpRuleTest.php b/tests/PHPStan/Rules/Arrays/OffsetAccessAssignOpRuleTest.php
index 3ed0aa09d7..88c7f9b270 100644
--- a/tests/PHPStan/Rules/Arrays/OffsetAccessAssignOpRuleTest.php
+++ b/tests/PHPStan/Rules/Arrays/OffsetAccessAssignOpRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<OffsetAccessAssignOpRule>
+ */
 class OffsetAccessAssignOpRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Arrays/OffsetAccessAssignmentRuleTest.php b/tests/PHPStan/Rules/Arrays/OffsetAccessAssignmentRuleTest.php
index ee0699b32d..2be1b66f10 100644
--- a/tests/PHPStan/Rules/Arrays/OffsetAccessAssignmentRuleTest.php
+++ b/tests/PHPStan/Rules/Arrays/OffsetAccessAssignmentRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<OffsetAccessAssignmentRule>
+ */
 class OffsetAccessAssignmentRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Arrays/OffsetAccessWithoutDimForReadingRuleTest.php b/tests/PHPStan/Rules/Arrays/OffsetAccessWithoutDimForReadingRuleTest.php
index 9843116c8f..027f8c420f 100644
--- a/tests/PHPStan/Rules/Arrays/OffsetAccessWithoutDimForReadingRuleTest.php
+++ b/tests/PHPStan/Rules/Arrays/OffsetAccessWithoutDimForReadingRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Arrays;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<OffsetAccessWithoutDimForReadingRule>
+ */
 class OffsetAccessWithoutDimForReadingRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Arrays/UnpackIterableInArrayRuleTest.php b/tests/PHPStan/Rules/Arrays/UnpackIterableInArrayRuleTest.php
index 8d22ec008e..38f701f936 100644
--- a/tests/PHPStan/Rules/Arrays/UnpackIterableInArrayRuleTest.php
+++ b/tests/PHPStan/Rules/Arrays/UnpackIterableInArrayRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<UnpackIterableInArrayRule>
+ */
 class UnpackIterableInArrayRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Cast/EchoRuleTest.php b/tests/PHPStan/Rules/Cast/EchoRuleTest.php
index 14f6759cf5..f300f22c9c 100644
--- a/tests/PHPStan/Rules/Cast/EchoRuleTest.php
+++ b/tests/PHPStan/Rules/Cast/EchoRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<EchoRule>
+ */
 class EchoRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Cast/InvalidCastRuleTest.php b/tests/PHPStan/Rules/Cast/InvalidCastRuleTest.php
index c77c7cf883..8c879e2a70 100644
--- a/tests/PHPStan/Rules/Cast/InvalidCastRuleTest.php
+++ b/tests/PHPStan/Rules/Cast/InvalidCastRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InvalidCastRule>
+ */
 class InvalidCastRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Cast/InvalidPartOfEncapsedStringRuleTest.php b/tests/PHPStan/Rules/Cast/InvalidPartOfEncapsedStringRuleTest.php
index fc64619a6e..a833c59364 100644
--- a/tests/PHPStan/Rules/Cast/InvalidPartOfEncapsedStringRuleTest.php
+++ b/tests/PHPStan/Rules/Cast/InvalidPartOfEncapsedStringRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InvalidPartOfEncapsedStringRule>
+ */
 class InvalidPartOfEncapsedStringRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Cast/PrintRuleTest.php b/tests/PHPStan/Rules/Cast/PrintRuleTest.php
index cc571f4039..d9511a67d3 100644
--- a/tests/PHPStan/Rules/Cast/PrintRuleTest.php
+++ b/tests/PHPStan/Rules/Cast/PrintRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<PrintRule>
+ */
 class PrintRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php b/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php
index 359dbedc49..4db3eef56d 100644
--- a/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php
+++ b/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ClassConstantRule>
+ */
 class ClassConstantRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php
index 130945fa25..c70cb12d7b 100644
--- a/tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php
+++ b/tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\Rule;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ExistingClassInClassExtendsRule>
+ */
 class ExistingClassInClassExtendsRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php
index d75f110795..406d0e7028 100644
--- a/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php
+++ b/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\Rule;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ExistingClassInInstanceOfRule>
+ */
 class ExistingClassInInstanceOfRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php
index 83507fb775..266d8392b4 100644
--- a/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php
+++ b/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\Rule;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ExistingClassInTraitUseRule>
+ */
 class ExistingClassInTraitUseRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php
index f64c12d815..7d3e8b03d0 100644
--- a/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php
+++ b/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\Rule;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ExistingClassesInClassImplementsRule>
+ */
 class ExistingClassesInClassImplementsRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php
index 49daf3d7d0..ed21296229 100644
--- a/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php
+++ b/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\Rule;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ExistingClassesInInterfaceExtendsRule>
+ */
 class ExistingClassesInInterfaceExtendsRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Classes/ImpossibleInstanceOfRuleTest.php b/tests/PHPStan/Rules/Classes/ImpossibleInstanceOfRuleTest.php
index 9eb3d7d03b..a8a25d2d3e 100644
--- a/tests/PHPStan/Rules/Classes/ImpossibleInstanceOfRuleTest.php
+++ b/tests/PHPStan/Rules/Classes/ImpossibleInstanceOfRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Classes;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ImpossibleInstanceOfRule>
+ */
 class ImpossibleInstanceOfRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php b/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php
index fe736cd686..d5ab2d0528 100644
--- a/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php
+++ b/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Rules\FunctionCallParametersCheck;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InstantiationRule>
+ */
 class InstantiationRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Classes/UnusedConstructorParametersRuleTest.php b/tests/PHPStan/Rules/Classes/UnusedConstructorParametersRuleTest.php
index df6f4b4378..bb15fd5700 100644
--- a/tests/PHPStan/Rules/Classes/UnusedConstructorParametersRuleTest.php
+++ b/tests/PHPStan/Rules/Classes/UnusedConstructorParametersRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\UnusedFunctionParametersCheck;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<UnusedConstructorParametersRule>
+ */
 class UnusedConstructorParametersRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Comparison/BooleanAndConstantConditionRuleTest.php b/tests/PHPStan/Rules/Comparison/BooleanAndConstantConditionRuleTest.php
index d4066bf81e..d7d89d210c 100644
--- a/tests/PHPStan/Rules/Comparison/BooleanAndConstantConditionRuleTest.php
+++ b/tests/PHPStan/Rules/Comparison/BooleanAndConstantConditionRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Comparison;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<BooleanAndConstantConditionRule>
+ */
 class BooleanAndConstantConditionRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Comparison/BooleanNotConstantConditionRuleTest.php b/tests/PHPStan/Rules/Comparison/BooleanNotConstantConditionRuleTest.php
index 04ea0f798a..165af1b411 100644
--- a/tests/PHPStan/Rules/Comparison/BooleanNotConstantConditionRuleTest.php
+++ b/tests/PHPStan/Rules/Comparison/BooleanNotConstantConditionRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Comparison;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<BooleanNotConstantConditionRule>
+ */
 class BooleanNotConstantConditionRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Comparison/BooleanOrConstantConditionRuleTest.php b/tests/PHPStan/Rules/Comparison/BooleanOrConstantConditionRuleTest.php
index c8a8c9e437..389087e779 100644
--- a/tests/PHPStan/Rules/Comparison/BooleanOrConstantConditionRuleTest.php
+++ b/tests/PHPStan/Rules/Comparison/BooleanOrConstantConditionRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Comparison;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<BooleanOrConstantConditionRule>
+ */
 class BooleanOrConstantConditionRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Comparison/ElseIfConstantConditionRuleTest.php b/tests/PHPStan/Rules/Comparison/ElseIfConstantConditionRuleTest.php
index fe4e5cbe14..dbec1ee5f3 100644
--- a/tests/PHPStan/Rules/Comparison/ElseIfConstantConditionRuleTest.php
+++ b/tests/PHPStan/Rules/Comparison/ElseIfConstantConditionRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Comparison;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ElseIfConstantConditionRule>
+ */
 class ElseIfConstantConditionRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Comparison/IfConstantConditionRuleTest.php b/tests/PHPStan/Rules/Comparison/IfConstantConditionRuleTest.php
index 4341a954c8..ef52cc69bd 100644
--- a/tests/PHPStan/Rules/Comparison/IfConstantConditionRuleTest.php
+++ b/tests/PHPStan/Rules/Comparison/IfConstantConditionRuleTest.php
@@ -9,6 +9,9 @@
 use PHPStan\Type\DynamicFunctionReturnTypeExtension;
 use PHPStan\Type\Type;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<IfConstantConditionRule>
+ */
 class IfConstantConditionRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeFunctionCallRuleTest.php b/tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeFunctionCallRuleTest.php
index 6935415a93..115a25ac04 100644
--- a/tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeFunctionCallRuleTest.php
+++ b/tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeFunctionCallRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Comparison;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ImpossibleCheckTypeFunctionCallRule>
+ */
 class ImpossibleCheckTypeFunctionCallRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeMethodCallRuleTest.php b/tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeMethodCallRuleTest.php
index 96f59f8326..e0fccdb1d9 100644
--- a/tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeMethodCallRuleTest.php
+++ b/tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeMethodCallRuleTest.php
@@ -12,6 +12,9 @@
 use PHPStan\Tests\AssertionClassMethodTypeSpecifyingExtension;
 use PHPStan\Type\MethodTypeSpecifyingExtension;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ImpossibleCheckTypeMethodCallRule>
+ */
 class ImpossibleCheckTypeMethodCallRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRuleTest.php b/tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRuleTest.php
index c505c99c1d..d5168e1625 100644
--- a/tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRuleTest.php
+++ b/tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Tests\AssertionClassStaticMethodTypeSpecifyingExtension;
 use PHPStan\Type\PHPUnit\Assert\AssertStaticMethodTypeSpecifyingExtension;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ImpossibleCheckTypeStaticMethodCallRule>
+ */
 class ImpossibleCheckTypeStaticMethodCallRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Comparison/NumberComparisonOperatorsConstantConditionRuleTest.php b/tests/PHPStan/Rules/Comparison/NumberComparisonOperatorsConstantConditionRuleTest.php
index 68fd6d3c0f..1732c56769 100644
--- a/tests/PHPStan/Rules/Comparison/NumberComparisonOperatorsConstantConditionRuleTest.php
+++ b/tests/PHPStan/Rules/Comparison/NumberComparisonOperatorsConstantConditionRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<NumberComparisonOperatorsConstantConditionRule>
+ */
 class NumberComparisonOperatorsConstantConditionRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Comparison/StrictComparisonOfDifferentTypesRuleTest.php b/tests/PHPStan/Rules/Comparison/StrictComparisonOfDifferentTypesRuleTest.php
index 12a1bb4e4d..1b9d36f857 100644
--- a/tests/PHPStan/Rules/Comparison/StrictComparisonOfDifferentTypesRuleTest.php
+++ b/tests/PHPStan/Rules/Comparison/StrictComparisonOfDifferentTypesRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Comparison;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<StrictComparisonOfDifferentTypesRule>
+ */
 class StrictComparisonOfDifferentTypesRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Comparison/TernaryOperatorConstantConditionRuleTest.php b/tests/PHPStan/Rules/Comparison/TernaryOperatorConstantConditionRuleTest.php
index 03ce50d20f..c82d1b7372 100644
--- a/tests/PHPStan/Rules/Comparison/TernaryOperatorConstantConditionRuleTest.php
+++ b/tests/PHPStan/Rules/Comparison/TernaryOperatorConstantConditionRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Comparison;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<TernaryOperatorConstantConditionRule>
+ */
 class TernaryOperatorConstantConditionRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Comparison/UnreachableIfBranchesRuleTest.php b/tests/PHPStan/Rules/Comparison/UnreachableIfBranchesRuleTest.php
index af7c3cc39d..4c6d9a33ee 100644
--- a/tests/PHPStan/Rules/Comparison/UnreachableIfBranchesRuleTest.php
+++ b/tests/PHPStan/Rules/Comparison/UnreachableIfBranchesRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<UnreachableIfBranchesRule>
+ */
 class UnreachableIfBranchesRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Comparison/UnreachableTernaryElseBranchRuleTest.php b/tests/PHPStan/Rules/Comparison/UnreachableTernaryElseBranchRuleTest.php
index 7dac470483..276115c7ef 100644
--- a/tests/PHPStan/Rules/Comparison/UnreachableTernaryElseBranchRuleTest.php
+++ b/tests/PHPStan/Rules/Comparison/UnreachableTernaryElseBranchRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<UnreachableTernaryElseBranchRule>
+ */
 class UnreachableTernaryElseBranchRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Constants/ConstantRuleTest.php b/tests/PHPStan/Rules/Constants/ConstantRuleTest.php
index 1900f43559..1428d7e0f1 100644
--- a/tests/PHPStan/Rules/Constants/ConstantRuleTest.php
+++ b/tests/PHPStan/Rules/Constants/ConstantRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Constants;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ConstantRule>
+ */
 class ConstantRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/DeadCode/UnreachableStatementRuleTest.php b/tests/PHPStan/Rules/DeadCode/UnreachableStatementRuleTest.php
index 997130ff21..8fa5700a3c 100644
--- a/tests/PHPStan/Rules/DeadCode/UnreachableStatementRuleTest.php
+++ b/tests/PHPStan/Rules/DeadCode/UnreachableStatementRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<UnreachableStatementRule>
+ */
 class UnreachableStatementRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/DummyRule.php b/tests/PHPStan/Rules/DummyRule.php
index e7314b66db..697c9a4ead 100644
--- a/tests/PHPStan/Rules/DummyRule.php
+++ b/tests/PHPStan/Rules/DummyRule.php
@@ -5,6 +5,9 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\FuncCall>
+ */
 class DummyRule implements \PHPStan\Rules\Rule
 {
 
@@ -13,11 +16,6 @@ public function getNodeType(): string
 		return 'PhpParser\Node\Expr\FuncCall';
 	}
 
-	/**
-	 * @param \PhpParser\Node $node
-	 * @param \PHPStan\Analyser\Scope $scope
-	 * @return string[]
-	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
 		return [];
diff --git a/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php b/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php
index 13f6a032e0..985b0f12cf 100644
--- a/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php
+++ b/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<CaughtExceptionExistenceRule>
+ */
 class CaughtExceptionExistenceRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Exceptions/DeadCatchRuleTest.php b/tests/PHPStan/Rules/Exceptions/DeadCatchRuleTest.php
index 25af4a8a90..828cab35ce 100644
--- a/tests/PHPStan/Rules/Exceptions/DeadCatchRuleTest.php
+++ b/tests/PHPStan/Rules/Exceptions/DeadCatchRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<DeadCatchRule>
+ */
 class DeadCatchRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Functions/ArrowFunctionReturnTypeRuleTest.php b/tests/PHPStan/Rules/Functions/ArrowFunctionReturnTypeRuleTest.php
index 0b471f5231..38b9805628 100644
--- a/tests/PHPStan/Rules/Functions/ArrowFunctionReturnTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/ArrowFunctionReturnTypeRuleTest.php
@@ -7,6 +7,9 @@
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ArrowFunctionReturnTypeRule>
+ */
 class ArrowFunctionReturnTypeRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Functions/CallCallablesRuleTest.php b/tests/PHPStan/Rules/Functions/CallCallablesRuleTest.php
index 8449a5b77c..c8798d6ea0 100644
--- a/tests/PHPStan/Rules/Functions/CallCallablesRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/CallCallablesRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\FunctionCallParametersCheck;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<CallCallablesRule>
+ */
 class CallCallablesRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Functions/CallToFunctionParametersRuleTest.php b/tests/PHPStan/Rules/Functions/CallToFunctionParametersRuleTest.php
index 030b766dcc..fec97e9f83 100644
--- a/tests/PHPStan/Rules/Functions/CallToFunctionParametersRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/CallToFunctionParametersRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\FunctionCallParametersCheck;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<CallToFunctionParametersRule>
+ */
 class CallToFunctionParametersRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Functions/CallToFunctionStamentWithoutSideEffectsRuleTest.php b/tests/PHPStan/Rules/Functions/CallToFunctionStamentWithoutSideEffectsRuleTest.php
index f28aabf057..42dbc96aac 100644
--- a/tests/PHPStan/Rules/Functions/CallToFunctionStamentWithoutSideEffectsRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/CallToFunctionStamentWithoutSideEffectsRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<CallToFunctionStamentWithoutSideEffectsRule>
+ */
 class CallToFunctionStamentWithoutSideEffectsRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Functions/CallToNonExistentFunctionRuleTest.php b/tests/PHPStan/Rules/Functions/CallToNonExistentFunctionRuleTest.php
index 8663cd42ee..e3ce219589 100644
--- a/tests/PHPStan/Rules/Functions/CallToNonExistentFunctionRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/CallToNonExistentFunctionRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Functions;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<CallToNonExistentFunctionRule>
+ */
 class CallToNonExistentFunctionRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Functions/ClosureReturnTypeRuleTest.php b/tests/PHPStan/Rules/Functions/ClosureReturnTypeRuleTest.php
index 21c6e9ada6..fa16cebbdd 100644
--- a/tests/PHPStan/Rules/Functions/ClosureReturnTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/ClosureReturnTypeRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\FunctionReturnTypeCheck;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ClosureReturnTypeRule>
+ */
 class ClosureReturnTypeRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php b/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php
index 687995a5e9..1c91067edb 100644
--- a/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\FunctionDefinitionCheck;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ExistingClassesInArrowFunctionTypehintsRule>
+ */
 class ExistingClassesInArrowFunctionTypehintsRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php b/tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php
index 9a61fe764b..f2ec18b0b0 100644
--- a/tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\FunctionDefinitionCheck;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ExistingClassesInClosureTypehintsRule>
+ */
 class ExistingClassesInClosureTypehintsRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php b/tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php
index 06bb77c8b5..df50409298 100644
--- a/tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\FunctionDefinitionCheck;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ExistingClassesInTypehintsRule>
+ */
 class ExistingClassesInTypehintsRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Functions/IncompatibleDefaultParameterTypeRuleTest.php b/tests/PHPStan/Rules/Functions/IncompatibleDefaultParameterTypeRuleTest.php
index 289cf24826..c0b74d33ff 100644
--- a/tests/PHPStan/Rules/Functions/IncompatibleDefaultParameterTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/IncompatibleDefaultParameterTypeRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<IncompatibleDefaultParameterTypeRule>
+ */
 class IncompatibleDefaultParameterTypeRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Functions/InnerFunctionRuleTest.php b/tests/PHPStan/Rules/Functions/InnerFunctionRuleTest.php
index cbe46b54a8..fe6fb38f23 100644
--- a/tests/PHPStan/Rules/Functions/InnerFunctionRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/InnerFunctionRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Functions;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InnerFunctionRule>
+ */
 class InnerFunctionRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Functions/PrintfParametersRuleTest.php b/tests/PHPStan/Rules/Functions/PrintfParametersRuleTest.php
index 717d41da60..7e3eb93104 100644
--- a/tests/PHPStan/Rules/Functions/PrintfParametersRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/PrintfParametersRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Functions;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<PrintfParametersRule>
+ */
 class PrintfParametersRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Functions/ReturnTypeRuleTest.php b/tests/PHPStan/Rules/Functions/ReturnTypeRuleTest.php
index 5de2cd2747..cbafd425f0 100644
--- a/tests/PHPStan/Rules/Functions/ReturnTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/ReturnTypeRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\FunctionReturnTypeCheck;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ReturnTypeRule>
+ */
 class ReturnTypeRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Functions/UnusedClosureUsesRuleTest.php b/tests/PHPStan/Rules/Functions/UnusedClosureUsesRuleTest.php
index 93d96851fa..16f7c7aa5b 100644
--- a/tests/PHPStan/Rules/Functions/UnusedClosureUsesRuleTest.php
+++ b/tests/PHPStan/Rules/Functions/UnusedClosureUsesRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\UnusedFunctionParametersCheck;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<UnusedClosureUsesRule>
+ */
 class UnusedClosureUsesRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Generators/YieldFromTypeRuleTest.php b/tests/PHPStan/Rules/Generators/YieldFromTypeRuleTest.php
index 5847cc3da4..e2b24c3113 100644
--- a/tests/PHPStan/Rules/Generators/YieldFromTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Generators/YieldFromTypeRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<YieldFromTypeRule>
+ */
 class YieldFromTypeRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Generators/YieldInGeneratorRuleTest.php b/tests/PHPStan/Rules/Generators/YieldInGeneratorRuleTest.php
index 24519e0c69..cb10501536 100644
--- a/tests/PHPStan/Rules/Generators/YieldInGeneratorRuleTest.php
+++ b/tests/PHPStan/Rules/Generators/YieldInGeneratorRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<YieldInGeneratorRule>
+ */
 class YieldInGeneratorRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Generators/YieldTypeRuleTest.php b/tests/PHPStan/Rules/Generators/YieldTypeRuleTest.php
index 1143832411..d104abcf8f 100644
--- a/tests/PHPStan/Rules/Generators/YieldTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Generators/YieldTypeRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<YieldTypeRule>
+ */
 class YieldTypeRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Generics/ClassAncestorsRuleTest.php b/tests/PHPStan/Rules/Generics/ClassAncestorsRuleTest.php
index 4ef9ab8310..0fc6568c4b 100644
--- a/tests/PHPStan/Rules/Generics/ClassAncestorsRuleTest.php
+++ b/tests/PHPStan/Rules/Generics/ClassAncestorsRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Testing\RuleTestCase;
 use PHPStan\Type\FileTypeMapper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ClassAncestorsRule>
+ */
 class ClassAncestorsRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php
index 3d2fed50b5..3df528ca0e 100644
--- a/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php
@@ -7,6 +7,9 @@
 use PHPStan\Testing\RuleTestCase;
 use PHPStan\Type\FileTypeMapper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ClassTemplateTypeRule>
+ */
 class ClassTemplateTypeRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php
index 539355e3fa..deee155788 100644
--- a/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php
@@ -7,6 +7,9 @@
 use PHPStan\Testing\RuleTestCase;
 use PHPStan\Type\FileTypeMapper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<FunctionTemplateTypeRule>
+ */
 class FunctionTemplateTypeRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Generics/InterfaceAncestorsRuleTest.php b/tests/PHPStan/Rules/Generics/InterfaceAncestorsRuleTest.php
index e6ef7012fc..d35f9335a2 100644
--- a/tests/PHPStan/Rules/Generics/InterfaceAncestorsRuleTest.php
+++ b/tests/PHPStan/Rules/Generics/InterfaceAncestorsRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Testing\RuleTestCase;
 use PHPStan\Type\FileTypeMapper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InterfaceAncestorsRule>
+ */
 class InterfaceAncestorsRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php
index f237063d4e..c7ffe73320 100644
--- a/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php
@@ -7,6 +7,9 @@
 use PHPStan\Testing\RuleTestCase;
 use PHPStan\Type\FileTypeMapper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InterfaceTemplateTypeRule>
+ */
 class InterfaceTemplateTypeRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php
index b9a19c574b..196310fc9e 100644
--- a/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php
@@ -7,6 +7,9 @@
 use PHPStan\Testing\RuleTestCase;
 use PHPStan\Type\FileTypeMapper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<MethodTemplateTypeRule>
+ */
 class MethodTemplateTypeRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php
index 583fe90796..cec70add67 100644
--- a/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php
@@ -7,6 +7,9 @@
 use PHPStan\Testing\RuleTestCase;
 use PHPStan\Type\FileTypeMapper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<TraitTemplateTypeRule>
+ */
 class TraitTemplateTypeRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Methods/CallMethodsRuleTest.php b/tests/PHPStan/Rules/Methods/CallMethodsRuleTest.php
index d05379c358..313eb509e9 100644
--- a/tests/PHPStan/Rules/Methods/CallMethodsRuleTest.php
+++ b/tests/PHPStan/Rules/Methods/CallMethodsRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<CallMethodsRule>
+ */
 class CallMethodsRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php b/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php
index fa60955dee..2939c0d320 100644
--- a/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php
+++ b/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Rules\FunctionCallParametersCheck;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<CallStaticMethodsRule>
+ */
 class CallStaticMethodsRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Methods/CallToMethodStamentWithoutSideEffectsRuleTest.php b/tests/PHPStan/Rules/Methods/CallToMethodStamentWithoutSideEffectsRuleTest.php
index a65460eb2f..5b86112814 100644
--- a/tests/PHPStan/Rules/Methods/CallToMethodStamentWithoutSideEffectsRuleTest.php
+++ b/tests/PHPStan/Rules/Methods/CallToMethodStamentWithoutSideEffectsRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<CallToMethodStamentWithoutSideEffectsRule>
+ */
 class CallToMethodStamentWithoutSideEffectsRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Methods/CallToStaticMethodStamentWithoutSideEffectsRuleTest.php b/tests/PHPStan/Rules/Methods/CallToStaticMethodStamentWithoutSideEffectsRuleTest.php
index 1f13dacbbe..634a54cde8 100644
--- a/tests/PHPStan/Rules/Methods/CallToStaticMethodStamentWithoutSideEffectsRuleTest.php
+++ b/tests/PHPStan/Rules/Methods/CallToStaticMethodStamentWithoutSideEffectsRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<CallToStaticMethodStamentWithoutSideEffectsRule>
+ */
 class CallToStaticMethodStamentWithoutSideEffectsRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php b/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php
index 3137736ae1..e80eeacb5c 100644
--- a/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php
+++ b/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\FunctionDefinitionCheck;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ExistingClassesInTypehintsRule>
+ */
 class ExistingClassesInTypehintsRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Methods/IncompatibleDefaultParameterTypeRuleTest.php b/tests/PHPStan/Rules/Methods/IncompatibleDefaultParameterTypeRuleTest.php
index 2ecfcc3f2c..1ac88bc4e2 100644
--- a/tests/PHPStan/Rules/Methods/IncompatibleDefaultParameterTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Methods/IncompatibleDefaultParameterTypeRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<IncompatibleDefaultParameterTypeRule>
+ */
 class IncompatibleDefaultParameterTypeRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Methods/MethodSignatureRuleTest.php b/tests/PHPStan/Rules/Methods/MethodSignatureRuleTest.php
index 7d32dc0872..978a8ca943 100644
--- a/tests/PHPStan/Rules/Methods/MethodSignatureRuleTest.php
+++ b/tests/PHPStan/Rules/Methods/MethodSignatureRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Methods;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<MethodSignatureRule>
+ */
 class MethodSignatureRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Methods/ReturnTypeRuleTest.php b/tests/PHPStan/Rules/Methods/ReturnTypeRuleTest.php
index 31518e62c1..faf7a33952 100644
--- a/tests/PHPStan/Rules/Methods/ReturnTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Methods/ReturnTypeRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\FunctionReturnTypeCheck;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ReturnTypeRule>
+ */
 class ReturnTypeRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Missing/MissingClosureNativeReturnTypehintRuleTest.php b/tests/PHPStan/Rules/Missing/MissingClosureNativeReturnTypehintRuleTest.php
index d9dff405d3..65dd141daa 100644
--- a/tests/PHPStan/Rules/Missing/MissingClosureNativeReturnTypehintRuleTest.php
+++ b/tests/PHPStan/Rules/Missing/MissingClosureNativeReturnTypehintRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<MissingClosureNativeReturnTypehintRule>
+ */
 class MissingClosureNativeReturnTypehintRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Missing/MissingReturnRuleTest.php b/tests/PHPStan/Rules/Missing/MissingReturnRuleTest.php
index ad6e789629..417e835501 100644
--- a/tests/PHPStan/Rules/Missing/MissingReturnRuleTest.php
+++ b/tests/PHPStan/Rules/Missing/MissingReturnRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<MissingReturnRule>
+ */
 class MissingReturnRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php b/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php
index a1b03f1eba..33a5a7e529 100644
--- a/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php
+++ b/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ExistingNamesInGroupUseRule>
+ */
 class ExistingNamesInGroupUseRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php b/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php
index cb18138881..6463a881b8 100644
--- a/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php
+++ b/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ExistingNamesInUseRule>
+ */
 class ExistingNamesInUseRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Operators/InvalidBinaryOperationRuleTest.php b/tests/PHPStan/Rules/Operators/InvalidBinaryOperationRuleTest.php
index 11a412a0a7..f6b9ef70d9 100644
--- a/tests/PHPStan/Rules/Operators/InvalidBinaryOperationRuleTest.php
+++ b/tests/PHPStan/Rules/Operators/InvalidBinaryOperationRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InvalidBinaryOperationRule>
+ */
 class InvalidBinaryOperationRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Operators/InvalidComparisonOperationRuleTest.php b/tests/PHPStan/Rules/Operators/InvalidComparisonOperationRuleTest.php
index 0a4f5603fa..c1c9f3a49e 100644
--- a/tests/PHPStan/Rules/Operators/InvalidComparisonOperationRuleTest.php
+++ b/tests/PHPStan/Rules/Operators/InvalidComparisonOperationRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InvalidComparisonOperationRule>
+ */
 class InvalidComparisonOperationRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Operators/InvalidIncDecOperationRuleTest.php b/tests/PHPStan/Rules/Operators/InvalidIncDecOperationRuleTest.php
index 2e493d6b15..a5564251cd 100644
--- a/tests/PHPStan/Rules/Operators/InvalidIncDecOperationRuleTest.php
+++ b/tests/PHPStan/Rules/Operators/InvalidIncDecOperationRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Operators;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InvalidIncDecOperationRule>
+ */
 class InvalidIncDecOperationRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Operators/InvalidUnaryOperationRuleTest.php b/tests/PHPStan/Rules/Operators/InvalidUnaryOperationRuleTest.php
index 8deb995308..c978abb5e4 100644
--- a/tests/PHPStan/Rules/Operators/InvalidUnaryOperationRuleTest.php
+++ b/tests/PHPStan/Rules/Operators/InvalidUnaryOperationRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Operators;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InvalidUnaryOperationRule>
+ */
 class InvalidUnaryOperationRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php b/tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php
index a7a142be6a..73968557e9 100644
--- a/tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php
+++ b/tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Generics\GenericObjectTypeCheck;
 use PHPStan\Type\FileTypeMapper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<IncompatiblePhpDocTypeRule>
+ */
 class IncompatiblePhpDocTypeRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php b/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php
index 109063e32b..8ac5822a2b 100644
--- a/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php
+++ b/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Generics\GenericObjectTypeCheck;
 use PHPStan\Rules\Rule;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<IncompatiblePropertyPhpDocTypeRule>
+ */
 class IncompatiblePropertyPhpDocTypeRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocTagValueRuleTest.php b/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocTagValueRuleTest.php
index 1c987895cc..812c84dc89 100644
--- a/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocTagValueRuleTest.php
+++ b/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocTagValueRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\PhpDocParser\Lexer\Lexer;
 use PHPStan\PhpDocParser\Parser\PhpDocParser;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InvalidPhpDocTagValueRule>
+ */
 class InvalidPhpDocTagValueRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php b/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php
index 186496509a..39d054450b 100644
--- a/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php
+++ b/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php
@@ -9,6 +9,9 @@
 use PHPStan\Testing\RuleTestCase;
 use PHPStan\Type\FileTypeMapper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InvalidPhpDocVarTagTypeRule>
+ */
 class InvalidPhpDocVarTagTypeRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/PhpDoc/InvalidThrowsPhpDocValueRuleTest.php b/tests/PHPStan/Rules/PhpDoc/InvalidThrowsPhpDocValueRuleTest.php
index 62040feea0..8e4b940abe 100644
--- a/tests/PHPStan/Rules/PhpDoc/InvalidThrowsPhpDocValueRuleTest.php
+++ b/tests/PHPStan/Rules/PhpDoc/InvalidThrowsPhpDocValueRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Type\FileTypeMapper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<InvalidThrowsPhpDocValueRule>
+ */
 class InvalidThrowsPhpDocValueRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/PhpDoc/WrongVariableNameInVarTagRuleTest.php b/tests/PHPStan/Rules/PhpDoc/WrongVariableNameInVarTagRuleTest.php
index 41edd3e513..986a7e540d 100644
--- a/tests/PHPStan/Rules/PhpDoc/WrongVariableNameInVarTagRuleTest.php
+++ b/tests/PHPStan/Rules/PhpDoc/WrongVariableNameInVarTagRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Testing\RuleTestCase;
 use PHPStan\Type\FileTypeMapper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<WrongVariableNameInVarTagRule>
+ */
 class WrongVariableNameInVarTagRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Properties/AccessPropertiesInAssignRuleTest.php b/tests/PHPStan/Rules/Properties/AccessPropertiesInAssignRuleTest.php
index 8fba0804d1..031b753f03 100644
--- a/tests/PHPStan/Rules/Properties/AccessPropertiesInAssignRuleTest.php
+++ b/tests/PHPStan/Rules/Properties/AccessPropertiesInAssignRuleTest.php
@@ -6,6 +6,9 @@
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<AccessPropertiesInAssignRule>
+ */
 class AccessPropertiesInAssignRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Properties/AccessPropertiesRuleTest.php b/tests/PHPStan/Rules/Properties/AccessPropertiesRuleTest.php
index 78a1c24fb3..fa0351f620 100644
--- a/tests/PHPStan/Rules/Properties/AccessPropertiesRuleTest.php
+++ b/tests/PHPStan/Rules/Properties/AccessPropertiesRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<AccessPropertiesRule>
+ */
 class AccessPropertiesRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php
index f02079da30..da22b9e996 100644
--- a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php
+++ b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php
@@ -7,6 +7,9 @@
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<AccessStaticPropertiesInAssignRule>
+ */
 class AccessStaticPropertiesInAssignRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php
index 402a161e15..cb3dd94949 100644
--- a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php
+++ b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<AccessStaticPropertiesRule>
+ */
 class AccessStaticPropertiesRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Properties/DefaultValueTypesAssignedToPropertiesRuleTest.php b/tests/PHPStan/Rules/Properties/DefaultValueTypesAssignedToPropertiesRuleTest.php
index 21c80287f2..7521dd5e1b 100644
--- a/tests/PHPStan/Rules/Properties/DefaultValueTypesAssignedToPropertiesRuleTest.php
+++ b/tests/PHPStan/Rules/Properties/DefaultValueTypesAssignedToPropertiesRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<DefaultValueTypesAssignedToPropertiesRule>
+ */
 class DefaultValueTypesAssignedToPropertiesRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php b/tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php
index 49d93387a8..bd85c3bfc8 100644
--- a/tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php
+++ b/tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\Rule;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ExistingClassesInPropertiesRule>
+ */
 class ExistingClassesInPropertiesRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Properties/ReadingWriteOnlyPropertiesRuleTest.php b/tests/PHPStan/Rules/Properties/ReadingWriteOnlyPropertiesRuleTest.php
index 1e0a34831f..50245183eb 100644
--- a/tests/PHPStan/Rules/Properties/ReadingWriteOnlyPropertiesRuleTest.php
+++ b/tests/PHPStan/Rules/Properties/ReadingWriteOnlyPropertiesRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ReadingWriteOnlyPropertiesRule>
+ */
 class ReadingWriteOnlyPropertiesRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Properties/TypesAssignedToPropertiesRuleTest.php b/tests/PHPStan/Rules/Properties/TypesAssignedToPropertiesRuleTest.php
index 9a627b0045..b351f6950b 100644
--- a/tests/PHPStan/Rules/Properties/TypesAssignedToPropertiesRuleTest.php
+++ b/tests/PHPStan/Rules/Properties/TypesAssignedToPropertiesRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<TypesAssignedToPropertiesRule>
+ */
 class TypesAssignedToPropertiesRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Properties/WritingToReadOnlyPropertiesRuleTest.php b/tests/PHPStan/Rules/Properties/WritingToReadOnlyPropertiesRuleTest.php
index d92933f5a8..eb7d2356e8 100644
--- a/tests/PHPStan/Rules/Properties/WritingToReadOnlyPropertiesRuleTest.php
+++ b/tests/PHPStan/Rules/Properties/WritingToReadOnlyPropertiesRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<WritingToReadOnlyPropertiesRule>
+ */
 class WritingToReadOnlyPropertiesRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Regexp/RegularExpressionPatternRuleTest.php b/tests/PHPStan/Rules/Regexp/RegularExpressionPatternRuleTest.php
index 9434c2a595..3c53137056 100644
--- a/tests/PHPStan/Rules/Regexp/RegularExpressionPatternRuleTest.php
+++ b/tests/PHPStan/Rules/Regexp/RegularExpressionPatternRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Regexp;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<RegularExpressionPatternRule>
+ */
 class RegularExpressionPatternRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/TooWideTypehints/TooWideClosureReturnTypehintRuleTest.php b/tests/PHPStan/Rules/TooWideTypehints/TooWideClosureReturnTypehintRuleTest.php
index fd42a690e1..de0e824daa 100644
--- a/tests/PHPStan/Rules/TooWideTypehints/TooWideClosureReturnTypehintRuleTest.php
+++ b/tests/PHPStan/Rules/TooWideTypehints/TooWideClosureReturnTypehintRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<TooWideClosureReturnTypehintRule>
+ */
 class TooWideClosureReturnTypehintRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRuleTest.php b/tests/PHPStan/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRuleTest.php
index db3089309e..c86f55d91d 100644
--- a/tests/PHPStan/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRuleTest.php
+++ b/tests/PHPStan/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<TooWideFunctionReturnTypehintRule>
+ */
 class TooWideFunctionReturnTypehintRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/TooWideTypehints/TooWideMethodReturnTypehintRuleTest.php b/tests/PHPStan/Rules/TooWideTypehints/TooWideMethodReturnTypehintRuleTest.php
index e042ee0602..63e2e0b891 100644
--- a/tests/PHPStan/Rules/TooWideTypehints/TooWideMethodReturnTypehintRuleTest.php
+++ b/tests/PHPStan/Rules/TooWideTypehints/TooWideMethodReturnTypehintRuleTest.php
@@ -5,6 +5,9 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<TooWideMethodReturnTypehintRule>
+ */
 class TooWideMethodReturnTypehintRuleTest extends RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Variables/DefinedVariableInAnonymousFunctionUseRuleTest.php b/tests/PHPStan/Rules/Variables/DefinedVariableInAnonymousFunctionUseRuleTest.php
index 528965e864..4350848a3c 100644
--- a/tests/PHPStan/Rules/Variables/DefinedVariableInAnonymousFunctionUseRuleTest.php
+++ b/tests/PHPStan/Rules/Variables/DefinedVariableInAnonymousFunctionUseRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Variables;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<DefinedVariableInAnonymousFunctionUseRule>
+ */
 class DefinedVariableInAnonymousFunctionUseRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Variables/DefinedVariableRuleTest.php b/tests/PHPStan/Rules/Variables/DefinedVariableRuleTest.php
index bae915bbee..10d3ebcc5a 100644
--- a/tests/PHPStan/Rules/Variables/DefinedVariableRuleTest.php
+++ b/tests/PHPStan/Rules/Variables/DefinedVariableRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Variables;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<DefinedVariableRule>
+ */
 class DefinedVariableRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Variables/ThisVariableRuleTest.php b/tests/PHPStan/Rules/Variables/ThisVariableRuleTest.php
index d1ec42d0c3..8b5dec224e 100644
--- a/tests/PHPStan/Rules/Variables/ThisVariableRuleTest.php
+++ b/tests/PHPStan/Rules/Variables/ThisVariableRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Variables;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ThisVariableRule>
+ */
 class ThisVariableRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Variables/ThrowTypeRuleTest.php b/tests/PHPStan/Rules/Variables/ThrowTypeRuleTest.php
index a63282fc43..f17acc8333 100644
--- a/tests/PHPStan/Rules/Variables/ThrowTypeRuleTest.php
+++ b/tests/PHPStan/Rules/Variables/ThrowTypeRuleTest.php
@@ -4,6 +4,9 @@
 
 use PHPStan\Rules\RuleLevelHelper;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<ThrowTypeRule>
+ */
 class ThrowTypeRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
diff --git a/tests/PHPStan/Rules/Variables/VariableCertaintyInIssetRuleTest.php b/tests/PHPStan/Rules/Variables/VariableCertaintyInIssetRuleTest.php
index 447eb7e056..18854c3b5b 100644
--- a/tests/PHPStan/Rules/Variables/VariableCertaintyInIssetRuleTest.php
+++ b/tests/PHPStan/Rules/Variables/VariableCertaintyInIssetRuleTest.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Variables;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<VariableCertaintyInIssetRule>
+ */
 class VariableCertaintyInIssetRuleTest extends \PHPStan\Testing\RuleTestCase
 {