#![feature(const_fn)]
#![feature(crate_visibility_modifier)]
-#![feature(custom_attribute)]
#![feature(nll)]
#![feature(non_exhaustive)]
#![feature(optin_builtin_traits)]
extern crate serialize as rustc_serialize; // used by deriving
pub mod edition;
+use edition::Edition;
pub mod hygiene;
pub use hygiene::{Mark, SyntaxContext, ExpnInfo, ExpnFormat, CompilerDesugaringKind};
symbol_interner: Lock<symbol::Interner>,
span_interner: Lock<span_encoding::SpanInterner>,
hygiene_data: Lock<hygiene::HygieneData>,
+ edition: Edition,
}
impl Globals {
- pub fn new() -> Globals {
+ pub fn new(edition: Edition) -> Globals {
Globals {
symbol_interner: Lock::new(symbol::Interner::fresh()),
span_interner: Lock::new(span_encoding::SpanInterner::default()),
hygiene_data: Lock::new(hygiene::HygieneData::new()),
+ edition,
}
}
}
/// Returns the source span -- this is either the supplied span, or the span for
/// the macro callsite that expanded to it.
pub fn source_callsite(self) -> Span {
- self.ctxt().outer().expn_info().map(|info| info.call_site.source_callsite()).unwrap_or(self)
+ self.ctxt().outer_expn_info().map(|info| info.call_site.source_callsite()).unwrap_or(self)
}
/// The `Span` for the tokens in the previous macro expansion from which `self` was generated,
/// if any.
pub fn parent(self) -> Option<Span> {
- self.ctxt().outer().expn_info().map(|i| i.call_site)
+ self.ctxt().outer_expn_info().map(|i| i.call_site)
}
/// Edition of the crate from which this span came.
pub fn edition(self) -> edition::Edition {
- self.ctxt().outer().expn_info().map_or_else(|| hygiene::default_edition(),
- |einfo| einfo.edition)
+ self.ctxt().outer_expn_info().map_or_else(|| {
+ Edition::from_session()
+ }, |einfo| einfo.edition)
}
#[inline]
/// corresponding to the source callsite.
pub fn source_callee(self) -> Option<ExpnInfo> {
fn source_callee(info: ExpnInfo) -> ExpnInfo {
- match info.call_site.ctxt().outer().expn_info() {
+ match info.call_site.ctxt().outer_expn_info() {
Some(info) => source_callee(info),
None => info,
}
}
- self.ctxt().outer().expn_info().map(source_callee)
+ self.ctxt().outer_expn_info().map(source_callee)
}
/// Checks if a span is "internal" to a macro in which `#[unstable]`
/// items can be used (that is, a macro marked with
/// `#[allow_internal_unstable]`).
pub fn allows_unstable(&self, feature: Symbol) -> bool {
- match self.ctxt().outer().expn_info() {
+ match self.ctxt().outer_expn_info() {
Some(info) => info
.allow_internal_unstable
.map_or(false, |features| features.iter().any(|&f|
/// Checks 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() {
+ match self.ctxt().outer_expn_info() {
Some(info) => match info.format {
ExpnFormat::CompilerDesugaring(k) => k == kind,
_ => false,
/// Returns the compiler desugaring that created this span, or `None`
/// if this span is not from a desugaring.
pub fn compiler_desugaring_kind(&self) -> Option<CompilerDesugaringKind> {
- match self.ctxt().outer().expn_info() {
+ match self.ctxt().outer_expn_info() {
Some(info) => match info.format {
ExpnFormat::CompilerDesugaring(k) => Some(k),
_ => None
/// can be used without triggering the `unsafe_code` lint
// (that is, a macro marked with `#[allow_internal_unsafe]`).
pub fn allows_unsafe(&self) -> bool {
- match self.ctxt().outer().expn_info() {
+ match self.ctxt().outer_expn_info() {
Some(info) => info.allow_internal_unsafe,
None => false,
}
pub fn macro_backtrace(mut self) -> Vec<MacroBacktrace> {
let mut prev_span = DUMMY_SP;
let mut result = vec![];
- while let Some(info) = self.ctxt().outer().expn_info() {
+ while let Some(info) = self.ctxt().outer_expn_info() {
// Don't print recursive invocations.
if !info.call_site.source_equal(&prev_span) {
let (pre, post) = match info.format {
)
}
- pub fn from_inner_byte_pos(self, start: usize, end: usize) -> Span {
+ pub fn from_inner(self, inner: InnerSpan) -> Span {
let span = self.data();
- Span::new(span.lo + BytePos::from_usize(start),
- span.lo + BytePos::from_usize(end),
+ Span::new(span.lo + BytePos::from_usize(inner.start),
+ span.lo + BytePos::from_usize(inner.end),
span.ctxt)
}
}
#[inline]
- pub fn glob_adjust(&mut self, expansion: Mark, glob_ctxt: SyntaxContext)
- -> Option<Option<Mark>> {
+ pub fn modernize_and_adjust(&mut self, expansion: Mark) -> Option<Mark> {
let mut span = self.data();
- let mark = span.ctxt.glob_adjust(expansion, glob_ctxt);
+ let mark = span.ctxt.modernize_and_adjust(expansion);
*self = Span::new(span.lo, span.hi, span.ctxt);
mark
}
#[inline]
- pub fn reverse_glob_adjust(&mut self, expansion: Mark, glob_ctxt: SyntaxContext)
+ pub fn glob_adjust(&mut self, expansion: Mark, glob_span: Span) -> Option<Option<Mark>> {
+ let mut span = self.data();
+ let mark = span.ctxt.glob_adjust(expansion, glob_span);
+ *self = Span::new(span.lo, span.hi, span.ctxt);
+ mark
+ }
+
+ #[inline]
+ pub fn reverse_glob_adjust(&mut self, expansion: Mark, glob_span: Span)
-> Option<Option<Mark>> {
let mut span = self.data();
- let mark = span.ctxt.reverse_glob_adjust(expansion, glob_ctxt);
+ let mark = span.ctxt.reverse_glob_adjust(expansion, glob_span);
*self = Span::new(span.lo, span.hi, span.ctxt);
mark
}
pub end_pos: BytePos
}
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub struct InnerSpan {
+ pub start: usize,
+ pub end: usize,
+}
+
+impl InnerSpan {
+ pub fn new(start: usize, end: usize) -> InnerSpan {
+ InnerSpan { start, end }
+ }
+}
+
// Given a slice of line start positions and a position, returns the index of
// the line the position is on. Returns -1 if the position is located before
// the first line.
projects / rust.git / blobdiff