TASK: Add basic support for PHP8

.github/workflows/build.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        php-versions: ['7.3', '7.4']
+        php-versions: ['7.3', '7.4', '8.0']
         dependencies: ['highest']
         composer-arguments: [''] # to run --ignore-platform-reqs in experimental builds
         static-analysis: ['no']
@@ -27,8 +27,8 @@ jobs:
             experimental: false
             dependencies: 'highest'
 
-          # Experimental build for PHP 8
-          #- php-versions: '8.0'
+          # Experimental build for PHP nightly
+          #- php-versions: 'nightly'
           #  composer-arguments: '--ignore-platform-reqs'
           #  static-analysis: 'no'
           #  experimental: true

Neos.Cache/Classes/Backend/FileBackend.php

@@ -281,7 +281,11 @@ public function flush(): void
     {
         Files::emptyDirectoryRecursively($this->cacheDirectory);
         if ($this->frozen === true) {
-            @unlink($this->cacheDirectory . 'FrozenCache.data');
+            try {
+                @unlink($this->cacheDirectory . 'FrozenCache.data');
+            } catch (\Throwable $e) {
+                // PHP 8 apparently throws for unlink even with shutup operator, but we really don't care at this place. It's also the only way to handle this race-condition free.
+            }
             $this->frozen = false;
         }
     }

Neos.Cache/Tests/Unit/Backend/FileBackendTest.php

@@ -572,7 +572,7 @@ public function requireOnceDoesNotSwallowPhpWarningsOfTheIncludedFile()
         $backend->setCache($mockCache);
 
         $entryIdentifier = 'SomePhpEntryWithPhpWarning';
-        $backend->set($entryIdentifier, '<?php trigger_error("Warning!", E_WARNING); ?>');
+        $backend->set($entryIdentifier, '<?php trigger_error("Warning!", E_USER_WARNING); ?>');
         $backend->requireOnce($entryIdentifier);
     }
 
@@ -589,7 +589,7 @@ public function requireOnceDoesNotSwallowPhpNoticesOfTheIncludedFile()
         $backend->setCache($mockCache);
 
         $entryIdentifier = 'SomePhpEntryWithPhpNotice';
-        $backend->set($entryIdentifier, '<?php $undefined ++; ?>');
+        $backend->set($entryIdentifier, '<?php trigger_error("Notice!", E_USER_NOTICE); ?>');
         $backend->requireOnce($entryIdentifier);
     }
 

Neos.Cache/Tests/Unit/Backend/SimpleFileBackendTest.php

@@ -405,7 +405,7 @@ public function requireOnceDoesNotSwallowPhpWarningsOfTheIncludedFile()
         $entryIdentifier = 'SomePhpEntryWithPhpWarning';
 
         $simpleFileBackend = $this->getSimpleFileBackend();
-        $simpleFileBackend->set($entryIdentifier, '<?php trigger_error("Warning!", E_WARNING); ?>');
+        $simpleFileBackend->set($entryIdentifier, '<?php trigger_error("Warning!", E_USER_WARNING); ?>');
         $simpleFileBackend->requireOnce($entryIdentifier);
     }
 
@@ -418,7 +418,7 @@ public function requireOnceDoesNotSwallowPhpNoticesOfTheIncludedFile()
         $entryIdentifier = 'SomePhpEntryWithPhpNotice';
 
         $simpleFileBackend = $this->getSimpleFileBackend();
-        $simpleFileBackend->set($entryIdentifier, '<?php $undefined ++; ?>');
+        $simpleFileBackend->set($entryIdentifier, '<?php trigger_error("Notice!", E_USER_NOTICE); ?>');
         $simpleFileBackend->requireOnce($entryIdentifier);
     }
 

Neos.Eel/Classes/Helper/MathHelper.php

@@ -407,7 +407,7 @@ public function round($subject, $precision = 0)
         if (!is_numeric($subject)) {
             return NAN;
         }
-        $subject = floatval($subject);
+        $subject = (float)$subject;
         if ($precision != null && !is_int($precision)) {
             return NAN;
         }
@@ -422,14 +422,14 @@ public function round($subject, $precision = 0)
      */
     public function sign($x)
     {
-        if ($x < 0) {
+        if (!is_numeric($x)) {
+            return NAN;
+        } elseif ($x < 0) {
             return -1;
         } elseif ($x > 0) {
             return 1;
-        } elseif ($x === 0 || $x === 0.0) {
-            return 0;
         } else {
-            return NAN;
+            return 0;
         }
     }
 
@@ -492,9 +492,9 @@ public function trunc($x)
         $sign = $this->sign($x);
         switch ($sign) {
             case -1:
-                return (int)ceil($x);
+                return (int)ceil((float)$x);
             case 1:
-                return (int)floor($x);
+                return (int)floor((float)$x);
             default:
                 return $sign;
         }

Neos.Flow/Classes/Core/LockManager.php

@@ -79,8 +79,15 @@ protected function removeExpiredLock()
         if (filemtime($this->lockFlagPathAndFilename) >= (time() - self::LOCKFILE_MAXIMUM_AGE)) {
             return;
         }
-        @unlink($this->lockFlagPathAndFilename);
-        @unlink($this->lockPathAndFilename);
+        try {
+            @unlink($this->lockFlagPathAndFilename);
+        } catch (\Throwable $e) {
+            // PHP 8 apparently throws for unlink even with shutup operator, but we really don't care at this place. It's also the only way to handle this race-condition free.
+        }
+        try {
+            @unlink($this->lockPathAndFilename);
+        } catch (\Throwable $e) {
+        }
     }
 
     /**
@@ -135,7 +142,13 @@ public function unlockSite()
             fclose($this->lockResource);
             unlink($this->lockPathAndFilename);
         }
-        @unlink($this->lockFlagPathAndFilename);
+        if ($this->isSiteLocked()) {
+            try {
+                @unlink($this->lockFlagPathAndFilename);
+            } catch (\Throwable $e) {
+                // PHP 8 apparently throws for unlink even with shutup operator, but we really don't care at this place. It's also the only way to handle this race-condition free.
+            }
+        }
     }
 
     /**

Neos.Flow/Classes/ObjectManagement/Configuration/ConfigurationBuilder.php

@@ -507,7 +507,11 @@ protected function autowireProperties(array &$objectConfigurations)
                 continue;
             }
 
-            $classMethodNames = get_class_methods($className);
+            try {
+                $classMethodNames = get_class_methods($className);
+            } catch (\TypeError $error) {
+                throw new UnknownClassException(sprintf('The class "%s" defined in the object configuration for object "%s", defined in package: %s, does not exist.', $className, $objectConfiguration->getObjectName(), $objectConfiguration->getPackageKey()), 1352371371);
+            }
             if (!is_array($classMethodNames)) {
                 if (!class_exists($className)) {
                     throw new UnknownClassException(sprintf('The class "%s" defined in the object configuration for object "%s", defined in package: %s, does not exist.', $className, $objectConfiguration->getObjectName(), $objectConfiguration->getPackageKey()), 1352371371);

Neos.Flow/Classes/Package/PackageManager.php

@@ -764,7 +764,11 @@ protected function savePackageStates(array $orderedPackageStates): void
         // Clean legacy file TODO: Remove at some point
         $legacyPackageStatesPath = FLOW_PATH_CONFIGURATION . 'PackageStates.php';
         if (is_file($legacyPackageStatesPath)) {
-            @unlink($legacyPackageStatesPath);
+            try {
+                @unlink($legacyPackageStatesPath);
+            } catch (\Throwable $e) {
+                // PHP 8 apparently throws for unlink even with shutup operator, but we really don't care at this place. It's also the only way to handle this race-condition free.
+            }
         }
         OpcodeCacheHelper::clearAllActive($this->packageInformationCacheFilePath);
 

Neos.Flow/Classes/Property/TypeConverter/MediaTypeConverter.php

@@ -92,12 +92,19 @@ protected function convertMediaType($requestBody, $mediaType)
                 }
             break;
             case 'xml':
-                $entityLoaderValue = libxml_disable_entity_loader(true);
+                // TODO: Remove those lines once the minimum PHP version is 8.0
+                if (PHP_MAJOR_VERSION < 8) {
+                    $entityLoaderValue = libxml_disable_entity_loader(true);
+                }
                 try {
                     $xmlElement = new \SimpleXMLElement(urldecode($requestBody), LIBXML_NOERROR);
-                    libxml_disable_entity_loader($entityLoaderValue);
+                    if (PHP_MAJOR_VERSION < 8) {
+                        libxml_disable_entity_loader($entityLoaderValue);
+                    }
                 } catch (\Exception $exception) {
-                    libxml_disable_entity_loader($entityLoaderValue);
+                    if (PHP_MAJOR_VERSION < 8) {
+                        libxml_disable_entity_loader($entityLoaderValue);
+                    }
                     return [];
                 }
                 $result = Arrays::convertObjectToArray($xmlElement);

Neos.Flow/Classes/Reflection/MethodReflection.php

@@ -95,15 +95,15 @@ public function getDescription()
     }
 
     /**
-     * @return string The name of a type (e.g. string, \stdClass) if it was declared as a return type, null otherwise
+     * @return string|null The name of a type (e.g. string, \stdClass) if it was declared as a return type, null otherwise
      */
     public function getDeclaredReturnType()
     {
         if (!is_callable([$this, 'getReturnType'])) {
             return null;
         }
         $type = $this->getReturnType();
-        return $type !== null ? (string)$type : null;
+        return $type !== null ? ltrim((string)$type, '?') : null;
     }
 
     /**

Neos.Flow/Classes/Reflection/ParameterReflection.php

@@ -52,14 +52,14 @@ public function getClass()
     }
 
     /**
-     * @return string The name of a builtin type (e.g. string, int) if it was declared for the parameter (scalar type declaration), null otherwise
+     * @return string|null The name of a builtin type (e.g. string, int) if it was declared for the parameter (scalar type declaration), null otherwise
      */
     public function getBuiltinType()
     {
         $type = $this->getType();
-        if ($type === null || !$type->isBuiltin()) {
+        if (!$type instanceof \ReflectionNamedType) {
             return null;
         }
-        return $type instanceof \ReflectionNamedType ? $type->getName() : (string)$type;
+        return $type->isBuiltin() ? $type->getName() : null;
     }
 }

Neos.Flow/Classes/Reflection/ReflectionService.php

@@ -1788,9 +1788,6 @@ protected function convertParameterReflectionToArray(ParameterReflection $parame
         if ($parameter->isPassedByReference()) {
             $parameterInformation[self::DATA_PARAMETER_BY_REFERENCE] = true;
         }
-        if ($parameter->isArray()) {
-            $parameterInformation[self::DATA_PARAMETER_ARRAY] = true;
-        }
         if ($parameter->isOptional()) {
             $parameterInformation[self::DATA_PARAMETER_OPTIONAL] = true;
         }
@@ -1800,11 +1797,20 @@ protected function convertParameterReflectionToArray(ParameterReflection $parame
 
         $parameterType = $parameter->getType();
         if ($parameterType !== null) {
+            // TODO: This needs to handle ReflectionUnionType
             $parameterType = ($parameterType instanceof \ReflectionNamedType) ? $parameterType->getName() : $parameterType->__toString();
         }
-        if ($parameter->getClass() !== null) {
+        if ($parameterType !== null && !TypeHandling::isSimpleType($parameterType)) {
             // We use parameter type here to make class_alias usage work and return the hinted class name instead of the alias
             $parameterInformation[self::DATA_PARAMETER_CLASS] = $parameterType;
+        } elseif ($parameterType === 'array') {
+            $parameterInformation[self::DATA_PARAMETER_ARRAY] = true;
+        } else {
+            $builtinType = $parameter->getBuiltinType();
+            if ($builtinType !== null) {
+                $parameterInformation[self::DATA_PARAMETER_TYPE] = $builtinType;
+                $parameterInformation[self::DATA_PARAMETER_SCALAR_DECLARATION] = true;
+            }
         }
         if ($parameter->isOptional() && $parameter->isDefaultValueAvailable()) {
             $parameterInformation[self::DATA_PARAMETER_DEFAULT_VALUE] = $parameter->getDefaultValue();
@@ -1816,17 +1822,10 @@ protected function convertParameterReflectionToArray(ParameterReflection $parame
                 $parameterType = $this->expandType($method->getDeclaringClass(), $explodedParameters[0]);
             }
         }
-        if (!$parameter->isArray()) {
-            $builtinType = $parameter->getBuiltinType();
-            if ($builtinType !== null) {
-                $parameterInformation[self::DATA_PARAMETER_TYPE] = $builtinType;
-                $parameterInformation[self::DATA_PARAMETER_SCALAR_DECLARATION] = true;
-            }
-        }
         if (!isset($parameterInformation[self::DATA_PARAMETER_TYPE]) && $parameterType !== null) {
             $parameterInformation[self::DATA_PARAMETER_TYPE] = $this->cleanClassName($parameterType);
         } elseif (!isset($parameterInformation[self::DATA_PARAMETER_TYPE])) {
-            $parameterInformation[self::DATA_PARAMETER_TYPE] = $parameter->isArray() ? 'array' : 'mixed';
+            $parameterInformation[self::DATA_PARAMETER_TYPE] = 'mixed';
         }
 
         return $parameterInformation;

Neos.Flow/Classes/SignalSlot/Dispatcher.php

@@ -149,7 +149,7 @@ public function dispatch(string $signalClassName, string $signalName, array $sig
         }
 
         foreach ($this->slots[$signalClassName][$signalName] as $slotInformation) {
-            $finalSignalArguments = $signalArguments;
+            $finalSignalArguments = array_values($signalArguments);
             if (isset($slotInformation['object'])) {
                 $object = $slotInformation['object'];
             } elseif (strpos($slotInformation['method'], '::') === 0) {

Neos.Flow/Classes/Utility/PhpAnalyzer.php

@@ -82,8 +82,14 @@ public function extractNamespace(): ?string
                     break;
                 }
                 list($type, $value) = $token;
+                if (defined('T_NAME_QUALIFIED') && $type === T_NAME_QUALIFIED) {
+                    return $value;
+                }
+                if (defined('T_NAME_FULLY_QUALIFIED') && $type === T_NAME_FULLY_QUALIFIED) {
+                    return ltrim($value, '\\');
+                }
                 if ($type === T_STRING) {
-                    $namespaceParts[] = $value;
+                    $namespaceParts[] = ltrim($value, '\\');
                     continue;
                 }
                 if ($type !== T_NS_SEPARATOR && $type !== T_WHITESPACE) {

Neos.Flow/Tests/Functional/Mvc/ActionControllerTest.php

@@ -429,7 +429,6 @@ public function argumentTestsDataProvider()
             'required date string'              => ['requiredDate', '1980-12-13T14:22:12+02:00', '1980-12-13'],
             'required date - missing value'     => ['requiredDate', null, $requiredArgumentExceptionText],
             'required date - mapping error'     => ['requiredDate', 'no date', 'Validation failed while trying to call Neos\Flow\Tests\Functional\Mvc\Fixtures\Controller\ActionControllerTestBController->requiredDateAction().'],
-            'required date - empty value'       => ['requiredDate', '', 'Uncaught Exception in Flow Argument 1 passed to Neos\Flow\Tests\Functional\Mvc\Fixtures\Controller\ActionControllerTestBController_Original::requiredDateAction() must be an instance of DateTime, null given'],
             'optional date string'              => ['optionalDate', '1980-12-13T14:22:12+02:00', '1980-12-13'],
             'optional date - default value'     => ['optionalDate', null, 'null'],
             'optional date - mapping error'     => ['optionalDate', 'no date', 'Validation failed while trying to call Neos\Flow\Tests\Functional\Mvc\Fixtures\Controller\ActionControllerTestBController->optionalDateAction().'],
@@ -460,6 +459,25 @@ public function argumentTests($action, $argument, $expectedResult)
         self::assertTrue(strpos(trim($response->getBody()->getContents()), (string)$expectedResult) === 0, sprintf('The resulting string did not start with the expected string. Expected: "%s", Actual: "%s"', $expectedResult, $response->getBody()->getContents()));
     }
 
+    /**
+     * @test
+     */
+    public function requiredDateNullArgumentTest()
+    {
+        $arguments = [
+            'argument' => '',
+        ];
+
+        $uri = str_replace('{@action}', 'requireddate', 'http://localhost/test/mvc/actioncontrollertestb/{@action}');
+        $response = $this->browser->request($uri, 'POST', $arguments);
+        if (PHP_MAJOR_VERSION < 8) {
+            $expectedResult = 'Uncaught Exception in Flow Argument 1 passed to Neos\Flow\Tests\Functional\Mvc\Fixtures\Controller\ActionControllerTestBController_Original::requiredDateAction() must be an instance of DateTime, null given';
+        } else {
+            $expectedResult = 'Uncaught Exception in Flow Neos\Flow\Tests\Functional\Mvc\Fixtures\Controller\ActionControllerTestBController_Original::requiredDateAction(): Argument #1 ($argument) must be of type DateTime, null given';
+        }
+        self::assertTrue(strpos(trim($response->getBody()->getContents()), (string)$expectedResult) === 0, sprintf('The resulting string did not start with the expected string. Expected: "%s", Actual: "%s"', $expectedResult, $response->getBody()->getContents()));
+    }
+
     /**
      * @test
      */

Neos.Flow/Tests/Unit/SignalSlot/DispatcherTest.php

@@ -144,7 +144,7 @@ public function dispatchPassesTheSignalArgumentsToTheSlotMethod(): void
         $dispatcher->connect('Foo', 'bar', $mockSlot, '', false);
         $dispatcher->injectObjectManager($mockObjectManager);
 
-        $dispatcher->dispatch('Foo', 'bar', ['foo' => 'bar', 'baz' => 'quux']);
+        $dispatcher->dispatch('Foo', 'bar', ['bar', 'quux']);
         self::assertSame(['bar', 'quux'], $arguments);
     }
 
@@ -160,7 +160,7 @@ public function dispatchPassesTheSignalArgumentsToTheStaticSlotMethod(): void
         $dispatcher->connect('Foo', 'bar', get_class($this), '::staticSlot', false);
         $dispatcher->injectObjectManager($mockObjectManager);
 
-        $dispatcher->dispatch('Foo', 'bar', ['foo' => 'bar', 'baz' => 'quux']);
+        $dispatcher->dispatch('Foo', 'bar', ['bar', 'quux']);
         self::assertSame(['bar', 'quux'], self::$arguments);
     }
 
@@ -172,8 +172,8 @@ public function dispatchPassesTheSignalArgumentsToTheStaticSlotMethodIfNoObjectm
         $dispatcher = new Dispatcher();
         $dispatcher->connect('Foo', 'bar', get_class($this), '::staticSlot', false);
 
-        $dispatcher->dispatch('Foo', 'bar', ['no' => 'object', 'manager' => 'exists']);
-        self::assertSame(['object', 'exists'], self::$arguments);
+        $dispatcher->dispatch('Foo', 'bar', ['no', 'object', 'manager', 'exists']);
+        self::assertSame(['no', 'object', 'manager', 'exists'], self::$arguments);
     }
 
     /**
@@ -210,7 +210,7 @@ public function dispatchRetrievesSlotInstanceFromTheObjectManagerIfOnlyAClassNam
         $dispatcher->injectObjectManager($mockObjectManager);
         $dispatcher->connect('Foo', 'bar', $slotClassName, 'slot', false);
 
-        $dispatcher->dispatch('Foo', 'bar', ['foo' => 'bar', 'baz' => 'quux']);
+        $dispatcher->dispatch('Foo', 'bar', ['bar', 'quux']);
         self::assertSame($mockSlot->arguments, ['bar', 'quux']);
     }
 
@@ -247,7 +247,7 @@ public function dispatchThrowsAnExceptionIfTheSpecifiedSlotMethodDoesNotExist():
         $dispatcher->injectObjectManager($mockObjectManager);
         $dispatcher->connect('Foo', 'bar', $slotClassName, 'unknownMethodName', true);
 
-        $dispatcher->dispatch('Foo', 'bar', ['foo' => 'bar', 'baz' => 'quux']);
+        $dispatcher->dispatch('Foo', 'bar', ['bar', 'quux']);
     }
 
     /**
@@ -266,7 +266,7 @@ public function dispatchPassesArgumentContainingSlotInformationLastIfTheConnecti
         $dispatcher->connect('SignalClassName', 'methodName', $mockSlot, '', true);
         $dispatcher->injectObjectManager($mockObjectManager);
 
-        $dispatcher->dispatch('SignalClassName', 'methodName', ['foo' => 'bar', 'baz' => 'quux']);
+        $dispatcher->dispatch('SignalClassName', 'methodName', ['bar', 'quux']);
         self::assertSame(['bar', 'quux', 'SignalClassName::methodName'], $arguments);
     }