}
}
+ /// 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]`).
+ pub fn allows_unsafe(&self) -> bool {
+ match self.ctxt.outer().expn_info() {
+ Some(info) => info.callee.allow_internal_unsafe,
+ None => false,
+ }
+ }
+
pub fn macro_backtrace(mut self) -> Vec<MacroBacktrace> {
let mut prev_span = DUMMY_SP;
let mut result = vec![];
if !info.call_site.source_equal(&prev_span) {
result.push(MacroBacktrace {
call_site: info.call_site,
- macro_decl_name: macro_decl_name,
- def_site_span: def_site_span,
+ macro_decl_name,
+ def_site_span,
});
}
pub label: Option<String>,
}
+impl Default for Span {
+ fn default() -> Self {
+ DUMMY_SP
+ }
+}
+
impl serialize::UseSpecializedEncodable for Span {
fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_struct("Span", 2, |s| {
&self.primary_spans
}
- /// Replaces all occurances of one Span with another. Used to move Spans in areas that don't
+ /// Replaces all occurrences of one Span with another. Used to move Spans in areas that don't
/// display well (like std macros). Returns true if replacements occurred.
pub fn replace(&mut self, before: Span, after: Span) -> bool {
let mut replacements_occurred = false;
for &(span, ref label) in &self.span_labels {
span_labels.push(SpanLabel {
- span: span,
+ span,
is_primary: is_primary(span),
label: Some(label.clone())
});
for &span in &self.primary_spans {
if !span_labels.iter().any(|sl| sl.span == span) {
span_labels.push(SpanLabel {
- span: span,
+ span,
is_primary: true,
label: None
});
let multibyte_chars: Vec<MultiByteChar> =
d.read_struct_field("multibyte_chars", 5, |d| Decodable::decode(d))?;
Ok(FileMap {
- name: name,
- name_was_remapped: name_was_remapped,
+ name,
+ name_was_remapped,
// `crate_of_origin` has to be set by the importer.
// This value matches up with rustc::hir::def_id::INVALID_CRATE.
// That constant is not available here unfortunately :(
crate_of_origin: ::std::u32::MAX - 1,
- start_pos: start_pos,
- end_pos: end_pos,
+ start_pos,
+ end_pos,
src: None,
- src_hash: src_hash,
+ src_hash,
external_src: RefCell::new(ExternalSource::AbsentOk),
lines: RefCell::new(lines),
multibyte_chars: RefCell::new(multibyte_chars)
let end_pos = start_pos.to_usize() + src.len();
FileMap {
- name: name,
- name_was_remapped: name_was_remapped,
+ name,
+ name_was_remapped,
crate_of_origin: 0,
src: Some(Rc::new(src)),
- src_hash: src_hash,
+ src_hash,
external_src: RefCell::new(ExternalSource::Unneeded),
- start_pos: start_pos,
+ start_pos,
end_pos: Pos::from_usize(end_pos),
lines: RefCell::new(Vec::new()),
multibyte_chars: RefCell::new(Vec::new()),
/// If the hash of the input doesn't match or no input is supplied via None,
/// it is interpreted as an error and the corresponding enum variant is set.
/// The return value signifies whether some kind of source is present.
- pub fn add_external_src(&self, src: Option<String>) -> bool {
+ pub fn add_external_src<F>(&self, get_src: F) -> bool
+ where F: FnOnce() -> Option<String>
+ {
if *self.external_src.borrow() == ExternalSource::AbsentOk {
+ let src = get_src();
let mut external_src = self.external_src.borrow_mut();
if let Some(src) = src {
let mut hasher: StableHasher<u128> = StableHasher::new();
pub fn record_multibyte_char(&self, pos: BytePos, bytes: usize) {
assert!(bytes >=2 && bytes <= 4);
let mbc = MultiByteChar {
- pos: pos,
- bytes: bytes,
+ pos,
+ bytes,
};
self.multibyte_chars.borrow_mut().push(mbc);
}