fix instanceof

Signed-off-by: Robert Landers <landers.robert@gmail.com>

Author: withinboredom

UPGRADING

@@ -211,7 +211,7 @@ PHP 8.6 UPGRADE NOTES
     `Box<string>`) synthesises a separate class entry whose canonical
     name is spelled out (`"Box<int>"`), registered in the class table,
     and visible through `get_class()`, `var_dump`, and
-    `instanceof Box<int>`. Function- and method-level generics are
+    `instanceof Box::<int>`. Function- and method-level generics are
     reified per call frame: each call carries its own type-argument
     table, with no persistent `id<int>` function entry (avoiding
     unbounded growth). Closures and generators preserve the table so
@@ -224,7 +224,7 @@ PHP 8.6 UPGRADE NOTES
     actually pass at this slot." Reified type arguments are kept on a
     side table and consulted at well-defined runtime points: monomorph
     synthesis, turbofish argument validation, deferred lookups for
-    `instanceof Box<T>` / `catch (Box<T> $e)`, bare `T`-ref resolution
+    `instanceof Box::<T>` / `catch (Box<T> $e)`, bare `T`-ref resolution
     (`instanceof T`, `catch (T $e)`, `new T()`, `T::method()`),
     inheritance linking, and Reflection.
   . It is now possible to use reference assign on WeakMap without the key

UPGRADING.INTERNALS

@@ -231,7 +231,7 @@ PHP 8.6 INTERNALS UPGRADE NOTES
         - ZEND_FETCH_CLASS_TYPE_PARAM_CLASS  (8) — class-level bare
           T-ref; resolves via the called-scope walk.
         - ZEND_FETCH_CLASS_GENERIC_DEFERRED  (9) — generic named type
-          whose args contain T-refs (`instanceof Box<T>`,
+          whose args contain T-refs (`instanceof Box::<T>`,
           `catch (Box<T> $e)`). The args_id sits in the high bits of
           op.num and points into the op_array's
           generic_types->turbofish_args side table.

Zend/tests/generics/erasure/instanceof_args_discarded.phpt

@@ -4,7 +4,7 @@ Erasure: instanceof on a non-generic class with type arguments is a compile-time
 <?php
 class C {}
 $c = new C;
-var_dump($c instanceof C<int>);
+var_dump($c instanceof C::<int>);
 ?>
 --EXPECTF--
 Fatal error: Type arguments are not allowed on non-generic class C in %s on line %d

Zend/tests/generics/errors/type_args_on_non_generic_instanceof.phpt

@@ -4,7 +4,7 @@ Type arguments on a non-generic class in `instanceof` are a compile-time error
 <?php
 class Plain {}
 $x = new Plain;
-var_dump($x instanceof Plain<int>);
+var_dump($x instanceof Plain::<int>);
 ?>
 --EXPECTF--
 Fatal error: Type arguments are not allowed on non-generic class Plain in %s on line %d

Zend/tests/generics/reification/instanceof_distinguishes_monos.phpt

@@ -12,10 +12,10 @@ $ba = new Box::<Animal>();
 
 // Each mono extends the bare class but is otherwise distinct.
 var_dump($bd instanceof Box);            // true: parent-name chain
-var_dump($bd instanceof Box<Dog>);       // true: same canonical mono
-var_dump($bd instanceof Box<Animal>);    // false: invariant distinction
-var_dump($ba instanceof Box<Dog>);       // false
-var_dump($ba instanceof Box<Animal>);    // true
+var_dump($bd instanceof Box::<Dog>);       // true: same canonical mono
+var_dump($bd instanceof Box::<Animal>);    // false: invariant distinction
+var_dump($ba instanceof Box::<Dog>);       // false
+var_dump($ba instanceof Box::<Animal>);    // true
 ?>
 --EXPECT--
 bool(true)

Zend/tests/generics/reification/instanceof_nested_t_ref.phpt

@@ -1,13 +1,13 @@
 --TEST--
-Reification: nested T-refs (instanceof Outer<Box<T>>) substitute through and resolve the outermost monomorph
+Reification: nested T-refs (instanceof Outer::<Box<T>>) substitute through and resolve the outermost monomorph
 --FILE--
 <?php
 class Box<U> {}
 class Outer<V> {}
 
 class Holder<T> {
     public function isOuterOfBox(mixed $x): bool {
-        return $x instanceof Outer<Box<T>>;
+        return $x instanceof Outer::<Box<T>>;
     }
 }
 

Zend/tests/generics/reification/instanceof_variance.phpt

@@ -15,23 +15,23 @@ $dogProd = new Producer::<Dog>();
 $animalCons = new Consumer::<Animal>();
 
 // Invariant: only same-arg passes.
-var_dump($dogBox instanceof Box<Dog>);       // true (identical)
-var_dump($dogBox instanceof Box<Animal>);    // false
-var_dump($dogBox instanceof Box<Cat>);       // false
+var_dump($dogBox instanceof Box::<Dog>);       // true (identical)
+var_dump($dogBox instanceof Box::<Animal>);    // false
+var_dump($dogBox instanceof Box::<Cat>);       // false
 
 // Covariant: Dog <: Animal, so Producer<Dog> <: Producer<Animal>.
-var_dump($dogProd instanceof Producer<Animal>);  // true
-var_dump($dogProd instanceof Producer<Cat>);     // false
-var_dump($dogProd instanceof Producer<Dog>);     // true
+var_dump($dogProd instanceof Producer::<Animal>);  // true
+var_dump($dogProd instanceof Producer::<Cat>);     // false
+var_dump($dogProd instanceof Producer::<Dog>);     // true
 
 // Contravariant: Animal :> Dog, so Consumer<Animal> <: Consumer<Dog>.
-var_dump($animalCons instanceof Consumer<Dog>);   // true
-var_dump($animalCons instanceof Consumer<Cat>);   // true
-var_dump($animalCons instanceof Consumer<Animal>);// true
+var_dump($animalCons instanceof Consumer::<Dog>);   // true
+var_dump($animalCons instanceof Consumer::<Cat>);   // true
+var_dump($animalCons instanceof Consumer::<Animal>);// true
 
 // Reverse contravariant fails.
 $dogCons = new Consumer::<Dog>();
-var_dump($dogCons instanceof Consumer<Animal>);   // false
+var_dump($dogCons instanceof Consumer::<Animal>);   // false
 ?>
 --EXPECT--
 bool(true)

Zend/tests/generics/reification/instanceof_with_t_ref_class_level.phpt

@@ -1,12 +1,12 @@
 --TEST--
-Reification: instanceof Box<T> with class-level T resolves against the called scope's monomorph args
+Reification: instanceof Box::<T> with class-level T resolves against the called scope's monomorph args
 --FILE--
 <?php
 class Box<T> {}
 
 class Outer<T> {
     public function isBox(mixed $x): bool {
-        return $x instanceof Box<T>;
+        return $x instanceof Box::<T>;
     }
 }
 

Zend/tests/generics/reification/instanceof_with_t_ref_function_level.phpt

@@ -1,11 +1,11 @@
 --TEST--
-Reification: instanceof Box<T> with function-level T resolves against the current frame's turbofish bindings
+Reification: instanceof Box::<T> with function-level T resolves against the current frame's turbofish bindings
 --FILE--
 <?php
 class Box<T> {}
 
 function isBoxOf<T>(mixed $x): bool {
-    return $x instanceof Box<T>;
+    return $x instanceof Box::<T>;
 }
 
 var_dump(isBoxOf::<int>(new Box::<int>));      // true

Zend/tests/generics/reification/monomorph_implements_substitution.phpt

@@ -4,7 +4,7 @@ Reification: a monomorph of `B<T> implements I<T>` should report `is_a I<bound>`
 <?php
 // Regression: when `B<T> implements I<T>` is monomorphized as `B<string>`,
 // the implements binding has to be substituted so that `B<string>` is also
-// known to implement `I<string>`. Otherwise `instanceof I<string>` /
+// known to implement `I<string>`. Otherwise `instanceof I::<string>` /
 // `is_a(..., 'I<string>')` returns false even though the type relationship
 // holds, and property writes typed `I<string>` reject `B<string>` values.