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