From 4acfef8f6319a1ae724ba174b4d87e0988d7e47d Mon Sep 17 00:00:00 2001 From: Hunter Praska Date: Sat, 12 Aug 2017 19:43:43 -0500 Subject: [PATCH 1/2] Implement CompilerDesugaringKind enum --- src/librustc/hir/lowering.rs | 3 ++- src/libsyntax_pos/hygiene.rs | 38 +++++++++++++++++++++++++++++++++--- src/libsyntax_pos/lib.rs | 13 +++++++++++- 3 files changed, 49 insertions(+), 5 deletions(-) diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index adf7d901be9c0..d8ea6f123ab54 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -397,11 +397,12 @@ impl<'a> LoweringContext<'a> { } fn allow_internal_unstable(&self, reason: &'static str, mut span: Span) -> Span { + let reason = codemap::CompilerDesugaringKind::from(reason); let mark = Mark::fresh(Mark::root()); mark.set_expn_info(codemap::ExpnInfo { call_site: span, callee: codemap::NameAndSpan { - format: codemap::CompilerDesugaring(Symbol::intern(reason)), + format: codemap::CompilerDesugaring(reason), span: Some(span), allow_internal_unstable: true, allow_internal_unsafe: false, diff --git a/src/libsyntax_pos/hygiene.rs b/src/libsyntax_pos/hygiene.rs index 514cc26666e39..6cef7775c3485 100644 --- a/src/libsyntax_pos/hygiene.rs +++ b/src/libsyntax_pos/hygiene.rs @@ -323,8 +323,8 @@ impl NameAndSpan { pub fn name(&self) -> Symbol { match self.format { ExpnFormat::MacroAttribute(s) | - ExpnFormat::MacroBang(s) | - ExpnFormat::CompilerDesugaring(s) => s, + ExpnFormat::MacroBang(s) => s, + ExpnFormat::CompilerDesugaring(ref kind) => kind.as_symbol(), } } } @@ -337,7 +337,39 @@ pub enum ExpnFormat { /// e.g. `format!()` MacroBang(Symbol), /// Desugaring done by the compiler during HIR lowering. - CompilerDesugaring(Symbol) + CompilerDesugaring(CompilerDesugaringKind) +} + +/// The kind of compiler desugaring. +#[derive(Clone, Hash, Debug, PartialEq, Eq)] +pub enum CompilerDesugaringKind { + BackArrow, + DotFill, + QuestionMark, +} + +impl CompilerDesugaringKind { + pub fn as_symbol(&self) -> Symbol { + use CompilerDesugaringKind::*; + let s = match *self { + BackArrow => "<-", + DotFill => "...", + QuestionMark => "?", + }; + Symbol::intern(s) + } +} + +impl<'a> From<&'a str> for CompilerDesugaringKind { + fn from(s: &'a str) -> Self { + use CompilerDesugaringKind::*; + match s { + "<-" => BackArrow, + "..." => DotFill, + "?" => QuestionMark, + _ => panic!("Invalid compiler desugaring"), + } + } } impl Encodable for SyntaxContext { diff --git a/src/libsyntax_pos/lib.rs b/src/libsyntax_pos/lib.rs index e162bc26412f2..f0e53c6408ca7 100644 --- a/src/libsyntax_pos/lib.rs +++ b/src/libsyntax_pos/lib.rs @@ -47,7 +47,7 @@ extern crate serialize; extern crate serialize as rustc_serialize; // used by deriving pub mod hygiene; -pub use hygiene::{SyntaxContext, ExpnInfo, ExpnFormat, NameAndSpan}; +pub use hygiene::{SyntaxContext, ExpnInfo, ExpnFormat, NameAndSpan, CompilerDesugaringKind}; pub mod symbol; @@ -153,6 +153,17 @@ impl Span { } } + /// Check if this span arises from a compiler desugaring of kind `kind`. + pub fn is_compiler_desugaring(&self, kind: CompilerDesugaringKind) -> bool { + match self.ctxt.outer().expn_info() { + Some(info) => match info.callee.format { + ExpnFormat::CompilerDesugaring(k) => k == kind, + _ => false, + }, + None => false, + } + } + /// Check if a span is "internal" to a macro in which `unsafe` /// can be used without triggering the `unsafe_code` lint // (that is, a macro marked with `#[allow_internal_unsafe]`). From ff047a8a25738badbb88b97edf0f8108b4bc356b Mon Sep 17 00:00:00 2001 From: Hunter Praska Date: Wed, 16 Aug 2017 18:46:48 -0500 Subject: [PATCH 2/2] Use direct references to CompilerDesugaringKind --- src/librustc/hir/lowering.rs | 19 ++++++++++++------- src/libsyntax_pos/hygiene.rs | 12 ------------ 2 files changed, 12 insertions(+), 19 deletions(-) diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index d8ea6f123ab54..1fc780952d272 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -59,7 +59,7 @@ use syntax::ast::*; use syntax::errors; use syntax::ext::hygiene::{Mark, SyntaxContext}; use syntax::ptr::P; -use syntax::codemap::{self, respan, Spanned}; +use syntax::codemap::{self, respan, Spanned, CompilerDesugaringKind}; use syntax::std_inject; use syntax::symbol::{Symbol, keywords}; use syntax::util::small_vector::SmallVector; @@ -396,8 +396,9 @@ impl<'a> LoweringContext<'a> { Symbol::gensym(s) } - fn allow_internal_unstable(&self, reason: &'static str, mut span: Span) -> Span { - let reason = codemap::CompilerDesugaringKind::from(reason); + fn allow_internal_unstable(&self, reason: CompilerDesugaringKind, mut span: Span) + -> Span + { let mark = Mark::fresh(Mark::root()); mark.set_expn_info(codemap::ExpnInfo { call_site: span, @@ -1763,7 +1764,8 @@ impl<'a> LoweringContext<'a> { let move_val_init = ["intrinsics", "move_val_init"]; let inplace_finalize = ["ops", "InPlace", "finalize"]; - let unstable_span = self.allow_internal_unstable("<-", e.span); + let unstable_span = + self.allow_internal_unstable(CompilerDesugaringKind::BackArrow, e.span); let make_call = |this: &mut LoweringContext, p, args| { let path = P(this.expr_std_path(unstable_span, p, ThinVec::new())); P(this.expr_call(e.span, path, args)) @@ -1976,12 +1978,14 @@ impl<'a> LoweringContext<'a> { e1.iter().map(|e| ("start", e)).chain(e2.iter().map(|e| ("end", e))) .map(|(s, e)| { let expr = P(self.lower_expr(&e)); - let unstable_span = self.allow_internal_unstable("...", e.span); + let unstable_span = + self.allow_internal_unstable(CompilerDesugaringKind::DotFill, e.span); self.field(Symbol::intern(s), expr, unstable_span) }).collect::>(); let is_unit = fields.is_empty(); - let unstable_span = self.allow_internal_unstable("...", e.span); + let unstable_span = + self.allow_internal_unstable(CompilerDesugaringKind::DotFill, e.span); let struct_path = iter::once("ops").chain(iter::once(path)) .collect::>(); @@ -2317,7 +2321,8 @@ impl<'a> LoweringContext<'a> { // return Try::from_error(From::from(err)), // } - let unstable_span = self.allow_internal_unstable("?", e.span); + let unstable_span = + self.allow_internal_unstable(CompilerDesugaringKind::QuestionMark, e.span); // Try::into_result() let discr = { diff --git a/src/libsyntax_pos/hygiene.rs b/src/libsyntax_pos/hygiene.rs index 6cef7775c3485..4ebde2a01c229 100644 --- a/src/libsyntax_pos/hygiene.rs +++ b/src/libsyntax_pos/hygiene.rs @@ -360,18 +360,6 @@ impl CompilerDesugaringKind { } } -impl<'a> From<&'a str> for CompilerDesugaringKind { - fn from(s: &'a str) -> Self { - use CompilerDesugaringKind::*; - match s { - "<-" => BackArrow, - "..." => DotFill, - "?" => QuestionMark, - _ => panic!("Invalid compiler desugaring"), - } - } -} - impl Encodable for SyntaxContext { fn encode(&self, _: &mut E) -> Result<(), E::Error> { Ok(()) // FIXME(jseyfried) intercrate hygiene