impl<'a> ToNameBinding<'a> for (Module<'a>, Span, ty::Visibility) {
fn to_name_binding(self) -> NameBinding<'a> {
- NameBinding { kind: NameBindingKind::Module(self.0), span: Some(self.1), vis: self.2 }
+ NameBinding { kind: NameBindingKind::Module(self.0), span: self.1, vis: self.2 }
}
}
impl<'a> ToNameBinding<'a> for (Def, Span, ty::Visibility) {
fn to_name_binding(self) -> NameBinding<'a> {
- NameBinding { kind: NameBindingKind::Def(self.0), span: Some(self.1), vis: self.2 }
+ NameBinding { kind: NameBindingKind::Def(self.0), span: self.1, vis: self.2 }
}
}
if let Some(binding) = resolver.current_module
.resolve_name_in_lexical_scope(name, ValueNS) {
if binding.is_import() {
- err.span_note(binding.span.unwrap(), "constant imported here");
+ err.span_note(binding.span, "constant imported here");
}
}
err
#[derive(Clone, Debug)]
pub struct NameBinding<'a> {
kind: NameBindingKind<'a>,
- span: Option<Span>,
+ span: Span,
vis: ty::Visibility,
}
identifier: ident,
parameters: params,
};
- let span = name_binding.span.unwrap_or(syntax::codemap::DUMMY_SP);
+ let span = name_binding.span;
let mut segms = path_segments.clone();
segms.push(segment);
let segms = HirVec::from_vec(segms);
binding: &NameBinding,
old_binding: &NameBinding) {
// Error on the second of two conflicting names
- if old_binding.span.unwrap().lo > binding.span.unwrap().lo {
+ if old_binding.span.lo > binding.span.lo {
return self.report_conflict(parent, name, ns, old_binding, binding);
}
false => ("defined", "definition"),
};
- let span = binding.span.unwrap();
+ let span = binding.span;
let msg = {
let kind = match (ns, old_binding.module()) {
(ValueNS, _) => "a value",
},
};
- let span = old_binding.span.unwrap();
- if span != codemap::DUMMY_SP {
- err.span_note(span, &format!("previous {} of `{}` here", noun, name));
+ if old_binding.span != codemap::DUMMY_SP {
+ err.span_note(old_binding.span, &format!("previous {} of `{}` here", noun, name));
}
err.emit();
}
use syntax::ast::{NodeId, Name};
use syntax::attr::AttrMetaMethods;
-use syntax::codemap::Span;
+use syntax::codemap::{Span, DUMMY_SP};
use syntax::util::lev_distance::find_best_match_for_name;
use std::cell::{Cell, RefCell};
directive: self,
privacy_error: privacy_error,
},
- span: Some(self.span),
+ span: self.span,
vis: self.vis,
}
}
if let SingleImport { target, .. } = e.import_directive.subclass {
let dummy_binding = self.resolver.arenas.alloc_name_binding(NameBinding {
kind: NameBindingKind::Def(Def::Err),
- span: None,
+ span: DUMMY_SP,
vis: ty::Visibility::Public,
});
let dummy_binding = e.import_directive.import(dummy_binding, None);
(error E0364), consider declaring its enum as `pub`",
name);
let lint = lint::builtin::PRIVATE_IN_PUBLIC;
- self.resolver.session.add_lint(lint, directive.id, binding.span.unwrap(), msg);
+ self.resolver.session.add_lint(lint, directive.id, binding.span, msg);
}
}
}