[#27744] Add compiler pass to check arguments type hint

symfony · alcalyn · Jun 29, 2018 · Jul 9, 2018 · Jul 9, 2018 · Jul 11, 2018
commit 4b5920107b156167dc38f2b2927366a75701533f
diff --git a/src/Symfony/Component/DependencyInjection/CHANGELOG.md b/src/Symfony/Component/DependencyInjection/CHANGELOG.md
@@ -6,6 +6,7 @@ CHANGELOG
 
  * added `ServiceSubscriberTrait`
  * added `ServiceLocatorArgument` for creating optimized service-locators
+ * added `CheckTypeHintsPass` to check injected parameters type during compilation
 
 4.1.0
 -----

diff --git a/src/Symfony/Component/DependencyInjection/Compiler/CheckTypeHintsPass.php b/src/Symfony/Component/DependencyInjection/Compiler/CheckTypeHintsPass.php
@@ -0,0 +1,165 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Exception\InvalidParameterTypeHintException;
+
+/**
+ * Checks whether injected parameters types are compatible with type hints.
+ * This pass should be added before removing (PassConfig::TYPE_BEFORE_REMOVING).
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ * @author Julien Maulny <jmaulny@darkmira.fr>
+ */
+class 
10000
CheckTypeHintsPass extends AbstractRecursivePass
+{
+    /**
+     * If set to true, allows to autoload classes during compilation
+     * in order to check type hints on parameters that are not yet loaded.
+     * Defaults to false to prevent code loading during compilation.
+     *
+     * @param bool
+     */
+    private $autoload;
+
+    public function __construct(bool $autoload = false)
+    {
+        $this->autoload = $autoload;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function processValue($value, $isRoot = false)
+    {
+        if (!$value instanceof Definition) {
+            return parent::processValue($value, $isRoot);
+        }
+
+        if (!$this->autoload && !class_exists($className = $this->getClassName($value), false) && !interface_exists($className, false)) {
+            return parent::processValue($value, $isRoot);
+        }
+
+        if (null !== $constructor = $this->getConstructor($value, false)) {
+            $this->checkArgumentsTypeHints($constructor, $value->getArguments());
+        }
+
+        foreach ($value->getMethodCalls() as $methodCall) {
+            $reflectionMethod = $this->getReflectionMethod($value, $methodCall[0]);
+
+            $this->checkArgumentsTypeHints($reflectionMethod, $methodCall[1]);
+        }
+
+        return parent::processValue($value, $isRoot);
+    }
+
+    /**
+     * Check type hints for every parameter of a method/constructor.
+     *
+     * @throws InvalidArgumentException on type hint incompatibility
+     */
+    private function checkArgumentsTypeHints(\ReflectionFunctionAbstract $reflectionFunction, array $configurationArguments): void
+    {
+        $numberOfRequiredParameters = $reflectionFunction->getNumberOfRequiredParameters();
+
+        if (count($configurationArguments) < $numberOfRequiredParameters) {
+            throw new InvalidArgumentException(sprintf(
+                'Invalid definition for service "%s": "%s::%s()" requires %d arguments, %d passed.', $this->currentId, $reflectionFunction->class, $reflectionFunction->name, $numberOfRequiredParameters, count($configurationArguments)));
+        }
+
+        $reflectionParameters = $reflectionFunction->getParameters();
+        $checksCount = min($reflectionFunction->getNumberOfParameters(), count($configurationArguments));
+
+        for ($i = 0; $i < $checksCount; ++$i) {
+            if (!$reflectionParameters[$i]->hasType() || $reflectionParameters[$i]->isVariadic()) {
+                continue;
+            }
+
+            $this->checkTypeHint($configurationArguments[$i], $reflectionParameters[$i]);
+        }
+
+        if ($reflectionFunction->isVariadic() && ($lastParameter = end($reflectionParameters))->hasType()) {
+            $variadicParameters = array_slice($configurationArguments, $lastParameter->getPosition());
+
+            foreach ($variadicParameters as $variadicParameter) {
+                $this->checkTypeHint($variadicParameter, $lastParameter);
+            }
+        }
+    }
+
+    /**
+     * Check type hints compatibility between
+     * a definition argument and a reflection parameter.
+     *
+     * @throws InvalidArgumentException on type hint incompatibility
+     */
+    private function checkTypeHint($configurationArgument, \ReflectionParameter $parameter): void
+    {
+        $referencedDefinition = $configurationArgument;
+
+        if ($referencedDefinition instanceof Reference) {
+            $referencedDefinition = $this->container->findDefinition((string) $referencedDefinition);
+        }
+
+        if ($referencedDefinition instanceof Definition) {
+            $class = $this->getClassName($referencedDefinition);
+
+            if (!$this->autoload && !class_exists($class, false)) {
+                return;
+            }
+
+            if (!is_a($class, $parameter->getType()->getName(), true)) {
+                throw new InvalidParameterTypeHintException($this->currentId, null === $class ? 'null' : $class, $parameter);
+            }
+        } else {
+            if (null === $configurationArgument && $parameter->allowsNull()) {
+                return;
+            }
+
+            if ($parameter->getType()->isBuiltin() && is_scalar($configurationArgument)) {
+                return;
+            }
+
+            $checkFunction = 'is_'.$parameter->getType()->getName();
+
+            if (!$parameter->getType()->isBuiltin() || !$checkFunction($configurationArgument)) {
+                throw new InvalidParameterTypeHintException($this->currentId, gettype($configurationArgument), $parameter);
+            }
+        }
+    }
+
+    /**
+     * Get class name from value that can have a factory.
+     *
+     * @return string|null
+     */
+    private function getClassName($value)
+    {
+        if (is_array($factory = $value->getFactory())) {
+            list($class, $method) = $factory;
+            if ($class instanceof Reference) {
+                $class = $this->container->findDefinition((string) $class)->getClass();
+            } elseif (null === $class) {
+                $class = $value->getClass();
+            } elseif ($class instanceof Definition) {
+                $class = $this->getClassName($class);
+            }
+        } else {
+            $class = $value->getClass();
+        }
+
+        return $class;
+    }
+}
diff --git a/src/Symfony/Component/DependencyInjection/Exception/InvalidParameterTypeHintException.php b/src/Symfony/Component/DependencyInjection/Exception/InvalidParameterTypeHintException.php
@@ -0,0 +1,28 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\DependencyInjection\Exception;
+
+/**
+ * Thrown when trying to inject a parameter into a constructor/method
+ * with a type that does not match type hint.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ * @author Julien Maulny <jmaulny@darkmira.fr>
+ */
+class InvalidParameterTypeHintException extends InvalidArgumentException
+{
+    public function __construct(string $serviceId, string $typeHint, \ReflectionParameter $parameter)
+    {
+        parent::__construct(sprintf(
+            'Invalid definition for service "%s": argument %d of "%s::%s" requires a "%s", "%s" passed.', $serviceId, $parameter->getPosition(), $parameter->getDeclaringClass()->getName(), $parameter->getDeclaringFunction()->getName(), $parameter->getType()->getName(), $typeHint));
+    }
+}
-Original file line number
+Diff line change
@@ Expand Up / @@ -6,6 +6,7 @@ CHANGELOG @@
      * added `ServiceSubscriberTrait`
      * added `ServiceLocatorArgument` for creating optimized service-locators
+     * added `CheckTypeHintsPass` to check injected parameters type during compilation
 .1.0
     -----
@@ Expand Down @@