support column definition

Author: tpetry

ide.json

@@ -13,6 +13,10 @@
             {
                 "classFqn": "Illuminate\\Database\\Schema\\Blueprint",
                 "mixinFqn": "Tpetry\\PostgresqlEnhanced\\Schema\\Blueprint"
+            },
+            {
+                "classFqn": "Illuminate\\Database\\Schema\\ColumnDefinition",
+                "mixinFqn": "Tpetry\\PostgresqlEnhanced\\Schema\\ColumnDefinition"
             }
         ]
     }

src/Schema/ColumnDefinition.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tpetry\PostgresqlEnhanced\Schema;
+
+use Illuminate\Contracts\Database\Query\Expression;
+use Illuminate\Database\Schema\ColumnDefinition as BaseColumnDefinition;
+
+/**
+ * @internal This class is not used. It only exists to teach Laravel projects using PHPStan or IDEs supporting auto-suggest about added functionality.
+ */
+class ColumnDefinition extends BaseColumnDefinition
+{
+    /**
+     * Specify the compression method for TOASTed values (PostgreSQL).
+     */
+    public function compression(string $algorithm): static
+    {
+        return $this;
+    }
+
+    /**
+     * Sets an initial value to the column (PostgreSQL).
+     */
+    public function initial(mixed $value): static
+    {
+        return $this;
+    }
+
+    /**
+     * Specify casting expression when changing the column type (PostgreSQL).
+     */
+    public function using(string|Expression $expression): static
+    {
+        return $this;
+    }
+}

src/Support/Phpstan/SchemaColumnDefinitionExtension.php

@@ -4,83 +4,31 @@
 
 namespace Tpetry\PostgresqlEnhanced\Support\Phpstan;
 
-use Illuminate\Contracts\Database\Query\Expression as ExpressionContract;
-use Illuminate\Database\Schema\ColumnDefinition;
+use Illuminate\Database\Schema\ColumnDefinition as BaseColumnDefinition;
 use PHPStan\Reflection\ClassReflection;
-use PHPStan\Reflection\FunctionVariant;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Reflection\MethodsClassReflectionExtension;
-use PHPStan\Type\Generic\TemplateTypeMap;
-use PHPStan\Type\MixedType;
-use PHPStan\Type\ObjectType;
-use PHPStan\Type\StringType;
-use Tpetry\PostgresqlEnhanced\Support\Phpstan\Values\ReflectedMethod;
-use Tpetry\PostgresqlEnhanced\Support\Phpstan\Values\ReflectedParameter;
+use PHPStan\Reflection\ReflectionProvider;
+use Tpetry\PostgresqlEnhanced\Schema\ColumnDefinition;
 
 class SchemaColumnDefinitionExtension implements MethodsClassReflectionExtension
 {
-    /**
-     * @param 'compression'|'initial'|'using' $methodName
-     */
+    public function __construct(
+        private ReflectionProvider $reflectionProvider,
+    ) {
+    }
+
     public function getMethod(ClassReflection $classReflection, string $methodName): MethodReflection
     {
-        return match ($methodName) {
-            'initial' => $this->getInitialMethod($classReflection),
-            'compression' => $this->getCompressionMethod($classReflection),
-            'using' => $this->getUsingMethod($classReflection),
-        };
+        return $this->reflectionProvider->getClass(ColumnDefinition::class)->getNativeMethod($methodName);
     }
 
     public function hasMethod(ClassReflection $classReflection, string $methodName): bool
     {
-        if (ColumnDefinition::class !== $classReflection->getName()) {
+        if (BaseColumnDefinition::class !== $classReflection->getName()) {
             return false;
         }
 
-        return \in_array($methodName, ['compression', 'initial', 'using']);
-    }
-
-    private function getCompressionMethod(ClassReflection $classReflection): MethodReflection
-    {
-        $parameters = [new ReflectedParameter('algorithm', new StringType())];
-        $returnType = new ObjectType(ColumnDefinition::class);
-
-        return new ReflectedMethod(
-            classReflection: $classReflection,
-            name: 'compression',
-            variants: [
-                new FunctionVariant(TemplateTypeMap::createEmpty(), null, $parameters, false, $returnType),
-            ],
-        );
-    }
-
-    private function getInitialMethod(ClassReflection $classReflection): MethodReflection
-    {
-        $parameters = [new ReflectedParameter('value', new MixedType())];
-        $returnType = new ObjectType(ColumnDefinition::class);
-
-        return new ReflectedMethod(
-            classReflection: $classReflection,
-            name: 'initial',
-            variants: [
-                new FunctionVariant(TemplateTypeMap::createEmpty(), null, $parameters, false, $returnType),
-            ],
-        );
-    }
-
-    private function getUsingMethod(ClassReflection $classReflection): MethodReflection
-    {
-        $parametersExpression = [new ReflectedParameter('expression', new ObjectType(ExpressionContract::class))];
-        $parametersString = [new ReflectedParameter('expression', new StringType())];
-        $returnType = new ObjectType(ColumnDefinition::class);
-
-        return new ReflectedMethod(
-            classReflection: $classReflection,
-            name: 'using',
-            variants: [
-                new FunctionVariant(TemplateTypeMap::createEmpty(), null, $parametersExpression, false, $returnType),
-                new FunctionVariant(TemplateTypeMap::createEmpty(), null, $parametersString, false, $returnType),
-            ],
-        );
+        return $this->reflectionProvider->getClass(ColumnDefinition::class)->hasNativeMethod($methodName);
     }
 }