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<<05b80ca1176423ba7bdc6dae70db2964>>
   7 //
   8 // To regenerate this file, run:
   9 //   hphp/hack/src/oxidize_regen.sh
  10
  11 use arena_trait::TrivialDrop;
  12 use no_pos_hash::NoPosHash;
  13 use ocamlrep_derive::FromOcamlRep;
  14 use ocamlrep_derive::FromOcamlRepIn;
  15 use ocamlrep_derive::ToOcamlRep;
  16 use serde::Serialize;
  17
  18 #[allow(unused_imports)]
  19 use crate::*;
  20
  21 pub use crate::ast_defs::shape_map;
  22
  23 pub use ast_defs::OgNullFlavor;
  24 pub use ast_defs::Pos;
  25 pub use ast_defs::PositionedByteString;
  26 pub use ast_defs::Pstring;
  27 pub use local_id::LocalId;
  28 pub use shape_map::ShapeMap;
  29
  30 pub use oxidized::aast_defs::Visibility;
  31
  32 #[derive(
  33     Clone,
  34     Debug,
  35     Eq,
  36     FromOcamlRepIn,
  37     Hash,
  38     NoPosHash,
  39     Ord,
  40     PartialEq,
  41     PartialOrd,
  42     Serialize,
  43     ToOcamlRep
  44 )]
  45 pub struct Lid<'a>(pub &'a Pos<'a>, pub &'a LocalId<'a>);
  46 impl<'a> TrivialDrop for Lid<'a> {}
  47
  48 pub type Sid<'a> = ast_defs::Id<'a>;
  49
  50 pub use oxidized::aast_defs::IsReified;
  51
  52 pub use oxidized::aast_defs::FuncReactive;
  53
  54 pub use oxidized::aast_defs::ParamMutability;
  55
  56 pub use oxidized::aast_defs::ImportFlavor;
  57
  58 #[derive(
  59     Clone,
  60     Copy,
  61     Debug,
  62     Eq,
  63     FromOcamlRepIn,
  64     Hash,
  65     NoPosHash,
  66     Ord,
  67     PartialEq,
  68     PartialOrd,
  69     Serialize,
  70     ToOcamlRep
  71 )]
  72 pub enum XhpChild<'a> {
  73     ChildName(&'a Sid<'a>),
  74     ChildList(&'a [XhpChild<'a>]),
  75     ChildUnary(&'a (XhpChild<'a>, oxidized::aast_defs::XhpChildOp)),
  76     ChildBinary(&'a (XhpChild<'a>, XhpChild<'a>)),
  77 }
  78 impl<'a> TrivialDrop for XhpChild<'a> {}
  79
  80 pub use oxidized::aast_defs::XhpChildOp;
  81
  82 #[derive(
  83     Clone,
  84     Debug,
  85     Eq,
  86     FromOcamlRepIn,
  87     Hash,
  88     NoPosHash,
  89     Ord,
  90     PartialEq,
  91     PartialOrd,
  92     Serialize,
  93     ToOcamlRep
  94 )]
  95 pub struct Hint<'a>(pub &'a Pos<'a>, pub &'a Hint_<'a>);
  96 impl<'a> TrivialDrop for Hint<'a> {}
  97
  98 pub use oxidized::aast_defs::MutableReturn;
  99
 100 pub type VariadicHint<'a> = Option<&'a Hint<'a>>;
 101
 102 #[derive(
 103     Clone,
 104     Debug,
 105     Eq,
 106     FromOcamlRepIn,
 107     Hash,
 108     NoPosHash,
 109     Ord,
 110     PartialEq,
 111     PartialOrd,
 112     Serialize,
 113     ToOcamlRep
 114 )]
 115 pub struct Contexts<'a>(pub &'a Pos<'a>, pub &'a [&'a Hint<'a>]);
 116 impl<'a> TrivialDrop for Contexts<'a> {}
 117
 118 #[derive(
 119     Clone,
 120     Debug,
 121     Eq,
 122     FromOcamlRepIn,
 123     Hash,
 124     NoPosHash,
 125     Ord,
 126     PartialEq,
 127     PartialOrd,
 128     Serialize,
 129     ToOcamlRep
 130 )]
 131 pub struct HintFun<'a> {
 132     pub reactive_kind: oxidized::aast_defs::FuncReactive,
 133     pub param_tys: &'a [&'a Hint<'a>],
 134     pub param_kinds: &'a [Option<oxidized::ast_defs::ParamKind>],
 135     pub param_mutability: &'a [Option<oxidized::aast_defs::ParamMutability>],
 136     pub variadic_ty: &'a VariadicHint<'a>,
 137     pub ctxs: Option<&'a Contexts<'a>>,
 138     pub return_ty: &'a Hint<'a>,
 139     pub is_mutable_return: &'a oxidized::aast_defs::MutableReturn,
 140 }
 141 impl<'a> TrivialDrop for HintFun<'a> {}
 142
 143 #[derive(
 144     Clone,
 145     Copy,
 146     Debug,
 147     Eq,
 148     FromOcamlRepIn,
 149     Hash,
 150     NoPosHash,
 151     Ord,
 152     PartialEq,
 153     PartialOrd,
 154     Serialize,
 155     ToOcamlRep
 156 )]
 157 pub enum Hint_<'a> {
 158     Hoption(&'a Hint<'a>),
 159     Hlike(&'a Hint<'a>),
 160     Hfun(&'a HintFun<'a>),
 161     Htuple(&'a [&'a Hint<'a>]),
 162     Happly(&'a (Sid<'a>, &'a [&'a Hint<'a>])),
 163     Hshape(&'a NastShapeInfo<'a>),
 164     /// This represents the use of a type const. Type consts are accessed like
 165     /// regular consts in Hack, i.e.
 166     ///
 167     /// [$x | self | static | Class]::TypeConst
 168     ///
 169     /// Class  => Happly "Class"
 170     /// self   => Happly of the class of definition
 171     /// static => Habstr ("static",
 172     ///           Habstr ("this", (Constraint_as, Happly of class of definition)))
 173     /// $x     => Hvar "$x"
 174     ///
 175     /// Type const access can be chained such as
 176     ///
 177     /// Class::TC1::TC2::TC3
 178     ///
 179     /// We resolve the root of the type access chain as a type as follows.
 180     ///
 181     /// This will result in the following representation
 182     ///
 183     /// Haccess (Happly "Class", ["TC1", "TC2", "TC3"])
 184     Haccess(&'a (&'a Hint<'a>, &'a [Sid<'a>])),
 185     Hsoft(&'a Hint<'a>),
 186     Hany,
 187     Herr,
 188     Hmixed,
 189     Hnonnull,
 190     Habstr(&'a (&'a str, &'a [&'a Hint<'a>])),
 191     Hdarray(&'a (&'a Hint<'a>, &'a Hint<'a>)),
 192     Hvarray(&'a Hint<'a>),
 193     HvarrayOrDarray(&'a (Option<&'a Hint<'a>>, &'a Hint<'a>)),
 194     Hprim(&'a Tprim),
 195     Hthis,
 196     Hdynamic,
 197     Hnothing,
 198     Hunion(&'a [&'a Hint<'a>]),
 199     Hintersection(&'a [&'a Hint<'a>]),
 200     HfunContext(&'a str),
 201     Hvar(&'a str),
 202 }
 203 impl<'a> TrivialDrop for Hint_<'a> {}
 204
 205 /// AST types such as Happly("int", []) are resolved to Hprim values
 206 #[derive(
 207     Clone,
 208     Copy,
 209     Debug,
 210     Eq,
 211     FromOcamlRep,
 212     FromOcamlRepIn,
 213     Hash,
 214     NoPosHash,
 215     Ord,
 216     PartialEq,
 217     PartialOrd,
 218     Serialize,
 219     ToOcamlRep
 220 )]
 221 pub enum Tprim {
 222     Tnull,
 223     Tvoid,
 224     Tint,
 225     Tbool,
 226     Tfloat,
 227     Tstring,
 228     Tresource,
 229     Tnum,
 230     Tarraykey,
 231     Tnoreturn,
 232 }
 233 impl TrivialDrop for Tprim {}
 234
 235 #[derive(
 236     Clone,
 237     Debug,
 238     Eq,
 239     FromOcamlRepIn,
 240     Hash,
 241     NoPosHash,
 242     Ord,
 243     PartialEq,
 244     PartialOrd,
 245     Serialize,
 246     ToOcamlRep
 247 )]
 248 pub struct ShapeFieldInfo<'a> {
 249     pub optional: bool,
 250     pub hint: &'a Hint<'a>,
 251     pub name: ast_defs::ShapeFieldName<'a>,
 252 }
 253 impl<'a> TrivialDrop for ShapeFieldInfo<'a> {}
 254
 255 #[derive(
 256     Clone,
 257     Debug,
 258     Eq,
 259     FromOcamlRepIn,
 260     Hash,
 261     NoPosHash,
 262     Ord,
 263     PartialEq,
 264     PartialOrd,
 265     Serialize,
 266     ToOcamlRep
 267 )]
 268 pub struct NastShapeInfo<'a> {
 269     pub allows_unknown_fields: bool,
 270     pub field_map: &'a [&'a ShapeFieldInfo<'a>],
 271 }
 272 impl<'a> TrivialDrop for NastShapeInfo<'a> {}
 273
 274 pub use oxidized::aast_defs::KvcKind;
 275
 276 pub use oxidized::aast_defs::VcKind;
 277
 278 pub use oxidized::aast_defs::UseAsVisibility;
 279
 280 pub use oxidized::aast_defs::TypedefVisibility;
 281
 282 #[derive(
 283     Clone,
 284     Debug,
 285     Eq,
 286     FromOcamlRepIn,
 287     Hash,
 288     NoPosHash,
 289     Ord,
 290     PartialEq,
 291     PartialOrd,
 292     Serialize,
 293     ToOcamlRep
 294 )]
 295 pub struct Enum_<'a> {
 296     pub base: &'a Hint<'a>,
 297     pub constraint: Option<&'a Hint<'a>>,
 298     pub includes: &'a [&'a Hint<'a>],
 299     pub enum_class: bool,
 300 }
 301 impl<'a> TrivialDrop for Enum_<'a> {}
 302
 303 #[derive(
 304     Clone,
 305     Debug,
 306     Eq,
 307     FromOcamlRepIn,
 308     Hash,
 309     NoPosHash,
 310     Ord,
 311     PartialEq,
 312     PartialOrd,
 313     Serialize,
 314     ToOcamlRep
 315 )]
 316 pub struct WhereConstraintHint<'a>(
 317     pub &'a Hint<'a>,
 318     pub oxidized::ast_defs::ConstraintKind,
 319     pub &'a Hint<'a>,
 320 );
 321 impl<'a> TrivialDrop for WhereConstraintHint<'a> {}
 322
 323 pub use oxidized::aast_defs::ReifyKind;