hphp/hack/src/oxidized_by_ref/gen/aast_defs.rs

   1 // Copyright (c) Facebook, Inc. and its affiliates.
   2 //
   3 // This source code is licensed under the MIT license found in the
   4 // LICENSE file in the "hack" directory of this source tree.
   5 //
   6 // @generated SignedSource<<3ec7f07f10127e2bf99ed4a47d71fd3b>>
   7 //
   8 // To regenerate this file, run:
   9 //   hphp/hack/src/oxidized_regen.sh
  10
  11 use arena_trait::TrivialDrop;
  12 pub use ast_defs::Pos;
  13 pub use ast_defs::PositionedByteString;
  14 pub use ast_defs::Pstring;
  15 pub use local_id::LocalId;
  16 use no_pos_hash::NoPosHash;
  17 use ocamlrep::FromOcamlRepIn;
  18 use ocamlrep::ToOcamlRep;
  19 pub use oxidized::aast_defs::OgNullFlavor;
  20 pub use oxidized::aast_defs::PropOrMethod;
  21 pub use oxidized::aast_defs::ReifyKind;
  22 pub use oxidized::aast_defs::Tprim;
  23 pub use oxidized::aast_defs::TypedefVisibility;
  24 pub use oxidized::aast_defs::Visibility;
  25 use serde::Deserialize;
  26 use serde::Serialize;
  27
  28 #[allow(unused_imports)]
  29 use crate::*;
  30
  31 #[derive(
  32     Clone,
  33     Debug,
  34     Deserialize,
  35     Eq,
  36     FromOcamlRepIn,
  37     Hash,
  38     NoPosHash,
  39     Ord,
  40     PartialEq,
  41     PartialOrd,
  42     Serialize,
  43     ToOcamlRep
  44 )]
  45 #[rust_to_ocaml(and)]
  46 #[repr(C)]
  47 pub struct Lid<'a>(
  48     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Pos<'a>,
  49     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a LocalId<'a>,
  50 );
  51 impl<'a> TrivialDrop for Lid<'a> {}
  52 arena_deserializer::impl_deserialize_in_arena!(Lid<'arena>);
  53
  54 #[rust_to_ocaml(and)]
  55 pub type Sid<'a> = ast_defs::Id<'a>;
  56
  57 #[rust_to_ocaml(and)]
  58 pub type ClassName<'a> = Sid<'a>;
  59
  60 /// Aast.program represents the top-level definitions in a Hack program.
  61 /// ex: Expression annotation type (when typechecking, the inferred type)
  62 /// en: Environment (tracking state inside functions and classes)
  63 #[derive(
  64     Clone,
  65     Copy,
  66     Debug,
  67     Deserialize,
  68     Eq,
  69     FromOcamlRepIn,
  70     Hash,
  71     NoPosHash,
  72     Ord,
  73     PartialEq,
  74     PartialOrd,
  75     Serialize,
  76     ToOcamlRep
  77 )]
  78 #[serde(bound(
  79     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
  80 ))]
  81 #[rust_to_ocaml(and)]
  82 #[repr(C)]
  83 pub struct Program<'a, Ex, En>(
  84     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a [Def<'a, Ex, En>],
  85 );
  86 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Program<'a, Ex, En> {}
  87 arena_deserializer::impl_deserialize_in_arena!(Program<'arena, Ex, En>);
  88
  89 #[derive(
  90     Clone,
  91     Debug,
  92     Deserialize,
  93     Eq,
  94     FromOcamlRepIn,
  95     Hash,
  96     NoPosHash,
  97     Ord,
  98     PartialEq,
  99     PartialOrd,
 100     Serialize,
 101     ToOcamlRep
 102 )]
 103 #[serde(bound(
 104     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
 105 ))]
 106 #[rust_to_ocaml(and)]
 107 #[repr(C)]
 108 pub struct Stmt<'a, Ex, En>(
 109     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Pos<'a>,
 110     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub Stmt_<'a, Ex, En>,
 111 );
 112 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Stmt<'a, Ex, En> {}
 113 arena_deserializer::impl_deserialize_in_arena!(Stmt<'arena, Ex, En>);
 114
 115 #[derive(
 116     Clone,
 117     Copy,
 118     Debug,
 119     Deserialize,
 120     Eq,
 121     FromOcamlRepIn,
 122     Hash,
 123     NoPosHash,
 124     Ord,
 125     PartialEq,
 126     PartialOrd,
 127     Serialize,
 128     ToOcamlRep
 129 )]
 130 #[serde(bound(
 131     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
 132 ))]
 133 #[rust_to_ocaml(and)]
 134 #[repr(C, u8)]
 135 pub enum Stmt_<'a, Ex, En> {
 136     /// Marker for a switch statement that falls through.
 137     ///
 138     ///     // FALLTHROUGH
 139     Fallthrough,
 140     /// Standalone expression.
 141     ///
 142     ///     1 + 2;
 143     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 144     Expr(&'a Expr<'a, Ex, En>),
 145     /// Break inside a loop or switch statement.
 146     ///
 147     ///     break;
 148     Break,
 149     /// Continue inside a loop or switch statement.
 150     ///
 151     ///     continue;
 152     Continue,
 153     /// Throw an exception.
 154     ///
 155     /// throw $foo;
 156     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 157     Throw(&'a Expr<'a, Ex, En>),
 158     /// Return, with an optional value.
 159     ///
 160     ///     return;
 161     ///     return $foo;
 162     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 163     Return(Option<&'a Expr<'a, Ex, En>>),
 164     /// Yield break, terminating the current generator. This behaves like
 165     /// return; but is more explicit, and ensures the function is treated
 166     /// as a generator.
 167     ///
 168     ///     yield break;
 169     #[rust_to_ocaml(name = "Yield_break")]
 170     YieldBreak,
 171     /// Concurrent block. All the await expressions are awaited at the
 172     /// same time, similar to genva().
 173     ///
 174     /// We store the desugared form. In the below example, the list is:
 175     /// [('__tmp$1', f()), (__tmp$2, g()), (None, h())]
 176     /// and the block assigns the temporary variables back to the locals.
 177     /// { $foo = __tmp$1; $bar = __tmp$2; }
 178     ///
 179     ///     concurrent {
 180     ///       $foo = await f();
 181     ///       $bar = await g();
 182     ///       await h();
 183     ///     }
 184     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 185     #[rust_to_ocaml(inline_tuple)]
 186     Awaitall(
 187         &'a (
 188             &'a [(Option<&'a Lid<'a>>, &'a Expr<'a, Ex, En>)],
 189             &'a Block<'a, Ex, En>,
 190         ),
 191     ),
 192     /// If statement.
 193     ///
 194     ///     if ($foo) { ... } else { ... }
 195     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 196     #[rust_to_ocaml(inline_tuple)]
 197     If(
 198         &'a (
 199             &'a Expr<'a, Ex, En>,
 200             &'a Block<'a, Ex, En>,
 201             &'a Block<'a, Ex, En>,
 202         ),
 203     ),
 204     /// Do-while loop.
 205     ///
 206     ///     do {
 207     ///       bar();
 208     ///     } while($foo)
 209     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 210     #[rust_to_ocaml(inline_tuple)]
 211     Do(&'a (&'a Block<'a, Ex, En>, &'a Expr<'a, Ex, En>)),
 212     /// While loop.
 213     ///
 214     ///     while ($foo) {
 215     ///       bar();
 216     ///     }
 217     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 218     #[rust_to_ocaml(inline_tuple)]
 219     While(&'a (&'a Expr<'a, Ex, En>, &'a Block<'a, Ex, En>)),
 220     /// Initialize a value that is automatically disposed of.
 221     ///
 222     ///     using $foo = bar(); // disposed at the end of the function
 223     ///     using ($foo = bar(), $baz = quux()) {} // disposed after the block
 224     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 225     Using(&'a UsingStmt<'a, Ex, En>),
 226     /// For loop. The initializer and increment parts can include
 227     /// multiple comma-separated statements. The termination condition is
 228     /// optional.
 229     ///
 230     ///     for ($i = 0; $i < 100; $i++) { ... }
 231     ///     for ($x = 0, $y = 0; ; $x++, $y++) { ... }
 232     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 233     #[rust_to_ocaml(inline_tuple)]
 234     For(
 235         &'a (
 236             &'a [&'a Expr<'a, Ex, En>],
 237             Option<&'a Expr<'a, Ex, En>>,
 238             &'a [&'a Expr<'a, Ex, En>],
 239             &'a Block<'a, Ex, En>,
 240         ),
 241     ),
 242     /// Switch statement.
 243     ///
 244     ///     switch ($foo) {
 245     ///       case X:
 246     ///         bar();
 247     ///         break;
 248     ///       default:
 249     ///         baz();
 250     ///         break;
 251     ///     }
 252     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 253     #[rust_to_ocaml(inline_tuple)]
 254     Switch(
 255         &'a (
 256             &'a Expr<'a, Ex, En>,
 257             &'a [Case<'a, Ex, En>],
 258             Option<DefaultCase<'a, Ex, En>>,
 259         ),
 260     ),
 261     /// For-each loop.
 262     ///
 263     ///     foreach ($items as $item) { ... }
 264     ///     foreach ($items as $key => value) { ... }
 265     ///     foreach ($items await as $item) { ... } // AsyncIterator<_>
 266     ///     foreach ($items await as $key => value) { ... } // AsyncKeyedIterator<_>
 267     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 268     #[rust_to_ocaml(inline_tuple)]
 269     Foreach(
 270         &'a (
 271             &'a Expr<'a, Ex, En>,
 272             AsExpr<'a, Ex, En>,
 273             &'a Block<'a, Ex, En>,
 274         ),
 275     ),
 276     /// Try statement, with catch blocks and a finally block.
 277     ///
 278     ///     try {
 279     ///       foo();
 280     ///     } catch (SomeException $e) {
 281     ///       bar();
 282     ///     } finally {
 283     ///       baz();
 284     ///     }
 285     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 286     #[rust_to_ocaml(inline_tuple)]
 287     Try(
 288         &'a (
 289             &'a Block<'a, Ex, En>,
 290             &'a [&'a Catch<'a, Ex, En>],
 291             &'a Block<'a, Ex, En>,
 292         ),
 293     ),
 294     /// No-op, the empty statement.
 295     ///
 296     ///     {}
 297     ///     while (true) ;
 298     ///     if ($foo) {} // the else is Noop here
 299     Noop,
 300     /// Block, a list of statements in curly braces.
 301     ///
 302     ///     { $foo = 42; }
 303     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 304     Block(&'a Block<'a, Ex, En>),
 305     /// The mode tag at the beginning of a file.
 306     /// TODO: this really belongs in def.
 307     ///
 308     ///     <?hh
 309     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 310     Markup(&'a Pstring<'a>),
 311     /// Used in IFC to track type inference environments. Not user
 312     /// denotable.
 313     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 314     #[rust_to_ocaml(inline_tuple)]
 315     AssertEnv(
 316         &'a (
 317             &'a oxidized::aast_defs::EnvAnnot,
 318             LocalIdMap<'a, (&'a Pos<'a>, Ex)>,
 319         ),
 320     ),
 321 }
 322 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Stmt_<'a, Ex, En> {}
 323 arena_deserializer::impl_deserialize_in_arena!(Stmt_<'arena, Ex, En>);
 324
 325 pub use oxidized::aast_defs::EnvAnnot;
 326
 327 #[derive(
 328     Clone,
 329     Debug,
 330     Deserialize,
 331     Eq,
 332     FromOcamlRepIn,
 333     Hash,
 334     NoPosHash,
 335     Ord,
 336     PartialEq,
 337     PartialOrd,
 338     Serialize,
 339     ToOcamlRep
 340 )]
 341 #[serde(bound(
 342     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
 343 ))]
 344 #[rust_to_ocaml(and)]
 345 #[rust_to_ocaml(prefix = "us_")]
 346 #[repr(C)]
 347 pub struct UsingStmt<'a, Ex, En> {
 348     pub is_block_scoped: bool,
 349     pub has_await: bool,
 350     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 351     pub exprs: (&'a Pos<'a>, &'a [&'a Expr<'a, Ex, En>]),
 352     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 353     pub block: &'a Block<'a, Ex, En>,
 354 }
 355 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for UsingStmt<'a, Ex, En> {}
 356 arena_deserializer::impl_deserialize_in_arena!(UsingStmt<'arena, Ex, En>);
 357
 358 #[derive(
 359     Clone,
 360     Copy,
 361     Debug,
 362     Deserialize,
 363     Eq,
 364     FromOcamlRepIn,
 365     Hash,
 366     NoPosHash,
 367     Ord,
 368     PartialEq,
 369     PartialOrd,
 370     Serialize,
 371     ToOcamlRep
 372 )]
 373 #[serde(bound(
 374     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
 375 ))]
 376 #[rust_to_ocaml(and)]
 377 #[repr(C, u8)]
 378 pub enum AsExpr<'a, Ex, En> {
 379     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 380     #[rust_to_ocaml(name = "As_v")]
 381     AsV(&'a Expr<'a, Ex, En>),
 382     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 383     #[rust_to_ocaml(name = "As_kv")]
 384     #[rust_to_ocaml(inline_tuple)]
 385     AsKv(&'a (&'a Expr<'a, Ex, En>, &'a Expr<'a, Ex, En>)),
 386     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 387     #[rust_to_ocaml(name = "Await_as_v")]
 388     #[rust_to_ocaml(inline_tuple)]
 389     AwaitAsV(&'a (&'a Pos<'a>, &'a Expr<'a, Ex, En>)),
 390     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 391     #[rust_to_ocaml(name = "Await_as_kv")]
 392     #[rust_to_ocaml(inline_tuple)]
 393     AwaitAsKv(&'a (&'a Pos<'a>, &'a Expr<'a, Ex, En>, &'a Expr<'a, Ex, En>)),
 394 }
 395 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for AsExpr<'a, Ex, En> {}
 396 arena_deserializer::impl_deserialize_in_arena!(AsExpr<'arena, Ex, En>);
 397
 398 #[rust_to_ocaml(and)]
 399 pub type Block<'a, Ex, En> = [&'a Stmt<'a, Ex, En>];
 400
 401 #[derive(
 402     Clone,
 403     Debug,
 404     Deserialize,
 405     Eq,
 406     FromOcamlRepIn,
 407     Hash,
 408     NoPosHash,
 409     Ord,
 410     PartialEq,
 411     PartialOrd,
 412     Serialize,
 413     ToOcamlRep
 414 )]
 415 #[serde(bound(
 416     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
 417 ))]
 418 #[rust_to_ocaml(and)]
 419 #[repr(C)]
 420 pub struct ClassId<'a, Ex, En>(
 421     #[serde(deserialize_with = "arena_deserializer::arena")] pub Ex,
 422     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Pos<'a>,
 423     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub ClassId_<'a, Ex, En>,
 424 );
 425 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for ClassId<'a, Ex, En> {}
 426 arena_deserializer::impl_deserialize_in_arena!(ClassId<'arena, Ex, En>);
 427
 428 /// Class ID, used in things like instantiation and static property access.
 429 #[derive(
 430     Clone,
 431     Copy,
 432     Debug,
 433     Deserialize,
 434     Eq,
 435     FromOcamlRepIn,
 436     Hash,
 437     NoPosHash,
 438     Ord,
 439     PartialEq,
 440     PartialOrd,
 441     Serialize,
 442     ToOcamlRep
 443 )]
 444 #[serde(bound(
 445     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
 446 ))]
 447 #[rust_to_ocaml(and)]
 448 #[repr(C, u8)]
 449 pub enum ClassId_<'a, Ex, En> {
 450     /// The class ID of the parent of the lexically scoped class.
 451     ///
 452     /// In a trait, it is the parent class ID of the using class.
 453     ///
 454     ///     parent::some_meth()
 455     ///     parent::$prop = 1;
 456     ///     new parent();
 457     CIparent,
 458     /// The class ID of the lexically scoped class.
 459     ///
 460     /// In a trait, it is the class ID of the using class.
 461     ///
 462     ///     self::some_meth()
 463     ///     self::$prop = 1;
 464     ///     new self();
 465     CIself,
 466     /// The class ID of the late static bound class.
 467     ///
 468     /// https://www.php.net/manual/en/language.oop5.late-static-bindings.php
 469     ///
 470     /// In a trait, it is the late static bound class ID of the using class.
 471     ///
 472     ///     static::some_meth()
 473     ///     static::$prop = 1;
 474     ///     new static();
 475     CIstatic,
 476     /// Dynamic class name.
 477     ///
 478     /// TODO: Syntactically this can only be an Lvar/This/Lplaceholder.
 479     /// We should use lid rather than expr.
 480     ///
 481     ///     // Assume $d has type dynamic.
 482     ///     $d::some_meth();
 483     ///     $d::$prop = 1;
 484     ///     new $d();
 485     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 486     CIexpr(&'a Expr<'a, Ex, En>),
 487     /// Explicit class name. This is the common case.
 488     ///
 489     ///     Foop::some_meth()
 490     ///     Foo::$prop = 1;
 491     ///     new Foo();
 492     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 493     CI(&'a ClassName<'a>),
 494 }
 495 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for ClassId_<'a, Ex, En> {}
 496 arena_deserializer::impl_deserialize_in_arena!(ClassId_<'arena, Ex, En>);
 497
 498 #[derive(
 499     Clone,
 500     Debug,
 501     Deserialize,
 502     Eq,
 503     FromOcamlRepIn,
 504     Hash,
 505     NoPosHash,
 506     Ord,
 507     PartialEq,
 508     PartialOrd,
 509     Serialize,
 510     ToOcamlRep
 511 )]
 512 #[serde(bound(
 513     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
 514 ))]
 515 #[rust_to_ocaml(and)]
 516 #[repr(C)]
 517 pub struct Expr<'a, Ex, En>(
 518     #[serde(deserialize_with = "arena_deserializer::arena")] pub Ex,
 519     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Pos<'a>,
 520     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub Expr_<'a, Ex, En>,
 521 );
 522 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Expr<'a, Ex, En> {}
 523 arena_deserializer::impl_deserialize_in_arena!(Expr<'arena, Ex, En>);
 524
 525 #[derive(
 526     Clone,
 527     Copy,
 528     Debug,
 529     Deserialize,
 530     Eq,
 531     FromOcamlRepIn,
 532     Hash,
 533     NoPosHash,
 534     Ord,
 535     PartialEq,
 536     PartialOrd,
 537     Serialize,
 538     ToOcamlRep
 539 )]
 540 #[serde(bound(deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>"))]
 541 #[rust_to_ocaml(and)]
 542 #[repr(C, u8)]
 543 pub enum CollectionTarg<'a, Ex> {
 544     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 545     CollectionTV(&'a Targ<'a, Ex>),
 546     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 547     #[rust_to_ocaml(inline_tuple)]
 548     CollectionTKV(&'a (&'a Targ<'a, Ex>, &'a Targ<'a, Ex>)),
 549 }
 550 impl<'a, Ex: TrivialDrop> TrivialDrop for CollectionTarg<'a, Ex> {}
 551 arena_deserializer::impl_deserialize_in_arena!(CollectionTarg<'arena, Ex>);
 552
 553 #[derive(
 554     Clone,
 555     Copy,
 556     Debug,
 557     Deserialize,
 558     Eq,
 559     FromOcamlRepIn,
 560     Hash,
 561     NoPosHash,
 562     Ord,
 563     PartialEq,
 564     PartialOrd,
 565     Serialize,
 566     ToOcamlRep
 567 )]
 568 #[serde(bound(
 569     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
 570 ))]
 571 #[rust_to_ocaml(and)]
 572 #[repr(C, u8)]
 573 pub enum FunctionPtrId<'a, Ex, En> {
 574     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 575     #[rust_to_ocaml(name = "FP_id")]
 576     FPId(&'a Sid<'a>),
 577     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 578     #[rust_to_ocaml(name = "FP_class_const")]
 579     #[rust_to_ocaml(inline_tuple)]
 580     FPClassConst(&'a (&'a ClassId<'a, Ex, En>, &'a Pstring<'a>)),
 581 }
 582 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for FunctionPtrId<'a, Ex, En> {}
 583 arena_deserializer::impl_deserialize_in_arena!(FunctionPtrId<'arena, Ex, En>);
 584
 585 /// An expression tree literal consists of a hint, splices, and
 586 ///  expressions. Consider this example:
 587 ///
 588 ///     Foo`1 + ${$x} + ${bar()}`
 589 #[derive(
 590     Clone,
 591     Debug,
 592     Deserialize,
 593     Eq,
 594     FromOcamlRepIn,
 595     Hash,
 596     NoPosHash,
 597     Ord,
 598     PartialEq,
 599     PartialOrd,
 600     Serialize,
 601     ToOcamlRep
 602 )]
 603 #[serde(bound(
 604     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
 605 ))]
 606 #[rust_to_ocaml(and)]
 607 #[rust_to_ocaml(prefix = "et_")]
 608 #[repr(C)]
 609 pub struct ExpressionTree<'a, Ex, En> {
 610     /// The hint before the backtick, so Foo in this example.
 611     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 612     pub hint: &'a Hint<'a>,
 613     /// The values spliced into expression tree at runtime are assigned
 614     /// to temporaries.
 615     ///
 616     ///     $0tmp1 = $x; $0tmp2 = bar();
 617     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 618     pub splices: &'a [&'a Stmt<'a, Ex, En>],
 619     /// The list of global functions and static methods assigned to
 620     /// temporaries.
 621     ///
 622     ///     $0fp1 = foo<>;
 623     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 624     pub function_pointers: &'a [&'a Stmt<'a, Ex, En>],
 625     /// The expression that gets type checked.
 626     ///
 627     ///     1 + $0tmp1 + $0tmp2
 628     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 629     pub virtualized_expr: &'a Expr<'a, Ex, En>,
 630     /// The expression that's executed at runtime.
 631     ///
 632     ///     Foo::makeTree($v ==> $v->visitBinOp(...))
 633     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 634     pub runtime_expr: &'a Expr<'a, Ex, En>,
 635     /// Position of the first $$ in a splice that refers
 636     /// to a variable outside the Expression Tree
 637     ///
 638     ///     $x |> Code`${ $$ }` // Pos of the $$
 639     ///     Code`${ $x |> foo($$) }` // None
 640     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 641     pub dollardollar_pos: Option<&'a Pos<'a>>,
 642 }
 643 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for ExpressionTree<'a, Ex, En> {}
 644 arena_deserializer::impl_deserialize_in_arena!(ExpressionTree<'arena, Ex, En>);
 645
 646 #[derive(
 647     Clone,
 648     Copy,
 649     Debug,
 650     Deserialize,
 651     Eq,
 652     FromOcamlRepIn,
 653     Hash,
 654     NoPosHash,
 655     Ord,
 656     PartialEq,
 657     PartialOrd,
 658     Serialize,
 659     ToOcamlRep
 660 )]
 661 #[serde(bound(
 662     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
 663 ))]
 664 #[rust_to_ocaml(and)]
 665 #[repr(C, u8)]
 666 pub enum Expr_<'a, Ex, En> {
 667     /// darray literal.
 668     ///
 669     ///     darray['x' => 0, 'y' => 1]
 670     ///     darray<string, int>['x' => 0, 'y' => 1]
 671     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 672     #[rust_to_ocaml(inline_tuple)]
 673     Darray(
 674         &'a (
 675             Option<&'a (&'a Targ<'a, Ex>, &'a Targ<'a, Ex>)>,
 676             &'a [(&'a Expr<'a, Ex, En>, &'a Expr<'a, Ex, En>)],
 677         ),
 678     ),
 679     /// varray literal.
 680     ///
 681     ///     varray['hello', 'world']
 682     ///     varray<string>['hello', 'world']
 683     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 684     #[rust_to_ocaml(inline_tuple)]
 685     Varray(&'a (Option<&'a Targ<'a, Ex>>, &'a [&'a Expr<'a, Ex, En>])),
 686     /// Shape literal.
 687     ///
 688     ///     shape('x' => 1, 'y' => 2)
 689     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 690     Shape(&'a [(ast_defs::ShapeFieldName<'a>, &'a Expr<'a, Ex, En>)]),
 691     /// Collection literal for indexable structures.
 692     ///
 693     ///     Vector {1, 2}
 694     ///     ImmVector {}
 695     ///     Set<string> {'foo', 'bar'}
 696     ///     vec[1, 2]
 697     ///     keyset[]
 698     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 699     #[rust_to_ocaml(inline_tuple)]
 700     ValCollection(
 701         &'a (
 702             oxidized::aast_defs::VcKind,
 703             Option<&'a Targ<'a, Ex>>,
 704             &'a [&'a Expr<'a, Ex, En>],
 705         ),
 706     ),
 707     /// Collection literal for key-value structures.
 708     ///
 709     ///     dict['x' => 1, 'y' => 2]
 710     ///     Map<int, string> {}
 711     ///     ImmMap {}
 712     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 713     #[rust_to_ocaml(inline_tuple)]
 714     KeyValCollection(
 715         &'a (
 716             oxidized::aast_defs::KvcKind,
 717             Option<&'a (&'a Targ<'a, Ex>, &'a Targ<'a, Ex>)>,
 718             &'a [&'a Field<'a, Ex, En>],
 719         ),
 720     ),
 721     /// Null literal.
 722     ///
 723     ///     null
 724     Null,
 725     /// The local variable representing the current class instance.
 726     ///
 727     ///     $this
 728     This,
 729     /// Boolean literal.
 730     ///
 731     ///     true
 732     True,
 733     /// Boolean literal.
 734     ///
 735     ///     false
 736     False,
 737     /// The empty expression.
 738     ///
 739     ///     list(, $y) = vec[1, 2] // Omitted is the first expression inside list()
 740     Omitted,
 741     /// An identifier. Used for method names and global constants.
 742     ///
 743     ///     SOME_CONST
 744     ///     $x->foo() // id: "foo"
 745     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 746     Id(&'a Sid<'a>),
 747     /// Local variable.
 748     ///
 749     ///     $foo
 750     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 751     Lvar(&'a Lid<'a>),
 752     /// The extra variable in a pipe expression.
 753     ///
 754     ///     $$
 755     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 756     Dollardollar(&'a Lid<'a>),
 757     /// Clone expression.
 758     ///
 759     ///     clone $foo
 760     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 761     Clone(&'a Expr<'a, Ex, En>),
 762     /// Array indexing.
 763     ///
 764     ///     $foo[]
 765     ///     $foo[$bar]
 766     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 767     #[rust_to_ocaml(name = "Array_get")]
 768     #[rust_to_ocaml(inline_tuple)]
 769     ArrayGet(&'a (&'a Expr<'a, Ex, En>, Option<&'a Expr<'a, Ex, En>>)),
 770     /// Instance property or method access.
 771     ///
 772     /// prop_or_method is:
 773     ///   - Is_prop for property access
 774     ///   - Is_method for method call, only possible when the node is
 775     ///   - the receiver in a Call node.
 776     ///
 777     ///     $foo->bar      // OG_nullthrows, Is_prop: access named property
 778     ///     ($foo->bar)()  // OG_nullthrows, Is_prop: call lambda stored in named property
 779     ///     $foo?->bar     // OG_nullsafe,   Is_prop
 780     ///     ($foo?->bar)() // OG_nullsafe,   Is_prop
 781     ///
 782     ///     $foo->bar()    // OG_nullthrows, Is_method: call named method
 783     ///     $foo->$bar()   // OG_nullthrows, Is_method: dynamic call, method name stored in local $bar
 784     ///     $foo?->bar()   // OG_nullsafe,   Is_method
 785     ///     $foo?->$bar()  // OG_nullsafe,   Is_method
 786     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 787     #[rust_to_ocaml(name = "Obj_get")]
 788     #[rust_to_ocaml(inline_tuple)]
 789     ObjGet(
 790         &'a (
 791             &'a Expr<'a, Ex, En>,
 792             &'a Expr<'a, Ex, En>,
 793             &'a oxidized::aast_defs::OgNullFlavor,
 794             &'a oxidized::aast_defs::PropOrMethod,
 795         ),
 796     ),
 797     /// Static property or dynamic method access. The rhs of the :: begins
 798     /// with $ or is some non-name expression appearing within braces {}.
 799     ///
 800     ///     Foo::$bar               // Is_prop: access named static property
 801     ///     Foo::{$bar}             // Is_prop
 802     ///     (Foo::$bar)();          // Is_prop: call lambda stored in static property Foo::$bar
 803     ///     $classname::$bar        // Is_prop
 804     ///
 805     ///     Foo::$bar();            // Is_method: dynamic call, method name stored in local $bar
 806     ///     Foo::{$bar}();          // Is_method
 807     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 808     #[rust_to_ocaml(name = "Class_get")]
 809     #[rust_to_ocaml(inline_tuple)]
 810     ClassGet(
 811         &'a (
 812             &'a ClassId<'a, Ex, En>,
 813             ClassGetExpr<'a, Ex, En>,
 814             &'a oxidized::aast_defs::PropOrMethod,
 815         ),
 816     ),
 817     /// Class constant or static method call. As a standalone expression,
 818     /// this is a class constant. Inside a Call node, this is a static
 819     /// method call. The rhs of the :: does not begin with $ or is a name
 820     /// appearing within braces {}.
 821     ///
 822     /// This is not ambiguous, because constants are not allowed to
 823     /// contain functions.
 824     ///
 825     ///     Foo::some_const            // Const
 826     ///     Foo::{another_const}       // Const: braces are elided
 827     ///     Foo::class                 // Const: fully qualified class name of Foo
 828     ///     Foo::staticMeth()          // Call
 829     ///     $classname::staticMeth()   // Call
 830     ///
 831     /// This syntax is used for both static and instance methods when
 832     /// calling the implementation on the superclass.
 833     ///
 834     ///     parent::someStaticMeth()
 835     ///     parent::someInstanceMeth()
 836     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 837     #[rust_to_ocaml(name = "Class_const")]
 838     #[rust_to_ocaml(inline_tuple)]
 839     ClassConst(&'a (&'a ClassId<'a, Ex, En>, &'a Pstring<'a>)),
 840     /// Function or method call.
 841     ///
 842     ///     foo()
 843     ///     $x()
 844     ///     foo<int>(1, 2, ...$rest)
 845     ///     $x->foo()
 846     ///     bar(inout $x);
 847     ///     foobar(inout $x[0])
 848     ///
 849     ///     async { return 1; }
 850     ///     // lowered to:
 851     ///     (async () ==> { return 1; })()
 852     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 853     #[rust_to_ocaml(inline_tuple)]
 854     Call(
 855         &'a (
 856             &'a Expr<'a, Ex, En>,
 857             &'a [&'a Targ<'a, Ex>],
 858             &'a [(ast_defs::ParamKind<'a>, &'a Expr<'a, Ex, En>)],
 859             Option<&'a Expr<'a, Ex, En>>,
 860         ),
 861     ),
 862     /// A reference to a function or method.
 863     ///
 864     ///     foo_fun<>
 865     ///     FooCls::meth<int>
 866     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 867     #[rust_to_ocaml(inline_tuple)]
 868     FunctionPointer(&'a (FunctionPtrId<'a, Ex, En>, &'a [&'a Targ<'a, Ex>])),
 869     /// Integer literal.
 870     ///
 871     ///     42
 872     ///     0123 // octal
 873     ///     0xBEEF // hexadecimal
 874     ///     0b11111111 // binary
 875     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 876     Int(&'a str),
 877     /// Float literal.
 878     ///
 879     ///     1.0
 880     ///     1.2e3
 881     ///     7E-10
 882     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 883     Float(&'a str),
 884     /// String literal.
 885     ///
 886     ///     "foo"
 887     ///     'foo'
 888     ///
 889     ///     <<<DOC
 890     ///     foo
 891     ///     DOC
 892     ///
 893     ///     <<<'DOC'
 894     ///     foo
 895     ///     DOC
 896     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 897     String(&'a bstr::BStr),
 898     /// Interpolated string literal.
 899     ///
 900     ///     "hello $foo $bar"
 901     ///
 902     ///     <<<DOC
 903     ///     hello $foo $bar
 904     ///     DOC
 905     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 906     String2(&'a [&'a Expr<'a, Ex, En>]),
 907     /// Prefixed string literal. Only used for regular expressions.
 908     ///
 909     ///     re"foo"
 910     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 911     #[rust_to_ocaml(inline_tuple)]
 912     PrefixedString(&'a (&'a str, &'a Expr<'a, Ex, En>)),
 913     /// Yield expression. The enclosing function should have an Iterator
 914     /// return type.
 915     ///
 916     ///     yield $foo // enclosing function returns an Iterator
 917     ///     yield $foo => $bar // enclosing function returns a KeyedIterator
 918     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 919     Yield(&'a Afield<'a, Ex, En>),
 920     /// Await expression.
 921     ///
 922     ///     await $foo
 923     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 924     Await(&'a Expr<'a, Ex, En>),
 925     /// Readonly expression.
 926     ///
 927     ///     readonly $foo
 928     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 929     ReadonlyExpr(&'a Expr<'a, Ex, En>),
 930     /// Tuple expression.
 931     ///
 932     ///     tuple("a", 1, $foo)
 933     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 934     Tuple(&'a [&'a Expr<'a, Ex, En>]),
 935     /// List expression, only used in destructuring. Allows any arbitrary
 936     /// lvalue as a subexpression. May also nest.
 937     ///
 938     ///     list($x, $y) = vec[1, 2];
 939     ///     list(, $y) = vec[1, 2]; // skipping items
 940     ///     list(list($x)) = vec[vec[1]]; // nesting
 941     ///     list($v[0], $x[], $y->foo) = $blah;
 942     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 943     List(&'a [&'a Expr<'a, Ex, En>]),
 944     /// Cast expression, converting a value to a different type. Only
 945     /// primitive types are supported in the hint position.
 946     ///
 947     ///     (int)$foo
 948     ///     (string)$foo
 949     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 950     #[rust_to_ocaml(inline_tuple)]
 951     Cast(&'a (&'a Hint<'a>, &'a Expr<'a, Ex, En>)),
 952     /// Unary operator.
 953     ///
 954     ///     !$foo
 955     ///     -$foo
 956     ///     +$foo
 957     ///     $foo++
 958     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 959     #[rust_to_ocaml(inline_tuple)]
 960     Unop(&'a (oxidized::ast_defs::Uop, &'a Expr<'a, Ex, En>)),
 961     /// Binary operator.
 962     ///
 963     ///     $foo + $bar
 964     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 965     #[rust_to_ocaml(inline_tuple)]
 966     Binop(
 967         &'a (
 968             ast_defs::Bop<'a>,
 969             &'a Expr<'a, Ex, En>,
 970             &'a Expr<'a, Ex, En>,
 971         ),
 972     ),
 973     /// Pipe expression. The lid is the ID of the $$ that is implicitly
 974     /// declared by this pipe.
 975     ///
 976     /// See also Dollardollar.
 977     ///
 978     ///     foo() |> bar(1, $$) // equivalent: bar(1, foo())
 979     ///
 980     /// $$ is not required on the RHS of pipe expressions, but it's
 981     /// pretty pointless to use pipes without $$.
 982     ///
 983     ///     foo() |> bar(); // equivalent: foo(); bar();
 984     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 985     #[rust_to_ocaml(inline_tuple)]
 986     Pipe(&'a (&'a Lid<'a>, &'a Expr<'a, Ex, En>, &'a Expr<'a, Ex, En>)),
 987     /// Ternary operator, or elvis operator.
 988     ///
 989     ///     $foo ? $bar : $baz // ternary
 990     ///     $foo ?: $baz // elvis
 991     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
 992     #[rust_to_ocaml(inline_tuple)]
 993     Eif(
 994         &'a (
 995             &'a Expr<'a, Ex, En>,
 996             Option<&'a Expr<'a, Ex, En>>,
 997             &'a Expr<'a, Ex, En>,
 998         ),
 999     ),
1000     /// Is operator.
1001     ///
1002     ///     $foo is SomeType
1003     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1004     #[rust_to_ocaml(inline_tuple)]
1005     Is(&'a (&'a Expr<'a, Ex, En>, &'a Hint<'a>)),
1006     /// As operator.
1007     ///
1008     ///     $foo as int
1009     ///     $foo ?as int
1010     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1011     #[rust_to_ocaml(inline_tuple)]
1012     As(&'a (&'a Expr<'a, Ex, En>, &'a Hint<'a>, bool)),
1013     /// Upcast operator.
1014     ///
1015     ///     $foo : int
1016     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1017     #[rust_to_ocaml(inline_tuple)]
1018     Upcast(&'a (&'a Expr<'a, Ex, En>, &'a Hint<'a>)),
1019     /// Instantiation.
1020     ///
1021     ///     new Foo(1, 2);
1022     ///     new Foo<int, T>();
1023     ///     new Foo('blah', ...$rest);
1024     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1025     #[rust_to_ocaml(inline_tuple)]
1026     New(
1027         &'a (
1028             &'a ClassId<'a, Ex, En>,
1029             &'a [&'a Targ<'a, Ex>],
1030             &'a [&'a Expr<'a, Ex, En>],
1031             Option<&'a Expr<'a, Ex, En>>,
1032             Ex,
1033         ),
1034     ),
1035     /// PHP-style lambda. Does not capture variables unless explicitly
1036     /// specified.
1037     ///
1038     /// Mnemonic: 'expanded lambda', since we can desugar Lfun to Efun.
1039     ///
1040     ///     function($x) { return $x; }
1041     ///     function(int $x): int { return $x; }
1042     ///     function($x) use ($y) { return $y; }
1043     ///     function($x): int use ($y, $z) { return $x + $y + $z; }
1044     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1045     #[rust_to_ocaml(inline_tuple)]
1046     Efun(&'a (&'a Fun_<'a, Ex, En>, &'a [&'a Lid<'a>])),
1047     /// Hack lambda. Captures variables automatically.
1048     ///
1049     ///     $x ==> $x
1050     ///     (int $x): int ==> $x + $other
1051     ///     ($x, $y) ==> { return $x + $y; }
1052     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1053     #[rust_to_ocaml(inline_tuple)]
1054     Lfun(&'a (&'a Fun_<'a, Ex, En>, &'a [&'a Lid<'a>])),
1055     /// XHP expression. May contain interpolated expressions.
1056     ///
1057     ///     <foo x="hello" y={$foo}>hello {$bar}</foo>
1058     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1059     #[rust_to_ocaml(inline_tuple)]
1060     Xml(
1061         &'a (
1062             &'a ClassName<'a>,
1063             &'a [XhpAttribute<'a, Ex, En>],
1064             &'a [&'a Expr<'a, Ex, En>],
1065         ),
1066     ),
1067     /// Include or require expression.
1068     ///
1069     ///     require('foo.php')
1070     ///     require_once('foo.php')
1071     ///     include('foo.php')
1072     ///     include_once('foo.php')
1073     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1074     #[rust_to_ocaml(inline_tuple)]
1075     Import(&'a (oxidized::aast_defs::ImportFlavor, &'a Expr<'a, Ex, En>)),
1076     /// Collection literal.
1077     ///
1078     /// TODO: T38184446 this is redundant with ValCollection/KeyValCollection.
1079     ///
1080     ///     Vector {}
1081     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1082     #[rust_to_ocaml(inline_tuple)]
1083     Collection(
1084         &'a (
1085             &'a ClassName<'a>,
1086             Option<CollectionTarg<'a, Ex>>,
1087             &'a [Afield<'a, Ex, En>],
1088         ),
1089     ),
1090     /// Expression tree literal. Expression trees are not evaluated at
1091     /// runtime, but desugared to an expression representing the code.
1092     ///
1093     ///     Foo`1 + bar()`
1094     ///     Foo`(() ==> { while(true) {} })()` // not an infinite loop at runtime
1095     ///
1096     /// Splices are evaluated as normal Hack code. The following two expression trees
1097     /// are equivalent. See also `ET_Splice`.
1098     ///
1099     ///     Foo`1 + ${do_stuff()}`
1100     ///
1101     ///     $x = do_stuff();
1102     ///     Foo`1 + ${$x}`
1103     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1104     ExpressionTree(&'a ExpressionTree<'a, Ex, En>),
1105     /// Placeholder local variable.
1106     ///
1107     ///     $_
1108     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1109     Lplaceholder(&'a Pos<'a>),
1110     /// Global function reference.
1111     ///
1112     ///     fun('foo')
1113     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1114     #[rust_to_ocaml(name = "Fun_id")]
1115     FunId(&'a Sid<'a>),
1116     /// Instance method reference on a specific instance.
1117     ///
1118     /// TODO: This is only created in naming, and ought to happen in
1119     /// lowering or be removed. The emitter just sees a normal Call.
1120     ///
1121     ///     inst_meth($f, 'some_meth') // equivalent: $f->some_meth<>
1122     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1123     #[rust_to_ocaml(name = "Method_id")]
1124     #[rust_to_ocaml(inline_tuple)]
1125     MethodId(&'a (&'a Expr<'a, Ex, En>, &'a Pstring<'a>)),
1126     /// Instance method reference that can be called with an instance.
1127     ///
1128     ///     meth_caller(FooClass::class, 'some_meth')
1129     ///     meth_caller('FooClass', 'some_meth')
1130     ///
1131     /// These examples are equivalent to:
1132     ///
1133     ///     (FooClass $f, ...$args) ==> $f->some_meth(...$args)
1134     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1135     #[rust_to_ocaml(name = "Method_caller")]
1136     #[rust_to_ocaml(inline_tuple)]
1137     MethodCaller(&'a (&'a ClassName<'a>, &'a Pstring<'a>)),
1138     /// Static method reference.
1139     ///
1140     ///     class_meth('FooClass', 'some_static_meth')
1141     ///     // equivalent: FooClass::some_static_meth<>
1142     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1143     #[rust_to_ocaml(name = "Smethod_id")]
1144     #[rust_to_ocaml(inline_tuple)]
1145     SmethodId(&'a (&'a ClassId<'a, Ex, En>, &'a Pstring<'a>)),
1146     /// Pair literal.
1147     ///
1148     ///     Pair {$foo, $bar}
1149     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1150     #[rust_to_ocaml(inline_tuple)]
1151     Pair(
1152         &'a (
1153             Option<&'a (&'a Targ<'a, Ex>, &'a Targ<'a, Ex>)>,
1154             &'a Expr<'a, Ex, En>,
1155             &'a Expr<'a, Ex, En>,
1156         ),
1157     ),
1158     /// Expression tree splice expression. Only valid inside an
1159     /// expression tree literal (backticks). See also `ExpressionTree`.
1160     ///
1161     ///     ${$foo}
1162     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1163     #[rust_to_ocaml(name = "ET_Splice")]
1164     ETSplice(&'a Expr<'a, Ex, En>),
1165     /// Label used for enum classes.
1166     ///
1167     ///     enum_name#label_name or #label_name
1168     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1169     #[rust_to_ocaml(inline_tuple)]
1170     EnumClassLabel(&'a (Option<&'a ClassName<'a>>, &'a str)),
1171     /// Annotation used to record failure in subtyping or coercion of an
1172     /// expression and calls to [unsafe_cast] or [enforced_cast].
1173     ///
1174     /// The [hole_source] indicates whether this came from an
1175     /// explicit call to [unsafe_cast] or [enforced_cast] or was
1176     /// generated during typing.
1177     ///
1178     /// Given a call to [unsafe_cast]:
1179     /// ```
1180     /// function f(int $x): void { /* ... */ }
1181     ///
1182     /// function g(float $x): void {
1183     ///    f(unsafe_cast<float,int>($x));
1184     /// }
1185     /// ```
1186     /// After typing, this is represented by the following TAST fragment
1187     /// ```
1188     /// Call
1189     ///   ( ( (..., function(int $x): void), Id (..., "\f"))
1190     ///   , []
1191     ///   , [ ( (..., int)
1192     ///       , Hole
1193     ///           ( ((..., float), Lvar (..., $x))
1194     ///           , float
1195     ///           , int
1196     ///           , UnsafeCast
1197     ///           )
1198     ///       )
1199     ///     ]
1200     ///   , None
1201     ///   )
1202     /// ```
1203     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1204     #[rust_to_ocaml(inline_tuple)]
1205     Hole(&'a (&'a Expr<'a, Ex, En>, Ex, Ex, HoleSource<'a>)),
1206 }
1207 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Expr_<'a, Ex, En> {}
1208 arena_deserializer::impl_deserialize_in_arena!(Expr_<'arena, Ex, En>);
1209
1210 #[derive(
1211     Clone,
1212     Copy,
1213     Debug,
1214     Deserialize,
1215     Eq,
1216     FromOcamlRepIn,
1217     Hash,
1218     NoPosHash,
1219     Ord,
1220     PartialEq,
1221     PartialOrd,
1222     Serialize,
1223     ToOcamlRep
1224 )]
1225 #[rust_to_ocaml(and)]
1226 #[repr(C, u8)]
1227 pub enum HoleSource<'a> {
1228     Typing,
1229     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1230     UnsafeCast(&'a [&'a Hint<'a>]),
1231     UnsafeNonnullCast,
1232     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1233     EnforcedCast(&'a [&'a Hint<'a>]),
1234 }
1235 impl<'a> TrivialDrop for HoleSource<'a> {}
1236 arena_deserializer::impl_deserialize_in_arena!(HoleSource<'arena>);
1237
1238 #[derive(
1239     Clone,
1240     Copy,
1241     Debug,
1242     Deserialize,
1243     Eq,
1244     FromOcamlRepIn,
1245     Hash,
1246     NoPosHash,
1247     Ord,
1248     PartialEq,
1249     PartialOrd,
1250     Serialize,
1251     ToOcamlRep
1252 )]
1253 #[serde(bound(
1254     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1255 ))]
1256 #[rust_to_ocaml(and)]
1257 #[repr(C, u8)]
1258 pub enum ClassGetExpr<'a, Ex, En> {
1259     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1260     CGstring(&'a Pstring<'a>),
1261     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1262     CGexpr(&'a Expr<'a, Ex, En>),
1263 }
1264 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for ClassGetExpr<'a, Ex, En> {}
1265 arena_deserializer::impl_deserialize_in_arena!(ClassGetExpr<'arena, Ex, En>);
1266
1267 #[derive(
1268     Clone,
1269     Copy,
1270     Debug,
1271     Deserialize,
1272     Eq,
1273     FromOcamlRepIn,
1274     Hash,
1275     NoPosHash,
1276     Ord,
1277     PartialEq,
1278     PartialOrd,
1279     Serialize,
1280     ToOcamlRep
1281 )]
1282 #[serde(bound(
1283     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1284 ))]
1285 #[rust_to_ocaml(and)]
1286 #[repr(C)]
1287 pub struct Case<'a, Ex, En>(
1288     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Expr<'a, Ex, En>,
1289     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Block<'a, Ex, En>,
1290 );
1291 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Case<'a, Ex, En> {}
1292 arena_deserializer::impl_deserialize_in_arena!(Case<'arena, Ex, En>);
1293
1294 #[derive(
1295     Clone,
1296     Copy,
1297     Debug,
1298     Deserialize,
1299     Eq,
1300     FromOcamlRepIn,
1301     Hash,
1302     NoPosHash,
1303     Ord,
1304     PartialEq,
1305     PartialOrd,
1306     Serialize,
1307     ToOcamlRep
1308 )]
1309 #[serde(bound(
1310     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1311 ))]
1312 #[rust_to_ocaml(and)]
1313 #[repr(C)]
1314 pub struct DefaultCase<'a, Ex, En>(
1315     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Pos<'a>,
1316     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Block<'a, Ex, En>,
1317 );
1318 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for DefaultCase<'a, Ex, En> {}
1319 arena_deserializer::impl_deserialize_in_arena!(DefaultCase<'arena, Ex, En>);
1320
1321 #[derive(
1322     Clone,
1323     Copy,
1324     Debug,
1325     Deserialize,
1326     Eq,
1327     FromOcamlRepIn,
1328     Hash,
1329     NoPosHash,
1330     Ord,
1331     PartialEq,
1332     PartialOrd,
1333     Serialize,
1334     ToOcamlRep
1335 )]
1336 #[serde(bound(
1337     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1338 ))]
1339 #[rust_to_ocaml(and)]
1340 #[repr(C, u8)]
1341 pub enum GenCase<'a, Ex, En> {
1342     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1343     Case(&'a Case<'a, Ex, En>),
1344     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1345     Default(&'a DefaultCase<'a, Ex, En>),
1346 }
1347 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for GenCase<'a, Ex, En> {}
1348 arena_deserializer::impl_deserialize_in_arena!(GenCase<'arena, Ex, En>);
1349
1350 #[derive(
1351     Clone,
1352     Debug,
1353     Deserialize,
1354     Eq,
1355     FromOcamlRepIn,
1356     Hash,
1357     NoPosHash,
1358     Ord,
1359     PartialEq,
1360     PartialOrd,
1361     Serialize,
1362     ToOcamlRep
1363 )]
1364 #[serde(bound(
1365     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1366 ))]
1367 #[rust_to_ocaml(and)]
1368 #[repr(C)]
1369 pub struct Catch<'a, Ex, En>(
1370     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a ClassName<'a>,
1371     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Lid<'a>,
1372     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Block<'a, Ex, En>,
1373 );
1374 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Catch<'a, Ex, En> {}
1375 arena_deserializer::impl_deserialize_in_arena!(Catch<'arena, Ex, En>);
1376
1377 #[derive(
1378     Clone,
1379     Debug,
1380     Deserialize,
1381     Eq,
1382     FromOcamlRepIn,
1383     Hash,
1384     NoPosHash,
1385     Ord,
1386     PartialEq,
1387     PartialOrd,
1388     Serialize,
1389     ToOcamlRep
1390 )]
1391 #[serde(bound(
1392     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1393 ))]
1394 #[rust_to_ocaml(and)]
1395 #[repr(C)]
1396 pub struct Field<'a, Ex, En>(
1397     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Expr<'a, Ex, En>,
1398     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Expr<'a, Ex, En>,
1399 );
1400 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Field<'a, Ex, En> {}
1401 arena_deserializer::impl_deserialize_in_arena!(Field<'arena, Ex, En>);
1402
1403 #[derive(
1404     Clone,
1405     Copy,
1406     Debug,
1407     Deserialize,
1408     Eq,
1409     FromOcamlRepIn,
1410     Hash,
1411     NoPosHash,
1412     Ord,
1413     PartialEq,
1414     PartialOrd,
1415     Serialize,
1416     ToOcamlRep
1417 )]
1418 #[serde(bound(
1419     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1420 ))]
1421 #[rust_to_ocaml(and)]
1422 #[repr(C, u8)]
1423 pub enum Afield<'a, Ex, En> {
1424     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1425     AFvalue(&'a Expr<'a, Ex, En>),
1426     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1427     #[rust_to_ocaml(inline_tuple)]
1428     AFkvalue(&'a (&'a Expr<'a, Ex, En>, &'a Expr<'a, Ex, En>)),
1429 }
1430 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Afield<'a, Ex, En> {}
1431 arena_deserializer::impl_deserialize_in_arena!(Afield<'arena, Ex, En>);
1432
1433 #[derive(
1434     Clone,
1435     Debug,
1436     Deserialize,
1437     Eq,
1438     FromOcamlRepIn,
1439     Hash,
1440     NoPosHash,
1441     Ord,
1442     PartialEq,
1443     PartialOrd,
1444     Serialize,
1445     ToOcamlRep
1446 )]
1447 #[serde(bound(
1448     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1449 ))]
1450 #[rust_to_ocaml(and)]
1451 #[rust_to_ocaml(prefix = "xs_")]
1452 #[repr(C)]
1453 pub struct XhpSimple<'a, Ex, En> {
1454     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1455     pub name: &'a Pstring<'a>,
1456     #[serde(deserialize_with = "arena_deserializer::arena")]
1457     pub type_: Ex,
1458     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1459     pub expr: &'a Expr<'a, Ex, En>,
1460 }
1461 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for XhpSimple<'a, Ex, En> {}
1462 arena_deserializer::impl_deserialize_in_arena!(XhpSimple<'arena, Ex, En>);
1463
1464 #[derive(
1465     Clone,
1466     Copy,
1467     Debug,
1468     Deserialize,
1469     Eq,
1470     FromOcamlRepIn,
1471     Hash,
1472     NoPosHash,
1473     Ord,
1474     PartialEq,
1475     PartialOrd,
1476     Serialize,
1477     ToOcamlRep
1478 )]
1479 #[serde(bound(
1480     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1481 ))]
1482 #[rust_to_ocaml(and)]
1483 #[repr(C, u8)]
1484 pub enum XhpAttribute<'a, Ex, En> {
1485     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1486     #[rust_to_ocaml(name = "Xhp_simple")]
1487     XhpSimple(&'a XhpSimple<'a, Ex, En>),
1488     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1489     #[rust_to_ocaml(name = "Xhp_spread")]
1490     XhpSpread(&'a Expr<'a, Ex, En>),
1491 }
1492 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for XhpAttribute<'a, Ex, En> {}
1493 arena_deserializer::impl_deserialize_in_arena!(XhpAttribute<'arena, Ex, En>);
1494
1495 pub use oxidized::aast_defs::IsVariadic;
1496
1497 #[derive(
1498     Clone,
1499     Debug,
1500     Deserialize,
1501     Eq,
1502     FromOcamlRepIn,
1503     Hash,
1504     NoPosHash,
1505     Ord,
1506     PartialEq,
1507     PartialOrd,
1508     Serialize,
1509     ToOcamlRep
1510 )]
1511 #[serde(bound(
1512     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1513 ))]
1514 #[rust_to_ocaml(and)]
1515 #[rust_to_ocaml(prefix = "param_")]
1516 #[repr(C)]
1517 pub struct FunParam<'a, Ex, En> {
1518     #[serde(deserialize_with = "arena_deserializer::arena")]
1519     pub annotation: Ex,
1520     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1521     pub type_hint: &'a TypeHint<'a, Ex>,
1522     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1523     pub is_variadic: &'a oxidized::aast_defs::IsVariadic,
1524     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1525     pub pos: &'a Pos<'a>,
1526     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1527     pub name: &'a str,
1528     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1529     pub expr: Option<&'a Expr<'a, Ex, En>>,
1530     pub readonly: Option<oxidized::ast_defs::ReadonlyKind>,
1531     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1532     pub callconv: ast_defs::ParamKind<'a>,
1533     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1534     pub user_attributes: &'a [&'a UserAttribute<'a, Ex, En>],
1535     pub visibility: Option<oxidized::aast_defs::Visibility>,
1536 }
1537 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for FunParam<'a, Ex, En> {}
1538 arena_deserializer::impl_deserialize_in_arena!(FunParam<'arena, Ex, En>);
1539
1540 #[derive(
1541     Clone,
1542     Debug,
1543     Deserialize,
1544     Eq,
1545     FromOcamlRepIn,
1546     Hash,
1547     NoPosHash,
1548     Ord,
1549     PartialEq,
1550     PartialOrd,
1551     Serialize,
1552     ToOcamlRep
1553 )]
1554 #[serde(bound(
1555     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1556 ))]
1557 #[rust_to_ocaml(and)]
1558 #[rust_to_ocaml(prefix = "f_")]
1559 #[repr(C)]
1560 pub struct Fun_<'a, Ex, En> {
1561     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1562     pub span: &'a Pos<'a>,
1563     pub readonly_this: Option<oxidized::ast_defs::ReadonlyKind>,
1564     #[serde(deserialize_with = "arena_deserializer::arena")]
1565     pub annotation: En,
1566     /// Whether the return value is readonly
1567     pub readonly_ret: Option<oxidized::ast_defs::ReadonlyKind>,
1568     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1569     pub ret: &'a TypeHint<'a, Ex>,
1570     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1571     pub name: Sid<'a>,
1572     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1573     pub tparams: &'a [&'a Tparam<'a, Ex, En>],
1574     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1575     pub where_constraints: &'a [&'a WhereConstraintHint<'a>],
1576     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1577     pub params: &'a [&'a FunParam<'a, Ex, En>],
1578     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1579     pub ctxs: Option<&'a Contexts<'a>>,
1580     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1581     pub unsafe_ctxs: Option<&'a Contexts<'a>>,
1582     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1583     pub body: &'a FuncBody<'a, Ex, En>,
1584     pub fun_kind: oxidized::ast_defs::FunKind,
1585     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1586     pub user_attributes: &'a [&'a UserAttribute<'a, Ex, En>],
1587     /// true if this declaration has no body because it is an
1588     /// external function declaration (e.g. from an HHI file)
1589     pub external: bool,
1590     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1591     pub doc_comment: Option<&'a DocComment<'a>>,
1592 }
1593 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Fun_<'a, Ex, En> {}
1594 arena_deserializer::impl_deserialize_in_arena!(Fun_<'arena, Ex, En>);
1595
1596 /// Naming has two phases and the annotation helps to indicate the phase.
1597 /// In the first pass, it will perform naming on everything except for function
1598 /// and method bodies and collect information needed. Then, another round of
1599 /// naming is performed where function bodies are named.
1600 #[derive(
1601     Clone,
1602     Debug,
1603     Deserialize,
1604     Eq,
1605     FromOcamlRepIn,
1606     Hash,
1607     NoPosHash,
1608     Ord,
1609     PartialEq,
1610     PartialOrd,
1611     Serialize,
1612     ToOcamlRep
1613 )]
1614 #[serde(bound(
1615     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1616 ))]
1617 #[rust_to_ocaml(and)]
1618 #[repr(C)]
1619 pub struct FuncBody<'a, Ex, En> {
1620     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1621     pub fb_ast: &'a Block<'a, Ex, En>,
1622 }
1623 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for FuncBody<'a, Ex, En> {}
1624 arena_deserializer::impl_deserialize_in_arena!(FuncBody<'arena, Ex, En>);
1625
1626 /// A type annotation is two things:
1627 /// - the localized hint, or if the hint is missing, the inferred type
1628 /// - The typehint associated to this expression if it exists
1629 #[derive(
1630     Clone,
1631     Debug,
1632     Deserialize,
1633     Eq,
1634     FromOcamlRepIn,
1635     Hash,
1636     NoPosHash,
1637     Ord,
1638     PartialEq,
1639     PartialOrd,
1640     Serialize,
1641     ToOcamlRep
1642 )]
1643 #[serde(bound(deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>"))]
1644 #[rust_to_ocaml(and)]
1645 #[repr(C)]
1646 pub struct TypeHint<'a, Ex>(
1647     #[serde(deserialize_with = "arena_deserializer::arena")] pub Ex,
1648     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a TypeHint_<'a>,
1649 );
1650 impl<'a, Ex: TrivialDrop> TrivialDrop for TypeHint<'a, Ex> {}
1651 arena_deserializer::impl_deserialize_in_arena!(TypeHint<'arena, Ex>);
1652
1653 /// Explicit type argument to function, constructor, or collection literal.
1654 /// 'ex = unit in NAST
1655 /// 'ex = Typing_defs.(locl ty) in TAST,
1656 /// and is used to record inferred type arguments, with wildcard hint.
1657 #[derive(
1658     Clone,
1659     Debug,
1660     Deserialize,
1661     Eq,
1662     FromOcamlRepIn,
1663     Hash,
1664     NoPosHash,
1665     Ord,
1666     PartialEq,
1667     PartialOrd,
1668     Serialize,
1669     ToOcamlRep
1670 )]
1671 #[serde(bound(deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>"))]
1672 #[rust_to_ocaml(and)]
1673 #[repr(C)]
1674 pub struct Targ<'a, Ex>(
1675     #[serde(deserialize_with = "arena_deserializer::arena")] pub Ex,
1676     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Hint<'a>,
1677 );
1678 impl<'a, Ex: TrivialDrop> TrivialDrop for Targ<'a, Ex> {}
1679 arena_deserializer::impl_deserialize_in_arena!(Targ<'arena, Ex>);
1680
1681 #[rust_to_ocaml(and)]
1682 pub type TypeHint_<'a> = Option<&'a Hint<'a>>;
1683
1684 #[derive(
1685     Clone,
1686     Debug,
1687     Deserialize,
1688     Eq,
1689     FromOcamlRepIn,
1690     Hash,
1691     NoPosHash,
1692     Ord,
1693     PartialEq,
1694     PartialOrd,
1695     Serialize,
1696     ToOcamlRep
1697 )]
1698 #[serde(bound(
1699     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1700 ))]
1701 #[rust_to_ocaml(and)]
1702 #[rust_to_ocaml(prefix = "ua_")]
1703 #[repr(C)]
1704 pub struct UserAttribute<'a, Ex, En> {
1705     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1706     pub name: Sid<'a>,
1707     /// user attributes are restricted to scalar values
1708     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1709     pub params: &'a [&'a Expr<'a, Ex, En>],
1710 }
1711 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for UserAttribute<'a, Ex, En> {}
1712 arena_deserializer::impl_deserialize_in_arena!(UserAttribute<'arena, Ex, En>);
1713
1714 #[derive(
1715     Clone,
1716     Debug,
1717     Deserialize,
1718     Eq,
1719     FromOcamlRepIn,
1720     Hash,
1721     NoPosHash,
1722     Ord,
1723     PartialEq,
1724     PartialOrd,
1725     Serialize,
1726     ToOcamlRep
1727 )]
1728 #[serde(bound(
1729     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1730 ))]
1731 #[rust_to_ocaml(and)]
1732 #[rust_to_ocaml(prefix = "fa_")]
1733 #[repr(C)]
1734 pub struct FileAttribute<'a, Ex, En> {
1735     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1736     pub user_attributes: &'a [&'a UserAttribute<'a, Ex, En>],
1737     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1738     pub namespace: &'a Nsenv<'a>,
1739 }
1740 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for FileAttribute<'a, Ex, En> {}
1741 arena_deserializer::impl_deserialize_in_arena!(FileAttribute<'arena, Ex, En>);
1742
1743 #[derive(
1744     Clone,
1745     Debug,
1746     Deserialize,
1747     Eq,
1748     FromOcamlRepIn,
1749     Hash,
1750     NoPosHash,
1751     Ord,
1752     PartialEq,
1753     PartialOrd,
1754     Serialize,
1755     ToOcamlRep
1756 )]
1757 #[serde(bound(
1758     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1759 ))]
1760 #[rust_to_ocaml(and)]
1761 #[rust_to_ocaml(prefix = "tp_")]
1762 #[repr(C)]
1763 pub struct Tparam<'a, Ex, En> {
1764     pub variance: oxidized::ast_defs::Variance,
1765     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1766     pub name: Sid<'a>,
1767     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1768     pub parameters: &'a [&'a Tparam<'a, Ex, En>],
1769     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1770     pub constraints: &'a [(oxidized::ast_defs::ConstraintKind, &'a Hint<'a>)],
1771     pub reified: oxidized::aast_defs::ReifyKind,
1772     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1773     pub user_attributes: &'a [&'a UserAttribute<'a, Ex, En>],
1774 }
1775 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Tparam<'a, Ex, En> {}
1776 arena_deserializer::impl_deserialize_in_arena!(Tparam<'arena, Ex, En>);
1777
1778 pub use oxidized::aast_defs::EmitId;
1779 pub use oxidized::aast_defs::RequireKind;
1780
1781 #[derive(
1782     Clone,
1783     Debug,
1784     Deserialize,
1785     Eq,
1786     FromOcamlRepIn,
1787     Hash,
1788     NoPosHash,
1789     Ord,
1790     PartialEq,
1791     PartialOrd,
1792     Serialize,
1793     ToOcamlRep
1794 )]
1795 #[serde(bound(
1796     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1797 ))]
1798 #[rust_to_ocaml(and)]
1799 #[rust_to_ocaml(prefix = "c_")]
1800 #[repr(C)]
1801 pub struct Class_<'a, Ex, En> {
1802     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1803     pub span: &'a Pos<'a>,
1804     #[serde(deserialize_with = "arena_deserializer::arena")]
1805     pub annotation: En,
1806     #[rust_to_ocaml(attr = "visitors.opaque")]
1807     pub mode: oxidized::file_info::Mode,
1808     pub final_: bool,
1809     pub is_xhp: bool,
1810     pub has_xhp_keyword: bool,
1811     pub kind: oxidized::ast_defs::ClassishKind,
1812     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1813     pub name: &'a ClassName<'a>,
1814     /// The type parameters of a class A<T> (T is the parameter)
1815     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1816     pub tparams: &'a [&'a Tparam<'a, Ex, En>],
1817     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1818     pub extends: &'a [&'a ClassHint<'a>],
1819     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1820     pub uses: &'a [&'a TraitHint<'a>],
1821     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1822     pub xhp_attr_uses: &'a [&'a XhpAttrHint<'a>],
1823     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1824     pub xhp_category: Option<&'a (&'a Pos<'a>, &'a [&'a Pstring<'a>])>,
1825     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1826     pub reqs: &'a [(&'a ClassHint<'a>, &'a oxidized::aast_defs::RequireKind)],
1827     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1828     pub implements: &'a [&'a ClassHint<'a>],
1829     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1830     pub where_constraints: &'a [&'a WhereConstraintHint<'a>],
1831     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1832     pub consts: &'a [&'a ClassConst<'a, Ex, En>],
1833     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1834     pub typeconsts: &'a [&'a ClassTypeconstDef<'a, Ex, En>],
1835     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1836     pub vars: &'a [&'a ClassVar<'a, Ex, En>],
1837     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1838     pub methods: &'a [&'a Method_<'a, Ex, En>],
1839     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1840     pub xhp_children: &'a [(&'a Pos<'a>, XhpChild<'a>)],
1841     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1842     pub xhp_attrs: &'a [&'a XhpAttr<'a, Ex, En>],
1843     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1844     pub namespace: &'a Nsenv<'a>,
1845     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1846     pub user_attributes: &'a [&'a UserAttribute<'a, Ex, En>],
1847     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1848     pub file_attributes: &'a [&'a FileAttribute<'a, Ex, En>],
1849     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1850     pub docs_url: Option<&'a str>,
1851     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1852     pub enum_: Option<&'a Enum_<'a>>,
1853     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1854     pub doc_comment: Option<&'a DocComment<'a>>,
1855     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1856     pub emit_id: Option<&'a oxidized::aast_defs::EmitId>,
1857     pub internal: bool,
1858     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1859     pub module: Option<Sid<'a>>,
1860 }
1861 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Class_<'a, Ex, En> {}
1862 arena_deserializer::impl_deserialize_in_arena!(Class_<'arena, Ex, En>);
1863
1864 #[rust_to_ocaml(and)]
1865 pub type ClassHint<'a> = Hint<'a>;
1866
1867 #[rust_to_ocaml(and)]
1868 pub type TraitHint<'a> = Hint<'a>;
1869
1870 #[rust_to_ocaml(and)]
1871 pub type XhpAttrHint<'a> = Hint<'a>;
1872
1873 pub use oxidized::aast_defs::XhpAttrTag;
1874
1875 #[derive(
1876     Clone,
1877     Debug,
1878     Deserialize,
1879     Eq,
1880     FromOcamlRepIn,
1881     Hash,
1882     NoPosHash,
1883     Ord,
1884     PartialEq,
1885     PartialOrd,
1886     Serialize,
1887     ToOcamlRep
1888 )]
1889 #[serde(bound(
1890     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1891 ))]
1892 #[rust_to_ocaml(and)]
1893 #[repr(C)]
1894 pub struct XhpAttr<'a, Ex, En>(
1895     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a TypeHint<'a, Ex>,
1896     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a ClassVar<'a, Ex, En>,
1897     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1898     pub  Option<&'a oxidized::aast_defs::XhpAttrTag>,
1899     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1900     pub  Option<&'a (&'a Pos<'a>, &'a [&'a Expr<'a, Ex, En>])>,
1901 );
1902 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for XhpAttr<'a, Ex, En> {}
1903 arena_deserializer::impl_deserialize_in_arena!(XhpAttr<'arena, Ex, En>);
1904
1905 #[derive(
1906     Clone,
1907     Copy,
1908     Debug,
1909     Deserialize,
1910     Eq,
1911     FromOcamlRepIn,
1912     Hash,
1913     NoPosHash,
1914     Ord,
1915     PartialEq,
1916     PartialOrd,
1917     Serialize,
1918     ToOcamlRep
1919 )]
1920 #[serde(bound(
1921     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1922 ))]
1923 #[rust_to_ocaml(and)]
1924 #[repr(C, u8)]
1925 pub enum ClassConstKind<'a, Ex, En> {
1926     /// CCAbstract represents the states
1927     ///     abstract const int X;
1928     ///     abstract const int Y = 4;
1929     /// The expr option is a default value
1930     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1931     CCAbstract(Option<&'a Expr<'a, Ex, En>>),
1932     /// CCConcrete represents
1933     ///     const int Z = 4;
1934     /// The expr is the value of the constant. It is not optional
1935     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1936     CCConcrete(&'a Expr<'a, Ex, En>),
1937 }
1938 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for ClassConstKind<'a, Ex, En> {}
1939 arena_deserializer::impl_deserialize_in_arena!(ClassConstKind<'arena, Ex, En>);
1940
1941 #[derive(
1942     Clone,
1943     Debug,
1944     Deserialize,
1945     Eq,
1946     FromOcamlRepIn,
1947     Hash,
1948     NoPosHash,
1949     Ord,
1950     PartialEq,
1951     PartialOrd,
1952     Serialize,
1953     ToOcamlRep
1954 )]
1955 #[serde(bound(
1956     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
1957 ))]
1958 #[rust_to_ocaml(and)]
1959 #[rust_to_ocaml(prefix = "cc_")]
1960 #[repr(C)]
1961 pub struct ClassConst<'a, Ex, En> {
1962     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1963     pub user_attributes: &'a [&'a UserAttribute<'a, Ex, En>],
1964     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1965     pub type_: Option<&'a Hint<'a>>,
1966     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1967     pub id: Sid<'a>,
1968     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1969     pub kind: ClassConstKind<'a, Ex, En>,
1970     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1971     pub span: &'a Pos<'a>,
1972     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
1973     pub doc_comment: Option<&'a DocComment<'a>>,
1974 }
1975 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for ClassConst<'a, Ex, En> {}
1976 arena_deserializer::impl_deserialize_in_arena!(ClassConst<'arena, Ex, En>);
1977
1978 /// This represents a type const definition. If a type const is abstract then
1979 /// then the type hint acts as a constraint. Any concrete definition of the
1980 /// type const must satisfy the constraint.
1981 ///
1982 /// If the type const is not abstract then a type must be specified.
1983 #[derive(
1984     Clone,
1985     Debug,
1986     Deserialize,
1987     Eq,
1988     FromOcamlRepIn,
1989     Hash,
1990     NoPosHash,
1991     Ord,
1992     PartialEq,
1993     PartialOrd,
1994     Serialize,
1995     ToOcamlRep
1996 )]
1997 #[rust_to_ocaml(and)]
1998 #[rust_to_ocaml(prefix = "c_atc_")]
1999 #[repr(C)]
2000 pub struct ClassAbstractTypeconst<'a> {
2001     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2002     pub as_constraint: Option<&'a Hint<'a>>,
2003     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2004     pub super_constraint: Option<&'a Hint<'a>>,
2005     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2006     pub default: Option<&'a Hint<'a>>,
2007 }
2008 impl<'a> TrivialDrop for ClassAbstractTypeconst<'a> {}
2009 arena_deserializer::impl_deserialize_in_arena!(ClassAbstractTypeconst<'arena>);
2010
2011 #[derive(
2012     Clone,
2013     Debug,
2014     Deserialize,
2015     Eq,
2016     FromOcamlRepIn,
2017     Hash,
2018     NoPosHash,
2019     Ord,
2020     PartialEq,
2021     PartialOrd,
2022     Serialize,
2023     ToOcamlRep
2024 )]
2025 #[rust_to_ocaml(and)]
2026 #[repr(C)]
2027 pub struct ClassConcreteTypeconst<'a> {
2028     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2029     pub c_tc_type: &'a Hint<'a>,
2030 }
2031 impl<'a> TrivialDrop for ClassConcreteTypeconst<'a> {}
2032 arena_deserializer::impl_deserialize_in_arena!(ClassConcreteTypeconst<'arena>);
2033
2034 #[derive(
2035     Clone,
2036     Copy,
2037     Debug,
2038     Deserialize,
2039     Eq,
2040     FromOcamlRepIn,
2041     Hash,
2042     NoPosHash,
2043     Ord,
2044     PartialEq,
2045     PartialOrd,
2046     Serialize,
2047     ToOcamlRep
2048 )]
2049 #[rust_to_ocaml(and)]
2050 #[repr(C, u8)]
2051 pub enum ClassTypeconst<'a> {
2052     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2053     TCAbstract(&'a ClassAbstractTypeconst<'a>),
2054     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2055     TCConcrete(&'a ClassConcreteTypeconst<'a>),
2056 }
2057 impl<'a> TrivialDrop for ClassTypeconst<'a> {}
2058 arena_deserializer::impl_deserialize_in_arena!(ClassTypeconst<'arena>);
2059
2060 #[derive(
2061     Clone,
2062     Debug,
2063     Deserialize,
2064     Eq,
2065     FromOcamlRepIn,
2066     Hash,
2067     NoPosHash,
2068     Ord,
2069     PartialEq,
2070     PartialOrd,
2071     Serialize,
2072     ToOcamlRep
2073 )]
2074 #[serde(bound(
2075     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
2076 ))]
2077 #[rust_to_ocaml(and)]
2078 #[rust_to_ocaml(prefix = "c_tconst_")]
2079 #[repr(C)]
2080 pub struct ClassTypeconstDef<'a, Ex, En> {
2081     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2082     pub user_attributes: &'a [&'a UserAttribute<'a, Ex, En>],
2083     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2084     pub name: Sid<'a>,
2085     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2086     pub kind: ClassTypeconst<'a>,
2087     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2088     pub span: &'a Pos<'a>,
2089     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2090     pub doc_comment: Option<&'a DocComment<'a>>,
2091     pub is_ctx: bool,
2092 }
2093 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for ClassTypeconstDef<'a, Ex, En> {}
2094 arena_deserializer::impl_deserialize_in_arena!(ClassTypeconstDef<'arena, Ex, En>);
2095
2096 #[derive(
2097     Clone,
2098     Debug,
2099     Deserialize,
2100     Eq,
2101     FromOcamlRepIn,
2102     Hash,
2103     NoPosHash,
2104     Ord,
2105     PartialEq,
2106     PartialOrd,
2107     Serialize,
2108     ToOcamlRep
2109 )]
2110 #[rust_to_ocaml(and)]
2111 #[rust_to_ocaml(prefix = "xai_")]
2112 #[repr(C)]
2113 pub struct XhpAttrInfo<'a> {
2114     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2115     pub like: Option<&'a Pos<'a>>,
2116     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2117     pub tag: Option<&'a oxidized::aast_defs::XhpAttrTag>,
2118     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2119     pub enum_values: &'a [ast_defs::XhpEnumValue<'a>],
2120 }
2121 impl<'a> TrivialDrop for XhpAttrInfo<'a> {}
2122 arena_deserializer::impl_deserialize_in_arena!(XhpAttrInfo<'arena>);
2123
2124 #[derive(
2125     Clone,
2126     Debug,
2127     Deserialize,
2128     Eq,
2129     FromOcamlRepIn,
2130     Hash,
2131     NoPosHash,
2132     Ord,
2133     PartialEq,
2134     PartialOrd,
2135     Serialize,
2136     ToOcamlRep
2137 )]
2138 #[serde(bound(
2139     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
2140 ))]
2141 #[rust_to_ocaml(and)]
2142 #[rust_to_ocaml(prefix = "cv_")]
2143 #[repr(C)]
2144 pub struct ClassVar<'a, Ex, En> {
2145     pub final_: bool,
2146     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2147     pub xhp_attr: Option<&'a XhpAttrInfo<'a>>,
2148     pub abstract_: bool,
2149     pub readonly: bool,
2150     pub visibility: oxidized::aast_defs::Visibility,
2151     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2152     pub type_: &'a TypeHint<'a, Ex>,
2153     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2154     pub id: Sid<'a>,
2155     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2156     pub expr: Option<&'a Expr<'a, Ex, En>>,
2157     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2158     pub user_attributes: &'a [&'a UserAttribute<'a, Ex, En>],
2159     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2160     pub doc_comment: Option<&'a DocComment<'a>>,
2161     pub is_promoted_variadic: bool,
2162     pub is_static: bool,
2163     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2164     pub span: &'a Pos<'a>,
2165 }
2166 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for ClassVar<'a, Ex, En> {}
2167 arena_deserializer::impl_deserialize_in_arena!(ClassVar<'arena, Ex, En>);
2168
2169 #[derive(
2170     Clone,
2171     Debug,
2172     Deserialize,
2173     Eq,
2174     FromOcamlRepIn,
2175     Hash,
2176     NoPosHash,
2177     Ord,
2178     PartialEq,
2179     PartialOrd,
2180     Serialize,
2181     ToOcamlRep
2182 )]
2183 #[serde(bound(
2184     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
2185 ))]
2186 #[rust_to_ocaml(and)]
2187 #[rust_to_ocaml(prefix = "m_")]
2188 #[repr(C)]
2189 pub struct Method_<'a, Ex, En> {
2190     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2191     pub span: &'a Pos<'a>,
2192     #[serde(deserialize_with = "arena_deserializer::arena")]
2193     pub annotation: En,
2194     pub final_: bool,
2195     pub abstract_: bool,
2196     pub static_: bool,
2197     pub readonly_this: bool,
2198     pub visibility: oxidized::aast_defs::Visibility,
2199     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2200     pub name: Sid<'a>,
2201     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2202     pub tparams: &'a [&'a Tparam<'a, Ex, En>],
2203     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2204     pub where_constraints: &'a [&'a WhereConstraintHint<'a>],
2205     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2206     pub params: &'a [&'a FunParam<'a, Ex, En>],
2207     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2208     pub ctxs: Option<&'a Contexts<'a>>,
2209     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2210     pub unsafe_ctxs: Option<&'a Contexts<'a>>,
2211     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2212     pub body: &'a FuncBody<'a, Ex, En>,
2213     pub fun_kind: oxidized::ast_defs::FunKind,
2214     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2215     pub user_attributes: &'a [&'a UserAttribute<'a, Ex, En>],
2216     pub readonly_ret: Option<oxidized::ast_defs::ReadonlyKind>,
2217     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2218     pub ret: &'a TypeHint<'a, Ex>,
2219     /// true if this declaration has no body because it is an external method
2220     /// declaration (e.g. from an HHI file)
2221     pub external: bool,
2222     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2223     pub doc_comment: Option<&'a DocComment<'a>>,
2224 }
2225 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Method_<'a, Ex, En> {}
2226 arena_deserializer::impl_deserialize_in_arena!(Method_<'arena, Ex, En>);
2227
2228 #[rust_to_ocaml(and)]
2229 pub type Nsenv<'a> = namespace_env::Env<'a>;
2230
2231 #[derive(
2232     Clone,
2233     Debug,
2234     Deserialize,
2235     Eq,
2236     FromOcamlRepIn,
2237     Hash,
2238     NoPosHash,
2239     Ord,
2240     PartialEq,
2241     PartialOrd,
2242     Serialize,
2243     ToOcamlRep
2244 )]
2245 #[serde(bound(
2246     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
2247 ))]
2248 #[rust_to_ocaml(and)]
2249 #[rust_to_ocaml(prefix = "t_")]
2250 #[repr(C)]
2251 pub struct Typedef<'a, Ex, En> {
2252     #[serde(deserialize_with = "arena_deserializer::arena")]
2253     pub annotation: En,
2254     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2255     pub name: Sid<'a>,
2256     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2257     pub tparams: &'a [&'a Tparam<'a, Ex, En>],
2258     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2259     pub as_constraint: Option<&'a Hint<'a>>,
2260     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2261     pub super_constraint: Option<&'a Hint<'a>>,
2262     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2263     pub kind: &'a Hint<'a>,
2264     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2265     pub user_attributes: &'a [&'a UserAttribute<'a, Ex, En>],
2266     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2267     pub file_attributes: &'a [&'a FileAttribute<'a, Ex, En>],
2268     #[rust_to_ocaml(attr = "visitors.opaque")]
2269     pub mode: oxidized::file_info::Mode,
2270     pub vis: oxidized::aast_defs::TypedefVisibility,
2271     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2272     pub namespace: &'a Nsenv<'a>,
2273     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2274     pub span: &'a Pos<'a>,
2275     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2276     pub emit_id: Option<&'a oxidized::aast_defs::EmitId>,
2277     pub is_ctx: bool,
2278     pub internal: bool,
2279     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2280     pub module: Option<Sid<'a>>,
2281     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2282     pub docs_url: Option<&'a str>,
2283 }
2284 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Typedef<'a, Ex, En> {}
2285 arena_deserializer::impl_deserialize_in_arena!(Typedef<'arena, Ex, En>);
2286
2287 #[derive(
2288     Clone,
2289     Debug,
2290     Deserialize,
2291     Eq,
2292     FromOcamlRepIn,
2293     Hash,
2294     NoPosHash,
2295     Ord,
2296     PartialEq,
2297     PartialOrd,
2298     Serialize,
2299     ToOcamlRep
2300 )]
2301 #[serde(bound(
2302     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
2303 ))]
2304 #[rust_to_ocaml(and)]
2305 #[rust_to_ocaml(prefix = "cst_")]
2306 #[repr(C)]
2307 pub struct Gconst<'a, Ex, En> {
2308     #[serde(deserialize_with = "arena_deserializer::arena")]
2309     pub annotation: En,
2310     #[rust_to_ocaml(attr = "visitors.opaque")]
2311     pub mode: oxidized::file_info::Mode,
2312     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2313     pub name: Sid<'a>,
2314     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2315     pub type_: Option<&'a Hint<'a>>,
2316     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2317     pub value: &'a Expr<'a, Ex, En>,
2318     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2319     pub namespace: &'a Nsenv<'a>,
2320     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2321     pub span: &'a Pos<'a>,
2322     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2323     pub emit_id: Option<&'a oxidized::aast_defs::EmitId>,
2324 }
2325 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Gconst<'a, Ex, En> {}
2326 arena_deserializer::impl_deserialize_in_arena!(Gconst<'arena, Ex, En>);
2327
2328 #[derive(
2329     Clone,
2330     Debug,
2331     Deserialize,
2332     Eq,
2333     FromOcamlRepIn,
2334     Hash,
2335     NoPosHash,
2336     Ord,
2337     PartialEq,
2338     PartialOrd,
2339     Serialize,
2340     ToOcamlRep
2341 )]
2342 #[serde(bound(
2343     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
2344 ))]
2345 #[rust_to_ocaml(and)]
2346 #[rust_to_ocaml(prefix = "fd_")]
2347 #[repr(C)]
2348 pub struct FunDef<'a, Ex, En> {
2349     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2350     pub namespace: &'a Nsenv<'a>,
2351     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2352     pub file_attributes: &'a [&'a FileAttribute<'a, Ex, En>],
2353     #[rust_to_ocaml(attr = "visitors.opaque")]
2354     pub mode: oxidized::file_info::Mode,
2355     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2356     pub fun: &'a Fun_<'a, Ex, En>,
2357     pub internal: bool,
2358     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2359     pub module: Option<Sid<'a>>,
2360 }
2361 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for FunDef<'a, Ex, En> {}
2362 arena_deserializer::impl_deserialize_in_arena!(FunDef<'arena, Ex, En>);
2363
2364 #[derive(
2365     Clone,
2366     Debug,
2367     Deserialize,
2368     Eq,
2369     FromOcamlRepIn,
2370     Hash,
2371     NoPosHash,
2372     Ord,
2373     PartialEq,
2374     PartialOrd,
2375     Serialize,
2376     ToOcamlRep
2377 )]
2378 #[serde(bound(
2379     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
2380 ))]
2381 #[rust_to_ocaml(and)]
2382 #[rust_to_ocaml(prefix = "md_")]
2383 #[repr(C)]
2384 pub struct ModuleDef<'a, Ex, En> {
2385     #[serde(deserialize_with = "arena_deserializer::arena")]
2386     pub annotation: En,
2387     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2388     pub name: ast_defs::Id<'a>,
2389     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2390     pub user_attributes: &'a [&'a UserAttribute<'a, Ex, En>],
2391     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2392     pub span: &'a Pos<'a>,
2393     #[rust_to_ocaml(attr = "visitors.opaque")]
2394     pub mode: oxidized::file_info::Mode,
2395     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2396     pub doc_comment: Option<&'a DocComment<'a>>,
2397     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2398     pub exports: Option<&'a [MdNameKind<'a>]>,
2399     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2400     pub imports: Option<&'a [MdNameKind<'a>]>,
2401 }
2402 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for ModuleDef<'a, Ex, En> {}
2403 arena_deserializer::impl_deserialize_in_arena!(ModuleDef<'arena, Ex, En>);
2404
2405 #[derive(
2406     Clone,
2407     Copy,
2408     Debug,
2409     Deserialize,
2410     Eq,
2411     FromOcamlRepIn,
2412     Hash,
2413     NoPosHash,
2414     Ord,
2415     PartialEq,
2416     PartialOrd,
2417     Serialize,
2418     ToOcamlRep
2419 )]
2420 #[rust_to_ocaml(and)]
2421 #[repr(C, u8)]
2422 pub enum MdNameKind<'a> {
2423     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2424     MDNameGlobal(&'a Pos<'a>),
2425     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2426     MDNamePrefix(&'a Sid<'a>),
2427     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2428     MDNameExact(&'a Sid<'a>),
2429 }
2430 impl<'a> TrivialDrop for MdNameKind<'a> {}
2431 arena_deserializer::impl_deserialize_in_arena!(MdNameKind<'arena>);
2432
2433 #[derive(
2434     Clone,
2435     Copy,
2436     Debug,
2437     Deserialize,
2438     Eq,
2439     FromOcamlRepIn,
2440     Hash,
2441     NoPosHash,
2442     Ord,
2443     PartialEq,
2444     PartialOrd,
2445     Serialize,
2446     ToOcamlRep
2447 )]
2448 #[serde(bound(
2449     deserialize = "Ex: 'de + arena_deserializer::DeserializeInArena<'de>, En: 'de + arena_deserializer::DeserializeInArena<'de>"
2450 ))]
2451 #[rust_to_ocaml(and)]
2452 #[repr(C, u8)]
2453 pub enum Def<'a, Ex, En> {
2454     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2455     Fun(&'a FunDef<'a, Ex, En>),
2456     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2457     Class(&'a Class_<'a, Ex, En>),
2458     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2459     Stmt(&'a Stmt<'a, Ex, En>),
2460     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2461     Typedef(&'a Typedef<'a, Ex, En>),
2462     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2463     Constant(&'a Gconst<'a, Ex, En>),
2464     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2465     #[rust_to_ocaml(inline_tuple)]
2466     Namespace(&'a (Sid<'a>, &'a [Def<'a, Ex, En>])),
2467     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2468     NamespaceUse(&'a [(&'a oxidized::aast_defs::NsKind, Sid<'a>, Sid<'a>)]),
2469     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2470     SetNamespaceEnv(&'a Nsenv<'a>),
2471     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2472     FileAttributes(&'a FileAttribute<'a, Ex, En>),
2473     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2474     Module(&'a ModuleDef<'a, Ex, En>),
2475     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2476     SetModule(&'a Sid<'a>),
2477 }
2478 impl<'a, Ex: TrivialDrop, En: TrivialDrop> TrivialDrop for Def<'a, Ex, En> {}
2479 arena_deserializer::impl_deserialize_in_arena!(Def<'arena, Ex, En>);
2480
2481 pub use oxidized::aast_defs::NsKind;
2482
2483 #[rust_to_ocaml(and)]
2484 pub type DocComment<'a> = ast_defs::Pstring<'a>;
2485
2486 pub use oxidized::aast_defs::ImportFlavor;
2487
2488 #[derive(
2489     Clone,
2490     Copy,
2491     Debug,
2492     Deserialize,
2493     Eq,
2494     FromOcamlRepIn,
2495     Hash,
2496     NoPosHash,
2497     Ord,
2498     PartialEq,
2499     PartialOrd,
2500     Serialize,
2501     ToOcamlRep
2502 )]
2503 #[rust_to_ocaml(and)]
2504 #[repr(C, u8)]
2505 pub enum XhpChild<'a> {
2506     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2507     ChildName(&'a Sid<'a>),
2508     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2509     ChildList(&'a [XhpChild<'a>]),
2510     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2511     #[rust_to_ocaml(inline_tuple)]
2512     ChildUnary(&'a (XhpChild<'a>, oxidized::aast_defs::XhpChildOp)),
2513     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2514     #[rust_to_ocaml(inline_tuple)]
2515     ChildBinary(&'a (XhpChild<'a>, XhpChild<'a>)),
2516 }
2517 impl<'a> TrivialDrop for XhpChild<'a> {}
2518 arena_deserializer::impl_deserialize_in_arena!(XhpChild<'arena>);
2519
2520 pub use oxidized::aast_defs::XhpChildOp;
2521
2522 #[derive(
2523     Clone,
2524     Debug,
2525     Deserialize,
2526     Eq,
2527     FromOcamlRepIn,
2528     Hash,
2529     NoPosHash,
2530     Ord,
2531     PartialEq,
2532     PartialOrd,
2533     Serialize,
2534     ToOcamlRep
2535 )]
2536 #[rust_to_ocaml(and)]
2537 #[repr(C)]
2538 pub struct Hint<'a>(
2539     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Pos<'a>,
2540     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Hint_<'a>,
2541 );
2542 impl<'a> TrivialDrop for Hint<'a> {}
2543 arena_deserializer::impl_deserialize_in_arena!(Hint<'arena>);
2544
2545 #[rust_to_ocaml(and)]
2546 pub type VariadicHint<'a> = Option<&'a Hint<'a>>;
2547
2548 #[derive(
2549     Clone,
2550     Debug,
2551     Deserialize,
2552     Eq,
2553     FromOcamlRepIn,
2554     Hash,
2555     NoPosHash,
2556     Ord,
2557     PartialEq,
2558     PartialOrd,
2559     Serialize,
2560     ToOcamlRep
2561 )]
2562 #[rust_to_ocaml(and)]
2563 #[repr(C)]
2564 pub struct Contexts<'a>(
2565     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Pos<'a>,
2566     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a [&'a Hint<'a>],
2567 );
2568 impl<'a> TrivialDrop for Contexts<'a> {}
2569 arena_deserializer::impl_deserialize_in_arena!(Contexts<'arena>);
2570
2571 #[derive(
2572     Clone,
2573     Debug,
2574     Deserialize,
2575     Eq,
2576     FromOcamlRepIn,
2577     Hash,
2578     NoPosHash,
2579     Ord,
2580     PartialEq,
2581     PartialOrd,
2582     Serialize,
2583     ToOcamlRep
2584 )]
2585 #[rust_to_ocaml(and)]
2586 #[rust_to_ocaml(prefix = "hfparam_")]
2587 #[repr(C)]
2588 pub struct HfParamInfo<'a> {
2589     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2590     pub kind: ast_defs::ParamKind<'a>,
2591     pub readonlyness: Option<oxidized::ast_defs::ReadonlyKind>,
2592 }
2593 impl<'a> TrivialDrop for HfParamInfo<'a> {}
2594 arena_deserializer::impl_deserialize_in_arena!(HfParamInfo<'arena>);
2595
2596 #[derive(
2597     Clone,
2598     Debug,
2599     Deserialize,
2600     Eq,
2601     FromOcamlRepIn,
2602     Hash,
2603     NoPosHash,
2604     Ord,
2605     PartialEq,
2606     PartialOrd,
2607     Serialize,
2608     ToOcamlRep
2609 )]
2610 #[rust_to_ocaml(and)]
2611 #[rust_to_ocaml(prefix = "hf_")]
2612 #[repr(C)]
2613 pub struct HintFun<'a> {
2614     pub is_readonly: Option<oxidized::ast_defs::ReadonlyKind>,
2615     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2616     pub param_tys: &'a [&'a Hint<'a>],
2617     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2618     pub param_info: &'a [Option<&'a HfParamInfo<'a>>],
2619     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2620     pub variadic_ty: &'a VariadicHint<'a>,
2621     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2622     pub ctxs: Option<&'a Contexts<'a>>,
2623     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2624     pub return_ty: &'a Hint<'a>,
2625     pub is_readonly_return: Option<oxidized::ast_defs::ReadonlyKind>,
2626 }
2627 impl<'a> TrivialDrop for HintFun<'a> {}
2628 arena_deserializer::impl_deserialize_in_arena!(HintFun<'arena>);
2629
2630 #[derive(
2631     Clone,
2632     Copy,
2633     Debug,
2634     Deserialize,
2635     Eq,
2636     FromOcamlRepIn,
2637     Hash,
2638     NoPosHash,
2639     Ord,
2640     PartialEq,
2641     PartialOrd,
2642     Serialize,
2643     ToOcamlRep
2644 )]
2645 #[rust_to_ocaml(and)]
2646 #[repr(C, u8)]
2647 pub enum Hint_<'a> {
2648     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2649     Hoption(&'a Hint<'a>),
2650     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2651     Hlike(&'a Hint<'a>),
2652     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2653     Hfun(&'a HintFun<'a>),
2654     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2655     Htuple(&'a [&'a Hint<'a>]),
2656     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2657     #[rust_to_ocaml(inline_tuple)]
2658     Happly(&'a (&'a ClassName<'a>, &'a [&'a Hint<'a>])),
2659     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2660     Hshape(&'a NastShapeInfo<'a>),
2661     /// This represents the use of a type const. Type consts are accessed like
2662     /// regular consts in Hack, i.e.
2663     ///
2664     /// [$x | self | static | Class]::TypeConst
2665     ///
2666     /// Class  => Happly "Class"
2667     /// self   => Happly of the class of definition
2668     /// static => Habstr ("static",
2669     ///           Habstr ("this", (Constraint_as, Happly of class of definition)))
2670     /// $x     => Hvar "$x"
2671     ///
2672     /// Type const access can be chained such as
2673     ///
2674     /// Class::TC1::TC2::TC3
2675     ///
2676     /// We resolve the root of the type access chain as a type as follows.
2677     ///
2678     /// This will result in the following representation
2679     ///
2680     /// Haccess (Happly "Class", ["TC1", "TC2", "TC3"])
2681     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2682     #[rust_to_ocaml(inline_tuple)]
2683     Haccess(&'a (&'a Hint<'a>, &'a [Sid<'a>])),
2684     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2685     Hsoft(&'a Hint<'a>),
2686     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2687     #[rust_to_ocaml(inline_tuple)]
2688     Hrefinement(&'a (&'a Hint<'a>, &'a [Refinement<'a>])),
2689     Hany,
2690     Herr,
2691     Hmixed,
2692     Hnonnull,
2693     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2694     #[rust_to_ocaml(inline_tuple)]
2695     Habstr(&'a (&'a str, &'a [&'a Hint<'a>])),
2696     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2697     #[rust_to_ocaml(name = "Hvec_or_dict")]
2698     #[rust_to_ocaml(inline_tuple)]
2699     HvecOrDict(&'a (Option<&'a Hint<'a>>, &'a Hint<'a>)),
2700     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2701     Hprim(&'a oxidized::aast_defs::Tprim),
2702     Hthis,
2703     Hdynamic,
2704     Hnothing,
2705     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2706     Hunion(&'a [&'a Hint<'a>]),
2707     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2708     Hintersection(&'a [&'a Hint<'a>]),
2709     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2710     #[rust_to_ocaml(name = "Hfun_context")]
2711     HfunContext(&'a str),
2712     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2713     Hvar(&'a str),
2714 }
2715 impl<'a> TrivialDrop for Hint_<'a> {}
2716 arena_deserializer::impl_deserialize_in_arena!(Hint_<'arena>);
2717
2718 #[derive(
2719     Clone,
2720     Copy,
2721     Debug,
2722     Deserialize,
2723     Eq,
2724     FromOcamlRepIn,
2725     Hash,
2726     NoPosHash,
2727     Ord,
2728     PartialEq,
2729     PartialOrd,
2730     Serialize,
2731     ToOcamlRep
2732 )]
2733 #[rust_to_ocaml(and)]
2734 #[repr(C, u8)]
2735 pub enum Refinement<'a> {
2736     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2737     #[rust_to_ocaml(inline_tuple)]
2738     Rctx(&'a (Sid<'a>, CtxRefinement<'a>)),
2739     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2740     #[rust_to_ocaml(inline_tuple)]
2741     Rtype(&'a (Sid<'a>, TypeRefinement<'a>)),
2742 }
2743 impl<'a> TrivialDrop for Refinement<'a> {}
2744 arena_deserializer::impl_deserialize_in_arena!(Refinement<'arena>);
2745
2746 #[derive(
2747     Clone,
2748     Copy,
2749     Debug,
2750     Deserialize,
2751     Eq,
2752     FromOcamlRepIn,
2753     Hash,
2754     NoPosHash,
2755     Ord,
2756     PartialEq,
2757     PartialOrd,
2758     Serialize,
2759     ToOcamlRep
2760 )]
2761 #[rust_to_ocaml(and)]
2762 #[repr(C, u8)]
2763 pub enum TypeRefinement<'a> {
2764     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2765     TRexact(&'a Hint<'a>),
2766     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2767     TRloose(&'a TypeRefinementBounds<'a>),
2768 }
2769 impl<'a> TrivialDrop for TypeRefinement<'a> {}
2770 arena_deserializer::impl_deserialize_in_arena!(TypeRefinement<'arena>);
2771
2772 #[derive(
2773     Clone,
2774     Debug,
2775     Deserialize,
2776     Eq,
2777     FromOcamlRepIn,
2778     Hash,
2779     NoPosHash,
2780     Ord,
2781     PartialEq,
2782     PartialOrd,
2783     Serialize,
2784     ToOcamlRep
2785 )]
2786 #[rust_to_ocaml(and)]
2787 #[rust_to_ocaml(prefix = "tr_")]
2788 #[repr(C)]
2789 pub struct TypeRefinementBounds<'a> {
2790     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2791     pub lower: &'a [&'a Hint<'a>],
2792     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2793     pub upper: &'a [&'a Hint<'a>],
2794 }
2795 impl<'a> TrivialDrop for TypeRefinementBounds<'a> {}
2796 arena_deserializer::impl_deserialize_in_arena!(TypeRefinementBounds<'arena>);
2797
2798 #[derive(
2799     Clone,
2800     Copy,
2801     Debug,
2802     Deserialize,
2803     Eq,
2804     FromOcamlRepIn,
2805     Hash,
2806     NoPosHash,
2807     Ord,
2808     PartialEq,
2809     PartialOrd,
2810     Serialize,
2811     ToOcamlRep
2812 )]
2813 #[rust_to_ocaml(and)]
2814 #[repr(C, u8)]
2815 pub enum CtxRefinement<'a> {
2816     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2817     CRexact(&'a Hint<'a>),
2818     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2819     CRloose(&'a CtxRefinementBounds<'a>),
2820 }
2821 impl<'a> TrivialDrop for CtxRefinement<'a> {}
2822 arena_deserializer::impl_deserialize_in_arena!(CtxRefinement<'arena>);
2823
2824 #[derive(
2825     Clone,
2826     Debug,
2827     Deserialize,
2828     Eq,
2829     FromOcamlRepIn,
2830     Hash,
2831     NoPosHash,
2832     Ord,
2833     PartialEq,
2834     PartialOrd,
2835     Serialize,
2836     ToOcamlRep
2837 )]
2838 #[rust_to_ocaml(and)]
2839 #[rust_to_ocaml(prefix = "cr_")]
2840 #[repr(C)]
2841 pub struct CtxRefinementBounds<'a> {
2842     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2843     pub lower: Option<&'a Hint<'a>>,
2844     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2845     pub upper: Option<&'a Hint<'a>>,
2846 }
2847 impl<'a> TrivialDrop for CtxRefinementBounds<'a> {}
2848 arena_deserializer::impl_deserialize_in_arena!(CtxRefinementBounds<'arena>);
2849
2850 #[derive(
2851     Clone,
2852     Debug,
2853     Deserialize,
2854     Eq,
2855     FromOcamlRepIn,
2856     Hash,
2857     NoPosHash,
2858     Ord,
2859     PartialEq,
2860     PartialOrd,
2861     Serialize,
2862     ToOcamlRep
2863 )]
2864 #[rust_to_ocaml(and)]
2865 #[rust_to_ocaml(prefix = "sfi_")]
2866 #[repr(C)]
2867 pub struct ShapeFieldInfo<'a> {
2868     pub optional: bool,
2869     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2870     pub hint: &'a Hint<'a>,
2871     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2872     pub name: ast_defs::ShapeFieldName<'a>,
2873 }
2874 impl<'a> TrivialDrop for ShapeFieldInfo<'a> {}
2875 arena_deserializer::impl_deserialize_in_arena!(ShapeFieldInfo<'arena>);
2876
2877 #[derive(
2878     Clone,
2879     Debug,
2880     Deserialize,
2881     Eq,
2882     FromOcamlRepIn,
2883     Hash,
2884     NoPosHash,
2885     Ord,
2886     PartialEq,
2887     PartialOrd,
2888     Serialize,
2889     ToOcamlRep
2890 )]
2891 #[rust_to_ocaml(and)]
2892 #[rust_to_ocaml(prefix = "nsi_")]
2893 #[repr(C)]
2894 pub struct NastShapeInfo<'a> {
2895     pub allows_unknown_fields: bool,
2896     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2897     pub field_map: &'a [&'a ShapeFieldInfo<'a>],
2898 }
2899 impl<'a> TrivialDrop for NastShapeInfo<'a> {}
2900 arena_deserializer::impl_deserialize_in_arena!(NastShapeInfo<'arena>);
2901
2902 pub use oxidized::aast_defs::KvcKind;
2903 pub use oxidized::aast_defs::VcKind;
2904
2905 #[derive(
2906     Clone,
2907     Debug,
2908     Deserialize,
2909     Eq,
2910     FromOcamlRepIn,
2911     Hash,
2912     NoPosHash,
2913     Ord,
2914     PartialEq,
2915     PartialOrd,
2916     Serialize,
2917     ToOcamlRep
2918 )]
2919 #[rust_to_ocaml(and)]
2920 #[rust_to_ocaml(prefix = "e_")]
2921 #[repr(C)]
2922 pub struct Enum_<'a> {
2923     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2924     pub base: &'a Hint<'a>,
2925     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2926     pub constraint: Option<&'a Hint<'a>>,
2927     #[serde(deserialize_with = "arena_deserializer::arena", borrow)]
2928     pub includes: &'a [&'a Hint<'a>],
2929 }
2930 impl<'a> TrivialDrop for Enum_<'a> {}
2931 arena_deserializer::impl_deserialize_in_arena!(Enum_<'arena>);
2932
2933 #[derive(
2934     Clone,
2935     Debug,
2936     Deserialize,
2937     Eq,
2938     FromOcamlRepIn,
2939     Hash,
2940     NoPosHash,
2941     Ord,
2942     PartialEq,
2943     PartialOrd,
2944     Serialize,
2945     ToOcamlRep
2946 )]
2947 #[rust_to_ocaml(and)]
2948 #[rust_to_ocaml(attr = r#"deriving ((show { with_path = false }), eq, ord,
2949     (visitors
2950        {
2951          variety = "iter";
2952          nude = true;
2953          visit_prefix = "on_";
2954          ancestors =
2955            ["Visitors_runtime.iter"; "Aast_defs_visitors_ancestors.iter"]
2956        }),
2957     (visitors
2958        {
2959          variety = "reduce";
2960          nude = true;
2961          visit_prefix = "on_";
2962          ancestors =
2963            ["Visitors_runtime.reduce"; "Aast_defs_visitors_ancestors.reduce"]
2964        }),
2965     (visitors
2966        {
2967          variety = "map";
2968          nude = true;
2969          visit_prefix = "on_";
2970          ancestors =
2971            ["Visitors_runtime.map"; "Aast_defs_visitors_ancestors.map"]
2972        }),
2973     (visitors
2974        {
2975          variety = "mapreduce";
2976          nude = true;
2977          visit_prefix = "on_";
2978          ancestors =
2979            ["Visitors_runtime.mapreduce";
2980            "Aast_defs_visitors_ancestors.mapreduce"]
2981        }),
2982     (visitors
2983        {
2984          variety = "endo";
2985          nude = true;
2986          visit_prefix = "on_";
2987          ancestors =
2988            ["Visitors_runtime.endo"; "Aast_defs_visitors_ancestors.endo"]
2989        }))"#)]
2990 #[repr(C)]
2991 pub struct WhereConstraintHint<'a>(
2992     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Hint<'a>,
2993     pub oxidized::ast_defs::ConstraintKind,
2994     #[serde(deserialize_with = "arena_deserializer::arena", borrow)] pub &'a Hint<'a>,
2995 );
2996 impl<'a> TrivialDrop for WhereConstraintHint<'a> {}
2997 arena_deserializer::impl_deserialize_in_arena!(WhereConstraintHint<'arena>);