hphp/hack/src/naming/naming_special_names.rs

   1 /*
   2  * Copyright (c) 2015, Facebook, Inc.
   3  * All rights reserved.
   4  *
   5  * This source code is licensed under the MIT license found in the
   6  * LICENSE file in the "hack" directory of this source tree.
   7  *
   8  */
   9
  10 /** Module consisting of the special names known to the typechecker */
  11
  12 pub mod classes {
  13
  14     pub const PARENT: &str = "parent";
  15
  16     pub const STATIC: &str = "static";
  17
  18     pub const SELF: &str = "self";
  19
  20     pub const UNKNOWN: &str = "\\*Unknown*";
  21
  22     /* Used for dynamic classnames, e.g. new $foo(); */
  23
  24     pub const AWAITABLE: &str = "\\HH\\Awaitable";
  25
  26     pub const GENERATOR: &str = "\\Generator";
  27
  28     pub const ASYNC_GENERATOR: &str = "\\HH\\AsyncGenerator";
  29
  30     pub const FORMAT_STRING: &str = "\\FormatString";
  31
  32     pub const HH_FORMAT_STRING: &str = "\\HH\\FormatString";
  33
  34     pub fn is_format_string(x: &str) -> bool {
  35         match x {
  36             FORMAT_STRING | HH_FORMAT_STRING => true,
  37             _ => false,
  38         }
  39     }
  40
  41     pub const HH_BUILTIN_ENUM: &str = "\\HH\\BuiltinEnum";
  42
  43     pub const THROWABLE: &str = "\\Throwable";
  44
  45     pub const STD_CLASS: &str = "\\stdClass";
  46
  47     pub const DATE_TIME: &str = "\\DateTime";
  48
  49     pub const DATE_TIME_IMMUTABLE: &str = "\\DateTimeImmutable";
  50
  51     pub const ASYNC_ITERATOR: &str = "\\HH\\AsyncIterator";
  52
  53     pub const ASYNC_KEYED_ITERATOR: &str = "\\HH\\AsyncKeyedIterator";
  54
  55     pub const STRINGISH: &str = "\\Stringish";
  56
  57     pub const XHP_CHILD: &str = "\\XHPChild";
  58
  59     pub const IMEMOIZE_PARAM: &str = "\\HH\\IMemoizeParam";
  60
  61     pub const CLASS_NAME: &str = "\\HH\\classname";
  62
  63     pub const TYPE_NAME: &str = "\\HH\\typename";
  64
  65     pub const IDISPOSABLE: &str = "\\IDisposable";
  66
  67     pub const IASYNC_DISPOSABLE: &str = "\\IAsyncDisposable";
  68 }
  69
  70 pub mod collections {
  71     /* concrete classes */
  72     pub const VECTOR: &str = "\\HH\\Vector";
  73
  74     pub const IMM_VECTOR: &str = "\\HH\\ImmVector";
  75
  76     pub const SET: &str = "\\HH\\Set";
  77
  78     pub const IMM_SET: &str = "\\HH\\ImmSet";
  79
  80     pub const MAP: &str = "\\HH\\Map";
  81
  82     pub const IMM_MAP: &str = "\\HH\\ImmMap";
  83
  84     pub const PAIR: &str = "\\HH\\Pair";
  85
  86     /* interfaces */
  87     pub const CONTAINER: &str = "\\HH\\Container";
  88
  89     pub const KEYED_CONTAINER: &str = "\\HH\\KeyedContainer";
  90
  91     pub const TRAVERSABLE: &str = "\\HH\\Traversable";
  92
  93     pub const KEYED_TRAVERSABLE: &str = "\\HH\\KeyedTraversable";
  94
  95     pub const COLLECTION: &str = "\\Collection";
  96
  97     pub const CONST_VECTOR: &str = "\\ConstVector";
  98
  99     pub const CONST_MAP: &str = "\\ConstMap";
 100
 101     pub const CONST_COLLECTION: &str = "\\ConstCollection";
 102
 103     pub const DICT: &str = "\\HH\\dict";
 104
 105     pub const VEC: &str = "\\HH\\vec";
 106
 107     pub const KEYSET: &str = "\\HH\\keyset";
 108 }
 109
 110 pub mod members {
 111
 112     use lazy_static::lazy_static;
 113     use std::collections::HashSet;
 114
 115     pub const M_CLASS: &str = "class";
 116
 117     pub const __CONSTRUCT: &str = "__construct";
 118
 119     pub const __DESTRUCT: &str = "__destruct";
 120
 121     pub const __CALL: &str = "__call";
 122
 123     pub const __CALL_STATIC: &str = "__callStatic";
 124
 125     pub const __CLONE: &str = "__clone";
 126
 127     pub const __DEBUG_INFO: &str = "__debugInfo";
 128
 129     pub const __DISPOSE: &str = "__dispose";
 130
 131     pub const __DISPOSE_ASYNC: &str = "__disposeAsync";
 132
 133     pub const __GET: &str = "__get";
 134
 135     pub const __INVOKE: &str = "__invoke";
 136
 137     pub const __ISSET: &str = "__isset";
 138
 139     pub const __SET: &str = "__set";
 140
 141     pub const __SET_STATE: &str = "__set_state";
 142
 143     pub const __SLEEP: &str = "__sleep";
 144
 145     pub const __TO_STRING: &str = "__toString";
 146
 147     pub const __UNSET: &str = "__unset";
 148
 149     pub const __WAKEUP: &str = "__wakeup";
 150
 151     lazy_static! {
 152         static ref AS_SET: HashSet<&'static str> = vec![
 153             __CONSTRUCT,
 154             __DESTRUCT,
 155             __CALL,
 156             __CALL_STATIC,
 157             __CLONE,
 158             __DEBUG_INFO,
 159             __DISPOSE,
 160             __DISPOSE_ASYNC,
 161             __GET,
 162             __INVOKE,
 163             __ISSET,
 164             __SET,
 165             __SET_STATE,
 166             __SLEEP,
 167             __TO_STRING,
 168             __UNSET,
 169             __WAKEUP
 170         ]
 171         .iter()
 172         .cloned()
 173         .collect();
 174         pub static ref AS_LOWERCASE_SET: HashSet<String> = {
 175             AS_SET
 176                 .iter()
 177                 .fold(HashSet::<String>::new(), |mut set, special_name| {
 178                     set.insert(special_name.to_ascii_lowercase());
 179                     set
 180                 })
 181         };
 182     }
 183
 184     /* Any data- or aria- attribute is always valid, even if it is not declared
 185      * for a given XHP element */
 186     pub fn is_special_xhp_attribute(s: &str) -> bool {
 187         s.len() >= 6
 188             && match &s[..6] {
 189                 ":data-" | ":aria-" => true,
 190                 _ => false,
 191             }
 192     }
 193 }
 194
 195 pub mod user_attributes {
 196
 197     use lazy_static::lazy_static;
 198     use std::collections::HashSet;
 199
 200     pub const OVERRIDE: &str = "__Override";
 201
 202     pub const CONSISTENT_CONSTRUCT: &str = "__ConsistentConstruct";
 203
 204     pub const CONST: &str = "__Const";
 205
 206     pub const DEPRECATED: &str = "__Deprecated";
 207
 208     pub const ENTRY_POINT: &str = "__EntryPoint";
 209
 210     pub const MEMOIZE: &str = "__Memoize";
 211
 212     pub const MEMOIZE_LSB: &str = "__MemoizeLSB";
 213
 214     pub const PHP_STD_LIB: &str = "__PHPStdLib";
 215
 216     pub const HIPHOP_SPECIFIC: &str = "__HipHopSpecific";
 217
 218     pub const ACCEPT_DISPOSABLE: &str = "__AcceptDisposable";
 219
 220     pub const RETURN_DISPOSABLE: &str = "__ReturnDisposable";
 221
 222     pub const REACTIVE: &str = "__Rx";
 223
 224     pub const LOCAL_REACTIVE: &str = "__RxLocal";
 225
 226     pub const SHALLOW_REACTIVE: &str = "__RxShallow";
 227
 228     pub const MUTABLE: &str = "__Mutable";
 229
 230     pub const MUTABLE_RETURN: &str = "__MutableReturn";
 231
 232     pub const ONLY_RX_IF_IMPL: &str = "__OnlyRxIfImpl";
 233
 234     pub const PROBABILISTIC_MODEL: &str = "__PPL";
 235
 236     pub const LSB: &str = "__LSB";
 237
 238     pub const AT_MOST_RX_AS_FUNC: &str = "__AtMostRxAsFunc";
 239
 240     pub const AT_MOST_RX_AS_ARGS: &str = "__AtMostRxAsArgs";
 241
 242     pub const SEALED: &str = "__Sealed";
 243
 244     pub const RETURNS_VOID_TO_RX: &str = "__ReturnsVoidToRx";
 245
 246     pub const MAYBE_MUTABLE: &str = "__MaybeMutable";
 247
 248     pub const LATE_INIT: &str = "__LateInit";
 249
 250     pub const OWNED_MUTABLE: &str = "__OwnedMutable";
 251
 252     pub const NON_RX: &str = "__NonRx";
 253
 254     pub const NEWABLE: &str = "__Newable";
 255
 256     pub const ENFORCEABLE: &str = "__Enforceable";
 257
 258     pub const EXPLICIT: &str = "__Explicit";
 259
 260     pub const SOFT: &str = "__Soft";
 261
 262     pub const WARN: &str = "__Warn";
 263
 264     pub const MOCK_CLASS: &str = "__MockClass";
 265
 266     pub const PROVENANCE_SKIP_FRAME: &str = "__ProvenanceSkipFrame";
 267
 268     pub const DYNAMICALLY_CALLABLE: &str = "__DynamicallyCallable";
 269
 270     pub const DYNAMICALLY_CONSTRUCTIBLE: &str = "__DynamicallyConstructible";
 271
 272     pub const REIFIABLE: &str = "__Reifiable";
 273
 274     pub const NEVER_INLINE: &str = "__NEVER_INLINE";
 275
 276     lazy_static! {
 277         static ref AS_SET: HashSet<&'static str> = vec![
 278             OVERRIDE,
 279             CONSISTENT_CONSTRUCT,
 280             CONST,
 281             DEPRECATED,
 282             ENTRY_POINT,
 283             MEMOIZE,
 284             MEMOIZE_LSB,
 285             PHP_STD_LIB,
 286             HIPHOP_SPECIFIC,
 287             ACCEPT_DISPOSABLE,
 288             RETURN_DISPOSABLE,
 289             REACTIVE,
 290             LOCAL_REACTIVE,
 291             MUTABLE,
 292             MUTABLE_RETURN,
 293             SHALLOW_REACTIVE,
 294             ONLY_RX_IF_IMPL,
 295             PROBABILISTIC_MODEL,
 296             LSB,
 297             SEALED,
 298             RETURNS_VOID_TO_RX,
 299             MAYBE_MUTABLE,
 300             LATE_INIT,
 301             AT_MOST_RX_AS_FUNC,
 302             AT_MOST_RX_AS_ARGS,
 303             OWNED_MUTABLE,
 304             NON_RX,
 305             NEWABLE,
 306             ENFORCEABLE,
 307             EXPLICIT,
 308             SOFT,
 309             WARN,
 310             MOCK_CLASS,
 311             PROVENANCE_SKIP_FRAME,
 312             DYNAMICALLY_CALLABLE,
 313             DYNAMICALLY_CONSTRUCTIBLE,
 314             REIFIABLE,
 315             NEVER_INLINE,
 316         ]
 317         .iter()
 318         .cloned()
 319         .collect();
 320     }
 321
 322     pub fn is_memoized(name: &str) -> bool {
 323         name == MEMOIZE || name == MEMOIZE_LSB
 324     }
 325
 326     // TODO(hrust) these should probably be added to the above map/fields, too
 327
 328     pub fn is_native(name: &str) -> bool {
 329         name == "__Native"
 330     }
 331
 332     pub fn is_foldable(name: &str) -> bool {
 333         name == "__IsFoldable"
 334     }
 335
 336     pub fn is_meth_caller(name: &str) -> bool {
 337         name == "__MethCaller"
 338     }
 339 }
 340
 341 pub mod attribute_kinds {
 342     use lazy_static::lazy_static;
 343     use std::collections::HashMap;
 344
 345     pub const CLS: &str = "\\HH\\ClassAttribute";
 346
 347     pub const ENUM: &str = "\\HH\\EnumAttribute";
 348
 349     pub const TYPE_ALIAS: &str = "\\HH\\TypeAliasAttribute";
 350
 351     pub const FN: &str = "\\HH\\FunctionAttribute";
 352
 353     pub const MTHD: &str = "\\HH\\MethodAttribute";
 354
 355     pub const INST_PROPERTY: &str = "\\HH\\InstancePropertyAttribute";
 356
 357     pub const STATIC_PROPERTY: &str = "\\HH\\StaticPropertyAttribute";
 358
 359     pub const PARAMETER: &str = "\\HH\\ParameterAttribute";
 360
 361     pub const TYPE_PARAM: &str = "\\HH\\TypeParameterAttribute";
 362
 363     pub const FILE: &str = "\\HH\\FileAttribute";
 364
 365     pub const TYPE_CONST: &str = "\\HH\\TypeConstantAttribute";
 366
 367     lazy_static! {
 368         pub static ref PLAIN_ENGLISH_MAP: HashMap<&'static str, &'static str> = [
 369             (CLS, "a class"),
 370             (ENUM, "an enum"),
 371             (TYPE_ALIAS, "a typealias"),
 372             (FN, "a function"),
 373             (MTHD, "a method"),
 374             (INST_PROPERTY, "an instance property"),
 375             (STATIC_PROPERTY, "a static property"),
 376             (PARAMETER, "a parameter"),
 377             (TYPE_PARAM, "a type parameter"),
 378             (FILE, "a file"),
 379             (TYPE_CONST, "a type pub constant")
 380         ]
 381         .iter()
 382         .cloned()
 383         .collect();
 384     }
 385 }
 386
 387 /* Tested before \\-prepending name-canonicalization */
 388 pub mod special_functions {
 389     pub const TUPLE: &str = "tuple"; /* pseudo-function */
 390
 391     pub const ECHO: &str = "echo"; /* pseudo-function */
 392
 393     pub const ASSERT_: &str = "assert";
 394
 395     pub const INVARIANT: &str = "invariant";
 396
 397     pub const INVARIANT_VIOLATION: &str = "invariant_violation";
 398
 399     pub const FUN_: &str = "fun";
 400
 401     pub const INST_METH: &str = "inst_meth";
 402
 403     pub const CLASS_METH: &str = "class_meth";
 404
 405     pub const METH_CALLER: &str = "meth_caller";
 406
 407     pub const CALL_USER_FUNC: &str = "call_user_func";
 408
 409     pub const AUTOLOAD: &str = "__autoload";
 410
 411     pub const CLONE: &str = "__clone";
 412 }
 413
 414 pub mod special_idents {
 415     pub const THIS: &str = "$this";
 416
 417     pub const PLACEHOLDER: &str = "$_";
 418
 419     pub const DOLLAR_DOLLAR: &str = "$$";
 420
 421     /* Intentionally using an invalid variable name to ensure it's translated */
 422     pub const TMP_VAR_PREFIX: &str = "__tmp$";
 423
 424     pub fn is_tmp_var(name: &str) -> bool {
 425         name.len() > 6 && &name[..6] == TMP_VAR_PREFIX
 426     }
 427
 428     pub fn assert_tmp_var(name: &str) {
 429         assert!(is_tmp_var(name))
 430     }
 431 }
 432
 433 pub mod pseudo_functions {
 434     use lazy_static::lazy_static;
 435
 436     pub const ISSET: &str = "\\isset";
 437
 438     pub const UNSET: &str = "\\unset";
 439
 440     pub const HH_SHOW: &str = "\\hh_show";
 441
 442     pub const HH_SHOW_ENV: &str = "\\hh_show_env";
 443
 444     pub const HH_LOG_LEVEL: &str = "\\hh_log_level";
 445
 446     pub const HH_FORCE_SOLVE: &str = "\\hh_force_solve";
 447
 448     pub const HH_LOOP_FOREVER: &str = "\\hh_loop_forever";
 449
 450     pub const ASSERT: &str = "\\assert";
 451
 452     pub const ECHO: &str = "\\echo";
 453
 454     pub const EXIT: &str = "\\exit";
 455
 456     pub const DIE: &str = "\\die";
 457
 458     lazy_static! {
 459         pub static ref ALL_PSEUDO_FUNCTIONS: Vec<&'static str> = vec![
 460             ISSET,
 461             UNSET,
 462             HH_SHOW,
 463             HH_SHOW_ENV,
 464             HH_LOG_LEVEL,
 465             HH_FORCE_SOLVE,
 466             HH_LOOP_FOREVER,
 467             ASSERT,
 468             ECHO,
 469             EXIT,
 470             DIE,
 471         ];
 472     }
 473 }
 474
 475 pub mod std_lib_functions {
 476     pub const IS_ARRAY: &str = "\\is_array";
 477
 478     pub const IS_NULL: &str = "\\is_null";
 479
 480     pub const GET_CLASS: &str = "\\get_class";
 481
 482     pub const ARRAY_FILTER: &str = "\\array_filter";
 483
 484     pub const ARRAY_MAP: &str = "\\array_map";
 485
 486     pub const TYPE_STRUCTURE: &str = "\\HH\\type_structure";
 487
 488     pub const MARK_LEGACY_HACK_ARRAY: &str = "\\HH\\mark_legacy_hack_array";
 489 }
 490
 491 pub mod typehints {
 492     use lazy_static::lazy_static;
 493     use std::collections::HashSet;
 494
 495     pub const NULL: &str = "null";
 496
 497     pub const VOID: &str = "void";
 498
 499     pub const RESOURCE: &str = "resource";
 500
 501     pub const NUM: &str = "num";
 502
 503     pub const ARRAYKEY: &str = "arraykey";
 504
 505     pub const NORETURN: &str = "noreturn";
 506
 507     pub const MIXED: &str = "mixed";
 508
 509     pub const NONNULL: &str = "nonnull";
 510
 511     pub const THIS: &str = "this";
 512
 513     pub const DYNAMIC: &str = "dynamic";
 514
 515     pub const NOTHING: &str = "nothing";
 516
 517     pub const INT: &str = "int";
 518
 519     pub const BOOL: &str = "bool";
 520
 521     pub const FLOAT: &str = "float";
 522
 523     pub const STRING: &str = "string";
 524
 525     pub const ARRAY: &str = "array";
 526
 527     pub const DARRAY: &str = "darray";
 528
 529     pub const VARRAY: &str = "varray";
 530
 531     pub const VARRAY_OR_DARRAY: &str = "varray_or_darray";
 532
 533     pub const CALLABLE: &str = "callable";
 534
 535     pub const OBJECT_CAST: &str = "object";
 536
 537     pub const WILDCARD: &str = "_";
 538
 539     lazy_static! {
 540         static ref RESERVED_GLOBAL_NAMES: HashSet<&'static str> = vec![
 541             ARRAY,
 542             CALLABLE,
 543             crate::classes::SELF,
 544             crate::classes::PARENT
 545         ]
 546         .into_iter()
 547         .collect();
 548     }
 549
 550     pub fn is_reserved_global_name(x: &str) -> bool {
 551         RESERVED_GLOBAL_NAMES.contains(x)
 552     }
 553
 554     lazy_static! {
 555         static ref RESERVED_HH_NAMES: HashSet<&'static str> = vec![
 556             VOID, NORETURN, INT, BOOL, FLOAT, NUM, STRING, RESOURCE, MIXED, ARRAY, ARRAYKEY,
 557             DYNAMIC, WILDCARD, NONNULL, NOTHING, THIS
 558         ]
 559         .into_iter()
 560         .collect();
 561     }
 562
 563     pub fn is_reserved_hh_name(x: &str) -> bool {
 564         RESERVED_HH_NAMES.contains(x)
 565     }
 566
 567     // This function checks if this is a namespace of the "(not HH)\\(...)*\\(reserved_name)"
 568     pub fn is_namespace_with_reserved_hh_name(x: &str) -> bool {
 569         // This splits the string into its namespaces
 570         fn unqualify(x: &str) -> (Vec<&str>, &str) {
 571             let mut as_list = x.split("\\").collect::<Vec<&str>>();
 572             // Retain if not empty
 573             as_list.retain(|&split| match split {
 574                 "" => false,
 575                 _ => true,
 576             });
 577             let last_split = match as_list.pop() {
 578                 None => "",
 579                 Some(x) => x,
 580             };
 581
 582             (as_list, last_split)
 583         }
 584
 585         // This returns a bool whether or not the list is just the string "HH"
 586         fn is_hh(qualifier: &Vec<&str>) -> bool {
 587             match qualifier.len() {
 588                 1 => qualifier[0] == "HH",
 589                 _ => false,
 590             }
 591         }
 592         let (qualifier, name) = unqualify(x);
 593         !is_hh(&qualifier) && !qualifier.is_empty() && is_reserved_hh_name(name)
 594     }
 595 }
 596
 597 pub mod pseudo_consts {
 598     use lazy_static::lazy_static;
 599     use std::collections::HashSet;
 600
 601     pub const G__LINE__: &str = "\\__LINE__";
 602
 603     pub const G__CLASS__: &str = "\\__CLASS__";
 604
 605     pub const G__TRAIT__: &str = "\\__TRAIT__";
 606
 607     pub const G__FILE__: &str = "\\__FILE__";
 608
 609     pub const G__DIR__: &str = "\\__DIR__";
 610
 611     pub const G__FUNCTION__: &str = "\\__FUNCTION__";
 612
 613     pub const G__METHOD__: &str = "\\__METHOD__";
 614
 615     pub const G__NAMESPACE__: &str = "\\__NAMESPACE__";
 616
 617     pub const G__COMPILER_FRONTEND__: &str = "\\__COMPILER_FRONTEND__";
 618
 619     pub const G__FUNCTION_CREDENTIAL__: &str = "\\__FUNCTION_CREDENTIAL__";
 620
 621     lazy_static! {
 622         static ref ALL_PSEUDO_CONSTS: Vec<&'static str> = vec![
 623             G__LINE__,
 624             G__CLASS__,
 625             G__TRAIT__,
 626             G__FILE__,
 627             G__DIR__,
 628             G__FUNCTION__,
 629             G__METHOD__,
 630             G__NAMESPACE__,
 631             G__COMPILER_FRONTEND__,
 632             G__FUNCTION_CREDENTIAL__
 633         ];
 634         static ref PSEUDO_SET: HashSet<&'static str> =
 635             { ALL_PSEUDO_CONSTS.iter().cloned().collect() };
 636     }
 637
 638     pub fn is_pseudo_const(x: &str) -> bool {
 639         PSEUDO_SET.contains(x)
 640     }
 641 }
 642
 643 pub mod fb {
 644     pub const ENUM: &str = "\\Enum";
 645
 646     pub const UNCHECKED_ENUM: &str = "\\UncheckedEnum";
 647
 648     pub const IDX: &str = "\\HH\\idx";
 649
 650     pub const TYPE_STRUCTURE: &str = "\\HH\\TypeStructure";
 651
 652     pub const INCORRECT_TYPE: &str = "\\HH\\INCORRECT_TYPE";
 653 }
 654
 655 pub mod hh {
 656     pub const ASIO_VA: &str = "\\HH\\Asio\\va";
 657
 658     pub const LIB_TUPLE_FROM_ASYNC: &str = "\\HH\\Lib\\Tuple\\from_async";
 659
 660     pub const LIB_TUPLE_GEN: &str = "\\HH\\Lib\\Tuple\\gen";
 661
 662     pub const CONTAINS: &str = "\\HH\\Lib\\C\\contains";
 663
 664     pub const CONTAINS_KEY: &str = "\\HH\\Lib\\C\\contains_key";
 665 }
 666
 667 pub mod rx {
 668     pub const FREEZE: &str = "\\HH\\Rx\\freeze";
 669
 670     pub const MUTABLE_: &str = "\\HH\\Rx\\mutable";
 671
 672     pub const TRAVERSABLE: &str = "\\HH\\Rx\\Traversable";
 673
 674     pub const IS_ENABLED: &str = "\\HH\\Rx\\IS_ENABLED";
 675
 676     pub const KEYED_TRAVERSABLE: &str = "\\HH\\Rx\\KeyedTraversable";
 677
 678     pub const ASYNC_ITERATOR: &str = "\\HH\\Rx\\AsyncIterator";
 679
 680     pub const MOVE: &str = "\\HH\\Rx\\move";
 681 }
 682
 683 pub mod shapes {
 684     pub const SHAPES: &str = "\\HH\\Shapes";
 685
 686     pub const IDX: &str = "idx";
 687
 688     pub const AT: &str = "at";
 689
 690     pub const KEY_EXISTS: &str = "keyExists";
 691
 692     pub const REMOVE_KEY: &str = "removeKey";
 693
 694     pub const TO_ARRAY: &str = "toArray";
 695
 696     pub const TO_DICT: &str = "toDict";
 697 }
 698
 699 pub mod superglobals {
 700     use lazy_static::lazy_static;
 701     use std::collections::HashSet;
 702     pub const GLOBALS: &str = "$GLOBALS";
 703
 704     lazy_static! {
 705         static ref SUPERGLOBALS: Vec<&'static str> = vec![
 706             "$_SERVER",
 707             "$_GET",
 708             "$_POST",
 709             "$_FILES",
 710             "$_COOKIE",
 711             "$_REQUEST",
 712             "$_ENV"
 713         ];
 714         static ref SUPERGLOBALS_SET: HashSet<&'static str> = SUPERGLOBALS.iter().cloned().collect();
 715     }
 716     pub fn is_superglobal(x: &str) -> bool {
 717         SUPERGLOBALS_SET.contains(x)
 718     }
 719     pub fn is_any_global(x: &str) -> bool {
 720         is_superglobal(x) || x == GLOBALS
 721     }
 722 }
 723
 724 pub mod ppl_functions {
 725     use lazy_static::lazy_static;
 726     use std::collections::HashSet;
 727     lazy_static! {
 728         static ref ALL_RESERVED: Vec<&'static str> = vec!(
 729             "sample",
 730             "\\sample",
 731             "factor",
 732             "\\factor",
 733             "observe",
 734             "\\observe",
 735             "condition",
 736             "\\condition",
 737             "sample_model",
 738             "\\sample_model"
 739         );
 740         static ref ALL_RESERVED_SET: HashSet<&'static str> = ALL_RESERVED.iter().cloned().collect();
 741     }
 742     pub fn is_reserved(x: &str) -> bool {
 743         ALL_RESERVED_SET.contains(x)
 744     }
 745 }
 746
 747 pub mod regex {
 748     pub const T_PATTERN: &str = "\\HH\\Lib\\Regex\\Pattern";
 749 }
 750
 751 #[cfg(test)]
 752 mod test {
 753     use crate::members::is_special_xhp_attribute;
 754     use crate::members::AS_LOWERCASE_SET;
 755     use crate::special_idents::is_tmp_var;
 756     use crate::typehints::is_namespace_with_reserved_hh_name;
 757
 758     #[test]
 759     fn test_special_idents_is_tmp_var() {
 760         assert!(!is_tmp_var("_tmp$Blah"));
 761         assert!(!is_tmp_var("__tmp$"));
 762
 763         assert!(is_tmp_var("__tmp$Blah"));
 764     }
 765
 766     #[test]
 767     fn test_members_as_lowercase_set() {
 768         assert!(AS_LOWERCASE_SET.contains("__tostring"));
 769         assert!(!AS_LOWERCASE_SET.contains("__toString"));
 770     }
 771
 772     #[test]
 773     fn test_members_is_special_xhp_attribute() {
 774         assert!(is_special_xhp_attribute(":data-blahblah"));
 775         assert!(is_special_xhp_attribute(":aria-blahblah"));
 776
 777         assert!(!is_special_xhp_attribute(":arla-blahblah"));
 778         assert!(!is_special_xhp_attribute(":aria"));
 779     }
 780
 781     #[test]
 782     fn test_typehint_is_namespace_with_reserved_hh_name() {
 783         assert!(!is_namespace_with_reserved_hh_name("HH\\void"));
 784         assert!(!is_namespace_with_reserved_hh_name("void"));
 785         assert!(!is_namespace_with_reserved_hh_name("ReturnType\\Lloyd"));
 786         assert!(!is_namespace_with_reserved_hh_name("Lloyd"));
 787
 788         assert!(is_namespace_with_reserved_hh_name("Anything\\Else\\void"));
 789     }
 790 }