hphp/test/slow/dynamic-calls/func/forbid-notice.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
 166 <<__DynamicallyConstructible>>
 167 class F extends A {
 168 }
 169
 170 async function positive_tests() {
 171   try { $x = 'func'; $x(); } catch (Exception $e) { wrap($e); }
 172   try { $x = 'async_func'; await $x(); } catch (Exception $e) { wrap($e); }
 173   try { $x = 'A::func'; $x(); } catch (Exception $e) { wrap($e); }
 174   try { $x = 'A::static_func'; $x(); } catch (Exception $e) { wrap($e); }
 175   try { $x = 'A::async_func'; await $x(); } catch (Exception $e) { wrap($e); }
 176   try { $x = 'A::static_async_func'; await $x(); } catch (Exception $e) { wrap($e); }
 177
 178   try { $x = ['A', 'func']; $x(); } catch (Exception $e) { wrap($e); }
 179   try { $x = ['A', 'static_func']; $x(); } catch (Exception $e) { wrap($e); }
 180   try { $x = ['A', 'async_func']; await $x(); } catch (Exception $e) { wrap($e); }
 181   try { $x = ['A', 'static_async_func']; await $x(); } catch (Exception $e) { wrap($e); }
 182
 183   try { $x = [new A, 'func']; $x(); } catch (Exception $e) { wrap($e); }
 184   try { $x = [new A, 'static_func']; $x(); } catch (Exception $e) { wrap($e); }
 185   try { $x = [new A, 'async_func']; await $x(); } catch (Exception $e) { wrap($e); }
 186   try { $x = [new A, 'static_async_func']; await $x(); } catch (Exception $e) { wrap($e); }
 187   try { $x = [new C, 'foobar']; $x(); } catch (Exception $e) { wrap($e); }
 188
 189   try { $x = 'A'; $x::static_func(); } catch (Exception $e) { wrap($e); }
 190
 191   try { $x = 'A'; await $x::static_async_func(); } catch (Exception $e) { wrap($e); }
 192
 193
 194   try { $x = 'static_func'; A::$x(); } catch (Exception $e) { wrap($e); }
 195
 196   try { $x = 'static_async_func'; await A::$x(); } catch (Exception $e) { wrap($e); }
 197
 198
 199   A::positive_test1();
 200
 201
 202   try { $x = 'A'; new $x(); } catch (Exception $e) { wrap($e); }
 203   try { $obj = new A; $x = 'func'; $obj->$x(); } catch (Exception $e) { wrap($e); }
 204
 205   try { $obj = new A; $x = 'async_func'; await $obj->$x(); } catch (Exception $e) { wrap($e); }
 206
 207   try { $obj = new C; $x = 'foobar'; $obj->$x(); } catch (Exception $e) { wrap($e); }
 208
 209   try { array_map('func', [true]); } catch (Exception $e) { wrap($e); }
 210   try { array_map('A::func', [true]); } catch (Exception $e) { wrap($e); }
 211   try { array_map('A::static_func', [true]); } catch (Exception $e) { wrap($e); }
 212
 213   try { array_map(['A', 'func'], [true]); } catch (Exception $e) { wrap($e); }
 214   try { array_map(['A', 'static_func'], [true]); } catch (Exception $e) { wrap($e); }
 215
 216   try { array_map([new A, 'func'], [true]); } catch (Exception $e) { wrap($e); }
 217   try { array_map([new A, 'static_func'], [true]); } catch (Exception $e) { wrap($e); }
 218   try { array_map([new C, 'foobar'], [true]); } catch (Exception $e) { wrap($e); }
 219
 220   $x = Vector::fromItems([[]]);
 221   try { $x->map('func'); } catch (Exception $e) { wrap($e); }
 222
 223   try { $x->map('A::static_func'); } catch (Exception $e) { wrap($e); }
 224
 225
 226   try { $x->map(['A', 'static_func']); } catch (Exception $e) { wrap($e); }
 227
 228   try { $x->map([new A, 'func']); } catch (Exception $e) { wrap($e); }
 229   try { $x->map([new A, 'static_func']); } catch (Exception $e) { wrap($e); }
 230   try { $x->map([new C, 'foobar']); } catch (Exception $e) { wrap($e); }
 231
 232   try { call_user_func('func'); } catch (Exception $e) { wrap($e); }
 233
 234   try { call_user_func('A::static_func'); } catch (Exception $e) { wrap($e); }
 235
 236
 237   try { call_user_func(['A', 'static_func']); } catch (Exception $e) { wrap($e); }
 238
 239   try { call_user_func([new A, 'func']); } catch (Exception $e) { wrap($e); }
 240   try { call_user_func([new A, 'static_func']); } catch (Exception $e) { wrap($e); }
 241   try { call_user_func([new C, 'foobar']); } catch (Exception $e) { wrap($e); }
 242
 243   try { call_user_func_array('func', []); } catch (Exception $e) { wrap($e); }
 244
 245   try { call_user_func_array('A::static_func', []); } catch (Exception $e) { wrap($e); }
 246
 247   try { call_user_func_array(['A', 'static_func'], []); } catch (Exception $e) { wrap($e); }
 248   try { call_user_func_array([new A, 'func'], []); } catch (Exception $e) { wrap($e); }
 249   try { call_user_func_array([new A, 'static_func'], []); } catch (Exception $e) { wrap($e); }
 250
 251   try { $x = 'cmp'; $y = [2, 1]; usort(inout $y, $x); } catch (Exception $e) { wrap($e); }
 252
 253   try { $x = 'A::static_cmp'; $y = [2, 1]; usort(inout $y, $x); } catch (Exception $e) { wrap($e); }
 254
 255
 256   try { $x = ['A', 'static_cmp']; $y = [2, 1]; usort(inout $y, $x); } catch (Exception $e) { wrap($e); }
 257
 258   try { $x = [new A, 'cmp']; $y = [2, 1]; usort(inout $y, $x); } catch (Exception $e) { wrap($e); }
 259   try { $x = [new A, 'static_cmp']; $y = [2, 1]; usort(inout $y, $x); } catch (Exception $e) { wrap($e); }
 260   try { $x = [new CCmp, 'foobar']; $y = [2, 1]; usort(inout $y, $x); } catch (Exception $e) { wrap($e); }
 261 }
 262
 263 async function negative_tests() {
 264   func();
 265   count([]);
 266   await async_func();
 267
 268   A::static_func();
 269
 270   await A::static_async_func();
 271
 272   Vector::fromItems([]);
 273
 274   $x = ($k ==> {});
 275   $x(1);
 276
 277   A::negative_test1();
 278
 279   HH\class_meth(A::class, 'static_func')();
 280
 281   new A;
 282   new Vector;
 283
 284   $obj = new A;
 285   $obj->func();
 286
 287   await $obj->async_func();
 288
 289
 290   $obj = new C;
 291   $obj->foobar();
 292
 293   $obj = new Vector;
 294   $obj->firstValue();
 295
 296
 297   array_map($k ==> {}, [true]);
 298   array_map(new Invokable, [true]);
 299
 300   $x = Vector::fromItems([true]);
 301   $x->map($k ==> {});
 302   $x->map(new Invokable);
 303
 304   $x = [2, 1];
 305   usort(inout $x, ($k1, $k2) ==> { return $k1 <=> $k2; });
 306
 307   $x = [2, 1];
 308   usort(inout $x, new InvokableCmp);
 309
 310   $x = 'count'; $x([]);
 311   array_map('count', [[]]);
 312   $x = Vector::fromItems([true]); $x->map('count');
 313   call_user_func('count', []);
 314   call_user_func_array('count', [[]]);
 315
 316   $x = 'HH\Vector::fromItems'; $x([]);
 317   $x = ['HH\Vector', 'fromItems']; $x([]);
 318   $x = [new Vector, 'fromItems']; $x([]);
 319   $x = 'fromItems'; Vector::$x([]);
 320   $x = [new Vector, 'firstValue']; $x();
 321   $x = 'HH\Vector'; $x::fromItems([]);
 322   $obj = new Vector; $x = 'firstValue'; $obj->$x();
 323
 324   array_map('HH\Vector::fromItems', [[]]);
 325   array_map(['HH\Vector', 'fromItems'], [[]]);
 326   array_map([new Vector, 'fromItems'], [[]]);
 327   $x = Vector::fromItems([[]]);
 328   $x->map('HH\Vector::fromItems');
 329   $x->map(['HH\Vector', 'fromItems']);
 330   $x->map([new Vector, 'fromItems']);
 331   call_user_func('HH\Vector::fromItems', []);
 332   call_user_func(['HH\Vector', 'fromItems'], []);
 333   call_user_func([new Vector, 'firstValue']);
 334   call_user_func([new Vector, 'fromItems'], []);
 335   call_user_func_array('HH\Vector::fromItems', [[]]);
 336   call_user_func_array(['HH\Vector', 'fromItems'], [[]]);
 337   call_user_func_array([new Vector, 'firstValue'], []);
 338   call_user_func_array([new Vector, 'fromItems'], [[]]);
 339
 340   $x = 'array_map';
 341   $x('count', []);
 342
 343   $obj = null; $obj?->foobar();
 344
 345   idx('foobar', 'key');
 346
 347   $x = 'func2'; $x();
 348   $x = 'async_func2'; await $x();
 349   $x = 'A::func2'; $x();
 350   $x = 'A::static_func2'; $x();
 351   $x = 'A::async_func2'; await $x();
 352   $x = 'A::static_async_func2'; await $x();
 353
 354   $x = ['A', 'func2']; $x();
 355   $x = ['A', 'static_func2']; $x();
 356   $x = ['A', 'async_func2']; await $x();
 357   $x = ['A', 'static_async_func2']; await $x();
 358
 359   $x = [new A, 'func2']; $x();
 360   $x = [new A, 'static_func2']; $x();
 361   $x = [new A, 'async_func2']; await $x();
 362   $x = [new A, 'static_async_func2']; await $x();
 363   $x = [new E, 'foobar']; $x();
 364
 365   $x = 'A'; $x::static_func2();
 366
 367   $x = 'A'; await $x::static_async_func2();
 368
 369
 370   $x = 'static_func2'; A::$x();
 371
 372   $x = 'static_async_func2'; await A::$x();
 373
 374
 375   $x = 'F'; new $x();
 376   $obj = new A; $x = 'func2'; $obj->$x();
 377
 378   $obj = new A; $x = 'async_func2'; await $obj->$x();
 379
 380   $obj = new E; $x = 'foobar'; $obj->$x();
 381
 382   array_map('func2', [true]);
 383   array_map('A::func2', [true]);
 384   array_map('A::static_func2', [true]);
 385
 386   array_map(['A', 'func2'], [true]);
 387   array_map(['A', 'static_func2'], [true]);
 388
 389   array_map([new A, 'func2'], [true]);
 390   array_map([new A, 'static_func2'], [true]);
 391   array_map([new E, 'foobar'], [true]);
 392
 393   $x = Vector::fromItems([[]]);
 394   $x->map('func2');
 395
 396   $x->map('A::static_func2');
 397
 398
 399   $x->map(['A', 'static_func2']);
 400
 401   $x->map([new A, 'func2']);
 402   $x->map([new A, 'static_func2']);
 403   $x->map([new E, 'foobar']);
 404
 405   call_user_func('func2');
 406
 407   call_user_func('A::static_func2');
 408
 409
 410   call_user_func(['A', 'static_func2']);
 411
 412   call_user_func([new A, 'func2']);
 413   call_user_func([new A, 'static_func2']);
 414   call_user_func([new E, 'foobar']);
 415
 416   call_user_func_array('func2', []);
 417
 418   call_user_func_array('A::static_func2', []);
 419
 420   call_user_func_array(['A', 'static_func2'], []);
 421   call_user_func_array([new A, 'func2'], []);
 422   call_user_func_array([new A, 'static_func2'], []);
 423
 424   $x = 'cmp2'; $y = [2, 1]; usort(inout $y, $x);
 425
 426   $x = 'A::static_cmp2'; $y = [2, 1]; usort(inout $y, $x);
 427
 428
 429   $x = ['A', 'static_cmp2']; $y = [2, 1]; usort(inout $y, $x);
 430
 431   $x = [new A, 'cmp2']; $y = [2, 1]; usort(inout $y, $x);
 432   $x = [new A, 'static_cmp2']; $y = [2, 1]; usort(inout $y, $x);
 433   $x = [new CCmp2, 'foobar']; $y = [2, 1]; usort(inout $y, $x);
 434 }
 435 <<__EntryPoint>>
 436 function main_entry(): void {
 437
 438   echo "=============== positive tests =====================\n";
 439   HH\Asio\join(positive_tests());
 440
 441   echo "=============== negative tests =====================\n";
 442   HH\Asio\join(negative_tests());
 443
 444   set_error_handler(
 445     function ($type, $msg, $file) { throw new Exception($msg); }
 446   );
 447   echo "=============== positive tests (exceptions) ========\n";
 448   HH\Asio\join(positive_tests());
 449 }