Merge pull request #49 from sabbelasichon/add-validator-resolver-rule

Add validator resolver rule

Author: sabbelasichon

.gitignore

@@ -4,4 +4,5 @@
 /.idea
 /index.php
 /public
-/var
+/var
+.phpunit.result.cache

composer.json

@@ -7,7 +7,7 @@
     "prefer-stable": true,
     "require": {
         "php": "^7.2 || ^8.0",
-        "phpstan/phpstan": "^1.6",
+        "phpstan/phpstan": "^1.7",
         "nikic/php-parser": ">= 4.13",
         "typo3/cms-core": "^8.7 || ^9.5 || ^10.4 || ^11.2",
         "typo3/cms-extbase": "^8.7 || ^9.5 || ^10.4 || ^11.2"

extension.neon

@@ -51,6 +51,10 @@ services:
             siteGetAttributeMapping: %typo3.siteGetAttributeMapping%
         tags:
             - phpstan.rules.rule
+    -
+        class: SaschaEgerer\PhpstanTypo3\Rule\ValidatorResolverOptionsRule
+        tags:
+            - phpstan.rules.rule
     -
         class: SaschaEgerer\PhpstanTypo3\Type\RepositoryQueryDynamicReturnTypeExtension
         tags:
@@ -71,6 +75,9 @@ services:
             siteGetAttributeMapping: %typo3.siteGetAttributeMapping%
         tags:
             - phpstan.broker.dynamicMethodReturnTypeExtension
+    -
+        class: SaschaEgerer\PhpstanTypo3\Service\ValidatorClassNameResolver
+
 parameters:
     bootstrapFiles:
         - phpstan.bootstrap.php

phpstan.neon

@@ -11,7 +11,14 @@ parameters:
          - src
          - tests
     reportUnmatchedIgnoredErrors: false
+    excludePaths:
+         - '*tests/*/Fixture/*'
+         - '*tests/*/Source/*'
     ignoreErrors:
         -
             message: '#^Class TYPO3\\CMS\\Core\\Context\\[a-zA-Z]* not found\.#'
-            path: %currentWorkingDirectory%/src/Type/ContextDynamicReturnTypeExtension.php
+            path: src/Type/ContextDynamicReturnTypeExtension.php
+        -
+            message: "#^Calling PHPStan\\\\Reflection\\\\InitializerExprTypeResolver\\:\\:getClassConstFetchType\\(\\) is not covered by backward compatibility promise\\. The method might change in a minor PHPStan version\\.$#"
+            count: 1
+            path: src/Rule/ValidatorResolverOptionsRule.php

src/Rule/ValidatorResolverOptionsRule.php

@@ -0,0 +1,264 @@
+<?php declare(strict_types = 1);
+
+namespace SaschaEgerer\PhpstanTypo3\Rule;
+
+use PhpParser\Node;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Expr\Array_;
+use PhpParser\Node\Expr\ArrayItem;
+use PhpParser\Node\Expr\ClassConstFetch;
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\InitializerExprTypeResolver;
+use PHPStan\Reflection\Php\PhpPropertyReflection;
+use PHPStan\Reflection\PropertyReflection;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\Constant\ConstantArrayType;
+use PHPStan\Type\Constant\ConstantBooleanType;
+use PHPStan\Type\Constant\ConstantStringType;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+use SaschaEgerer\PhpstanTypo3\Rule\ValueObject\ValidatorOptionsConfiguration;
+use SaschaEgerer\PhpstanTypo3\Service\ValidatorClassNameResolver;
+use TYPO3\CMS\Extbase\Validation\Validator\AbstractValidator;
+use TYPO3\CMS\Extbase\Validation\ValidatorResolver;
+
+/**
+ * @implements Rule<MethodCall>
+ */
+final class ValidatorResolverOptionsRule implements Rule
+{
+
+	/** @var InitializerExprTypeResolver */
+	private $initializerExprTypeResolver;
+
+	/** @var ValidatorClassNameResolver */
+	private $validatorClassNameResolver;
+
+	public function __construct(InitializerExprTypeResolver $initializerExprTypeResolver, ValidatorClassNameResolver $validatorClassNameResolver)
+	{
+		$this->initializerExprTypeResolver = $initializerExprTypeResolver;
+		$this->validatorClassNameResolver = $validatorClassNameResolver;
+	}
+
+	public function getNodeType(): string
+	{
+		return MethodCall::class;
+	}
+
+	/**
+	 * @param MethodCall $node
+	 */
+	public function processNode(Node $node, Scope $scope): array
+	{
+		if ($this->shouldSkip($node, $scope)) {
+			return [];
+		}
+
+		$validatorTypeArgument = $node->getArgs()[0] ?? null;
+		$validatorOptionsArgument = $node->getArgs()[1] ?? null;
+
+		if ($validatorTypeArgument === null) {
+			return [];
+		}
+
+		$validatorType = $scope->getType($validatorTypeArgument->value);
+
+		try {
+			$validatorClassName = $this->validatorClassNameResolver->resolve($validatorType);
+		} catch (\TYPO3\CMS\Extbase\Validation\Exception\NoSuchValidatorException $e) {
+			if ($validatorType instanceof ConstantStringType) {
+				$validatorClassName = $validatorType->getValue();
+				$message = sprintf('Could not create validator for "%s"', $validatorClassName);
+			} else {
+				$message = 'Could not create validator';
+			}
+
+			return [
+				RuleErrorBuilder::message($message)->build(),
+			];
+		}
+
+		if ($validatorClassName === null) {
+			return [];
+		}
+
+		$validatorObjectType = new ObjectType($validatorClassName);
+		$validatorClassReflection = $validatorObjectType->getClassReflection();
+
+		if ( ! $validatorClassReflection instanceof ClassReflection) {
+			return [];
+		}
+
+		if (!$validatorClassReflection->isSubclassOf(AbstractValidator::class)) {
+			return [];
+		}
+
+		try {
+			$supportedOptions = $validatorClassReflection->getProperty('supportedOptions', $scope);
+		} catch (\PHPStan\Reflection\MissingPropertyFromReflectionException $e) {
+			return [];
+		}
+
+		$validatorOptionsConfiguration = $this->extractValidatorOptionsConfiguration($supportedOptions, $scope);
+		$providedOptionsArray = $this->extractProvidedOptions($validatorOptionsArgument, $scope);
+
+		$unsupportedOptions = array_diff($providedOptionsArray, $validatorOptionsConfiguration->getSupportedOptions());
+		$neededRequiredOptions = array_diff($validatorOptionsConfiguration->getRequiredOptions(), $providedOptionsArray);
+
+		$errors = [];
+
+		if ($neededRequiredOptions !== []) {
+			foreach ($neededRequiredOptions as $neededRequiredOption) {
+				$errorMessage = sprintf('Required validation option not set: %s', $neededRequiredOption);
+				$errors[] = RuleErrorBuilder::message($errorMessage)->build();
+			}
+		}
+
+		if ($unsupportedOptions !== []) {
+			$errorMessage = 'Unsupported validation option(s) found: ' . implode(', ', $unsupportedOptions);
+			$errors[] = RuleErrorBuilder::message($errorMessage)->build();
+		}
+
+		return $errors;
+	}
+
+	private function shouldSkip(MethodCall $methodCall, Scope $scope): bool
+	{
+		$objectType = $scope->getType($methodCall->var);
+		$validatorResolverType = new ObjectType(ValidatorResolver::class);
+
+		if ($validatorResolverType->isSuperTypeOf($objectType)->no()) {
+			return true;
+		}
+
+		if ( ! $methodCall->name instanceof Node\Identifier) {
+			return true;
+		}
+
+		return $methodCall->name->toString() !== 'createValidator';
+	}
+
+	/**
+	 * @return string[]
+	 */
+	private function extractProvidedOptions(?Arg $validatorOptionsArgument, Scope $scope): array
+	{
+		if ( ! $validatorOptionsArgument instanceof Arg) {
+			return [];
+		}
+
+		$providedOptionsArray = [];
+
+		$validatorOptionsArgumentType = $scope->getType($validatorOptionsArgument->value);
+
+		if ( ! $validatorOptionsArgumentType instanceof ConstantArrayType) {
+			return [];
+		}
+
+		$keysArray = $validatorOptionsArgumentType->getKeysArray();
+
+		foreach ($keysArray->getValueTypes() as $valueType) {
+			if ( ! ($valueType instanceof ConstantStringType)) {
+				continue;
+			}
+
+			$providedOptionsArray[] = $valueType->getValue();
+		}
+
+		return $providedOptionsArray;
+	}
+
+	private function extractValidatorOptionsConfiguration(PropertyReflection $supportedOptions, Scope $scope): ValidatorOptionsConfiguration
+	{
+		$collectedSupportedOptions = [];
+		$collectedRequiredOptions = [];
+
+		if ( ! $supportedOptions instanceof PhpPropertyReflection) {
+			return ValidatorOptionsConfiguration::empty();
+		}
+
+		$defaultValues = $supportedOptions->getNativeReflection()->getDefaultValueExpr();
+
+		if ( ! $defaultValues instanceof Array_) {
+			return ValidatorOptionsConfiguration::empty();
+		}
+
+		foreach ($defaultValues->items as $defaultValue) {
+
+			if ( ! $defaultValue instanceof ArrayItem) {
+				continue;
+			}
+
+			if ($defaultValue->key === null) {
+				continue;
+			}
+
+			$supportedOptionKey = $this->resolveOptionKeyValue($defaultValue, $supportedOptions, $scope);
+
+			if ($supportedOptionKey === null) {
+				continue;
+			}
+
+			$collectedSupportedOptions[] = $supportedOptionKey;
+
+			$optionDefinition = $defaultValue->value;
+			if ( ! $optionDefinition instanceof Array_) {
+				continue;
+			}
+
+			if ( ! isset($optionDefinition->items[3])) {
+				continue;
+			}
+
+			$requiredValueType = $scope->getType($optionDefinition->items[3]->value);
+
+			if (!$requiredValueType instanceof ConstantBooleanType) {
+				continue;
+			}
+
+			if (!$requiredValueType->getValue()) {
+				continue;
+			}
+
+			$collectedRequiredOptions[] = $supportedOptionKey;
+		}
+
+		return new ValidatorOptionsConfiguration($collectedSupportedOptions, $collectedRequiredOptions);
+	}
+
+	private function resolveOptionKeyValue(ArrayItem $defaultValue, PhpPropertyReflection $supportedOptions, Scope $scope): ?string
+	{
+		if ($defaultValue->key === null) {
+			return null;
+		}
+
+		if ($defaultValue->key instanceof ClassConstFetch && $defaultValue->key->name instanceof Node\Identifier) {
+			$keyType = $this->initializerExprTypeResolver->getClassConstFetchType(
+				$defaultValue->key->class,
+				$defaultValue->key->name->toString(),
+				$supportedOptions->getDeclaringClass()->getName(),
+				static function (\PhpParser\Node\Expr $expr) use ($scope): Type {
+					return $scope->getType($expr);
+				}
+			);
+
+			if ($keyType instanceof ConstantStringType) {
+				return $keyType->getValue();
+			}
+
+			return null;
+		}
+
+		$keyType = $scope->getType($defaultValue->key);
+
+		if ($keyType instanceof ConstantStringType) {
+			return $keyType->getValue();
+		}
+
+		return null;
+	}
+
+}

src/Rule/ValueObject/ValidatorOptionsConfiguration.php

@@ -0,0 +1,45 @@
+<?php declare(strict_types = 1);
+
+namespace SaschaEgerer\PhpstanTypo3\Rule\ValueObject;
+
+final class ValidatorOptionsConfiguration
+{
+
+	/** @var string[] */
+	private $supportedOptions;
+
+	/** @var string[] */
+	private $requriedOptions;
+
+	/**
+	 * @param string[] $supportedOptions
+	 * @param string[] $requriedOptions
+	 */
+	public function __construct(array $supportedOptions, array $requriedOptions)
+	{
+		$this->supportedOptions = $supportedOptions;
+		$this->requriedOptions = $requriedOptions;
+	}
+
+	public static function empty(): self
+	{
+		return new self([], []);
+	}
+
+	/**
+	 * @return string[]
+	 */
+	public function getSupportedOptions(): array
+	{
+		return $this->supportedOptions;
+	}
+
+	/**
+	 * @return string[]
+	 */
+	public function getRequiredOptions(): array
+	{
+		return $this->requriedOptions;
+	}
+
+}