comparison vendor/doctrine/common/lib/Doctrine/Common/Proxy/ProxyGenerator.php @ 12:7a779792577d

Update Drupal core to v8.4.5 (via Composer)

 {
     /**
      * Used to match very simple id methods that don't need
      * to be decorated since the identifier is known.
      */
-    const PATTERN_MATCH_ID_METHOD = '((public\s+)?(function\s+%s\s*\(\)\s*)\s*{\s*return\s*\$this->%s;\s*})i';
+    const PATTERN_MATCH_ID_METHOD = '((public\s+)?(function\s+%s\s*\(\)\s*)\s*(?::\s*\??\s*\\\\?[a-z_\x7f-\xff][\w\x7f-\xff]*(?:\\\\[a-z_\x7f-\xff][\w\x7f-\xff]*)*\s*)?{\s*return\s*\$this->%s;\s*})i';
 
     /**
      * The namespace that contains all proxy classes.
      *
      * @var string

                 $identifier = lcfirst(substr($name, 3));
                 $fieldType  = $class->getTypeOfField($identifier);
                 $cast       = in_array($fieldType, ['integer', 'smallint']) ? '(int) ' : '';
 
                 $methods .= '        if ($this->__isInitialized__ === false) {' . "\n";
-                $methods .= '            return ' . $cast . ' parent::' . $method->getName() . "();\n";
+                $methods .= '            ';
+                $methods .= $this->shouldProxiedMethodReturn($method) ? 'return ' : '';
+                $methods .= $cast . ' parent::' . $method->getName() . "();\n";
                 $methods .= '        }' . "\n\n";
             }
 
             $invokeParamsString = implode(', ', $this->getParameterNamesForInvoke($method->getParameters()));
             $callParamsString = implode(', ', $this->getParameterNamesForParentCall($method->getParameters()));
 
             $methods .= "\n        \$this->__initializer__ "
                 . "&& \$this->__initializer__->__invoke(\$this, " . var_export($name, true)
                 . ", [" . $invokeParamsString . "]);"
-                . "\n\n        return parent::" . $name . '(' . $callParamsString . ');'
+                . "\n\n        "
+                . ($this->shouldProxiedMethodReturn($method) ? 'return ' : '')
+                . "parent::" . $name . '(' . $callParamsString . ');'
                 . "\n" . '    }' . "\n";
         }
 
         return $methods;
     }

      *
      * @return string|null
      */
     private function getParameterType(ClassMetadata $class, \ReflectionMethod $method, \ReflectionParameter $parameter)
     {
-
-        // We need to pick the type hint class too
+        if (method_exists($parameter, 'hasType')) {
+            if ( ! $parameter->hasType()) {
+                return '';
+            }
+
+            return $this->formatType($parameter->getType(), $parameter->getDeclaringFunction(), $parameter);
+        }
+
+        // For PHP 5.x, we need to pick the type hint in the old way (to be removed for PHP 7.0+)
         if ($parameter->isArray()) {
             return 'array';
         }
 
         if ($parameter->isCallable()) {
             return 'callable';
-        }
-
-        if (method_exists($parameter, 'hasType') && $parameter->hasType() && $parameter->getType()->isBuiltin()) {
-            return (string) $parameter->getType();
         }
 
         try {
             $parameterClass = $parameter->getClass();
 

      *
      * @return string
      */
     private function getMethodReturnType(\ReflectionMethod $method)
     {
-        if (! (method_exists($method, 'hasReturnType') && $method->hasReturnType())) {
+        if ( ! method_exists($method, 'hasReturnType') || ! $method->hasReturnType()) {
             return '';
         }
 
-        $returnType = $method->getReturnType();
-
-        if ($returnType->isBuiltin()) {
-            return ': ' . $returnType;
-        }
-
-        $nameLower = strtolower((string) $returnType);
+        return ': ' . $this->formatType($method->getReturnType(), $method);
+    }
+
+    /**
+     * @param \ReflectionMethod $method
+     *
+     * @return bool
+     */
+    private function shouldProxiedMethodReturn(\ReflectionMethod $method)
+    {
+        if ( ! method_exists($method, 'hasReturnType') || ! $method->hasReturnType()) {
+            return true;
+        }
+
+        return 'void' !== strtolower($this->formatType($method->getReturnType(), $method));
+    }
+
+    /**
+     * @param \ReflectionType $type
+     * @param \ReflectionMethod $method
+     * @param \ReflectionParameter|null $parameter
+     *
+     * @return string
+     */
+    private function formatType(
+        \ReflectionType $type,
+        \ReflectionMethod $method,
+        \ReflectionParameter $parameter = null
+    ) {
+        $name = method_exists($type, 'getName') ? $type->getName() : (string) $type;
+        $nameLower = strtolower($name);
 
         if ('self' === $nameLower) {
-            return ': \\' . $method->getDeclaringClass()->getName();
+            $name = $method->getDeclaringClass()->getName();
         }
 
         if ('parent' === $nameLower) {
-            return ': \\' . $method->getDeclaringClass()->getParentClass()->getName();
-        }
-
-        return ': \\' . (string) $returnType;
+            $name = $method->getDeclaringClass()->getParentClass()->getName();
+        }
+
+        if ( ! $type->isBuiltin() && ! class_exists($name) && ! interface_exists($name)) {
+            if (null !== $parameter) {
+                throw UnexpectedValueException::invalidParameterTypeHint(
+                    $method->getDeclaringClass()->getName(),
+                    $method->getName(),
+                    $parameter->getName()
+                );
+            }
+
+            throw UnexpectedValueException::invalidReturnTypeHint(
+                $method->getDeclaringClass()->getName(),
+                $method->getName()
+            );
+        }
+
+        if ( ! $type->isBuiltin()) {
+            $name = '\\' . $name;
+        }
+
+        if ($type->allowsNull()
+            && (null === $parameter || ! $parameter->isDefaultValueAvailable() || null !== $parameter->getDefaultValue())
+        ) {
+            $name = '?' . $name;
+        }
+
+        return $name;
     }
 }