hphp/test/slow/dynamic-calls/inst_meth/forbid-throw.php

   1 <?hh
   2
   3 function wrap($e) { echo "Exception: {$e->getMessage()}\n"; }
   4
   5 function func() {}
   6 async function async_func() { return 5; }
   7 function cmp($x, $y) { return $x <=> $y; }
   8
   9 <<__DynamicallyCallable>> function func2() {}
  10 <<__DynamicallyCallable>> async function async_func2() { return 5; }
  11 <<__DynamicallyCallable>> function cmp2($x, $y) { return $x <=> $y; }
  12
  13 class D {
  14   public function __call($a, $b) {}
  15
  16 }
  17
  18 class C extends D {
  19   public function __call($a, $b) {}
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34 }
  35
  36 class G  {
  37   <<__DynamicallyCallable>> public function __call($a, $b) {}
  38
  39 }
  40
  41 class E extends G {
  42   <<__DynamicallyCallable>> public function __call($a, $b) {}
  43
  44
  45
  46
  47
  48
  49
  50
  51 }
  52
  53 class CCmp {
  54   public function __call($a, $b) { return $b[0] <=> $b[1]; }
  55
  56 }
  57
  58 class CCmp2 {
  59   <<__DynamicallyCallable>> public function __call($a, $b) { return $b[0] <=> $b[1]; }
  60
  61 }
  62
  63 class Invokable {
  64   public function __invoke() {}
  65 }
  66
  67 class InvokableCmp {
  68   public function __invoke($a, $b) { return $a <=> $b; }
  69 }
  70
  71 class B {
  72   public function func() {}
  73   public static function static_func() {}
  74   public async function async_func() { return 5; }
  75   public static async function static_async_func() { return 5; }
  76
  77   <<__DynamicallyCallable>> public function func2() {}
  78   <<__DynamicallyCallable>> public static function static_func2() {}
  79   <<__DynamicallyCallable>> public async function async_func2() { return 5; }
  80   <<__DynamicallyCallable>> public static async function static_async_func2() { return 5; }
  81 }
  82
  83 class A extends B {
  84   public function __construct() {}
  85
  86   public function func() {}
  87   public async function async_func() { return 5; }
  88   public function cmp($x, $y) { return $x <=> $y; }
  89   public static function static_func() {}
  90   public static async function static_async_func() { return 5; }
  91   public static function static_cmp($x, $y) { return $x <=> $y; }
  92
  93   <<__DynamicallyCallable>> public function func2() {}
  94   <<__DynamicallyCallable>> public async function async_func2() { return 5; }
  95   <<__DynamicallyCallable>> public function cmp2($x, $y) { return $x <=> $y; }
  96   <<__DynamicallyCallable>> public static function static_func2() {}
  97   <<__DynamicallyCallable>> public static async function static_async_func2() { return 5; }
  98   <<__DynamicallyCallable>> public static function static_cmp2($x, $y) { return $x <=> $y; }
  99
 100   public static async function positive_test1() {
 101
 102
 103
 104
 105
 106     $x = 'static_func';
 107     try { self::$x(); } catch (Exception $e) { wrap($e); }
 108     try { static::$x(); } catch (Exception $e) { wrap($e); }
 109     try { parent::$x(); } catch (Exception $e) { wrap($e); }
 110
 111
 112
 113
 114
 115
 116     $x = 'static_async_func';
 117     try { await self::$x(); } catch (Exception $e) { wrap($e); }
 118     try { await static::$x(); } catch (Exception $e) { wrap($e); }
 119     try { await parent::$x(); } catch (Exception $e) { wrap($e); }
 120   }
 121
 122   public static async function negative_test1() {
 123
 124
 125
 126
 127     self::static_func();
 128     static::static_func();
 129     parent::static_func();
 130
 131
 132
 133
 134
 135     await self::static_async_func();
 136     await static::static_async_func();
 137     await parent::static_async_func();
 138
 139     new self;
 140     new static;
 141     new parent;
 142
 143
 144
 145
 146
 147
 148     $x = 'static_func2';
 149     self::$x();
 150     static::$x();
 151     parent::$x();
 152
 153
 154
 155
 156
 157
 158     $x = 'static_async_func2';
 159     await self::$x();
 160     await static::$x();
 161     await parent::$x();
 162   }
 163 }
 164
 165 <<__DynamicallyConstructible>>
 166 class F extends A {
 167 }
 168
 169 async function positive_tests() {
 170   try { $x = 'func'; $x(); } catch (Exception $e) { wrap($e); }
 171   try { $x = 'async_func'; await $x(); } catch (Exception $e) { wrap($e); }
 172   try { $x = 'A::func'; $x(); } catch (Exception $e) { wrap($e); }
 173   try { $x = 'A::static_func'; $x(); } catch (Exception $e) { wrap($e); }
 174   try { $x = 'A::async_func'; await $x(); } catch (Exception $e) { wrap($e); }
 175   try { $x = 'A::static_async_func'; await $x(); } catch (Exception $e) { wrap($e); }
 176
 177   try { $x = ['A', 'func']; $x(); } catch (Exception $e) { wrap($e); }
 178   try { $x = ['A', 'static_func']; $x(); } catch (Exception $e) { wrap($e); }
 179   try { $x = ['A', 'async_func']; await $x(); } catch (Exception $e) { wrap($e); }
 180   try { $x = ['A', 'static_async_func']; await $x(); } catch (Exception $e) { wrap($e); }
 181
 182   try { $x = [new A, 'func']; $x(); } catch (Exception $e) { wrap($e); }
 183   try { $x = [new A, 'static_func']; $x(); } catch (Exception $e) { wrap($e); }
 184   try { $x = [new A, 'async_func']; await $x(); } catch (Exception $e) { wrap($e); }
 185   try { $x = [new A, 'static_async_func']; await $x(); } catch (Exception $e) { wrap($e); }
 186   try { $x = [new C, 'foobar']; $x(); } catch (Exception $e) { wrap($e); }
 187
 188   try { $x = 'A'; $x::static_func(); } catch (Exception $e) { wrap($e); }
 189
 190   try { $x = 'A'; await $x::static_async_func(); } catch (Exception $e) { wrap($e); }
 191
 192
 193   try { $x = 'static_func'; A::$x(); } catch (Exception $e) { wrap($e); }
 194
 195   try { $x = 'static_async_func'; await A::$x(); } catch (Exception $e) { wrap($e); }
 196
 197
 198   A::positive_test1();
 199
 200
 201   try { $x = 'A'; new $x(); } catch (Exception $e) { wrap($e); }
 202   try { $obj = new A; $x = 'func'; $obj->$x(); } catch (Exception $e) { wrap($e); }
 203
 204   try { $obj = new A; $x = 'async_func'; await $obj->$x(); } catch (Exception $e) { wrap($e); }
 205
 206   try { $obj = new C; $x = 'foobar'; $obj->$x(); } catch (Exception $e) { wrap($e); }
 207
 208   try { array_map('func', [true]); } catch (Exception $e) { wrap($e); }
 209   try { array_map('A::func', [true]); } catch (Exception $e) { wrap($e); }
 210   try { array_map('A::static_func', [true]); } catch (Exception $e) { wrap($e); }
 211
 212   try { array_map(['A', 'func'], [true]); } catch (Exception $e) { wrap($e); }
 213   try { array_map(['A', 'static_func'], [true]); } catch (Exception $e) { wrap($e); }
 214
 215   try { array_map([new A, 'func'], [true]); } catch (Exception $e) { wrap($e); }
 216   try { array_map([new A, 'static_func'], [true]); } catch (Exception $e) { wrap($e); }
 217   try { array_map([new C, 'foobar'], [true]); } catch (Exception $e) { wrap($e); }
 218
 219   $x = Vector::fromItems([[]]);
 220   try { $x->map('func'); } catch (Exception $e) { wrap($e); }
 221
 222   try { $x->map('A::static_func'); } catch (Exception $e) { wrap($e); }
 223
 224
 225   try { $x->map(['A', 'static_func']); } catch (Exception $e) { wrap($e); }
 226
 227   try { $x->map([new A, 'func']); } catch (Exception $e) { wrap($e); }
 228   try { $x->map([new A, 'static_func']); } catch (Exception $e) { wrap($e); }
 229   try { $x->map([new C, 'foobar']); } catch (Exception $e) { wrap($e); }
 230
 231   try { call_user_func('func'); } catch (Exception $e) { wrap($e); }
 232
 233   try { call_user_func('A::static_func'); } catch (Exception $e) { wrap($e); }
 234
 235
 236   try { call_user_func(['A', 'static_func']); } catch (Exception $e) { wrap($e); }
 237
 238   try { call_user_func([new A, 'func']); } catch (Exception $e) { wrap($e); }
 239   try { call_user_func([new A, 'static_func']); } catch (Exception $e) { wrap($e); }
 240   try { call_user_func([new C, 'foobar']); } catch (Exception $e) { wrap($e); }
 241
 242   try { call_user_func_array('func', []); } catch (Exception $e) { wrap($e); }
 243
 244   try { call_user_func_array('A::static_func', []); } catch (Exception $e) { wrap($e); }
 245
 246   try { call_user_func_array(['A', 'static_func'], []); } catch (Exception $e) { wrap($e); }
 247   try { call_user_func_array([new A, 'func'], []); } catch (Exception $e) { wrap($e); }
 248   try { call_user_func_array([new A, 'static_func'], []); } catch (Exception $e) { wrap($e); }
 249
 250   try { $x = 'cmp'; $y = [2, 1]; usort(inout $y, $x); } catch (Exception $e) { wrap($e); }
 251
 252   try { $x = 'A::static_cmp'; $y = [2, 1]; usort(inout $y, $x); } catch (Exception $e) { wrap($e); }
 253
 254
 255   try { $x = ['A', 'static_cmp']; $y = [2, 1]; usort(inout $y, $x); } catch (Exception $e) { wrap($e); }
 256
 257   try { $x = [new A, 'cmp']; $y = [2, 1]; usort(inout $y, $x); } catch (Exception $e) { wrap($e); }
 258   try { $x = [new A, 'static_cmp']; $y = [2, 1]; usort(inout $y, $x); } catch (Exception $e) { wrap($e); }
 259   try { $x = [new CCmp, 'foobar']; $y = [2, 1]; usort(inout $y, $x); } catch (Exception $e) { wrap($e); }
 260 }
 261
 262 async function negative_tests() {
 263   func();
 264   count([]);
 265   await async_func();
 266
 267   A::static_func();
 268
 269   await A::static_async_func();
 270
 271   Vector::fromItems([]);
 272
 273   $x = ($k ==> {});
 274   $x(1);
 275
 276   A::negative_test1();
 277
 278   HH\class_meth(A::class, 'static_func')();
 279
 280   new A;
 281   new Vector;
 282
 283   $obj = new A;
 284   $obj->func();
 285
 286   await $obj->async_func();
 287
 288
 289   $obj = new C;
 290   $obj->foobar();
 291
 292   $obj = new Vector;
 293   $obj->firstValue();
 294
 295
 296   array_map($k ==> {}, [true]);
 297   array_map(new Invokable, [true]);
 298
 299   $x = Vector::fromItems([true]);
 300   $x->map($k ==> {});
 301   $x->map(new Invokable);
 302
 303   $x = [2, 1];
 304   usort(inout $x, ($k1, $k2) ==> { return $k1 <=> $k2; });
 305
 306   $x = [2, 1];
 307   usort(inout $x, new InvokableCmp);
 308
 309   $x = 'count'; $x([]);
 310   array_map('count', [[]]);
 311   $x = Vector::fromItems([true]); $x->map('count');
 312   call_user_func('count', []);
 313   call_user_func_array('count', [[]]);
 314
 315   $x = 'HH\Vector::fromItems'; $x([]);
 316   $x = ['HH\Vector', 'fromItems']; $x([]);
 317   $x = [new Vector, 'fromItems']; $x([]);
 318   $x = 'fromItems'; Vector::$x([]);
 319   $x = [new Vector, 'firstValue']; $x();
 320   $x = 'HH\Vector'; $x::fromItems([]);
 321   $obj = new Vector; $x = 'firstValue'; $obj->$x();
 322
 323   array_map('HH\Vector::fromItems', [[]]);
 324   array_map(['HH\Vector', 'fromItems'], [[]]);
 325   array_map([new Vector, 'fromItems'], [[]]);
 326   $x = Vector::fromItems([[]]);
 327   $x->map('HH\Vector::fromItems');
 328   $x->map(['HH\Vector', 'fromItems']);
 329   $x->map([new Vector, 'fromItems']);
 330   call_user_func('HH\Vector::fromItems', []);
 331   call_user_func(['HH\Vector', 'fromItems'], []);
 332   call_user_func([new Vector, 'firstValue']);
 333   call_user_func([new Vector, 'fromItems'], []);
 334   call_user_func_array('HH\Vector::fromItems', [[]]);
 335   call_user_func_array(['HH\Vector', 'fromItems'], [[]]);
 336   call_user_func_array([new Vector, 'firstValue'], []);
 337   call_user_func_array([new Vector, 'fromItems'], [[]]);
 338
 339   $x = 'array_map';
 340   $x('count', []);
 341
 342   $obj = null; $obj?->foobar();
 343
 344   idx('foobar', 'key');
 345
 346   $x = 'func2'; $x();
 347   $x = 'async_func2'; await $x();
 348   $x = 'A::func2'; $x();
 349   $x = 'A::static_func2'; $x();
 350   $x = 'A::async_func2'; await $x();
 351   $x = 'A::static_async_func2'; await $x();
 352
 353   $x = ['A', 'func2']; $x();
 354   $x = ['A', 'static_func2']; $x();
 355   $x = ['A', 'async_func2']; await $x();
 356   $x = ['A', 'static_async_func2']; await $x();
 357
 358   $x = [new A, 'func2']; $x();
 359   $x = [new A, 'static_func2']; $x();
 360   $x = [new A, 'async_func2']; await $x();
 361   $x = [new A, 'static_async_func2']; await $x();
 362   $x = [new E, 'foobar']; $x();
 363
 364   $x = 'A'; $x::static_func2();
 365
 366   $x = 'A'; await $x::static_async_func2();
 367
 368
 369   $x = 'static_func2'; A::$x();
 370
 371   $x = 'static_async_func2'; await A::$x();
 372
 373
 374   $x = 'F'; new $x();
 375   $obj = new A; $x = 'func2'; $obj->$x();
 376
 377   $obj = new A; $x = 'async_func2'; await $obj->$x();
 378
 379   $obj = new E; $x = 'foobar'; $obj->$x();
 380
 381   array_map('func2', [true]);
 382   array_map('A::func2', [true]);
 383   array_map('A::static_func2', [true]);
 384
 385   array_map(['A', 'func2'], [true]);
 386   array_map(['A', 'static_func2'], [true]);
 387
 388   array_map([new A, 'func2'], [true]);
 389   array_map([new A, 'static_func2'], [true]);
 390   array_map([new E, 'foobar'], [true]);
 391
 392   $x = Vector::fromItems([[]]);
 393   $x->map('func2');
 394
 395   $x->map('A::static_func2');
 396
 397
 398   $x->map(['A', 'static_func2']);
 399
 400   $x->map([new A, 'func2']);
 401   $x->map([new A, 'static_func2']);
 402   $x->map([new E, 'foobar']);
 403
 404   call_user_func('func2');
 405
 406   call_user_func('A::static_func2');
 407
 408
 409   call_user_func(['A', 'static_func2']);
 410
 411   call_user_func([new A, 'func2']);
 412   call_user_func([new A, 'static_func2']);
 413   call_user_func([new E, 'foobar']);
 414
 415   call_user_func_array('func2', []);
 416
 417   call_user_func_array('A::static_func2', []);
 418
 419   call_user_func_array(['A', 'static_func2'], []);
 420   call_user_func_array([new A, 'func2'], []);
 421   call_user_func_array([new A, 'static_func2'], []);
 422
 423   $x = 'cmp2'; $y = [2, 1]; usort(inout $y, $x);
 424
 425   $x = 'A::static_cmp2'; $y = [2, 1]; usort(inout $y, $x);
 426
 427
 428   $x = ['A', 'static_cmp2']; $y = [2, 1]; usort(inout $y, $x);
 429
 430   $x = [new A, 'cmp2']; $y = [2, 1]; usort(inout $y, $x);
 431   $x = [new A, 'static_cmp2']; $y = [2, 1]; usort(inout $y, $x);
 432   $x = [new CCmp2, 'foobar']; $y = [2, 1]; usort(inout $y, $x);
 433 }
 434 <<__EntryPoint>> function main(): void {
 435 echo "=============== positive tests =====================\n";
 436 HH\Asio\join(positive_tests());
 437
 438 echo "=============== negative tests =====================\n";
 439 HH\Asio\join(negative_tests());
 440 }