[RFC] Optional interfaces

Zend/tests/optional_interfaces/autoloading.phpt

@@ -0,0 +1,24 @@
+--TEST--
+Optional interfaces are autoloaded
+--FILE--
+<?php
+
+spl_autoload_register(function ($class) {
+    echo "Autoloading: $class\n";
+
+    if ($class === 'ExistingInterface')
+        eval("interface ExistingInterface {}");
+});
+
+class TestClass implements ?ExistingInterface, ?NonExistantInterface {}
+
+$c = new TestClass;
+echo implode(',', class_implements($c))."\n";
+echo implode(',', class_implements('TestClass'))."\n";
+
+?>
+--EXPECT--
+Autoloading: ExistingInterface
+Autoloading: NonExistantInterface
+ExistingInterface
+ExistingInterface

Zend/tests/optional_interfaces/dynamic_definition.phpt

@@ -0,0 +1,41 @@
+--TEST--
+Dynamically defined interfaces only affect classes defined later
+--FILE--
+<?php
+
+class AncientClass implements ?OptionalInterface {}
+$ancientClass = new AncientClass;
+echo 'AC implements:'.implode(', ', class_implements('AncientClass')),"\n";
+echo 'AC object implements:'.implode(', ', class_implements($ancientClass)),"\n\n";
+
+eval('interface OptionalInterface {}');
+echo "Interface defined\n\n";
+
+class NewClass implements ?OptionalInterface {}
+
+// Newly defined class implements the interface
+$newClass = new NewClass;
+echo 'NC implements:'.implode(', ', class_implements('NewClass')),"\n";
+echo 'NC implements:'.implode(', ', class_implements($newClass)),"\n\n";
+
+// The old class doesn't
+echo 'AC object implements:'.implode(', ', class_implements($ancientClass)),"\n";
+
+echo 'AC implements:'.implode(', ', class_implements('AncientClass')),"\n";
+
+$ancientClass2 = new AncientClass;
+echo 'New AC object implements:'.implode(', ', class_implements($ancientClass2)),"\n";
+
+?>
+--EXPECT--
+AC implements:
+AC object implements:
+
+Interface defined
+
+NC implements:OptionalInterface
+NC implements:OptionalInterface
+
+AC object implements:
+AC implements:
+New AC object implements:

Zend/tests/optional_interfaces/optional_interface_with_parent.phpt

@@ -0,0 +1,13 @@
+--TEST--
+Optional interface with parent
+--FILE--
+<?php
+
+interface I {}
+class P implements I {}
+class C extends P implements ?OptionalInterface {}
+
+?>
+===DONE===
+--EXPECT--
+===DONE===

Zend/tests/optional_interfaces/optional_interfaces.phpt

@@ -0,0 +1,77 @@
+--TEST--
+Optional interfaces work
+--FILE--
+<?php
+
+interface ExistingInterface {}
+
+class ImplementingOptionalInterface implements ?ExistingInterface {}
+class SkippingOptionalInterface implements ?NonExistantInterface {}
+class MultipleOptionalsExistingFirst implements ?ExistingInterface, ?NonExistantInterface {}
+class MultipleOptionalsExistingLast implements ?NonExistantInterface, ?ExistingInterface {}
+class MixedOptionalFirst implements ?NonExistantInterface, ExistingInterface {}
+class MixedOptionalLast implements ExistingInterface, ?NonExistantInterface {}
+
+interface ExtendingExistingOptional extends ExistingInterface {}
+interface ExtendingNonexistantOptional extends ?NonExistantInterface {}
+
+class ImplementsInheritedExisting implements ExtendingExistingOptional {}
+class ImplementsInheritedSkipped implements ExtendingNonexistantOptional {}
+
+$classes = [
+    ImplementingOptionalInterface::class,
+    SkippingOptionalInterface::class,
+    MultipleOptionalsExistingFirst::class,
+    MultipleOptionalsExistingLast::class,
+    MixedOptionalFirst::class,
+    MixedOptionalLast::class,
+    ImplementsInheritedExisting::class,
+    ImplementsInheritedSkipped::class,
+];
+
+foreach ($classes as $class) {
+    echo "$class\n";
+    echo '    class implements:'.implode(', ', class_implements($class))."\n";
+    echo '    object implements:'.implode(', ', class_implements(new $class))."\n";
+}
+
+$interfaces = [
+    ExtendingExistingOptional::class,
+    ExtendingNonexistantOptional::class,
+];
+
+foreach ($interfaces as $interface) {
+    echo "$interface\n";
+    echo '    interface extends:'.implode(', ', class_implements($class))."\n";
+}
+
+?>
+--EXPECT--
+ImplementingOptionalInterface
+    class implements:ExistingInterface
+    object implements:ExistingInterface
+SkippingOptionalInterface
+    class implements:
+    object implements:
+MultipleOptionalsExistingFirst
+    class implements:ExistingInterface
+    object implements:ExistingInterface
+MultipleOptionalsExistingLast
+    class implements:ExistingInterface
+    object implements:ExistingInterface
+MixedOptionalFirst
+    class implements:ExistingInterface
+    object implements:ExistingInterface
+MixedOptionalLast
+    class implements:ExistingInterface
+    object implements:ExistingInterface
+ImplementsInheritedExisting
+    class implements:ExtendingExistingOptional, ExistingInterface
+    object implements:ExtendingExistingOptional, ExistingInterface
+ImplementsInheritedSkipped
+    class implements:ExtendingNonexistantOptional
+    object implements:ExtendingNonexistantOptional
+ExtendingExistingOptional
+    interface extends:ExtendingNonexistantOptional
+ExtendingNonexistantOptional
+    interface extends:ExtendingNonexistantOptional

Zend/tests/optional_interfaces/optional_interfaces_are_checked.phpt

@@ -0,0 +1,25 @@
+--TEST--
+Optional interfaces are checked
+--FILE--
+<?php
+
+interface Iface
+{
+    public function method();
+}
+
+class DecentClass implements ?Iface
+{
+    public function method() {}
+}
+
+$anInstance = new DecentClass;
+if ($anInstance instanceof Iface)
+    echo "Existing interfaces can be implemented.";
+
+class BadClass implements ?Iface {}
+
+?>
+--EXPECTF--
+Existing interfaces can be implemented.
+Fatal error: Class BadClass contains 1 abstract method and must therefore be declared abstract or implement the remaining method (Iface::method) in %soptional_interfaces_are_checked.php on line %d

Zend/tests/optional_interfaces/override.phpt

@@ -0,0 +1,22 @@
+--TEST--
+Optional interfaces doesn't make Override optional
+--FILE--
+<?php
+
+interface ExistingInterface
+{
+    public function method();
+}
+
+class TestClass implements ?ExistingInterface, ?NonExistantInterface
+{
+    #[\Override]
+    public function method() {}
+
+    #[\Override]
+    public function other() {}
+}
+
+?>
+--EXPECTF--
+Fatal error: TestClass::other() has #[\Override] attribute, but no matching parent method exists in %soverride.php on line %d

Zend/tests/optional_interfaces/reflection.phpt

@@ -0,0 +1,15 @@
+--TEST--
+Reflection works on optional interfaces
+--FILE--
+<?php
+
+interface ExistingInterface {}
+
+class TestClass implements ?ExistingInterface, ?NonexistantInterface {}
+
+$reflection = new ReflectionClass('TestClass');
+echo implode(', ', $reflection->getInterfaceNames());
+
+?>
+--EXPECT--
+ExistingInterface

Zend/tests/optional_interfaces/serialization.phpt

@@ -0,0 +1,16 @@
+--TEST--
+Classes with optional interfaces survive serialization
+--FILE--
+<?php
+
+interface ExistingInterface {}
+class TestClass implements ?ExistingInterface, ?NonExistantInterface {}
+
+$original = new TestClass;
+$deserialized = unserialize(serialize($original));
+
+echo implode(',', class_implements($deserialized));
+
+?>
+--EXPECT--
+ExistingInterface

Zend/tests/optional_interfaces/stringable.phpt

@@ -0,0 +1,20 @@
+--TEST--
+Adding stringable is not broken with Optional interfaces
+--FILE--
+<?php
+
+trait Str
+{
+    public function __toString() {}
+}
+
+class TestClass implements ?NonexistantInterface
+{
+    use Str;
+}
+
+echo implode(',', class_implements('TestClass'));
+
+?>
+--EXPECT--
+Stringable

Zend/tests/optional_interfaces/type_checks.phpt

@@ -0,0 +1,27 @@
+--TEST--
+Only the existing interfaces pass the type checks
+--INI--
+zend.exception_ignore_args = On
+--FILE--
+<?php
+
+interface ExistingInterface {}
+
+class TestClass implements ?ExistingInterface, ?NonExistantInterface {}
+
+function f1(ExistingInterface $x) { echo "F1"; }
+function f2(NonExistantInterface $x) { echo "F2"; }
+
+$c = new TestClass;
+
+f1($c);
+f2($c);
+
+?>
+--EXPECTF--
+F1
+Fatal error: Uncaught TypeError: f2(): Argument #1 ($x) must be of type NonExistantInterface, TestClass given, called in %stype_checks.php on line %d and defined in %stype_checks.php:%d
+Stack trace:
+#0 %s
+#1 {main}
+  thrown in %stype_checks.php on line %d

Zend/zend.h

@@ -87,6 +87,12 @@ typedef struct _zend_class_name {
 	zend_string *lc_name;
 } zend_class_name;
 
+typedef struct _zend_interface_name {
+	zend_string *name;
+	zend_string *lc_name;
+	bool is_optional;
+} zend_interface_name;
+
 typedef struct _zend_trait_method_reference {
 	zend_string *method_name;
 	zend_string *class_name;
@@ -210,7 +216,7 @@ struct _zend_class_entry {
 	/* class_entry or string(s) depending on ZEND_ACC_LINKED */
 	union {
 		zend_class_entry **interfaces;
-		zend_class_name *interface_names;
+		zend_interface_name *interface_names;
 	};
 
 	zend_class_name *trait_names;

Zend/zend_ast.c

@@ -1394,11 +1394,11 @@ static ZEND_COLD void zend_ast_export_ns_name(smart_str *str, zend_ast *ast, int
 		zval *zv = zend_ast_get_zval(ast);
 
 		if (Z_TYPE_P(zv) == IS_STRING) {
-		    if (ast->attr == ZEND_NAME_FQ) {
+			if (NAME_QUAL(ast->attr) == ZEND_NAME_FQ) {
 				smart_str_appendc(str, '\\');
-		    } else if (ast->attr == ZEND_NAME_RELATIVE) {
+			} else if (NAME_QUAL(ast->attr) == ZEND_NAME_RELATIVE) {
 				smart_str_appends(str, "namespace\\");
-		    }
+			}
 			smart_str_append(str, Z_STR_P(zv));
 			return;
 		}