add nullable types for php7.3

Author: gossi

src/config/CodeGeneratorConfig.php

@@ -43,6 +43,7 @@ protected function configureOptions(OptionsResolver $resolver): void {
 			},
 			'generateScalarTypeHints' => false,
 			'generateReturnTypeHints' => false,
+			'generateNullableTypes' => false,
 			'enableFormatting' => false,
 			'enableSorting' => true,
 			'useStatementSorting' => CodeGenerator::SORT_USESTATEMENTS_DEFAULT,
@@ -56,6 +57,7 @@ protected function configureOptions(OptionsResolver $resolver): void {
 		$resolver->setAllowedTypes('generateEmptyDocblock', 'bool');
 		$resolver->setAllowedTypes('generateScalarTypeHints', 'bool');
 		$resolver->setAllowedTypes('generateReturnTypeHints', 'bool');
+		$resolver->setAllowedTypes('generateNullableTypes', 'bool');
 		$resolver->setAllowedTypes('enableFormatting', 'bool');
 		$resolver->setAllowedTypes('enableSorting', 'bool');
 		$resolver->setAllowedTypes('useStatementSorting', ['bool', 'string', '\Closure', 'phootwork\lang\Comparator']);
@@ -141,6 +143,8 @@ public function setGenerateEmptyDocblock(bool $generate) {
 	public function getGenerateScalarTypeHints(): bool {
 		return $this->options['generateScalarTypeHints'];
 	}
+	
+	
 
 	/**
 	 * Returns whether sorting is enabled
@@ -226,6 +230,26 @@ public function setGenerateReturnTypeHints(bool $generate) {
 		$this->options['generateReturnTypeHints'] = $generate;
 		return $this;
 	}
+	
+	/**
+	 * Returns whether return nullable type hints will be generated (PHP 7.3)
+	 *
+	 * @return bool `true` if they will be generated and `false` if not
+	 */
+	public function getGenerateNullableTypes(): bool {
+	    return $this->options['generateNullableTypes'];
+	}
+	
+	/**
+	 * Sets whether return nullable type hints will be generated (PHP 7.3)
+	 *
+	 * @param bool $generate `true` if they will be generated and `false` if not
+	 * @return $this
+	 */
+	public function setGenerateNullableTypes(bool $generate) {
+	    $this->options['generateNullableTypes'] = $generate;
+	    return $this;
+	}
 
 	/**
 	 * Sets whether sorting is enabled

src/generator/builder/ParameterBuilder.php

@@ -13,7 +13,7 @@ class ParameterBuilder extends AbstractBuilder {
 	use TypeBuilderPart;
 
 	public function build(AbstractModel $model): void {
-		$type = $this->getType($model, $this->config->getGenerateScalarTypeHints());
+	    $type = $this->getType($model, $this->config->getGenerateScalarTypeHints(), $this->config->getGenerateNullableTypes());
 		if ($type !== null) {
 			$this->writer->write($type . ' ');
 		}

src/generator/builder/parts/RoutineBuilderPart.php

@@ -42,7 +42,7 @@ protected function writeParameters(RoutineInterface $model): void {
 	}
 
 	protected function writeFunctionReturnType(RoutineInterface $model): void {
-		$type = $this->getType($model, $this->config->getGenerateReturnTypeHints());
+	    $type = $this->getType($model, $this->config->getGenerateReturnTypeHints(), $this->config->getGenerateNullableTypes());
 		if ($type !== null && $this->config->getGenerateReturnTypeHints()) {
 			$this->writer->write(': ')->write($type);
 		}

src/generator/builder/parts/TypeBuilderPart.php

@@ -31,15 +31,20 @@ trait TypeBuilderPart {
 	 * @param bool $allowed
 	 * @return string|null
 	 */
-	private function getType(AbstractModel $model, bool $allowed): ?string {
+	private function getType(AbstractModel $model, bool $allowed, bool $nullable): ?string {
 		$type = $model->getType();
 		if (!empty($type) && strpos($type, '|') === false
 				&& (!in_array($type, self::$noTypeHints)
 					|| ($allowed && in_array($type, self::$php7typeHints)))
 				) {
-			if (isset(self::$typeHintMap[$type])) {
-				return self::$typeHintMap[$type];
-			}
+
+            $type = isset(self::$typeHintMap[$type])
+                ? self::$typeHintMap[$type]
+                : $type;
+
+            if ($nullable && $model->getNullable()) {
+                $type = '?' . $type;
+            }
 
 			return $type;
 		}

src/model/parts/TypePart.php

@@ -17,6 +17,9 @@ trait TypePart {
 
 	/** @var string */
 	private $typeDescription;
+	
+	/** @var bool */
+	private $typeNullable;
 
 	/**
 	 * Sets the type
@@ -62,4 +65,24 @@ public function getType(): ?string {
 	public function getTypeDescription(): ?string {
 		return $this->typeDescription;
 	}
+	
+	/**
+	 * Returns whether the type is nullable
+	 * 
+	 * @return bool
+	 */
+	public function getNullable(): bool {
+        return $this->typeNullable;
+	}
+	
+	/**
+	 * Sets the type nullable
+	 * 
+	 * @param bool $nullable
+	 * @return $this
+	 */
+	public function setNullable(bool $nullable) {
+	    $this->typeNullable = $nullable;
+	    return $this;
+	}
 }

tests/config/ConfigTest.php

@@ -63,6 +63,9 @@ public function testCodeGeneratorConfigSetters() {
 
 		$config->setGenerateScalarTypeHints(true);
 		$this->assertTrue($config->getGenerateScalarTypeHints());
+		
+		$config->setGenerateNullableTypes(true);
+		$this->assertTrue($config->getGenerateNullableTypes());
 
 		$config->setUseStatementSorting(false);
 		$this->assertFalse($config->getUseStatementSorting());

tests/generator/MethodGeneratorTest.php

@@ -90,5 +90,17 @@ public function testReturnType() {
 		$method = PhpMethod::create('foo')->setType('int');
 		$this->assertEquals($expected, $generator->generate($method));
 	}
+	
+	public function testNullableReturnType() {
+	    $expected = "public function foo(): ?int {\n}\n";
+	    $generator = new ModelGenerator([
+	        'generateReturnTypeHints' => true, 
+	        'generateDocblock' => false,
+	        'generateNullableTypes' => true
+	    ]);
+	    
+	    $method = PhpMethod::create('foo')->setType('int')->setNullable(true);
+	    $this->assertEquals($expected, $generator->generate($method));
+	}
 
 }

tests/generator/ParameterGeneratorTest.php

@@ -95,6 +95,13 @@ public function testPhp7TypeHints() {
 		$param = PhpParameter::create('foo')->setType('resource');
 		$this->assertEquals('$foo', $generator->generate($param));
 	}
+	
+	public function testPhp73Nullable() {
+	    $generator = new ModelGenerator(['generateScalarTypeHints' => true, 'generateNullableTypes' => true]);
+	    
+	    $param = PhpParameter::create('foo')->setType('float')->setNullable(true);
+	    $this->assertEquals('?float $foo', $generator->generate($param));
+	}
 
 	public function testValues() {
 		$generator = new ModelGenerator();