Fix options created from callbacks that return void

Author: axlon

src/Type/PhpOption/EnsureReturnTypeExtension.php

@@ -60,7 +60,9 @@ static function (Type $type, callable $traverse) use ($noneValueType, $scope): T
 
                 if ($type->isCallable()->yes()) {
                     $type = TypeCombinator::union(...array_map(
-                        static fn (CallableParametersAcceptor $variant) => $variant->getReturnType(),
+                        static function (CallableParametersAcceptor $variant) {
+                            return TypeUtil::replaceVoid($variant->getReturnType());
+                        },
                         $type->getCallableParametersAcceptors($scope),
                     ));
                 }

src/Type/PhpOption/FromReturnReturnTypeExtension.php

@@ -54,7 +54,7 @@ public function getTypeFromStaticMethodCall(
             : [];
 
         $returnType = ParametersAcceptorSelector::selectFromArgs($scope, $args, $parametersAcceptors)->getReturnType();
-        $valueType = TypeCombinator::remove($returnType, $noneValueType);
+        $valueType = TypeCombinator::remove(TypeUtil::replaceVoid($returnType), $noneValueType);
 
         return new GenericObjectType('PhpOption\LazyOption', [
             $valueType->generalize(GeneralizePrecision::templateArgument()),

src/Type/PhpOption/LiftReturnTypeExtension.php

@@ -11,12 +11,14 @@
 use PHPStan\Reflection\ParameterReflection;
 use PHPStan\Type\ClosureType;
 use PHPStan\Type\DynamicStaticMethodReturnTypeExtension;
+use PHPStan\Type\GeneralizePrecision;
 use PHPStan\Type\Generic\GenericObjectType;
-use PHPStan\Type\NeverType;
 use PHPStan\Type\NullType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\TypeTraverser;
+use PHPStan\Type\UnionType;
 use Resolve\PHPStan\Reflection\PhpOption\LiftedParameterReflection;
 
 /**
@@ -61,24 +63,24 @@ static function (ParameterReflection $parameterReflection) {
                     $parametersAcceptor->getParameters(),
                 );
 
-                $returnTypeIsOption = (new ObjectType('PhpOption\Option'))->isSuperTypeOf(
+                $returnType = TypeTraverser::map(
                     $parametersAcceptor->getReturnType(),
-                );
+                    static function (Type $type, callable $traverse) use ($noneValueType): Type {
+                        if ($type instanceof UnionType) {
+                            return $traverse($type);
+                        }
+
+                        if ((new ObjectType('PhpOption\Option'))->isSuperTypeOf($type)->yes()) {
+                            return $type;
+                        }
 
-                if ($returnTypeIsOption->yes() || $returnTypeIsOption->maybe()) {
-                    $returnType = $parametersAcceptor->getReturnType();
-                } else {
-                    $returnType = new NeverType();
-                }
+                        $type = TypeCombinator::remove(TypeUtil::replaceVoid($type), $noneValueType);
 
-                if ($returnTypeIsOption->no() || $returnTypeIsOption->maybe()) {
-                    $returnType = TypeCombinator::union(
-                        $returnType,
-                        new GenericObjectType('PhpOption\Option', [
-                            TypeCombinator::remove($parametersAcceptor->getReturnType(), $noneValueType),
-                        ]),
-                    );
-                }
+                        return new GenericObjectType('PhpOption\Option', [
+                            $type->generalize(GeneralizePrecision::templateArgument()),
+                        ]);
+                    },
+                );
 
                 return new ClosureType($parameters, $returnType);
             },

src/Type/PhpOption/TypeUtil.php

@@ -5,6 +5,7 @@
 namespace Resolve\PHPStan\Type\PhpOption;
 
 use PHPStan\Type\NeverType;
+use PHPStan\Type\NullType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeTraverser;
 use PHPStan\Type\UnionType;
@@ -28,4 +29,15 @@ public static function forShallowComparison(Type $type): Type
             return new NeverType();
         });
     }
+
+    public static function replaceVoid(Type $type): Type
+    {
+        return TypeTraverser::map($type, static function (Type $type, callable $traverse): Type {
+            if ($type instanceof UnionType) {
+                return $traverse($type);
+            }
+
+            return $type->isVoid()->yes() ? new NullType() : $type;
+        });
+    }
 }

tests/Type/PhpOption/data/option-ensure.php

@@ -10,7 +10,6 @@
  * @var string|null $value
  */
 assertType('PhpOption\Option<string>', Option::ensure($value));
-assertType('PhpOption\Option<string>', Option::ensure($value, null));
 assertType('PhpOption\Option<null>|PhpOption\Option<string>', Option::ensure($value, 123));
 
 /**
@@ -22,5 +21,15 @@
  * @var \PhpOption\Option<string>|123|(callable(): float)|null $option
  */
 assertType('PhpOption\Option<float>|PhpOption\Option<int>|PhpOption\Option<string>', Option::ensure($option));
-assertType('PhpOption\Option<float>|PhpOption\Option<int>|PhpOption\Option<string>', Option::ensure($option, null));
 assertType('PhpOption\Option<float>|PhpOption\Option<null>|PhpOption\Option<string>', Option::ensure($option, 123));
+
+/**
+ * @var callable(): string $value
+ */
+assertType('PhpOption\Option<string>', Option::ensure($value));
+
+/**
+ * @var callable(): void $value
+ */
+assertType('PhpOption\Option<*NEVER*>', Option::ensure($value));
+assertType('PhpOption\Option<null>', Option::ensure($value, 123));

tests/Type/PhpOption/data/option-from-return.php

@@ -10,5 +10,10 @@
  * @var callable(): (string|null) $fn
  */
 assertType('PhpOption\LazyOption<string>', Option::fromReturn($fn));
-assertType('PhpOption\LazyOption<string>', Option::fromReturn($fn, [], null));
-assertType('PhpOption\LazyOption<string|null>', Option::fromReturn($fn, [], 123));
+assertType('PhpOption\LazyOption<string|null>', Option::fromReturn($fn, noneValue: 123));
+
+/**
+ * @var callable(): void $fn
+ */
+assertType('PhpOption\LazyOption<*NEVER*>', Option::fromReturn($fn));
+assertType('PhpOption\LazyOption<null>', Option::fromReturn($fn, noneValue: 123));

tests/Type/PhpOption/data/option-lift.php

@@ -20,3 +20,10 @@
  * @var callable(int ...): string $fn
  */
 assertType('Closure(PhpOption\Option<int> ...): PhpOption\Option<string>', Option::lift($fn));
+
+
+/**
+ * @var callable(): void $fn
+ */
+assertType('Closure(): PhpOption\Option<never>', Option::lift($fn));
+assertType('Closure(): PhpOption\Option<null>', Option::lift($fn, 123));