Check whether function parameter+return has typehint

composer.json

@@ -29,6 +29,10 @@
 		}
 	},
 	"autoload-dev": {
-		"classmap": ["tests/"]
+		"classmap": ["tests/"],
+		"files": [
+			"tests/Rules/Functions/data/missing-function-parameter-typehint.php",
+			"tests/Rules/Functions/data/missing-function-return-typehint.php"
+		]
 	}
 }

rules.neon

@@ -14,6 +14,8 @@ rules:
 	- PHPStan\Rules\BooleansInConditions\BooleanInTernaryOperatorRule
 	- PHPStan\Rules\DisallowedConstructs\DisallowedEmptyRule
 	- PHPStan\Rules\DisallowedConstructs\DisallowedImplicitArrayCreationRule
+	- PHPStan\Rules\Functions\MissingFunctionParameterTypehintRule
+	- PHPStan\Rules\Functions\MissingFunctionReturnTypehintRule
 	- PHPStan\Rules\Methods\MissingMethodParameterTypehintRule
 	- PHPStan\Rules\Methods\MissingMethodReturnTypehintRule
 	- PHPStan\Rules\Methods\WrongCaseOfInheritedMethodRule

src/Rules/Functions/MissingFunctionParameterTypehintRule.php

@@ -0,0 +1,67 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Functions;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Broker\Broker;
+use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Reflection\ParameterReflection;
+use PHPStan\Type\MixedType;
+
+final class MissingFunctionParameterTypehintRule implements \PHPStan\Rules\Rule
+{
+
+	/** @var Broker */
+	private $broker;
+
+	public function __construct(Broker $broker)
+    {
+        $this->broker = $broker;
+    }
+
+    public function getNodeType(): string
+	{
+		return \PhpParser\Node\Stmt\Function_::class;
+	}
+
+	/**
+	 * @param \PhpParser\Node\Stmt\Function_ $node
+	 * @param \PHPStan\Analyser\Scope $scope
+	 *
+	 * @return string[] errors
+	 */
+	public function processNode(Node $node, Scope $scope): array
+	{
+		$functionReflection = $this->broker->getCustomFunction(new Node\Name($node->name), $scope);
+
+		$messages = [];
+
+		foreach ($functionReflection->getParameters() as $parameterReflection) {
+			$message = $this->checkFunctionParameter($functionReflection, $parameterReflection);
+			if ($message === null) {
+				continue;
+			}
+
+			$messages[] = $message;
+		}
+
+		return $messages;
+	}
+
+	private function checkFunctionParameter(FunctionReflection $functionReflection, ParameterReflection $parameterReflection): ?string
+	{
+		$parameterType = $parameterReflection->getType();
+
+		if ($parameterType instanceof MixedType && !$parameterType->isExplicitMixed()) {
+			return sprintf(
+				'Function %s() has parameter $%s with no typehint specified.',
+				$functionReflection->getName(),
+				$parameterReflection->getName()
+			);
+		}
+
+		return null;
+	}
+
+}

src/Rules/Functions/MissingFunctionReturnTypehintRule.php

@@ -0,0 +1,49 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Functions;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Broker\Broker;
+use PHPStan\Type\MixedType;
+
+final class MissingFunctionReturnTypehintRule implements \PHPStan\Rules\Rule
+{
+
+	/** @var Broker */
+	private $broker;
+
+	public function __construct(Broker $broker)
+    {
+        $this->broker = $broker;
+    }
+
+    public function getNodeType(): string
+	{
+		return \PhpParser\Node\Stmt\Function_::class;
+	}
+
+	/**
+	 * @param \PhpParser\Node\Stmt\Function_ $node
+	 * @param \PHPStan\Analyser\Scope $scope
+	 *
+	 * @return string[] errors
+	 */
+	public function processNode(Node $node, Scope $scope): array
+	{
+		$functionReflection = $this->broker->getCustomFunction(new Node\Name($node->name), $scope);
+		$returnType = $functionReflection->getReturnType();
+
+		if ($returnType instanceof MixedType && !$returnType->isExplicitMixed()) {
+			return [
+				sprintf(
+					'Function %s() has no return typehint specified.',
+					$functionReflection->getName()
+				),
+			];
+		}
+
+		return [];
+	}
+
+}

tests/Rules/Functions/MissingFunctionParameterTypehintRuleTest.php

@@ -0,0 +1,33 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Functions;
+
+class MissingFunctionParameterTypehintRuleTest extends \PHPStan\Testing\RuleTestCase
+{
+
+	protected function getRule(): \PHPStan\Rules\Rule
+	{
+		$rule = new MissingFunctionParameterTypehintRule($this->createBroker([], []));
+
+		return $rule;
+	}
+
+	public function testRule(): void
+	{
+		$this->analyse([__DIR__ . '/data/missing-function-parameter-typehint.php'], [
+			[
+				'Function globalFunction() has parameter $b with no typehint specified',
+				9,
+			],
+			[
+				'Function globalFunction() has parameter $c with no typehint specified',
+				9,
+			],
+			[
+				'Function MissingFunctionParameterTypehint\namespacedFunction() has parameter $d with no typehint specified',
+				24,
+			],
+		]);
+	}
+
+}

tests/Rules/Functions/MissingFunctionReturnTypehintRuleTest.php

@@ -0,0 +1,29 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Functions;
+
+class MissingFunctionReturnTypehintRuleTest extends \PHPStan\Testing\RuleTestCase
+{
+
+	protected function getRule(): \PHPStan\Rules\Rule
+	{
+		$rule = new MissingFunctionReturnTypehintRule($this->createBroker([], []));
+
+		return $rule;
+	}
+
+	public function testRule(): void
+	{
+		$this->analyse([__DIR__ . '/data/missing-function-return-typehint.php'], [
+			[
+				'Function globalFunction1() has no return typehint specified',
+				5,
+			],
+			[
+				'Function MissingFunctionReturnTypehint\namespacedFunction1() has no return typehint specified',
+				30,
+			],
+		]);
+	}
+
+}

tests/Rules/Functions/data/missing-function-parameter-typehint.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace
+{
+	/**
+	 * @param int $a
+	 * @param $b
+	 */
+	function globalFunction($a, $b, $c): bool
+	{
+		$closure = function($a, $b, $c) {
+
+		};
+
+		return false;
+	}
+}
+
+namespace MissingFunctionParameterTypehint
+{
+	/**
+	 * @param $d
+	 */
+	function namespacedFunction($d, bool $e): int {
+		return 9;
+	};
+}

tests/Rules/Functions/data/missing-function-return-typehint.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace
+{
+	function globalFunction1($a, $b, $c)
+	{
+		return false;
+	}
+
+	function globalFunction2($a, $b, $c): bool
+	{
+		$closure = function($a, $b, $c) {
+
+		};
+
+		return false;
+	}
+
+	/**
+	 * @return bool
+	 */
+	function globalFunction3($a, $b, $c)
+	{
+		return false;
+	}
+}
+
+namespace MissingFunctionReturnTypehint
+{
+	function namespacedFunction1($d, $e)
+	{
+		return 9;
+	};
+
+	function namespacedFunction2($d, $e): int
+	{
+		return 9;
+	};
+
+	/**
+	 * @return int
+	 */
+	function namespacedFunction3($d, $e)
+	{
+		return 9;
+	};
+}