Add the service map

Author: mglaman

composer.json

@@ -10,7 +10,8 @@
     ],
     "require": {
         "php": "^7.1",
-        "phpstan/phpstan": "^0.10.6"
+        "phpstan/phpstan": "^0.10.6",
+        "symfony/yaml": "^4.2"
     },
     "autoload": {
         "psr-4": {

extension.neon

@@ -19,8 +19,16 @@ rules:
 	- PHPStan\Rules\Drupal\GlobalDrupalDependencyInjectionRule
 	- PHPStan\Rules\Drupal\PluginManager\PluginManagerSetsCacheBackendRule
 services:
+	drupal.serviceMapFactory:
+		class: PHPStan\Drupal\ServiceMapFactoryInterface
+		factory: PHPStan\Drupal\ServiceMapFactory(%drupalServiceMap%)
+	-
+		class: @drupal.serviceMapFactory::create()
 	-
 		class: PHPStan\Type\EntityTypeManagerGetStorageDynamicReturnTypeExtension
 		arguments:
 			entityTypeStorageMapping: %drupal.entityTypeStorageMapping%
 		tags: [phpstan.broker.dynamicMethodReturnTypeExtension]
+	-
+		class: PHPStan\Type\ServiceDynamicReturnTypeExtension
+		tags: [phpstan.broker.dynamicMethodReturnTypeExtension]

src/DependencyInjection/DrupalExtension.php

@@ -7,6 +7,7 @@
 use PHPStan\Drupal\ExtensionDiscovery;
 use PHPStan\Rules\Classes\EnhancedRequireParentConstructCallRule;
 use PHPStan\Rules\Classes\RequireParentConstructCallRule;
+use Symfony\Component\Yaml\Yaml;
 
 class DrupalExtension extends CompilerExtension
 {
@@ -103,12 +104,65 @@ public function loadConfiguration(): void
         }, $profiles);
         $extensionDiscovery->setProfileDirectories($profile_directories);
 
+
+        $serviceYamls = [
+            'core' => $this->drupalRoot . '/core/core.services.yml',
+        ];
+        $serviceClassProviders = [
+            'core' => 'Drupal\Core\CoreServiceProvider',
+        ];
+
         foreach ($extensionDiscovery->scan('module') as $extension) {
             $module_dir = $this->drupalRoot . '/' . $extension->getPath();
-            $servicesFileName = $module_dir . '/' . $extension->getName() . '.services.yml';
+            $moduleName = $extension->getName();
+            $servicesFileName = $module_dir . '/' . $moduleName . '.services.yml';
             if (file_exists($servicesFileName)) {
-                // @todo load and parse, push basic definitions into container parameters
+                $serviceYamls[$moduleName] = $servicesFileName;
+            }
+
+            $camelized = $this->camelize($extension->getName());
+            $name = "{$camelized}ServiceProvider";
+            $class = "Drupal\\{$moduleName}\\{$name}";
+
+            if (class_exists($class)) {
+                $serviceClassProviders[$moduleName] = $class;
             }
         }
+
+        foreach ($serviceYamls as $extension => $serviceYaml) {
+            $yaml = Yaml::parseFile($serviceYaml);
+            // Weed out service files which only provide parameters.
+            if (!isset($yaml['services']) || !is_array($yaml['services'])) {
+                continue;
+            }
+            foreach ($yaml['services'] as $serviceId => $serviceDefinition) {
+                // Prevent \Nette\DI\ContainerBuilder::completeStatement from array_walk_recursive into the arguments
+                // and thinking these are real services for PHPStan's container.
+                if (isset($serviceDefinition['arguments']) && is_array($serviceDefinition['arguments'])) {
+                    array_walk($serviceDefinition['arguments'], function (&$argument) {
+                        $argument = str_replace('@', '', $argument);
+                    });
+                }
+                unset($serviceDefinition['tags']);
+                // @todo sanitize "calls" and "configurator" and "factory"
+                /**
+                jsonapi.params.enhancer:
+                    class: Drupal\jsonapi\Routing\JsonApiParamEnhancer
+                    calls:
+                        - [setContainer, ['@service_container']]
+                    tags:
+                        - { name: route_enhancer }
+                 */
+                unset($serviceDefinition['calls']);
+                unset($serviceDefinition['configurator']);
+                unset($serviceDefinition['factory']);
+                $builder->parameters['drupalServiceMap'][$serviceId] = $serviceDefinition;
+            }
+        }
+    }
+
+    protected function camelize($id)
+    {
+        return strtr(ucwords(strtr($id, ['_' => ' ', '.' => '_ ', '\\' => '_ '])), [' ' => '']);
     }
 }

src/Drupal/DrupalServiceDefinition.php

@@ -0,0 +1,53 @@
+<?php declare(strict_types=1);
+
+namespace PHPStan\Drupal;
+
+class DrupalServiceDefinition
+{
+    private $id;
+    private $class;
+    private $public;
+    private $alias;
+
+    public function __construct(string $id, ?string $class, bool $public = true, ?string $alias = null)
+    {
+        $this->id = $id;
+        $this->class = $class;
+        $this->public = $public;
+        $this->alias = $alias;
+    }
+
+    /**
+     * @return string
+     */
+    public function getId(): string
+    {
+        return $this->id;
+    }
+
+    /**
+     * @return string|null
+     */
+    public function getClass(): ?string
+    {
+        return $this->class;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isPublic(): bool
+    {
+        return $this->public;
+    }
+
+    /**
+     * @return string|null
+     */
+    public function getAlias(): ?string
+    {
+        return $this->alias;
+    }
+
+}
+

src/Drupal/ServiceMap.php

@@ -0,0 +1,43 @@
+<?php declare(strict_types=1);
+
+namespace PHPStan\Drupal;
+
+class ServiceMap
+{
+    /** @var \PHPStan\Drupal\DrupalServiceDefinition[] */
+    private $services;
+
+    /**
+     * ServiceMap constructor.
+     * @param array $drupalServices
+     */
+    public function __construct(array $drupalServices)
+    {
+        foreach ($drupalServices as $serviceId => $serviceDefinition) {
+            // @todo support factories
+            if (!isset($serviceDefinition['class'])) {
+                continue;
+            }
+            $this->services[$serviceId] = new DrupalServiceDefinition(
+                $serviceId,
+                $serviceDefinition['class'],
+                $serviceDefinition['public'] ?? true,
+                $serviceDefinition['alias'] ?? null
+            );
+        }
+    }
+
+    /**
+     * @return DrupalServiceDefinition[]
+     */
+    public function getServices(): array
+    {
+        return $this->services;
+    }
+
+    public function getService(string $id): ?DrupalServiceDefinition
+    {
+        return $this->services[$id] ?? null;
+    }
+
+}

src/Drupal/ServiceMapFactory.php

@@ -0,0 +1,19 @@
+<?php declare(strict_types=1);
+
+namespace PHPStan\Drupal;
+
+class ServiceMapFactory implements ServiceMapFactoryInterface
+{
+    private $drupalServices;
+
+    public function __construct(array $drupalServiceMap = [])
+    {
+        $this->drupalServices = $drupalServiceMap;
+    }
+
+    public function create(): ServiceMap
+    {
+        return new ServiceMap($this->drupalServices);
+    }
+
+}

src/Drupal/ServiceMapFactoryInterface.php

@@ -0,0 +1,10 @@
+<?php declare(strict_types=1);
+
+namespace PHPStan\Drupal;
+
+interface ServiceMapFactoryInterface
+{
+
+    public function create(): ServiceMap;
+
+}

src/Type/ServiceDynamicReturnTypeExtension.php

@@ -0,0 +1,63 @@
+<?php declare(strict_types=1);
+
+namespace PHPStan\Type;
+
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Drupal\DrupalServiceDefinition;
+use PHPStan\Drupal\ServiceMap;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\ParametersAcceptorSelector;
+use PHPStan\ShouldNotHappenException;
+use PHPStan\Type\Constant\ConstantBooleanType;
+
+class ServiceDynamicReturnTypeExtension implements DynamicMethodReturnTypeExtension
+{
+    /**
+     * @var ServiceMap
+     */
+    private $serviceMap;
+
+    public function __construct(ServiceMap $serviceMap)
+    {
+        $this->serviceMap = $serviceMap;
+    }
+
+    public function getClass(): string
+    {
+        return 'Symfony\Component\DependencyInjection\ContainerInterface';
+    }
+
+    public function isMethodSupported(MethodReflection $methodReflection): bool
+    {
+        return in_array($methodReflection->getName(), ['get', 'has'], true);
+    }
+
+    public function getTypeFromMethodCall(
+        MethodReflection $methodReflection,
+        MethodCall $methodCall,
+        Scope $scope
+    ): Type {
+        $returnType = ParametersAcceptorSelector::selectSingle($methodReflection->getVariants())->getReturnType();
+        if (!isset($methodCall->args[0])) {
+            return $returnType;
+        }
+
+        $serviceId = (string)$methodCall->args[0]->value->value;
+
+        if ($methodReflection->getName() === 'get') {
+            $service = $this->serviceMap->getService($serviceId);
+            if ($service instanceof DrupalServiceDefinition) {
+                return new ObjectType($service->getClass() ?? $serviceId);
+            }
+            return $returnType;
+        }
+
+        if ($methodReflection->getName() === 'has') {
+            return new ConstantBooleanType($this->serviceMap->getService($serviceId) instanceof DrupalServiceDefinition);
+        }
+
+        throw new ShouldNotHappenException();
+    }
+
+}