Refactor: added NullableParameterFixer

Author: janpecha

src/Ast/DefaultValue.php

@@ -35,6 +35,13 @@ public function toString(): string
 		}
 
 
+		public function isNull(): bool
+		{
+			$literalValue = trim($this->literal->getLiteral());
+			return strtolower($literalValue) === 'null';
+		}
+
+
 		public static function parseForFunctionParameter(NodeParser $parser): self
 		{
 			$nodeIndentation = $parser->consumeNodeIndentation();

src/Ast/NamedType.php

@@ -48,6 +48,18 @@ public function toString(): string
 		}
 
 
+		public function isNullable(): bool
+		{
+			return $this->nullableSign === '?';
+		}
+
+
+		public function setNullable(bool $nullable): void
+		{
+			$this->nullableSign = $nullable ? '?' : '';
+		}
+
+
 		public static function parse(NodeParser $parser): self
 		{
 			$nodeIndentation = $parser->consumeNodeIndentation();

src/Ast/Parameter.php

@@ -62,6 +62,18 @@ public function hasPromotedProperty(): bool
 		}
 
 
+		public function getType(): ?Type
+		{
+			return $this->type;
+		}
+
+
+		public function getDefaultValue(): ?DefaultValue
+		{
+			return $this->defaultValue;
+		}
+
+
 		public function toString()
 		{
 			$s = $this->indentation;

src/Ast/Type.php

@@ -28,6 +28,47 @@ public function __construct(string $indentation, array $types)
 		}
 
 
+		/**
+		 * @return NamedType[]
+		 */
+		public function getNamedTypes(): array
+		{
+			return $this->types;
+		}
+
+
+		public function isNullable(): bool
+		{
+			foreach ($this->types as $namedType) {
+				if ($namedType->isNullable()) {
+					return TRUE;
+				}
+			}
+
+			return FALSE;
+		}
+
+
+		public function setNullable(bool $nullable): void
+		{
+			$namedTypes = $this->types;
+
+			if (count($namedTypes) > 1) {
+				throw new \CzProject\PhpSimpleAst\InvalidStateException('Union types are not supported.');
+			}
+
+			foreach ($namedTypes as $namedType) {
+				$namedType->setNullable($nullable);
+			}
+		}
+
+
+		public function isSingle(): bool
+		{
+			return count($this->types) === 1;
+		}
+
+
 		public function toString(): string
 		{
 			$s = $this->indentation;

src/Refactor/NullableParameterFixer.php

@@ -0,0 +1,43 @@
+<?php
+
+	declare(strict_types=1);
+
+	namespace CzProject\PhpSimpleAst\Refactor;
+
+	use CzProject\PhpSimpleAst\Reflection;
+
+
+	class NullableParameterFixer
+	{
+		/**
+		 * @param  Reflection\ClassReflection[] $classes
+		 */
+		public static function processClasses(array $classes): void
+		{
+			foreach ($classes as $class) {
+				self::processClass($class);
+			}
+		}
+
+
+		public static function processClass(Reflection\ClassReflection $classReflection): void
+		{
+			foreach ($classReflection->getMethods() as $methodReflection) {
+				$parameters = $methodReflection->getParameters();
+
+				foreach ($parameters as $parameter) {
+					$type = $parameter->getType();
+					$defaultValue = $parameter->getDefaultValue();
+
+					if ($type !== NULL
+						&& $defaultValue !== NULL
+						&& $defaultValue->isNull()
+						&& $type->isSingle()
+						&& !$type->isNullable()
+					) {
+						$parameter->setNullable(true);
+					}
+				}
+			}
+		}
+	}

src/Reflection/ParameterReflection.php

@@ -45,4 +45,40 @@ public function isPassedByReference(): bool
 		{
 			return $this->parameter->isPassedByReference();
 		}
+
+
+		public function getType(): ?Ast\Type
+		{
+			return $this->parameter->getType();
+		}
+
+
+		public function getDefaultValue(): ?Ast\DefaultValue
+		{
+			return $this->parameter->getDefaultValue();
+		}
+
+
+		public function isNullable(): bool
+		{
+			$type = $this->parameter->getType();
+
+			if ($type === NULL) {
+				return FALSE;
+			}
+
+			return $type->isNullable();
+		}
+
+
+		public function setNullable(bool $nullable): void
+		{
+			$type = $this->parameter->getType();
+
+			if ($type === NULL) {
+				throw new \CzProject\PhpSimpleAst\InvalidStateException('Parameter has no type.');
+			}
+
+			$type->setNullable($nullable);
+		}
 	}

tests/PhpSimpleAst/Refactor/NullableParameterFixer.phpt

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+use CzProject\PhpSimpleAst;
+use Tester\Assert;
+
+require __DIR__ . '/../../bootstrap.php';
+
+
+test('nullable parameter fixer', function () {
+	$reflection = PhpSimpleAst\Reflection\FilesReflection::scanFile(Fixtures::path('Refactoring/NullableParameterFixer.php'));
+	$classReflection = $reflection->getClass(\Foo\TestClass::class);
+
+	PhpSimpleAst\Refactor\NullableParameterFixer::processClass($classReflection);
+
+	$method = $classReflection->getMethod('methodWithNullableParams');
+	$parameters = $method->getParameters();
+
+	// param1: string $param1 = null should become nullable
+	Assert::true($parameters['param1']->isNullable());
+
+	// param2: int $param2 = 42 should NOT become nullable (default is not null)
+	Assert::false($parameters['param2']->isNullable());
+
+	// param3: array $param3 = null should become nullable
+	Assert::true($parameters['param3']->isNullable());
+
+	// param4: $param4 = null should NOT be affected (no type declaration)
+	Assert::false($parameters['param4']->isNullable());
+
+	// Test method without defaults - should not be affected
+	$method2 = $classReflection->getMethod('methodWithoutDefaults');
+	$parameters2 = $method2->getParameters();
+	Assert::false($parameters2['param1']->isNullable());
+	Assert::false($parameters2['param2']->isNullable());
+
+	// Test method with already nullable types - should remain unchanged
+	$method3 = $classReflection->getMethod('methodWithNullableTypes');
+	$parameters3 = $method3->getParameters();
+	Assert::true($parameters3['param1']->isNullable());
+	Assert::true($parameters3['param2']->isNullable());
+
+	Assert::same(
+		Fixtures::load('Refactoring/NullableParameterFixer.result'),
+		$reflection->getFiles()[0]->toString()
+	);
+});