src/libsyntax_pos/hygiene.rs

   1 //! Machinery for hygienic macros, inspired by the `MTWT[1]` paper.
   2 //!
   3 //! `[1]` Matthew Flatt, Ryan Culpepper, David Darais, and Robert Bruce Findler. 2012.
   4 //! *Macros that work together: Compile-time bindings, partial expansion,
   5 //! and definition contexts*. J. Funct. Program. 22, 2 (March 2012), 181-216.
   6 //! DOI=10.1017/S0956796812000093 <https://doi.org/10.1017/S0956796812000093>
   7
   8 use crate::GLOBALS;
   9 use crate::Span;
  10 use crate::edition::Edition;
  11 use crate::symbol::{kw, Symbol};
  12
  13 use serialize::{Encodable, Decodable, Encoder, Decoder};
  14 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
  15 use rustc_data_structures::sync::Lrc;
  16 use std::{fmt, mem};
  17
  18 /// A SyntaxContext represents a chain of macro expansions (represented by marks).
  19 #[derive(Clone, Copy, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
  20 pub struct SyntaxContext(u32);
  21
  22 #[derive(Copy, Clone, Debug)]
  23 struct SyntaxContextData {
  24     outer_mark: Mark,
  25     transparency: Transparency,
  26     prev_ctxt: SyntaxContext,
  27     /// This context, but with all transparent and semi-transparent marks filtered away.
  28     opaque: SyntaxContext,
  29     /// This context, but with all transparent marks filtered away.
  30     opaque_and_semitransparent: SyntaxContext,
  31     /// Name of the crate to which `$crate` with this context would resolve.
  32     dollar_crate_name: Symbol,
  33 }
  34
  35 /// A mark is a unique ID associated with a macro expansion.
  36 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)]
  37 pub struct Mark(u32);
  38
  39 #[derive(Clone, Debug)]
  40 struct MarkData {
  41     parent: Mark,
  42     default_transparency: Transparency,
  43     expn_info: Option<ExpnInfo>,
  44 }
  45
  46 /// A property of a macro expansion that determines how identifiers
  47 /// produced by that expansion are resolved.
  48 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Hash, Debug)]
  49 pub enum Transparency {
  50     /// Identifier produced by a transparent expansion is always resolved at call-site.
  51     /// Call-site spans in procedural macros, hygiene opt-out in `macro` should use this.
  52     Transparent,
  53     /// Identifier produced by a semi-transparent expansion may be resolved
  54     /// either at call-site or at definition-site.
  55     /// If it's a local variable, label or `$crate` then it's resolved at def-site.
  56     /// Otherwise it's resolved at call-site.
  57     /// `macro_rules` macros behave like this, built-in macros currently behave like this too,
  58     /// but that's an implementation detail.
  59     SemiTransparent,
  60     /// Identifier produced by an opaque expansion is always resolved at definition-site.
  61     /// Def-site spans in procedural macros, identifiers from `macro` by default use this.
  62     Opaque,
  63 }
  64
  65 impl Mark {
  66     pub fn fresh(parent: Mark) -> Self {
  67         HygieneData::with(|data| {
  68             data.marks.push(MarkData {
  69                 parent,
  70                 // By default expansions behave like `macro_rules`.
  71                 default_transparency: Transparency::SemiTransparent,
  72                 expn_info: None,
  73             });
  74             Mark(data.marks.len() as u32 - 1)
  75         })
  76     }
  77
  78     /// The mark of the theoretical expansion that generates freshly parsed, unexpanded AST.
  79     #[inline]
  80     pub fn root() -> Self {
  81         Mark(0)
  82     }
  83
  84     #[inline]
  85     pub fn as_u32(self) -> u32 {
  86         self.0
  87     }
  88
  89     #[inline]
  90     pub fn from_u32(raw: u32) -> Mark {
  91         Mark(raw)
  92     }
  93
  94     #[inline]
  95     pub fn parent(self) -> Mark {
  96         HygieneData::with(|data| data.marks[self.0 as usize].parent)
  97     }
  98
  99     #[inline]
 100     pub fn expn_info(self) -> Option<ExpnInfo> {
 101         HygieneData::with(|data| data.expn_info(self))
 102     }
 103
 104     #[inline]
 105     pub fn set_expn_info(self, info: ExpnInfo) {
 106         HygieneData::with(|data| data.marks[self.0 as usize].expn_info = Some(info))
 107     }
 108
 109     #[inline]
 110     pub fn set_default_transparency(self, transparency: Transparency) {
 111         assert_ne!(self, Mark::root());
 112         HygieneData::with(|data| data.marks[self.0 as usize].default_transparency = transparency)
 113     }
 114
 115     pub fn is_descendant_of(self, ancestor: Mark) -> bool {
 116         HygieneData::with(|data| data.is_descendant_of(self, ancestor))
 117     }
 118
 119     /// `mark.outer_is_descendant_of(ctxt)` is equivalent to but faster than
 120     /// `mark.is_descendant_of(ctxt.outer())`.
 121     pub fn outer_is_descendant_of(self, ctxt: SyntaxContext) -> bool {
 122         HygieneData::with(|data| data.is_descendant_of(self, data.outer(ctxt)))
 123     }
 124
 125     /// Computes a mark such that both input marks are descendants of (or equal to) the returned
 126     /// mark. That is, the following holds:
 127     ///
 128     /// ```rust
 129     /// let la = least_ancestor(a, b);
 130     /// assert!(a.is_descendant_of(la))
 131     /// assert!(b.is_descendant_of(la))
 132     /// ```
 133     pub fn least_ancestor(mut a: Mark, mut b: Mark) -> Mark {
 134         HygieneData::with(|data| {
 135             // Compute the path from a to the root
 136             let mut a_path = FxHashSet::<Mark>::default();
 137             while a != Mark::root() {
 138                 a_path.insert(a);
 139                 a = data.marks[a.0 as usize].parent;
 140             }
 141
 142             // While the path from b to the root hasn't intersected, move up the tree
 143             while !a_path.contains(&b) {
 144                 b = data.marks[b.0 as usize].parent;
 145             }
 146
 147             b
 148         })
 149     }
 150
 151     // Used for enabling some compatibility fallback in resolve.
 152     #[inline]
 153     pub fn looks_like_proc_macro_derive(self) -> bool {
 154         HygieneData::with(|data| {
 155             let mark_data = &data.marks[self.0 as usize];
 156             if mark_data.default_transparency == Transparency::Opaque {
 157                 if let Some(expn_info) = &mark_data.expn_info {
 158                     if let ExpnFormat::MacroAttribute(name) = expn_info.format {
 159                         if name.as_str().starts_with("derive(") {
 160                             return true;
 161                         }
 162                     }
 163                 }
 164             }
 165             false
 166         })
 167     }
 168 }
 169
 170 #[derive(Debug)]
 171 crate struct HygieneData {
 172     marks: Vec<MarkData>,
 173     syntax_contexts: Vec<SyntaxContextData>,
 174     markings: FxHashMap<(SyntaxContext, Mark, Transparency), SyntaxContext>,
 175 }
 176
 177 impl HygieneData {
 178     crate fn new() -> Self {
 179         HygieneData {
 180             marks: vec![MarkData {
 181                 parent: Mark::root(),
 182                 // If the root is opaque, then loops searching for an opaque mark
 183                 // will automatically stop after reaching it.
 184                 default_transparency: Transparency::Opaque,
 185                 expn_info: None,
 186             }],
 187             syntax_contexts: vec![SyntaxContextData {
 188                 outer_mark: Mark::root(),
 189                 transparency: Transparency::Opaque,
 190                 prev_ctxt: SyntaxContext(0),
 191                 opaque: SyntaxContext(0),
 192                 opaque_and_semitransparent: SyntaxContext(0),
 193                 dollar_crate_name: kw::DollarCrate,
 194             }],
 195             markings: FxHashMap::default(),
 196         }
 197     }
 198
 199     fn with<T, F: FnOnce(&mut HygieneData) -> T>(f: F) -> T {
 200         GLOBALS.with(|globals| f(&mut *globals.hygiene_data.borrow_mut()))
 201     }
 202
 203     fn expn_info(&self, mark: Mark) -> Option<ExpnInfo> {
 204         self.marks[mark.0 as usize].expn_info.clone()
 205     }
 206
 207     fn is_descendant_of(&self, mut mark: Mark, ancestor: Mark) -> bool {
 208         while mark != ancestor {
 209             if mark == Mark::root() {
 210                 return false;
 211             }
 212             mark = self.marks[mark.0 as usize].parent;
 213         }
 214         true
 215     }
 216
 217     fn default_transparency(&self, mark: Mark) -> Transparency {
 218         self.marks[mark.0 as usize].default_transparency
 219     }
 220
 221     fn modern(&self, ctxt: SyntaxContext) -> SyntaxContext {
 222         self.syntax_contexts[ctxt.0 as usize].opaque
 223     }
 224
 225     fn modern_and_legacy(&self, ctxt: SyntaxContext) -> SyntaxContext {
 226         self.syntax_contexts[ctxt.0 as usize].opaque_and_semitransparent
 227     }
 228
 229     fn outer(&self, ctxt: SyntaxContext) -> Mark {
 230         self.syntax_contexts[ctxt.0 as usize].outer_mark
 231     }
 232
 233     fn transparency(&self, ctxt: SyntaxContext) -> Transparency {
 234         self.syntax_contexts[ctxt.0 as usize].transparency
 235     }
 236
 237     fn prev_ctxt(&self, ctxt: SyntaxContext) -> SyntaxContext {
 238         self.syntax_contexts[ctxt.0 as usize].prev_ctxt
 239     }
 240
 241     fn remove_mark(&self, ctxt: &mut SyntaxContext) -> Mark {
 242         let outer_mark = self.syntax_contexts[ctxt.0 as usize].outer_mark;
 243         *ctxt = self.prev_ctxt(*ctxt);
 244         outer_mark
 245     }
 246
 247     fn marks(&self, mut ctxt: SyntaxContext) -> Vec<(Mark, Transparency)> {
 248         let mut marks = Vec::new();
 249         while ctxt != SyntaxContext::empty() {
 250             let outer_mark = self.outer(ctxt);
 251             let transparency = self.transparency(ctxt);
 252             let prev_ctxt = self.prev_ctxt(ctxt);
 253             marks.push((outer_mark, transparency));
 254             ctxt = prev_ctxt;
 255         }
 256         marks.reverse();
 257         marks
 258     }
 259
 260     fn adjust(&self, ctxt: &mut SyntaxContext, expansion: Mark) -> Option<Mark> {
 261         let mut scope = None;
 262         while !self.is_descendant_of(expansion, self.outer(*ctxt)) {
 263             scope = Some(self.remove_mark(ctxt));
 264         }
 265         scope
 266     }
 267 }
 268
 269 pub fn clear_markings() {
 270     HygieneData::with(|data| data.markings = FxHashMap::default());
 271 }
 272
 273 impl SyntaxContext {
 274     #[inline]
 275     pub const fn empty() -> Self {
 276         SyntaxContext(0)
 277     }
 278
 279     #[inline]
 280     crate fn as_u32(self) -> u32 {
 281         self.0
 282     }
 283
 284     #[inline]
 285     crate fn from_u32(raw: u32) -> SyntaxContext {
 286         SyntaxContext(raw)
 287     }
 288
 289     // Allocate a new SyntaxContext with the given ExpnInfo. This is used when
 290     // deserializing Spans from the incr. comp. cache.
 291     // FIXME(mw): This method does not restore MarkData::parent or
 292     // SyntaxContextData::prev_ctxt or SyntaxContextData::opaque. These things
 293     // don't seem to be used after HIR lowering, so everything should be fine
 294     // as long as incremental compilation does not kick in before that.
 295     pub fn allocate_directly(expansion_info: ExpnInfo) -> Self {
 296         HygieneData::with(|data| {
 297             data.marks.push(MarkData {
 298                 parent: Mark::root(),
 299                 default_transparency: Transparency::SemiTransparent,
 300                 expn_info: Some(expansion_info),
 301             });
 302
 303             let mark = Mark(data.marks.len() as u32 - 1);
 304
 305             data.syntax_contexts.push(SyntaxContextData {
 306                 outer_mark: mark,
 307                 transparency: Transparency::SemiTransparent,
 308                 prev_ctxt: SyntaxContext::empty(),
 309                 opaque: SyntaxContext::empty(),
 310                 opaque_and_semitransparent: SyntaxContext::empty(),
 311                 dollar_crate_name: kw::DollarCrate,
 312             });
 313             SyntaxContext(data.syntax_contexts.len() as u32 - 1)
 314         })
 315     }
 316
 317     /// Extend a syntax context with a given mark and default transparency for that mark.
 318     pub fn apply_mark(self, mark: Mark) -> SyntaxContext {
 319         assert_ne!(mark, Mark::root());
 320         self.apply_mark_with_transparency(
 321             mark, HygieneData::with(|data| data.default_transparency(mark))
 322         )
 323     }
 324
 325     /// Extend a syntax context with a given mark and transparency
 326     pub fn apply_mark_with_transparency(self, mark: Mark, transparency: Transparency)
 327                                         -> SyntaxContext {
 328         assert_ne!(mark, Mark::root());
 329         if transparency == Transparency::Opaque {
 330             return self.apply_mark_internal(mark, transparency);
 331         }
 332
 333         let call_site_ctxt =
 334             mark.expn_info().map_or(SyntaxContext::empty(), |info| info.call_site.ctxt());
 335         let call_site_ctxt = if transparency == Transparency::SemiTransparent {
 336             call_site_ctxt.modern()
 337         } else {
 338             call_site_ctxt.modern_and_legacy()
 339         };
 340
 341         if call_site_ctxt == SyntaxContext::empty() {
 342             return self.apply_mark_internal(mark, transparency);
 343         }
 344
 345         // Otherwise, `mark` is a macros 1.0 definition and the call site is in a
 346         // macros 2.0 expansion, i.e., a macros 1.0 invocation is in a macros 2.0 definition.
 347         //
 348         // In this case, the tokens from the macros 1.0 definition inherit the hygiene
 349         // at their invocation. That is, we pretend that the macros 1.0 definition
 350         // was defined at its invocation (i.e., inside the macros 2.0 definition)
 351         // so that the macros 2.0 definition remains hygienic.
 352         //
 353         // See the example at `test/run-pass/hygiene/legacy_interaction.rs`.
 354         let mut ctxt = call_site_ctxt;
 355         for (mark, transparency) in self.marks() {
 356             ctxt = ctxt.apply_mark_internal(mark, transparency);
 357         }
 358         ctxt.apply_mark_internal(mark, transparency)
 359     }
 360
 361     fn apply_mark_internal(self, mark: Mark, transparency: Transparency) -> SyntaxContext {
 362         HygieneData::with(|data| {
 363             let syntax_contexts = &mut data.syntax_contexts;
 364             let mut opaque = syntax_contexts[self.0 as usize].opaque;
 365             let mut opaque_and_semitransparent =
 366                 syntax_contexts[self.0 as usize].opaque_and_semitransparent;
 367
 368             if transparency >= Transparency::Opaque {
 369                 let prev_ctxt = opaque;
 370                 opaque = *data.markings.entry((prev_ctxt, mark, transparency)).or_insert_with(|| {
 371                     let new_opaque = SyntaxContext(syntax_contexts.len() as u32);
 372                     syntax_contexts.push(SyntaxContextData {
 373                         outer_mark: mark,
 374                         transparency,
 375                         prev_ctxt,
 376                         opaque: new_opaque,
 377                         opaque_and_semitransparent: new_opaque,
 378                         dollar_crate_name: kw::DollarCrate,
 379                     });
 380                     new_opaque
 381                 });
 382             }
 383
 384             if transparency >= Transparency::SemiTransparent {
 385                 let prev_ctxt = opaque_and_semitransparent;
 386                 opaque_and_semitransparent =
 387                         *data.markings.entry((prev_ctxt, mark, transparency)).or_insert_with(|| {
 388                     let new_opaque_and_semitransparent =
 389                         SyntaxContext(syntax_contexts.len() as u32);
 390                     syntax_contexts.push(SyntaxContextData {
 391                         outer_mark: mark,
 392                         transparency,
 393                         prev_ctxt,
 394                         opaque,
 395                         opaque_and_semitransparent: new_opaque_and_semitransparent,
 396                         dollar_crate_name: kw::DollarCrate,
 397                     });
 398                     new_opaque_and_semitransparent
 399                 });
 400             }
 401
 402             let prev_ctxt = self;
 403             *data.markings.entry((prev_ctxt, mark, transparency)).or_insert_with(|| {
 404                 let new_opaque_and_semitransparent_and_transparent =
 405                     SyntaxContext(syntax_contexts.len() as u32);
 406                 syntax_contexts.push(SyntaxContextData {
 407                     outer_mark: mark,
 408                     transparency,
 409                     prev_ctxt,
 410                     opaque,
 411                     opaque_and_semitransparent,
 412                     dollar_crate_name: kw::DollarCrate,
 413                 });
 414                 new_opaque_and_semitransparent_and_transparent
 415             })
 416         })
 417     }
 418
 419     /// Pulls a single mark off of the syntax context. This effectively moves the
 420     /// context up one macro definition level. That is, if we have a nested macro
 421     /// definition as follows:
 422     ///
 423     /// ```rust
 424     /// macro_rules! f {
 425     ///    macro_rules! g {
 426     ///        ...
 427     ///    }
 428     /// }
 429     /// ```
 430     ///
 431     /// and we have a SyntaxContext that is referring to something declared by an invocation
 432     /// of g (call it g1), calling remove_mark will result in the SyntaxContext for the
 433     /// invocation of f that created g1.
 434     /// Returns the mark that was removed.
 435     pub fn remove_mark(&mut self) -> Mark {
 436         HygieneData::with(|data| data.remove_mark(self))
 437     }
 438
 439     pub fn marks(self) -> Vec<(Mark, Transparency)> {
 440         HygieneData::with(|data| data.marks(self))
 441     }
 442
 443     /// Adjust this context for resolution in a scope created by the given expansion.
 444     /// For example, consider the following three resolutions of `f`:
 445     ///
 446     /// ```rust
 447     /// mod foo { pub fn f() {} } // `f`'s `SyntaxContext` is empty.
 448     /// m!(f);
 449     /// macro m($f:ident) {
 450     ///     mod bar {
 451     ///         pub fn f() {} // `f`'s `SyntaxContext` has a single `Mark` from `m`.
 452     ///         pub fn $f() {} // `$f`'s `SyntaxContext` is empty.
 453     ///     }
 454     ///     foo::f(); // `f`'s `SyntaxContext` has a single `Mark` from `m`
 455     ///     //^ Since `mod foo` is outside this expansion, `adjust` removes the mark from `f`,
 456     ///     //| and it resolves to `::foo::f`.
 457     ///     bar::f(); // `f`'s `SyntaxContext` has a single `Mark` from `m`
 458     ///     //^ Since `mod bar` not outside this expansion, `adjust` does not change `f`,
 459     ///     //| and it resolves to `::bar::f`.
 460     ///     bar::$f(); // `f`'s `SyntaxContext` is empty.
 461     ///     //^ Since `mod bar` is not outside this expansion, `adjust` does not change `$f`,
 462     ///     //| and it resolves to `::bar::$f`.
 463     /// }
 464     /// ```
 465     /// This returns the expansion whose definition scope we use to privacy check the resolution,
 466     /// or `None` if we privacy check as usual (i.e., not w.r.t. a macro definition scope).
 467     pub fn adjust(&mut self, expansion: Mark) -> Option<Mark> {
 468         HygieneData::with(|data| data.adjust(self, expansion))
 469     }
 470
 471     /// Adjust this context for resolution in a scope created by the given expansion
 472     /// via a glob import with the given `SyntaxContext`.
 473     /// For example:
 474     ///
 475     /// ```rust
 476     /// m!(f);
 477     /// macro m($i:ident) {
 478     ///     mod foo {
 479     ///         pub fn f() {} // `f`'s `SyntaxContext` has a single `Mark` from `m`.
 480     ///         pub fn $i() {} // `$i`'s `SyntaxContext` is empty.
 481     ///     }
 482     ///     n(f);
 483     ///     macro n($j:ident) {
 484     ///         use foo::*;
 485     ///         f(); // `f`'s `SyntaxContext` has a mark from `m` and a mark from `n`
 486     ///         //^ `glob_adjust` removes the mark from `n`, so this resolves to `foo::f`.
 487     ///         $i(); // `$i`'s `SyntaxContext` has a mark from `n`
 488     ///         //^ `glob_adjust` removes the mark from `n`, so this resolves to `foo::$i`.
 489     ///         $j(); // `$j`'s `SyntaxContext` has a mark from `m`
 490     ///         //^ This cannot be glob-adjusted, so this is a resolution error.
 491     ///     }
 492     /// }
 493     /// ```
 494     /// This returns `None` if the context cannot be glob-adjusted.
 495     /// Otherwise, it returns the scope to use when privacy checking (see `adjust` for details).
 496     pub fn glob_adjust(&mut self, expansion: Mark, glob_span: Span) -> Option<Option<Mark>> {
 497         let mut scope = None;
 498         let mut glob_ctxt = glob_span.ctxt().modern();
 499         while !expansion.outer_is_descendant_of(glob_ctxt) {
 500             scope = Some(glob_ctxt.remove_mark());
 501             if self.remove_mark() != scope.unwrap() {
 502                 return None;
 503             }
 504         }
 505         if self.adjust(expansion).is_some() {
 506             return None;
 507         }
 508         Some(scope)
 509     }
 510
 511     /// Undo `glob_adjust` if possible:
 512     ///
 513     /// ```rust
 514     /// if let Some(privacy_checking_scope) = self.reverse_glob_adjust(expansion, glob_ctxt) {
 515     ///     assert!(self.glob_adjust(expansion, glob_ctxt) == Some(privacy_checking_scope));
 516     /// }
 517     /// ```
 518     pub fn reverse_glob_adjust(&mut self, expansion: Mark, glob_span: Span)
 519                                -> Option<Option<Mark>> {
 520         if self.adjust(expansion).is_some() {
 521             return None;
 522         }
 523
 524         let mut glob_ctxt = glob_span.ctxt().modern();
 525         let mut marks = Vec::new();
 526         while !expansion.outer_is_descendant_of(glob_ctxt) {
 527             marks.push(glob_ctxt.remove_mark());
 528         }
 529
 530         let scope = marks.last().cloned();
 531         while let Some(mark) = marks.pop() {
 532             *self = self.apply_mark(mark);
 533         }
 534         Some(scope)
 535     }
 536
 537     #[inline]
 538     pub fn modern(self) -> SyntaxContext {
 539         HygieneData::with(|data| data.modern(self))
 540     }
 541
 542     #[inline]
 543     pub fn modern_and_legacy(self) -> SyntaxContext {
 544         HygieneData::with(|data| data.modern_and_legacy(self))
 545     }
 546
 547     #[inline]
 548     pub fn outer(self) -> Mark {
 549         HygieneData::with(|data| data.outer(self))
 550     }
 551
 552     /// `ctxt.outer_expn_info()` is equivalent to but faster than
 553     /// `ctxt.outer().expn_info()`.
 554     #[inline]
 555     pub fn outer_expn_info(self) -> Option<ExpnInfo> {
 556         HygieneData::with(|data| data.expn_info(data.outer(self)))
 557     }
 558
 559     pub fn dollar_crate_name(self) -> Symbol {
 560         HygieneData::with(|data| data.syntax_contexts[self.0 as usize].dollar_crate_name)
 561     }
 562
 563     pub fn set_dollar_crate_name(self, dollar_crate_name: Symbol) {
 564         HygieneData::with(|data| {
 565             let prev_dollar_crate_name = mem::replace(
 566                 &mut data.syntax_contexts[self.0 as usize].dollar_crate_name, dollar_crate_name
 567             );
 568             assert!(dollar_crate_name == prev_dollar_crate_name ||
 569                     prev_dollar_crate_name == kw::DollarCrate,
 570                     "$crate name is reset for a syntax context");
 571         })
 572     }
 573 }
 574
 575 impl fmt::Debug for SyntaxContext {
 576     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 577         write!(f, "#{}", self.0)
 578     }
 579 }
 580
 581 /// Extra information for tracking spans of macro and syntax sugar expansion
 582 #[derive(Clone, Hash, Debug, RustcEncodable, RustcDecodable)]
 583 pub struct ExpnInfo {
 584     /// The location of the actual macro invocation or syntax sugar , e.g.
 585     /// `let x = foo!();` or `if let Some(y) = x {}`
 586     ///
 587     /// This may recursively refer to other macro invocations, e.g., if
 588     /// `foo!()` invoked `bar!()` internally, and there was an
 589     /// expression inside `bar!`; the call_site of the expression in
 590     /// the expansion would point to the `bar!` invocation; that
 591     /// call_site span would have its own ExpnInfo, with the call_site
 592     /// pointing to the `foo!` invocation.
 593     pub call_site: Span,
 594     /// The span of the macro definition itself. The macro may not
 595     /// have a sensible definition span (e.g., something defined
 596     /// completely inside libsyntax) in which case this is None.
 597     /// This span serves only informational purpose and is not used for resolution.
 598     pub def_site: Option<Span>,
 599     /// The format with which the macro was invoked.
 600     pub format: ExpnFormat,
 601     /// List of #[unstable]/feature-gated features that the macro is allowed to use
 602     /// internally without forcing the whole crate to opt-in
 603     /// to them.
 604     pub allow_internal_unstable: Option<Lrc<[Symbol]>>,
 605     /// Whether the macro is allowed to use `unsafe` internally
 606     /// even if the user crate has `#![forbid(unsafe_code)]`.
 607     pub allow_internal_unsafe: bool,
 608     /// Enables the macro helper hack (`ident!(...)` -> `$crate::ident!(...)`)
 609     /// for a given macro.
 610     pub local_inner_macros: bool,
 611     /// Edition of the crate in which the macro is defined.
 612     pub edition: Edition,
 613 }
 614
 615 /// The source of expansion.
 616 #[derive(Clone, Hash, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable)]
 617 pub enum ExpnFormat {
 618     /// e.g., #[derive(...)] <item>
 619     MacroAttribute(Symbol),
 620     /// e.g., `format!()`
 621     MacroBang(Symbol),
 622     /// Desugaring done by the compiler during HIR lowering.
 623     CompilerDesugaring(CompilerDesugaringKind)
 624 }
 625
 626 impl ExpnFormat {
 627     pub fn name(&self) -> Symbol {
 628         match *self {
 629             ExpnFormat::MacroBang(name) | ExpnFormat::MacroAttribute(name) => name,
 630             ExpnFormat::CompilerDesugaring(kind) => kind.name(),
 631         }
 632     }
 633 }
 634
 635 /// The kind of compiler desugaring.
 636 #[derive(Clone, Copy, Hash, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable)]
 637 pub enum CompilerDesugaringKind {
 638     /// We desugar `if c { i } else { e }` to `match $ExprKind::Use(c) { true => i, _ => e }`.
 639     /// However, we do not want to blame `c` for unreachability but rather say that `i`
 640     /// is unreachable. This desugaring kind allows us to avoid blaming `c`.
 641     IfTemporary,
 642     QuestionMark,
 643     TryBlock,
 644     /// Desugaring of an `impl Trait` in return type position
 645     /// to an `existential type Foo: Trait;` and replacing the
 646     /// `impl Trait` with `Foo`.
 647     ExistentialReturnType,
 648     Async,
 649     Await,
 650     ForLoop,
 651 }
 652
 653 impl CompilerDesugaringKind {
 654     pub fn name(self) -> Symbol {
 655         Symbol::intern(match self {
 656             CompilerDesugaringKind::IfTemporary => "if",
 657             CompilerDesugaringKind::Async => "async",
 658             CompilerDesugaringKind::Await => "await",
 659             CompilerDesugaringKind::QuestionMark => "?",
 660             CompilerDesugaringKind::TryBlock => "try block",
 661             CompilerDesugaringKind::ExistentialReturnType => "existential type",
 662             CompilerDesugaringKind::ForLoop => "for loop",
 663         })
 664     }
 665 }
 666
 667 impl Encodable for SyntaxContext {
 668     fn encode<E: Encoder>(&self, _: &mut E) -> Result<(), E::Error> {
 669         Ok(()) // FIXME(jseyfried) intercrate hygiene
 670     }
 671 }
 672
 673 impl Decodable for SyntaxContext {
 674     fn decode<D: Decoder>(_: &mut D) -> Result<SyntaxContext, D::Error> {
 675         Ok(SyntaxContext::empty()) // FIXME(jseyfried) intercrate hygiene
 676     }
 677 }