Request validation rules documentation based on static analysis instead of eval

src/Infer/Analyzer/MethodAnalysisResult.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Dedoc\Scramble\Infer\Analyzer;
+
+use Dedoc\Scramble\Infer\Definition\FunctionLikeDefinition;
+use Dedoc\Scramble\Infer\Scope\Scope;
+
+class MethodAnalysisResult
+{
+    public function __construct(
+        public Scope $scope,
+        public FunctionLikeDefinition $definition,
+    ) {
+    }
+}

src/Infer/Analyzer/MethodAnalyzer.php

@@ -28,7 +28,7 @@ public function __construct(
 
     public function analyze(FunctionLikeDefinition $methodDefinition, array $indexBuilders = [])
     {
-        $this->traverseClassMethod(
+        $scope = $this->traverseClassMethod(
             [$this->getClassReflector()->getMethod($methodDefinition->type->name)->getAstNode()],
             $methodDefinition,
             $indexBuilders,
@@ -40,7 +40,10 @@ public function analyze(FunctionLikeDefinition $methodDefinition, array $indexBu
 
         $methodDefinition->isFullyAnalyzed = true;
 
-        return $methodDefinition;
+        return new MethodAnalysisResult(
+            scope: $scope,
+            definition: $methodDefinition,
+        );
     }
 
     private function getClassReflector(): ClassReflector
@@ -57,7 +60,7 @@ private function traverseClassMethod(array $nodes, FunctionLikeDefinition $metho
         $traverser->addVisitor(new TypeInferer(
             $this->index,
             $nameResolver,
-            new Scope($this->index, new NodeTypesResolver(), new ScopeContext($this->classDefinition), $nameResolver),
+            $scope = new Scope($this->index, new NodeTypesResolver(), new ScopeContext($this->classDefinition), $nameResolver),
             Context::getInstance()->extensionsBroker->extensions,
             [new IndexBuildingHandler($indexBuilders)],
         ));
@@ -70,6 +73,6 @@ private function traverseClassMethod(array $nodes, FunctionLikeDefinition $metho
 
         $traverser->traverse(Arr::wrap($node));
 
-        return $node;
+        return $scope;
     }
 }

src/Infer/Definition/ClassDefinition.php

@@ -20,6 +20,8 @@
 
 class ClassDefinition
 {
+    private array $methodsScopes = [];
+
     public function __construct(
         // FQ name
         public string $name,
@@ -57,10 +59,13 @@ public function getMethodDefinition(string $name, Scope $scope = new GlobalScope
         $methodDefinition = $this->methods[$name];
 
         if (! $methodDefinition->isFullyAnalyzed()) {
-            $this->methods[$name] = (new MethodAnalyzer(
+            $result = (new MethodAnalyzer(
                 $scope->index,
                 $this
             ))->analyze($methodDefinition, $indexBuilders);
+
+            $this->methodsScopes[$name] = $result->scope;
+            $this->methods[$name] = $result->definition;
         }
 
         $methodScope = new Scope(
@@ -116,4 +121,11 @@ private function replaceTemplateInType(Type $type, array $templateTypesMap)
 
         return $type;
     }
+
+    public function getMethodScope(string $methodName)
+    {
+        $this->getMethodDefinition($methodName);
+
+        return $this->methodsScopes[$methodName] ?? null;
+    }
 }

src/Infer/Extensions/Event/FunctionCallEvent.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Dedoc\Scramble\Infer\Extensions\Event;
+
+use Dedoc\Scramble\Infer\Extensions\Event\Concerns\ArgumentTypesAware;
+use Dedoc\Scramble\Infer\Scope\Scope;
+
+class FunctionCallEvent
+{
+    use ArgumentTypesAware;
+
+    public function __construct(
+        public readonly string $name,
+        public readonly Scope $scope,
+        public readonly array $arguments,
+    ) {
+    }
+
+    public function getDefinition()
+    {
+        return $this->scope->index->getFunctionDefinition($this->name);
+    }
+
+    public function getName()
+    {
+        return $this->name;
+    }
+}

src/Infer/Extensions/ExtensionsBroker.php

@@ -41,6 +41,22 @@ public function getMethodReturnType($event)
         return null;
     }
 
+    public function getFunctionReturnType($event)
+    {
+        $extensions = array_filter($this->extensions, function ($e) use ($event) {
+            return $e instanceof FunctionReturnTypeExtension
+                && $e->shouldHandle($event->getName());
+        });
+
+        foreach ($extensions as $extension) {
+            if ($propertyType = $extension->getFunctionReturnType($event)) {
+                return $propertyType;
+            }
+        }
+
+        return null;
+    }
+
     public function getStaticMethodReturnType($event)
     {
         $extensions = array_filter($this->extensions, function ($e) use ($event) {

src/Infer/Extensions/FunctionReturnTypeExtension.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Dedoc\Scramble\Infer\Extensions;
+
+use Dedoc\Scramble\Infer\Extensions\Event\FunctionCallEvent;
+use Dedoc\Scramble\Support\Type\Type;
+
+interface FunctionReturnTypeExtension extends InferExtension
+{
+    public function shouldHandle(string $name): bool;
+
+    public function getFunctionReturnType(FunctionCallEvent $event): ?Type;
+}

src/Infer/Handler/ConcatHandler.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Dedoc\Scramble\Infer\Handler;
+
+use Dedoc\Scramble\Infer\Scope\Scope;
+use Dedoc\Scramble\Support\Type\ConcatenatedStringType;
+use Dedoc\Scramble\Support\Type\TypeHelper;
+use PhpParser\Node;
+
+class ConcatHandler
+{
+    public function shouldHandle($node)
+    {
+        return $node instanceof Node\Expr\BinaryOp\Concat;
+    }
+
+    public function leave(Node\Expr\BinaryOp\Concat $node, Scope $scope)
+    {
+        $scope->setType(
+            $node,
+            new ConcatenatedStringType(TypeHelper::flattenStringConcatTypes([
+                $scope->getType($node->left),
+                $scope->getType($node->right),
+            ])),
+        );
+    }
+}

src/Infer/Scope/Scope.php

@@ -15,11 +15,13 @@
 use Dedoc\Scramble\Support\Type\CallableStringType;
 use Dedoc\Scramble\Support\Type\KeyedArrayType;
 use Dedoc\Scramble\Support\Type\ObjectType;
+use Dedoc\Scramble\Support\Type\Reference\AbstractReferenceType;
 use Dedoc\Scramble\Support\Type\Reference\CallableCallReferenceType;
 use Dedoc\Scramble\Support\Type\Reference\MethodCallReferenceType;
 use Dedoc\Scramble\Support\Type\Reference\NewCallReferenceType;
 use Dedoc\Scramble\Support\Type\Reference\PropertyFetchReferenceType;
 use Dedoc\Scramble\Support\Type\Reference\StaticMethodCallReferenceType;
+use Dedoc\Scramble\Support\Type\Reference\StaticPropertyFetchReferenceType;
 use Dedoc\Scramble\Support\Type\SelfType;
 use Dedoc\Scramble\Support\Type\TemplateType;
 use Dedoc\Scramble\Support\Type\Type;
@@ -54,7 +56,13 @@ public function getType(Node $node): Type
         }
 
         if ($node instanceof Node\Expr\ConstFetch) {
-            return (new ConstFetchTypeGetter)($node);
+            $type = (new ConstFetchTypeGetter)($node);
+
+            if (! $type instanceof AbstractReferenceType) {
+                return $type;
+            }
+
+            return $this->setType($node, $type);
         }
 
         if ($node instanceof Node\Expr\Ternary) {
@@ -73,7 +81,13 @@ public function getType(Node $node): Type
         }
 
         if ($node instanceof Node\Expr\ClassConstFetch) {
-            return (new ClassConstFetchTypeGetter)($node, $this);
+            $type = (new ClassConstFetchTypeGetter)($node, $this);
+
+            if (! $type instanceof AbstractReferenceType) {
+                return $type;
+            }
+
+            return $this->setType($node, $type);
         }
 
         if ($node instanceof Node\Expr\BooleanNot) {
@@ -117,11 +131,11 @@ public function getType(Node $node): Type
 
             $calleeType = $this->getType($node->var);
             if ($calleeType instanceof TemplateType) {
-                // @todo
-                // if ($calleeType->is instanceof ObjectType) {
-                //     $calleeType = $calleeType->is;
-                // }
-                return $this->setType($node, new UnknownType("Cannot infer type of method [{$node->name->name}] call on template type: not supported yet."));
+                if ($calleeType->is instanceof ObjectType) {
+                    $calleeType = $calleeType->is;
+                } else {
+                    return $this->setType($node, new UnknownType("Cannot infer type of method [{$node->name->name}] call on template type: not supported yet."));
+                }
             }
 
             return $this->setType(
@@ -147,6 +161,23 @@ public function getType(Node $node): Type
             );
         }
 
+        if ($node instanceof Node\Expr\StaticPropertyFetch) {
+            // Only string method names support.
+            if (! $node->name instanceof Node\Identifier) {
+                return $type;
+            }
+
+            // Only string class names support.
+            if (! $node->class instanceof Node\Name) {
+                return $type;
+            }
+
+            return $this->setType(
+                $node,
+                new StaticPropertyFetchReferenceType($node->class->toString(), $node->name->name),
+            );
+        }
+
         if ($node instanceof Node\Expr\PropertyFetch) {
             // Only string prop names support.
             if (! $name = ($node->name->name ?? null)) {
@@ -303,11 +334,6 @@ private function getVariableType(Node\Expr\Variable $node)
         return $type;
     }
 
-    public function getMethodCallType(Type $calledOn, string $methodName, array $arguments = []): Type
-    {
-
-    }
-
     public function getPropertyFetchType(Type $calledOn, string $propertyName): Type
     {
         return (new ReferenceTypeResolver($this->index))->resolve($this, new PropertyFetchReferenceType($calledOn, $propertyName));

src/Infer/Scope/ScopeTypeResolver.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Dedoc\Scramble\Infer\Scope;
+
+use Dedoc\Scramble\Infer\Services\ReferenceTypeResolver;
+use Dedoc\Scramble\Support\Type\Type;
+use PhpParser\Node;
+
+class ScopeTypeResolver
+{
+    public function __construct(private Scope $scope)
+    {
+    }
+
+    public function getType(Node $node): ?Type
+    {
+        $type = $this->scope->getType($node);
+
+        if (! $type) {
+            return null;
+        }
+
+        return (new ReferenceTypeResolver($this->scope->index))
+            ->resolve($this->scope, $type)
+            ->mergeAttributes($type->attributes());
+    }
+}

src/Infer/Services/ConstFetchTypeGetter.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Dedoc\Scramble\Infer\Services;
+
+use Dedoc\Scramble\Infer\Scope\Scope;
+use Dedoc\Scramble\Support\Type\Literal\LiteralStringType;
+use Dedoc\Scramble\Support\Type\TypeHelper;
+use Dedoc\Scramble\Support\Type\UnknownType;
+
+class ConstFetchTypeGetter
+{
+    public function __invoke(Scope $scope, string $className, string $constName)
+    {
+        if ($constName === 'class') {
+            return new LiteralStringType($className);
+        }
+
+        try {
+            $constantReflection = new \ReflectionClassConstant($className, $constName);
+            $constantValue = $constantReflection->getValue();
+
+            $type = TypeHelper::createTypeFromValue($constantValue);
+
+            if ($type) {
+                return $type;
+            }
+        } catch (\ReflectionException $e) {
+            return new UnknownType('Cannot get const value');
+        }
+
+        return new UnknownType('ConstFetchTypeGetter is not yet implemented fully for non-class const fetches.');
+    }
+}