ConstructorReturnTypeRule

conf/config.level0.neon

@@ -75,6 +75,7 @@ rules:
 	- PHPStan\Rules\Methods\AbstractMethodInNonAbstractClassRule
 	- PHPStan\Rules\Methods\CallMethodsRule
 	- PHPStan\Rules\Methods\CallStaticMethodsRule
+	- PHPStan\Rules\Methods\ConstructorReturnTypeRule
 	- PHPStan\Rules\Methods\ExistingClassesInTypehintsRule
 	- PHPStan\Rules\Methods\FinalPrivateMethodRule
 	- PHPStan\Rules\Methods\MethodCallableRule

src/Analyser/NodeScopeResolver.php

@@ -4369,6 +4369,7 @@ private function processNodesForTraitUse($node, ClassReflection $traitReflection
 						continue;
 					}
 
+					$methodAst->setAttribute('originalTraitMethodName', $methodAst->name->toLowerString());
 					$methodAst->name = $methodNames[$methodName];
 				}
 				$this->processStmtNodes($node, $stmts, $scope->enterTrait($traitReflection), $nodeCallback, StatementContext::createTopLevel());

src/Rules/Methods/ConstructorReturnTypeRule.php

@@ -0,0 +1,63 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Methods;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Node\InClassMethodNode;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use function sprintf;
+
+/**
+ * @implements Rule<InClassMethodNode>
+ */
+class ConstructorReturnTypeRule implements Rule
+{
+
+	public function getNodeType(): string
+	{
+		return InClassMethodNode::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		$classReflection = $node->getClassReflection();
+		$methodNode = $node->getOriginalNode();
+		if ($scope->isInTrait()) {
+			$originalMethodName = $methodNode->getAttribute('originalTraitMethodName');
+			if (
+				$originalMethodName === '__construct'
+				&& $methodNode->returnType !== null
+			) {
+				return [
+					RuleErrorBuilder::message(sprintf('Original constructor of trait %s has a return type.', $scope->getTraitReflection()->getDisplayName()))
+						->identifier('constructor.returnType')
+						->nonIgnorable()
+						->build(),
+				];
+			}
+		}
+		if (!$classReflection->hasConstructor()) {
+			return [];
+		}
+
+		$constructorReflection = $classReflection->getConstructor();
+		$methodReflection = $node->getMethodReflection();
+		if ($methodReflection->getName() !== $constructorReflection->getName()) {
+			return [];
+		}
+
+		if ($methodNode->returnType === null) {
+			return [];
+		}
+
+		return [
+			RuleErrorBuilder::message(sprintf('Constructor of class %s has a return type.', $classReflection->getDisplayName()))
+				->identifier('constructor.returnType')
+				->nonIgnorable()
+				->build(),
+		];
+	}
+
+}

tests/PHPStan/Rules/Methods/ConstructorReturnTypeRuleTest.php

@@ -0,0 +1,37 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Methods;
+
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<ConstructorReturnTypeRule>
+ */
+class ConstructorReturnTypeRuleTest extends RuleTestCase
+{
+
+	protected function getRule(): Rule
+	{
+		return new ConstructorReturnTypeRule();
+	}
+
+	public function testRule(): void
+	{
+		$this->analyse([__DIR__ . '/data/constructor-return-type.php'], [
+			[
+				'Constructor of class ConstructorReturnType\Bar has a return type.',
+				17,
+			],
+			[
+				'Constructor of class ConstructorReturnType\UsesFooTrait has a return type.',
+				26,
+			],
+			[
+				'Original constructor of trait ConstructorReturnType\BarTrait has a return type.',
+				35,
+			],
+		]);
+	}
+
+}

tests/PHPStan/Rules/Methods/data/constructor-return-type.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace ConstructorReturnType;
+
+class Foo
+{
+
+	public function __construct()
+	{
+	}
+
+}
+
+class Bar
+{
+
+	public function __construct(): void
+	{
+	}
+
+}
+
+trait FooTrait
+{
+
+	public function __construct(): void
+	{
+	}
+
+}
+
+trait BarTrait
+{
+
+	public function __construct(): void
+	{
+	}
+
+}
+
+class UsesFooTrait
+{
+	use FooTrait;
+}
+
+class RenamesBarTrait
+{
+	use BarTrait {
+		__construct as baseConstructor;
+	}
+}