support index definition

Author: tpetry

ide.json

@@ -17,6 +17,14 @@
             {
                 "classFqn": "Illuminate\\Database\\Schema\\ColumnDefinition",
                 "mixinFqn": "Tpetry\\PostgresqlEnhanced\\Schema\\ColumnDefinition"
+            },
+            {
+                "classFqn": "Illuminate\\Database\\Schema\\IndexDefinition",
+                "mixinFqn": "Tpetry\\PostgresqlEnhanced\\Schema\\IndexDefinition"
+            },
+            {
+                "classFqn": "Illuminate\\Support\\Facades\\Schema",
+                "mixinFqn": "Tpetry\\PostgresqlEnhanced\\Support\\Facades\\Schema"
             }
         ]
     }

src/Schema/ColumnDefinition.php

@@ -15,23 +15,23 @@ class ColumnDefinition extends BaseColumnDefinition
     /**
      * Specify the compression method for TOASTed values (PostgreSQL).
      */
-    public function compression(string $algorithm): static
+    public function compression(string $algorithm): self
     {
         return $this;
     }
 
     /**
      * Sets an initial value to the column (PostgreSQL).
      */
-    public function initial(mixed $value): static
+    public function initial(mixed $value): self
     {
         return $this;
     }
 
     /**
      * Specify casting expression when changing the column type (PostgreSQL).
      */
-    public function using(string|Expression $expression): static
+    public function using(string|Expression $expression): self
     {
         return $this;
     }

src/Schema/IndexDefinition.php

@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tpetry\PostgresqlEnhanced\Schema;
+
+use Illuminate\Database\Schema\IndexDefinition as BaseIndexDefinition;
+
+/**
+ * @internal This class is not used. It only exists to teach Laravel projects using PHPStan or IDEs supporting auto-suggest about added functionality.
+ */
+class IndexDefinition extends BaseIndexDefinition
+{
+    /**
+     * Include non-key columns in the index (PostgreSQL).
+     *
+     * @param string|array<int, string> $columns
+     */
+    public function include(string|array $columns): self
+    {
+        return $this;
+    }
+
+    /**
+     * Mark NULLs as not distinct values (PostgreSQL).
+     */
+    public function nullsNotDistinct(): self
+    {
+        return $this;
+    }
+
+    /**
+     * Specify fulltext index weight for columns (PostgreSQL).
+     *
+     * @param array<int, string> $labels
+     */
+    public function weight(array $labels): self
+    {
+        return $this;
+    }
+
+    /**
+     * Build a partial index by specifying the rows that should be included (PostgreSQL).
+     *
+     * @param string|(callable(\Illuminate\Database\Query\Builder):mixed)|(callable(\Illuminate\Contracts\Database\Query\Builder):mixed) $columns
+     */
+    public function where(string|callable $columns): self
+    {
+        return $this;
+    }
+
+    /**
+     * Specify index parameters to fine-tune its configuration (PostgreSQL).
+     *
+     * @param array<string, bool|float|int|string> $options
+     */
+    public function with(array $options): self
+    {
+        return $this;
+    }
+}

src/Support/Phpstan/SchemaIndexDefinitionExtension.php

@@ -4,73 +4,31 @@
 
 namespace Tpetry\PostgresqlEnhanced\Support\Phpstan;
 
-use Illuminate\Contracts\Database\Query\Builder as BuilderContract;
-use Illuminate\Database\Query\Builder as BuilderQuery;
-use Illuminate\Database\Schema\IndexDefinition;
+use Illuminate\Database\Schema\IndexDefinition as BaseIndexDefinition;
 use PHPStan\Reflection\ClassReflection;
-use PHPStan\Reflection\FunctionVariant;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Reflection\MethodsClassReflectionExtension;
-use PHPStan\Type\ArrayType;
-use PHPStan\Type\BooleanType;
-use PHPStan\Type\CallableType;
-use PHPStan\Type\FloatType;
-use PHPStan\Type\Generic\TemplateTypeMap;
-use PHPStan\Type\IntegerType;
-use PHPStan\Type\ObjectType;
-use PHPStan\Type\StringType;
-use PHPStan\Type\TypeCombinator;
-use Tpetry\PostgresqlEnhanced\Support\Phpstan\Values\ReflectedMethod;
-use Tpetry\PostgresqlEnhanced\Support\Phpstan\Values\ReflectedParameter;
-use UnexpectedValueException;
+use PHPStan\Reflection\ReflectionProvider;
+use Tpetry\PostgresqlEnhanced\Schema\IndexDefinition;
 
 class SchemaIndexDefinitionExtension implements MethodsClassReflectionExtension
 {
+    public function __construct(
+        private ReflectionProvider $reflectionProvider,
+    ) {
+    }
+
     public function getMethod(ClassReflection $classReflection, string $methodName): MethodReflection
     {
-        return match ($methodName) {
-            'include' => new ReflectedMethod($classReflection, $methodName, [
-                $this->createFunctionVariant([new ReflectedParameter('columns', new StringType())]),
-                $this->createFunctionVariant([new ReflectedParameter('columns', new ArrayType(new IntegerType(), new StringType()))]),
-            ]),
-            'nullsNotDistinct' => new ReflectedMethod($classReflection, $methodName, [
-                $this->createFunctionVariant([]),
-            ]),
-            'weight' => new ReflectedMethod($classReflection, $methodName, [
-                $this->createFunctionVariant([new ReflectedParameter('labels', new ArrayType(new IntegerType(), new StringType()))]),
-            ]),
-            'where' => new ReflectedMethod($classReflection, $methodName, [
-                $this->createFunctionVariant([new ReflectedParameter('columns', new StringType())]),
-                $this->createFunctionVariant([new ReflectedParameter('columns', new CallableType([new ReflectedParameter('builder', new ObjectType(BuilderContract::class))], new ObjectType(BuilderContract::class), false))]),
-                $this->createFunctionVariant([new ReflectedParameter('columns', new CallableType([new ReflectedParameter('builder', new ObjectType(BuilderQuery::class))], new ObjectType(BuilderContract::class), false))]),
-            ]),
-            'with' => new ReflectedMethod($classReflection, $methodName, [
-                $this->createFunctionVariant([new ReflectedParameter('options', new ArrayType(new StringType(), TypeCombinator::union(new BooleanType(), new FloatType(), new IntegerType(), new StringType())))]),
-            ]),
-            default => throw new UnexpectedValueException("'{$methodName}' is not defined for IndexDefinition."),
-        };
+        return $this->reflectionProvider->getClass(IndexDefinition::class)->getNativeMethod($methodName);
     }
 
     public function hasMethod(ClassReflection $classReflection, string $methodName): bool
     {
-        if (IndexDefinition::class !== $classReflection->getName()) {
+        if (BaseIndexDefinition::class !== $classReflection->getName()) {
             return false;
         }
 
-        return \in_array($methodName, ['include', 'nullsNotDistinct', 'weight', 'where', 'with']);
-    }
-
-    /**
-     * @param array<int, \PHPStan\Reflection\ParameterReflection> $parameters
-     */
-    private function createFunctionVariant(array $parameters): FunctionVariant
-    {
-        return new FunctionVariant(
-            templateTypeMap: TemplateTypeMap::createEmpty(),
-            resolvedTemplateTypeMap: null,
-            parameters: $parameters,
-            isVariadic: false,
-            returnType: new ObjectType(IndexDefinition::class),
-        );
+        return $this->reflectionProvider->getClass(IndexDefinition::class)->hasNativeMethod($methodName);
     }
 }