- Successful merges: #30272, #30286, #30365, #30381, #30384, #30398, #30406, #30408, #30420, #30431, #30447, #30452
- Failed merges:
breaking existing macros.
The macro system does not deal with parse ambiguity at all. For example, the
-grammar `$($t:ty)* $e:expr` will always fail to parse, because the parser would
-be forced to choose between parsing `$t` and parsing `$e`. Changing the
+grammar `$($i:ident)* $e:expr` will always fail to parse, because the parser would
+be forced to choose between parsing `$i` and parsing `$e`. Changing the
invocation syntax to put a distinctive token in front can solve the problem. In
-this case, you can write `$(T $t:ty)* E $e:exp`.
+this case, you can write `$(I $i:ident)* E $e:expr`.
[item]: ../reference.html#items
they introduce shadowing. For example:
```rust
-let x = 'x';
+let x = 1;
let c = 'c';
match c {
```text
x: c c: c
-x: x
+x: 1
```
In other words, `x =>` matches the pattern and introduces a new binding named
-`x` that’s in scope for the match arm. Because we already have a binding named
-`x`, this new `x` shadows it.
+`x`. This new binding is in scope for the match arm and takes on the value of
+`c`. Notice that the value of `x` outside the scope of the match has no bearing
+on the value of `x` within it. Because we already have a binding named `x`, this
+new `x` shadows it.
# Multiple patterns
use rustc_front::util;
use rustc_front::intravisit as hir_visit;
use syntax::visit as ast_visit;
-use syntax::diagnostic;
+use syntax::errors;
/// Information about the registered lints.
///
match (sess, from_plugin) {
// We load builtin lints first, so a duplicate is a compiler bug.
// Use early_error when handling -W help with no crate.
- (None, _) => early_error(diagnostic::Auto, &msg[..]),
+ (None, _) => early_error(errors::ColorConfig::Auto, &msg[..]),
(Some(sess), false) => sess.bug(&msg[..]),
// A duplicate name from a plugin is a user error.
match (sess, from_plugin) {
// We load builtin lints first, so a duplicate is a compiler bug.
// Use early_error when handling -W help with no crate.
- (None, _) => early_error(diagnostic::Auto, &msg[..]),
+ (None, _) => early_error(errors::ColorConfig::Auto, &msg[..]),
(Some(sess), false) => sess.bug(&msg[..]),
// A duplicate name from a plugin is a user error.
ty::TyEnum(adt, _) | ty::TyStruct(adt, _) => {
let v = adt.variant_of_ctor(ctor);
if let VariantKind::Struct = v.kind() {
- let field_pats: Vec<_> = v.fields.iter()
+ let field_pats: hir::HirVec<_> = v.fields.iter()
.zip(pats)
.filter(|&(_, ref pat)| pat.node != hir::PatWild)
.map(|(field, pat)| Spanned {
ty::TyArray(_, n) => match ctor {
&Single => {
assert_eq!(pats_len, n);
- hir::PatVec(pats.collect(), None, vec!())
+ hir::PatVec(pats.collect(), None, hir::HirVec::new())
},
_ => unreachable!()
},
ty::TySlice(_) => match ctor {
&Slice(n) => {
assert_eq!(pats_len, n);
- hir::PatVec(pats.collect(), None, vec!())
+ hir::PatVec(pats.collect(), None, hir::HirVec::new())
},
_ => unreachable!()
},
ty::TyArray(_, len) => {
assert_eq!(pats_len, len);
- hir::PatVec(pats.collect(), None, vec![])
+ hir::PatVec(pats.collect(), None, hir::HirVec::new())
}
_ => {
hir::ExprVec(ref exprs) => {
let pats = exprs.iter().map(|expr| const_expr_to_pat(tcx, &**expr, span)).collect();
- hir::PatVec(pats, None, vec![])
+ hir::PatVec(pats, None, hir::HirVec::new())
}
hir::ExprPath(_, ref path) => {
let opt_def = tcx.def_map.borrow().get(&expr.id).map(|d| d.full_def());
match opt_def {
Some(def::DefStruct(..)) =>
- hir::PatStruct(path.clone(), vec![], false),
+ hir::PatStruct(path.clone(), hir::HirVec::new(), false),
Some(def::DefVariant(..)) =>
hir::PatEnum(path.clone(), None),
_ => {
self.delegate.consume(consume_id, consume_span, cmt, mode);
}
- fn consume_exprs(&mut self, exprs: &Vec<P<hir::Expr>>) {
+ fn consume_exprs(&mut self, exprs: &[P<hir::Expr>]) {
for expr in exprs {
self.consume_expr(&**expr);
}
fn walk_struct_expr(&mut self,
_expr: &hir::Expr,
- fields: &Vec<hir::Field>,
+ fields: &[hir::Field],
opt_with: &Option<P<hir::Expr>>) {
// Consume the expressions supplying values for each field.
for field in fields {
self.walk_expr(with_expr);
fn contains_field_named(field: ty::FieldDef,
- fields: &Vec<hir::Field>)
+ fields: &[hir::Field])
-> bool
{
fields.iter().any(
use std::char::from_u32;
use std::fmt;
use syntax::ast;
-use syntax::owned_slice::OwnedSlice;
use syntax::codemap::{self, Pos, Span};
use syntax::parse::token;
use syntax::ptr::P;
}
fn rebuild_ty_params(&self,
- ty_params: OwnedSlice<hir::TyParam>,
+ ty_params: P<[hir::TyParam]>,
lifetime: hir::Lifetime,
region_names: &HashSet<ast::Name>)
- -> OwnedSlice<hir::TyParam> {
+ -> P<[hir::TyParam]> {
ty_params.map(|ty_param| {
let bounds = self.rebuild_ty_param_bounds(ty_param.bounds.clone(),
lifetime,
}
fn rebuild_ty_param_bounds(&self,
- ty_param_bounds: OwnedSlice<hir::TyParamBound>,
+ ty_param_bounds: hir::TyParamBounds,
lifetime: hir::Lifetime,
region_names: &HashSet<ast::Name>)
- -> OwnedSlice<hir::TyParamBound> {
+ -> hir::TyParamBounds {
ty_param_bounds.map(|tpb| {
match tpb {
&hir::RegionTyParamBound(lt) => {
add: &Vec<hir::Lifetime>,
keep: &HashSet<ast::Name>,
remove: &HashSet<ast::Name>,
- ty_params: OwnedSlice<hir::TyParam>,
+ ty_params: P<[hir::TyParam]>,
where_clause: hir::WhereClause)
-> hir::Generics {
let mut lifetimes = Vec::new();
for lt in add {
lifetimes.push(hir::LifetimeDef { lifetime: *lt,
- bounds: Vec::new() });
+ bounds: hir::HirVec::new() });
}
for lt in &generics.lifetimes {
if keep.contains(<.lifetime.name) ||
}
}
hir::Generics {
- lifetimes: lifetimes,
+ lifetimes: lifetimes.into(),
ty_params: ty_params,
where_clause: where_clause,
}
lifetime: hir::Lifetime,
anon_nums: &HashSet<u32>,
region_names: &HashSet<ast::Name>)
- -> Vec<hir::Arg> {
+ -> hir::HirVec<hir::Arg> {
let mut new_inputs = Vec::new();
for arg in inputs {
let new_ty = self.rebuild_arg_ty_or_output(&*arg.ty, lifetime,
};
new_inputs.push(possibly_new_arg);
}
- new_inputs
+ new_inputs.into()
}
fn rebuild_output(&self, ty: &hir::FunctionRetTy,
}
});
hir::AngleBracketedParameters(hir::AngleBracketedParameterData {
- lifetimes: new_lts,
+ lifetimes: new_lts.into(),
types: new_types,
bindings: new_bindings,
})
hir::Path {
span: path.span,
global: path.global,
- segments: new_segs
+ segments: new_segs.into()
}
}
}
enum ScopeChain<'a> {
/// EarlyScope(i, ['a, 'b, ...], s) extends s with early-bound
/// lifetimes, assigning indexes 'a => i, 'b => i+1, ... etc.
- EarlyScope(subst::ParamSpace, &'a Vec<hir::LifetimeDef>, Scope<'a>),
+ EarlyScope(subst::ParamSpace, &'a [hir::LifetimeDef], Scope<'a>),
/// LateScope(['a, 'b, ...], s) extends s with late-bound
/// lifetimes introduced by the declaration binder_id.
- LateScope(&'a Vec<hir::LifetimeDef>, Scope<'a>),
+ LateScope(&'a [hir::LifetimeDef], Scope<'a>),
/// lifetimes introduced by a fn are scoped to the call-site for that fn.
FnScope { fn_id: ast::NodeId, body_id: ast::NodeId, s: Scope<'a> },
// a trait ref, which introduces a binding scope.
match self.def_map.get(&ty.id).map(|d| (d.base_def, d.depth)) {
Some((def::DefTrait(..), 0)) => {
- self.with(LateScope(&Vec::new(), self.scope), |_, this| {
+ self.with(LateScope(&[], self.scope), |_, this| {
this.visit_path(path, ty.id);
});
}
lifetime_ref.name);
}
- fn check_lifetime_defs(&mut self, old_scope: Scope, lifetimes: &Vec<hir::LifetimeDef>) {
+ fn check_lifetime_defs(&mut self, old_scope: Scope, lifetimes: &[hir::LifetimeDef]) {
for i in 0..lifetimes.len() {
let lifetime_i = &lifetimes[i];
}
}
-fn search_lifetimes<'a>(lifetimes: &'a Vec<hir::LifetimeDef>,
+fn search_lifetimes<'a>(lifetimes: &'a [hir::LifetimeDef],
lifetime_ref: &hir::Lifetime)
-> Option<(u32, &'a hir::Lifetime)> {
for (i, lifetime_decl) in lifetimes.iter().enumerate() {
impl<'a, 'tcx: 'a> Annotator<'a, 'tcx> {
// Determine the stability for a node based on its attributes and inherited
// stability. The stability is recorded in the index and used as the parent.
- fn annotate<F>(&mut self, id: NodeId, attrs: &Vec<Attribute>,
+ fn annotate<F>(&mut self, id: NodeId, attrs: &[Attribute],
item_sp: Span, kind: AnnotationKind, visit_children: F)
where F: FnOnce(&mut Annotator)
{
use std::rc::Rc;
use syntax::abi;
-use syntax::owned_slice::OwnedSlice;
+use syntax::ptr::P;
use rustc_front::hir;
}
}
-impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for OwnedSlice<T> {
- fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> OwnedSlice<T> {
+impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for P<[T]> {
+ fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> P<[T]> {
self.iter().map(|t| t.fold_with(folder)).collect()
}
}
use syntax::ast::{self, IntTy, UintTy};
use syntax::attr;
use syntax::attr::AttrMetaMethods;
-use syntax::diagnostic::{ColorConfig, Auto, Always, Never, SpanHandler};
+use syntax::errors::{ColorConfig, Handler};
use syntax::parse;
use syntax::parse::token::InternedString;
use syntax::feature_gate::UnstableFeatures;
debugging_opts: basic_debugging_options(),
prints: Vec::new(),
cg: basic_codegen_options(),
- color: Auto,
+ color: ColorConfig::Auto,
show_span: None,
externs: HashMap::new(),
crate_name: None,
v
}
-pub fn build_target_config(opts: &Options, sp: &SpanHandler) -> Config {
+pub fn build_target_config(opts: &Options, sp: &Handler) -> Config {
let target = match Target::search(&opts.target_triple) {
Ok(t) => t,
Err(e) => {
- panic!(sp.handler().fatal(&format!("Error loading target specification: {}", e)));
+ panic!(sp.fatal(&format!("Error loading target specification: {}", e)));
}
};
let (int_type, uint_type) = match &target.target_pointer_width[..] {
"32" => (ast::TyI32, ast::TyU32),
"64" => (ast::TyI64, ast::TyU64),
- w => panic!(sp.handler().fatal(&format!("target specification was invalid: \
- unrecognized target-pointer-width {}", w))),
+ w => panic!(sp.fatal(&format!("target specification was invalid: \
+ unrecognized target-pointer-width {}", w))),
};
Config {
pub fn build_session_options(matches: &getopts::Matches) -> Options {
let color = match matches.opt_str("color").as_ref().map(|s| &s[..]) {
- Some("auto") => Auto,
- Some("always") => Always,
- Some("never") => Never,
+ Some("auto") => ColorConfig::Auto,
+ Some("always") => ColorConfig::Always,
+ Some("never") => ColorConfig::Never,
- None => Auto,
+ None => ColorConfig::Auto,
Some(arg) => {
- early_error(Auto, &format!("argument for --color must be auto, always \
- or never (instead was `{}`)",
- arg))
+ early_error(ColorConfig::Auto, &format!("argument for --color must be auto, always \
+ or never (instead was `{}`)",
+ arg))
}
};
let sessopts = build_session_options(&matches);
let sess = build_session(sessopts, None, registry,
Rc::new(DummyCrateStore));
- assert!(!sess.can_print_warnings);
+ assert!(!sess.diagnostic().can_emit_warnings);
}
{
let sessopts = build_session_options(&matches);
let sess = build_session(sessopts, None, registry,
Rc::new(DummyCrateStore));
- assert!(sess.can_print_warnings);
+ assert!(sess.diagnostic().can_emit_warnings);
}
{
let sessopts = build_session_options(&matches);
let sess = build_session(sessopts, None, registry,
Rc::new(DummyCrateStore));
- assert!(sess.can_print_warnings);
+ assert!(sess.diagnostic().can_emit_warnings);
}
}
}
use syntax::ast::{NodeId, NodeIdAssigner, Name};
use syntax::codemap::Span;
-use syntax::diagnostic::{self, Emitter};
+use syntax::errors;
+use syntax::errors::emitter::{Emitter, BasicEmitter};
use syntax::diagnostics;
use syntax::feature_gate;
use syntax::parse;
pub crate_metadata: RefCell<Vec<String>>,
pub features: RefCell<feature_gate::Features>,
- pub delayed_span_bug: RefCell<Option<(codemap::Span, String)>>,
-
/// The maximum recursion limit for potentially infinitely recursive
/// operations such as auto-dereference and monomorphization.
pub recursion_limit: Cell<usize>,
- pub can_print_warnings: bool,
-
/// The metadata::creader module may inject an allocator dependency if it
/// didn't already find one, and this tracks what was injected.
pub injected_allocator: Cell<Option<ast::CrateNum>>,
impl Session {
pub fn span_fatal(&self, sp: Span, msg: &str) -> ! {
- if self.opts.treat_err_as_bug {
- self.span_bug(sp, msg);
- }
panic!(self.diagnostic().span_fatal(sp, msg))
}
pub fn span_fatal_with_code(&self, sp: Span, msg: &str, code: &str) -> ! {
- if self.opts.treat_err_as_bug {
- self.span_bug(sp, msg);
- }
panic!(self.diagnostic().span_fatal_with_code(sp, msg, code))
}
pub fn fatal(&self, msg: &str) -> ! {
- if self.opts.treat_err_as_bug {
- self.bug(msg);
- }
- panic!(self.diagnostic().handler().fatal(msg))
+ panic!(self.diagnostic().fatal(msg))
}
pub fn span_err_or_warn(&self, is_warning: bool, sp: Span, msg: &str) {
if is_warning {
}
}
pub fn span_err(&self, sp: Span, msg: &str) {
- if self.opts.treat_err_as_bug {
- self.span_bug(sp, msg);
- }
match split_msg_into_multilines(msg) {
Some(msg) => self.diagnostic().span_err(sp, &msg[..]),
None => self.diagnostic().span_err(sp, msg)
See RFC 1214 for details."));
}
pub fn span_err_with_code(&self, sp: Span, msg: &str, code: &str) {
- if self.opts.treat_err_as_bug {
- self.span_bug(sp, msg);
- }
match split_msg_into_multilines(msg) {
Some(msg) => self.diagnostic().span_err_with_code(sp, &msg[..], code),
None => self.diagnostic().span_err_with_code(sp, msg, code)
}
}
pub fn err(&self, msg: &str) {
- if self.opts.treat_err_as_bug {
- self.bug(msg);
- }
- self.diagnostic().handler().err(msg)
+ self.diagnostic().err(msg)
}
pub fn err_count(&self) -> usize {
- self.diagnostic().handler().err_count()
+ self.diagnostic().err_count()
}
pub fn has_errors(&self) -> bool {
- self.diagnostic().handler().has_errors()
+ self.diagnostic().has_errors()
}
pub fn abort_if_errors(&self) {
- self.diagnostic().handler().abort_if_errors();
-
- let delayed_bug = self.delayed_span_bug.borrow();
- match *delayed_bug {
- Some((span, ref errmsg)) => {
- self.diagnostic().span_bug(span, errmsg);
- },
- _ => {}
- }
+ self.diagnostic().abort_if_errors();
}
pub fn abort_if_new_errors<F>(&self, mut f: F)
where F: FnMut()
}
}
pub fn span_warn(&self, sp: Span, msg: &str) {
- if self.can_print_warnings {
- self.diagnostic().span_warn(sp, msg)
- }
+ self.diagnostic().span_warn(sp, msg)
}
pub fn span_warn_with_code(&self, sp: Span, msg: &str, code: &str) {
- if self.can_print_warnings {
- self.diagnostic().span_warn_with_code(sp, msg, code)
- }
+ self.diagnostic().span_warn_with_code(sp, msg, code)
}
pub fn warn(&self, msg: &str) {
- if self.can_print_warnings {
- self.diagnostic().handler().warn(msg)
- }
+ self.diagnostic().warn(msg)
}
pub fn opt_span_warn(&self, opt_sp: Option<Span>, msg: &str) {
match opt_sp {
/// Prints out a message with a suggested edit of the code.
///
- /// See `diagnostic::RenderSpan::Suggestion` for more information.
+ /// See `errors::RenderSpan::Suggestion` for more information.
pub fn span_suggestion(&self, sp: Span, msg: &str, suggestion: String) {
self.diagnostic().span_suggestion(sp, msg, suggestion)
}
self.diagnostic().fileline_help(sp, msg)
}
pub fn note(&self, msg: &str) {
- self.diagnostic().handler().note(msg)
+ self.diagnostic().note(msg)
}
pub fn help(&self, msg: &str) {
- self.diagnostic().handler().help(msg)
+ self.diagnostic().help(msg)
}
pub fn opt_span_bug(&self, opt_sp: Option<Span>, msg: &str) -> ! {
match opt_sp {
}
/// Delay a span_bug() call until abort_if_errors()
pub fn delay_span_bug(&self, sp: Span, msg: &str) {
- let mut delayed = self.delayed_span_bug.borrow_mut();
- *delayed = Some((sp, msg.to_string()));
+ self.diagnostic().delay_span_bug(sp, msg)
}
pub fn span_bug(&self, sp: Span, msg: &str) -> ! {
self.diagnostic().span_bug(sp, msg)
}
pub fn bug(&self, msg: &str) -> ! {
- self.diagnostic().handler().bug(msg)
+ self.diagnostic().bug(msg)
}
pub fn span_unimpl(&self, sp: Span, msg: &str) -> ! {
self.diagnostic().span_unimpl(sp, msg)
}
pub fn unimpl(&self, msg: &str) -> ! {
- self.diagnostic().handler().unimpl(msg)
+ self.diagnostic().unimpl(msg)
}
pub fn add_lint(&self,
lint: &'static lint::Lint,
id
}
- pub fn diagnostic<'a>(&'a self) -> &'a diagnostic::SpanHandler {
+ pub fn diagnostic<'a>(&'a self) -> &'a errors::Handler {
&self.parse_sess.span_diagnostic
}
pub fn codemap<'a>(&'a self) -> &'a codemap::CodeMap {
// This exists to help with refactoring to eliminate impossible
// cases later on
pub fn impossible_case(&self, sp: Span, msg: &str) -> ! {
- self.span_bug(sp,
- &format!("impossible case reached: {}", msg));
+ self.span_bug(sp, &format!("impossible case reached: {}", msg));
}
pub fn verbose(&self) -> bool { self.opts.debugging_opts.verbose }
pub fn time_passes(&self) -> bool { self.opts.debugging_opts.time_passes }
.map(|&(_, ref level)| *level != lint::Allow)
.last()
.unwrap_or(true);
+ let treat_err_as_bug = sopts.treat_err_as_bug;
- let codemap = codemap::CodeMap::new();
+ let codemap = Rc::new(codemap::CodeMap::new());
let diagnostic_handler =
- diagnostic::Handler::new(sopts.color, Some(registry), can_print_warnings);
- let span_diagnostic_handler =
- diagnostic::SpanHandler::new(diagnostic_handler, codemap);
+ errors::Handler::new(sopts.color,
+ Some(registry),
+ can_print_warnings,
+ treat_err_as_bug,
+ codemap.clone());
- build_session_(sopts, local_crate_source_file, span_diagnostic_handler, cstore)
+ build_session_(sopts, local_crate_source_file, diagnostic_handler, codemap, cstore)
}
pub fn build_session_(sopts: config::Options,
local_crate_source_file: Option<PathBuf>,
- span_diagnostic: diagnostic::SpanHandler,
+ span_diagnostic: errors::Handler,
+ codemap: Rc<codemap::CodeMap>,
cstore: Rc<for<'a> CrateStore<'a>>)
-> Session {
let host = match Target::search(config::host_triple()) {
Ok(t) => t,
Err(e) => {
- panic!(span_diagnostic.handler()
- .fatal(&format!("Error loading host specification: {}", e)));
+ panic!(span_diagnostic.fatal(&format!("Error loading host specification: {}", e)));
}
};
let target_cfg = config::build_target_config(&sopts, &span_diagnostic);
- let p_s = parse::ParseSess::with_span_handler(span_diagnostic);
+ let p_s = parse::ParseSess::with_span_handler(span_diagnostic, codemap);
let default_sysroot = match sopts.maybe_sysroot {
Some(_) => None,
None => Some(filesearch::get_or_default_sysroot())
}
);
- let can_print_warnings = sopts.lint_opts
- .iter()
- .filter(|&&(ref key, _)| *key == "warnings")
- .map(|&(_, ref level)| *level != lint::Allow)
- .last()
- .unwrap_or(true);
-
let sess = Session {
target: target_cfg,
host: host,
crate_types: RefCell::new(Vec::new()),
dependency_formats: RefCell::new(FnvHashMap()),
crate_metadata: RefCell::new(Vec::new()),
- delayed_span_bug: RefCell::new(None),
features: RefCell::new(feature_gate::Features::new()),
recursion_limit: Cell::new(64),
- can_print_warnings: can_print_warnings,
next_node_id: Cell::new(1),
injected_allocator: Cell::new(None),
available_macros: RefCell::new(HashSet::new()),
sess
}
-// Seems out of place, but it uses session, so I'm putting it here
-pub fn expect<T, M>(sess: &Session, opt: Option<T>, msg: M) -> T where
- M: FnOnce() -> String,
-{
- diagnostic::expect(sess.diagnostic(), opt, msg)
-}
-
-pub fn early_error(color: diagnostic::ColorConfig, msg: &str) -> ! {
- let mut emitter = diagnostic::EmitterWriter::stderr(color, None);
- emitter.emit(None, msg, None, diagnostic::Fatal);
- panic!(diagnostic::FatalError);
+pub fn early_error(color: errors::ColorConfig, msg: &str) -> ! {
+ let mut emitter = BasicEmitter::stderr(color);
+ emitter.emit(None, msg, None, errors::Level::Fatal);
+ panic!(errors::FatalError);
}
-pub fn early_warn(color: diagnostic::ColorConfig, msg: &str) {
- let mut emitter = diagnostic::EmitterWriter::stderr(color, None);
- emitter.emit(None, msg, None, diagnostic::Warning);
+pub fn early_warn(color: errors::ColorConfig, msg: &str) {
+ let mut emitter = BasicEmitter::stderr(color);
+ emitter.emit(None, msg, None, errors::Level::Warning);
}
use std::slice;
use std::path::{Path, PathBuf};
use session::early_error;
-use syntax::diagnostic;
+use syntax::errors;
#[derive(Clone, Debug)]
pub struct SearchPaths {
SearchPaths { paths: Vec::new() }
}
- pub fn add_path(&mut self, path: &str, color: diagnostic::ColorConfig) {
+ pub fn add_path(&mut self, path: &str, color: errors::ColorConfig) {
let (kind, path) = if path.starts_with("native=") {
(PathKind::Native, &path["native=".len()..])
} else if path.starts_with("crate=") {
use serialize::json::Json;
use std::default::Default;
use std::io::prelude::*;
-use syntax::{diagnostic, abi};
+use syntax::abi;
mod android_base;
mod apple_base;
pub fn from_json(obj: Json) -> Target {
// this is 1. ugly, 2. error prone.
-
- let handler = diagnostic::Handler::new(diagnostic::Auto, None, true);
-
let get_req_field = |name: &str| {
match obj.find(name)
.map(|s| s.as_string())
.and_then(|os| os.map(|s| s.to_string())) {
Some(val) => val,
None => {
- panic!(handler.fatal(&format!("Field {} in target specification is required",
- name)))
+ panic!("Field {} in target specification is required", name)
}
}
};
extern crate syntax;
extern crate syntax_ext;
-pub use syntax::diagnostic;
-
use driver::CompileController;
use pretty::{PpMode, UserIdentifiedItem};
use syntax::ast;
use syntax::parse;
-use syntax::diagnostic::Emitter;
+use syntax::errors;
+use syntax::errors::emitter::Emitter;
use syntax::diagnostics;
use syntax::parse::token;
fn early_callback(&mut self,
_: &getopts::Matches,
_: &diagnostics::registry::Registry,
- _: diagnostic::ColorConfig)
+ _: errors::ColorConfig)
-> Compilation {
Compilation::Continue
}
fn early_callback(&mut self,
matches: &getopts::Matches,
descriptions: &diagnostics::registry::Registry,
- color: diagnostic::ColorConfig)
+ color: errors::ColorConfig)
-> Compilation {
match matches.opt_str("explain") {
Some(ref code) => {
&opt.opt_group.short_name
};
if m.opt_present(opt_name) {
- early_error(diagnostic::Auto,
+ early_error(errors::ColorConfig::Auto,
&format!("use of unstable option '{}' requires -Z \
unstable-options",
opt_name));
}
m
}
- Err(f) => early_error(diagnostic::Auto, &f.to_string()),
+ Err(f) => early_error(errors::ColorConfig::Auto, &f.to_string()),
}
}
}
Err(value) => {
// Thread panicked without emitting a fatal diagnostic
- if !value.is::<diagnostic::FatalError>() {
- let mut emitter = diagnostic::EmitterWriter::stderr(diagnostic::Auto, None);
+ if !value.is::<errors::FatalError>() {
+ let mut emitter = errors::emitter::BasicEmitter::stderr(errors::ColorConfig::Auto);
// a .span_bug or .bug call has already printed what
// it wants to print.
- if !value.is::<diagnostic::ExplicitBug>() {
- emitter.emit(None, "unexpected panic", None, diagnostic::Bug);
+ if !value.is::<errors::ExplicitBug>() {
+ emitter.emit(None, "unexpected panic", None, errors::Level::Bug);
}
let xs = ["the compiler unexpectedly panicked. this is a bug.".to_string(),
format!("we would appreciate a bug report: {}", BUG_REPORT_URL)];
for note in &xs {
- emitter.emit(None, ¬e[..], None, diagnostic::Note)
+ emitter.emit(None, ¬e[..], None, errors::Level::Note)
}
if let None = env::var_os("RUST_BACKTRACE") {
emitter.emit(None,
"run with `RUST_BACKTRACE=1` for a backtrace",
None,
- diagnostic::Note);
+ errors::Level::Note);
}
println!("{}", str::from_utf8(&data.lock().unwrap()).unwrap());
//! # Standalone Tests for the Inference Module
-use diagnostic;
-use diagnostic::Emitter;
use driver;
use rustc_lint;
use rustc_resolve as resolve;
use rustc::session::{self, config};
use std::rc::Rc;
use syntax::{abi, ast};
-use syntax::codemap;
use syntax::codemap::{Span, CodeMap, DUMMY_SP};
-use syntax::diagnostic::{Level, RenderSpan, Bug, Fatal, Error, Warning, Note, Help};
+use syntax::errors;
+use syntax::errors::emitter::Emitter;
+use syntax::errors::{Level, RenderSpan};
use syntax::parse::token;
use syntax::feature_gate::UnstableFeatures;
fn remove_message(e: &mut ExpectErrorEmitter, msg: &str, lvl: Level) {
match lvl {
- Bug | Fatal | Error => {}
- Warning | Note | Help => {
+ Level::Bug | Level::Fatal | Level::Error => {}
+ Level::Warning | Level::Note | Level::Help => {
return;
}
}
impl Emitter for ExpectErrorEmitter {
fn emit(&mut self,
- _cmsp: Option<(&codemap::CodeMap, Span)>,
+ _sp: Option<Span>,
msg: &str,
_: Option<&str>,
lvl: Level) {
remove_message(self, msg, lvl);
}
- fn custom_emit(&mut self, _cm: &codemap::CodeMap, _sp: RenderSpan, msg: &str, lvl: Level) {
+ fn custom_emit(&mut self, _sp: RenderSpan, msg: &str, lvl: Level) {
remove_message(self, msg, lvl);
}
}
let mut options = config::basic_options();
options.debugging_opts.verbose = true;
options.unstable_features = UnstableFeatures::Allow;
- let codemap = CodeMap::new();
- let diagnostic_handler = diagnostic::Handler::with_emitter(true, emitter);
- let span_diagnostic_handler = diagnostic::SpanHandler::new(diagnostic_handler, codemap);
+ let diagnostic_handler = errors::Handler::with_emitter(true, false, emitter);
let cstore = Rc::new(CStore::new(token::get_ident_interner()));
- let sess = session::build_session_(options, None, span_diagnostic_handler,
- cstore.clone());
+ let sess = session::build_session_(options, None, diagnostic_handler,
+ Rc::new(CodeMap::new()), cstore.clone());
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
let krate_config = Vec::new();
let input = config::Input::Str(source_string.to_string());
self.infcx.glb(true, trace)
}
- pub fn make_lub_ty(&self, t1: Ty<'tcx>, t2: Ty<'tcx>) -> Ty<'tcx> {
- match self.lub().relate(&t1, &t2) {
- Ok(t) => t,
- Err(ref e) => panic!("unexpected error computing LUB: {}", e),
- }
- }
-
/// Checks that `t1 <: t2` is true (this may register additional
/// region checks).
pub fn check_sub(&self, t1: Ty<'tcx>, t2: Ty<'tcx>) {
use syntax::attr::ThinAttributesExt;
use hir;
use syntax::codemap::{respan, Span, Spanned};
-use syntax::owned_slice::OwnedSlice;
use syntax::ptr::P;
use syntax::parse::token;
use syntax::util::move_map::MoveMap;
noop_fold_crate(c, self)
}
- fn fold_meta_items(&mut self, meta_items:
Vec<P<MetaItem>>) -> Vec<P<MetaItem>> {
+ fn fold_meta_items(&mut self, meta_items:
HirVec<P<MetaItem>>) -> HirVec<P<MetaItem>> {
noop_fold_meta_items(meta_items, self)
}
noop_fold_variant_data(vdata, self)
}
- fn fold_lifetimes(&mut self, lts: Vec<Lifetime>) -> Vec<Lifetime> {
+ fn fold_lifetimes(&mut self, lts: HirVec<Lifetime>) -> HirVec<Lifetime> {
noop_fold_lifetimes(lts, self)
}
- fn fold_lifetime_defs(&mut self, lts: Vec<LifetimeDef>) -> Vec<LifetimeDef> {
+ fn fold_lifetime_defs(&mut self, lts: HirVec<LifetimeDef>) -> HirVec<LifetimeDef> {
noop_fold_lifetime_defs(lts, self)
}
noop_fold_ty_param(tp, self)
}
- fn fold_ty_params(&mut self, tps: OwnedSlice<TyParam>) -> OwnedSlice<TyParam> {
+ fn fold_ty_params(&mut self, tps: P<[TyParam]>) -> P<[TyParam]> {
noop_fold_ty_params(tps, self)
}
}
fn fold_opt_bounds(&mut self,
- b: Option<OwnedSlice<TyParamBound>>)
- -> Option<OwnedSlice<TyParamBound>> {
+ b: Option<TyParamBounds>)
+ -> Option<TyParamBounds> {
noop_fold_opt_bounds(b, self)
}
- fn fold_bounds(&mut self, b: OwnedSlice<TyParamBound>) -> OwnedSlice<TyParamBound> {
+ fn fold_bounds(&mut self, b: TyParamBounds) -> TyParamBounds {
noop_fold_bounds(b, self)
}
}
}
-pub fn noop_fold_meta_items<T: Folder>(meta_items: Vec<P<MetaItem>>,
+pub fn noop_fold_meta_items<T: Folder>(meta_items:
HirVec<P<MetaItem>>,
fld: &mut T)
- -> Vec<P<MetaItem>> {
+ ->
HirVec<P<MetaItem>> {
meta_items.move_map(|x| fld.fold_meta_item(x))
}
})
}
-pub fn fold_attrs<T: Folder>(attrs:
Vec<Attribute>, fld: &mut T) -> Vec<Attribute> {
+pub fn fold_attrs<T: Folder>(attrs:
HirVec<Attribute>, fld: &mut T) -> HirVec<Attribute> {
attrs.move_flat_map(|x| fld.fold_attribute(x))
}
pat: fld.fold_pat(pat),
init: init.map(|e| fld.fold_expr(e)),
span: fld.new_span(span),
- attrs: attrs.map_thin_attrs(|attrs| fold_attrs(attrs, fld)),
+ attrs: attrs.map_thin_attrs(|attrs| fold_attrs(attrs.into(), fld).into()),
}
})
}
}
}
-pub fn noop_fold_ty_params<T: Folder>(tps: OwnedSlice<TyParam>,
+pub fn noop_fold_ty_params<T: Folder>(tps: P<[TyParam]>,
fld: &mut T)
- -> OwnedSlice<TyParam> {
+ -> P<[TyParam]> {
tps.move_map(|tp| fld.fold_ty_param(tp))
}
}
}
-pub fn noop_fold_lifetimes<T: Folder>(lts: Vec<Lifetime>, fld: &mut T) -> Vec<Lifetime> {
+pub fn noop_fold_lifetimes<T: Folder>(lts: HirVec<Lifetime>, fld: &mut T) -> HirVec<Lifetime> {
lts.move_map(|l| fld.fold_lifetime(l))
}
-pub fn noop_fold_lifetime_defs<T: Folder>(lts: Vec<LifetimeDef>, fld: &mut T) -> Vec<LifetimeDef> {
+pub fn noop_fold_lifetime_defs<T: Folder>(lts: HirVec<LifetimeDef>,
+ fld: &mut T)
+ -> HirVec<LifetimeDef> {
lts.move_map(|l| fld.fold_lifetime_def(l))
}
}
}
-pub fn noop_fold_opt_bounds<T: Folder>(b: Option<OwnedSlice<TyParamBound>>,
+pub fn noop_fold_opt_bounds<T: Folder>(b: Option<TyParamBounds>,
folder: &mut T)
- -> Option<OwnedSlice<TyParamBound>> {
+ -> Option<TyParamBounds> {
b.map(|bounds| folder.fold_bounds(bounds))
}
}
},
span: folder.new_span(span),
- attrs: attrs.map_thin_attrs(|attrs| fold_attrs(attrs, folder)),
+ attrs: attrs.map_thin_attrs(|attrs| fold_attrs(attrs.into(), folder).into()),
}
}
use syntax::codemap::{self, Span, Spanned, DUMMY_SP, ExpnId};
use syntax::abi::Abi;
use syntax::ast::{Name, NodeId, DUMMY_NODE_ID, TokenTree, AsmDialect};
-use syntax::ast::{Attribute, Lit, StrStyle, FloatTy, IntTy, UintTy, CrateConfig};
+use syntax::ast::{Attribute, Lit, StrStyle, FloatTy, IntTy, UintTy, MetaItem};
use syntax::attr::ThinAttributes;
-use syntax::owned_slice::OwnedSlice;
use syntax::parse::token::InternedString;
use syntax::ptr::P;
use std::hash::{Hash, Hasher};
use serialize::{Encodable, Decodable, Encoder, Decoder};
+/// HIR doesn't commit to a concrete storage type and have its own alias for a vector.
+/// It can be `Vec`, `P<[T]>` or potentially `Box<[T]>`, or some other container with similar
+/// behavior. Unlike AST, HIR is mostly a static structure, so we can use an owned slice instead
+/// of `Vec` to avoid keeping extra capacity.
+pub type HirVec<T> = Vec<T>;
+
+macro_rules! hir_vec {
+ ($elem:expr; $n:expr) => (
+ $crate::hir::HirVec::from(vec![$elem; $n])
+ );
+ ($($x:expr),*) => (
+ $crate::hir::HirVec::from(vec![$($x),*])
+ );
+ ($($x:expr,)*) => (vec![$($x),*])
+}
+
/// Identifier in HIR
#[derive(Clone, Copy, Eq)]
pub struct Ident {
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct LifetimeDef {
pub lifetime: Lifetime,
- pub bounds: Vec<Lifetime>,
+ pub bounds: HirVec<Lifetime>,
}
/// A "Path" is essentially Rust's notion of a name; for instance:
/// module (like paths in an import).
pub global: bool,
/// The segments in the path: the things separated by `::`.
- pub segments: Vec<PathSegment>,
+ pub segments:
HirVec<PathSegment>,
}
impl fmt::Debug for Path {
impl PathParameters {
pub fn none() -> PathParameters {
AngleBracketedParameters(AngleBracketedParameterData {
- lifetimes: Vec::new(),
- types: OwnedSlice::empty(),
- bindings: OwnedSlice::empty(),
+ lifetimes: HirVec::new(),
+ types: P::empty(),
+ bindings: P::empty(),
})
}
/// Returns the types that the user wrote. Note that these do not necessarily map to the type
/// parameters in the parenthesized case.
- pub fn types(&self) -> Vec<&P<Ty>> {
+ pub fn types(&self) -> HirVec<&P<Ty>> {
match *self {
AngleBracketedParameters(ref data) => {
data.types.iter().collect()
}
}
- pub fn lifetimes(&self) -> Vec<&Lifetime> {
+ pub fn lifetimes(&self) -> HirVec<&Lifetime> {
match *self {
AngleBracketedParameters(ref data) => {
data.lifetimes.iter().collect()
}
ParenthesizedParameters(_) => {
- Vec::new()
+ HirVec::new()
}
}
}
- pub fn bindings(&self) -> Vec<&TypeBinding> {
+ pub fn bindings(&self) -> HirVec<&TypeBinding> {
match *self {
AngleBracketedParameters(ref data) => {
data.bindings.iter().collect()
}
ParenthesizedParameters(_) => {
- Vec::new()
+ HirVec::new()
}
}
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct AngleBracketedParameterData {
/// The lifetime parameters for this path segment.
- pub lifetimes: Vec<Lifetime>,
+ pub lifetimes: HirVec<Lifetime>,
/// The type parameters for this path segment, if present.
- pub types: OwnedSlice<P<Ty>>,
+ pub types: P<[P<Ty>]>,
/// Bindings (equality constraints) on associated types, if present.
/// E.g., `Foo<A=Bar>`.
- pub bindings: OwnedSlice<TypeBinding>,
+ pub bindings: P<[TypeBinding]>,
}
impl AngleBracketedParameterData {
pub span: Span,
/// `(A,B)`
- pub inputs: Vec<P<Ty>>,
+ pub inputs:
HirVec<P<Ty>>,
/// `C`
pub output: Option<P<Ty>>,
Maybe,
}
-pub type TyParamBounds = OwnedSlice<TyParamBound>;
+pub type TyParamBounds = P<[TyParamBound]>;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct TyParam {
/// of a function, enum, trait, etc.
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct Generics {
- pub lifetimes: Vec<LifetimeDef>,
- pub ty_params: OwnedSlice<TyParam>,
+ pub lifetimes: HirVec<LifetimeDef>,
+ pub ty_params: P<[TyParam]>,
pub where_clause: WhereClause,
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct WhereClause {
pub id: NodeId,
- pub predicates: Vec<WherePredicate>,
+ pub predicates: HirVec<WherePredicate>,
}
/// A single predicate in a `where` clause
pub struct WhereBoundPredicate {
pub span: Span,
/// Any lifetimes from a `for` binding
- pub bound_lifetimes: Vec<LifetimeDef>,
+ pub bound_lifetimes: HirVec<LifetimeDef>,
/// The type being bounded
pub bounded_ty: P<Ty>,
/// Trait and lifetime bounds (`Clone+Send+'static`)
- pub bounds: OwnedSlice<TyParamBound>,
+ pub bounds: TyParamBounds,
}
/// A lifetime predicate, e.g. `'a: 'b+'c`
pub struct WhereRegionPredicate {
pub span: Span,
pub lifetime: Lifetime,
- pub bounds: Vec<Lifetime>,
+ pub bounds: HirVec<Lifetime>,
}
/// An equality predicate (unsupported), e.g. `T=int`
pub ty: P<Ty>,
}
+pub type CrateConfig = HirVec<P<MetaItem>>;
+
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Debug)]
pub struct Crate {
pub module: Mod,
- pub attrs: Vec<Attribute>,
+ pub attrs:
HirVec<Attribute>,
pub config: CrateConfig,
pub span: Span,
- pub exported_macros: Vec<MacroDef>,
+ pub exported_macros: HirVec<MacroDef>,
// NB: We use a BTreeMap here so that `visit_all_items` iterates
// over the ids in increasing order. In principle it should not
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct MacroDef {
pub name: Name,
- pub attrs: Vec<Attribute>,
+ pub attrs:
HirVec<Attribute>,
pub id: NodeId,
pub span: Span,
pub imported_from: Option<Name>,
pub export: bool,
pub use_locally: bool,
pub allow_internal_unstable: bool,
- pub body: Vec<TokenTree>,
+ pub body: HirVec<TokenTree>,
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct Block {
/// Statements in a block
- pub stmts: Vec<Stmt>,
+ pub stmts: HirVec<Stmt>,
/// An expression at the end of the block
/// without a semicolon, if any
pub expr: Option<P<Expr>>,
PatIdent(BindingMode, Spanned<Ident>, Option<P<Pat>>),
/// "None" means a `Variant(..)` pattern where we don't bind the fields to names.
- PatEnum(Path, Option<Vec<P<Pat>>>),
+ PatEnum(Path, Option<
HirVec<P<Pat>>>),
/// An associated const named using the qualified path `<T>::CONST` or
/// `<T as Trait>::CONST`. Associated consts from inherent impls can be
/// Destructuring of a struct, e.g. `Foo {x, y, ..}`
/// The `bool` is `true` in the presence of a `..`
- PatStruct(Path, Vec<Spanned<FieldPat>>, bool),
+ PatStruct(Path, HirVec<Spanned<FieldPat>>, bool),
/// A tuple pattern `(a, b)`
- PatTup(Vec<P<Pat>>),
+ PatTup(
HirVec<P<Pat>>),
/// A `box` pattern
PatBox(P<Pat>),
/// A reference pattern, e.g. `&mut (a, b)`
PatRange(P<Expr>, P<Expr>),
/// `[a, b, ..i, y, z]` is represented as:
/// `PatVec(box [a, b], Some(i), box [y, z])`
- PatVec(
Vec<P<Pat>>, Option<P<Pat>>, Vec<P<Pat>>),
+ PatVec(
HirVec<P<Pat>>, Option<P<Pat>>, HirVec<P<Pat>>),
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
/// represents one arm of a 'match'
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct Arm {
- pub attrs: Vec<Attribute>,
- pub pats: Vec<P<Pat>>,
+ pub attrs:
HirVec<Attribute>,
+ pub pats:
HirVec<P<Pat>>,
pub guard: Option<P<Expr>>,
pub body: P<Expr>,
}
/// A `box x` expression.
ExprBox(P<Expr>),
/// An array (`[a, b, c, d]`)
- ExprVec(Vec<P<Expr>>),
+ ExprVec(
HirVec<P<Expr>>),
/// A function call
///
/// The first field resolves to the function itself,
/// and the second field is the list of arguments
- ExprCall(P<Expr>, Vec<P<Expr>>),
+ ExprCall(P<Expr>,
HirVec<P<Expr>>),
/// A method call (`x.foo::<Bar, Baz>(a, b, c, d)`)
///
/// The `Spanned<Name>` is the identifier for the method name.
///
/// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as
/// `ExprMethodCall(foo, [Bar, Baz], [x, a, b, c, d])`.
- ExprMethodCall(Spanned<Name>,
Vec<P<Ty>>, Vec<P<Expr>>),
+ ExprMethodCall(Spanned<Name>,
HirVec<P<Ty>>, HirVec<P<Expr>>),
/// A tuple (`(a, b, c ,d)`)
- ExprTup(Vec<P<Expr>>),
+ ExprTup(
HirVec<P<Expr>>),
/// A binary operation (For example: `a + b`, `a * b`)
ExprBinary(BinOp, P<Expr>, P<Expr>),
/// A unary operation (For example: `!x`, `*x`)
ExprLoop(P<Block>, Option<Ident>),
/// A `match` block, with a source that indicates whether or not it is
/// the result of a desugaring, and if so, which kind.
- ExprMatch(P<Expr>, Vec<Arm>, MatchSource),
+ ExprMatch(P<Expr>,
HirVec<Arm>, MatchSource),
/// A closure (for example, `move |a, b, c| {a + b + c}`)
ExprClosure(CaptureClause, P<FnDecl>, P<Block>),
/// A block (`{ ... }`)
/// parameters, e.g. foo::bar::<baz>.
///
/// Optionally "qualified",
- /// e.g. `<Vec<T> as SomeTrait>::SomeType`.
+ /// e.g. `<HirVec<T> as SomeTrait>::SomeType`.
ExprPath(Option<QSelf>, Path),
/// A referencing operation (`&a` or `&mut a`)
///
/// For example, `Foo {x: 1, y: 2}`, or
/// `Foo {x: 1, .. base}`, where `base` is the `Option<Expr>`.
- ExprStruct(Path, Vec<Field>, Option<P<Expr>>),
+ ExprStruct(Path,
HirVec<Field>, Option<P<Expr>>),
/// A vector literal constructed from one repeated element.
///
/// separately. `position` represents the index of the associated
/// item qualified with this Self type.
///
-/// <Vec<T> as a::b::Trait>::AssociatedItem
+/// <HirVec<T> as a::b::Trait>::AssociatedItem
/// ^~~~~ ~~~~~~~~~~~~~~^
/// ty position = 3
///
-/// <Vec<T>>::AssociatedItem
+/// <HirVec<T>>::AssociatedItem
/// ^~~~~ ^
/// ty position = 0
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct TraitItem {
pub id: NodeId,
pub name: Name,
- pub attrs: Vec<Attribute>,
+ pub attrs:
HirVec<Attribute>,
pub node: TraitItem_,
pub span: Span,
}
pub id: NodeId,
pub name: Name,
pub vis: Visibility,
- pub attrs: Vec<Attribute>,
+ pub attrs:
HirVec<Attribute>,
pub node: ImplItemKind,
pub span: Span,
}
pub struct BareFnTy {
pub unsafety: Unsafety,
pub abi: Abi,
- pub lifetimes: Vec<LifetimeDef>,
+ pub lifetimes: HirVec<LifetimeDef>,
pub decl: P<FnDecl>,
}
/// A bare function (e.g. `fn(usize) -> bool`)
TyBareFn(P<BareFnTy>),
/// A tuple (`(A, B, C, D,...)`)
- TyTup(Vec<P<Ty>>),
/// A path (`module::module::...::Type`), optionally
- /// "qualified", e.g. `<Vec<T> as SomeTrait>::SomeType`.
+ /// "qualified", e.g. `<HirVec<T> as SomeTrait>::SomeType`.
///
/// Type parameters are stored in the Path itself
TyPath(Option<QSelf>, Path),
pub struct InlineAsm {
pub asm: InternedString,
pub asm_str_style: StrStyle,
- pub outputs: Vec<InlineAsmOutput>,
- pub inputs: Vec<(InternedString, P<Expr>)>,
- pub clobbers: Vec<InternedString>,
+ pub outputs: HirVec<InlineAsmOutput>,
+ pub inputs: HirVec<(InternedString, P<Expr>)>,
+ pub clobbers: HirVec<InternedString>,
pub volatile: bool,
pub alignstack: bool,
pub dialect: AsmDialect,
/// Represents the header (not the body) of a function declaration
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct FnDecl {
- pub inputs: Vec<Arg>,
+ pub inputs:
HirVec<Arg>,
pub output: FunctionRetTy,
pub variadic: bool,
}
/// For `mod foo;`, the inner span ranges from the first token
/// to the last token in the external file.
pub inner: Span,
- pub item_ids: Vec<ItemId>,
+ pub item_ids: HirVec<ItemId>,
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct ForeignMod {
pub abi: Abi,
- pub items: Vec<ForeignItem>,
+ pub items: HirVec<ForeignItem>,
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct EnumDef {
- pub variants: Vec<Variant>,
+ pub variants: HirVec<Variant>,
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct Variant_ {
pub name: Name,
- pub attrs: Vec<Attribute>,
+ pub attrs:
HirVec<Attribute>,
pub data: VariantData,
/// Explicit discriminant, eg `Foo = 1`
pub disr_expr: Option<P<Expr>>,
ViewPathGlob(Path),
/// `foo::bar::{a,b,c}`
- ViewPathList(Path, Vec<PathListItem>),
+ ViewPathList(Path,
HirVec<PathListItem>),
}
/// TraitRef's appear in impls.
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct PolyTraitRef {
/// The `'a` in `<'a> Foo<&'a T>`
- pub bound_lifetimes: Vec<LifetimeDef>,
+ pub bound_lifetimes: HirVec<LifetimeDef>,
/// The `Foo<&'a T>` in `<'a> Foo<&'a T>`
pub trait_ref: TraitRef,
pub kind: StructFieldKind,
pub id: NodeId,
pub ty: P<Ty>,
- pub attrs: Vec<Attribute>,
+ pub attrs:
HirVec<Attribute>,
}
impl StructField_ {
/// Id of the whole struct lives in `Item`.
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum VariantData {
- Struct(Vec<StructField>, NodeId),
- Tuple(Vec<StructField>, NodeId),
+ Struct(HirVec<StructField>, NodeId),
+ Tuple(HirVec<StructField>, NodeId),
Unit(NodeId),
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct Item {
pub name: Name,
- pub attrs: Vec<Attribute>,
+ pub attrs:
HirVec<Attribute>,
pub id: NodeId,
pub node: Item_,
pub vis: Visibility,
/// A struct definition, e.g. `struct Foo<A> {x: A}`
ItemStruct(VariantData, Generics),
/// Represents a Trait Declaration
- ItemTrait(Unsafety, Generics, TyParamBounds, Vec<TraitItem>),
+ ItemTrait(Unsafety, Generics, TyParamBounds, HirVec<TraitItem>),
// Default trait implementations
///
Generics,
Option<TraitRef>, // (optional) trait this impl implements
P<Ty>, // self
- Vec<ImplItem>),
+ HirVec<ImplItem>),
}
impl Item_ {
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct ForeignItem {
pub name: Name,
- pub attrs: Vec<Attribute>,
+ pub attrs:
HirVec<Attribute>,
pub node: ForeignItem_,
pub id: NodeId,
pub span: Span,
extern crate serialize as rustc_serialize; // used by deriving
+#[macro_use]
pub mod hir;
pub mod lowering;
pub mod fold;
use syntax::ext::mtwt;
use syntax::ptr::P;
use syntax::codemap::{respan, Spanned, Span};
-use syntax::owned_slice::OwnedSlice;
use syntax::parse::token;
use syntax::std_inject;
use syntax::visit::{self, Visitor};
}
}
+pub fn lower_attrs(_lctx: &LoweringContext, attrs: &Vec<Attribute>) -> hir::HirVec<Attribute> {
+ attrs.clone().into()
+}
+
pub fn lower_view_path(lctx: &LoweringContext, view_path: &ViewPath) -> P<hir::ViewPath> {
P(Spanned {
node: match view_path.node {
pub fn lower_arm(lctx: &LoweringContext, arm: &Arm) -> hir::Arm {
hir::Arm {
- attrs: arm.attrs.clone(),
+ attrs: lower_attrs(lctx, &arm.attrs),
pats: arm.pats.iter().map(|x| lower_pat(lctx, x)).collect(),
guard: arm.guard.as_ref().map(|ref x| lower_expr(lctx, x)),
body: lower_expr(lctx, &arm.body),
Spanned {
node: hir::Variant_ {
name: v.node.name.name,
- attrs: v.node.attrs.clone(),
+ attrs: lower_attrs(lctx, &v.node.attrs),
data: lower_variant_data(lctx, &v.node.data),
disr_expr: v.node.disr_expr.as_ref().map(|e| lower_expr(lctx, e)),
},
}
pub fn lower_ty_params(lctx: &LoweringContext,
- tps: &OwnedSlice<TyParam>)
- -> OwnedSlice<hir::TyParam> {
+ tps: &P<[TyParam]>)
+ -> P<[hir::TyParam]> {
tps.iter().map(|tp| lower_ty_param(lctx, tp)).collect()
}
}
}
-pub fn lower_lifetimes(lctx: &LoweringContext, lts: &Vec<Lifetime>) -> Vec<hir::Lifetime> {
+pub fn lower_lifetimes(lctx: &LoweringContext, lts: &Vec<Lifetime>) -> hir::HirVec<hir::Lifetime> {
lts.iter().map(|l| lower_lifetime(lctx, l)).collect()
}
pub fn lower_lifetime_defs(lctx: &LoweringContext,
lts: &Vec<LifetimeDef>)
- -> Vec<hir::LifetimeDef> {
+ -> hir::HirVec<hir::LifetimeDef> {
lts.iter().map(|l| lower_lifetime_def(lctx, l)).collect()
}
id: f.node.id,
kind: lower_struct_field_kind(lctx, &f.node.kind),
ty: lower_ty(lctx, &f.node.ty),
- attrs: f.node.attrs.clone(),
+ attrs: lower_attrs(lctx, &f.node.attrs),
},
span: f.span,
}
}
pub fn lower_opt_bounds(lctx: &LoweringContext,
- b: &Option<OwnedSlice<TyParamBound>>)
- -> Option<OwnedSlice<hir::TyParamBound>> {
+ b: &Option<TyParamBounds>)
+ -> Option<hir::TyParamBounds> {
b.as_ref().map(|ref bounds| lower_bounds(lctx, bounds))
}
hir::TraitItem {
id: i.id,
name: i.ident.name,
- attrs: i.attrs.clone(),
+ attrs: lower_attrs(lctx, &i.attrs),
node: match i.node {
ConstTraitItem(ref ty, ref default) => {
hir::ConstTraitItem(lower_ty(lctx, ty),
hir::ImplItem {
id: i.id,
name: i.ident.name,
- attrs: i.attrs.clone(),
+ attrs: lower_attrs(lctx, &i.attrs),
vis: lower_visibility(lctx, i.vis),
node: match i.node {
ImplItemKind::Const(ref ty, ref expr) => {
hir::Crate {
module: lower_mod(lctx, &c.module),
- attrs: c.attrs.clone(),
- config: c.config.clone(),
+ attrs: lower_attrs(lctx, &c.attrs),
+ config: c.config.clone().into(),
span: c.span,
exported_macros: c.exported_macros.iter().map(|m| lower_macro_def(lctx, m)).collect(),
items: items,
}
}
-pub fn lower_macro_def(_lctx: &LoweringContext, m: &MacroDef) -> hir::MacroDef {
+pub fn lower_macro_def(lctx: &LoweringContext, m: &MacroDef) -> hir::MacroDef {
hir::MacroDef {
name: m.ident.name,
- attrs: m.attrs.clone(),
+ attrs: lower_attrs(lctx, &m.attrs),
id: m.id,
span: m.span,
imported_from: m.imported_from.map(|x| x.name),
export: m.export,
use_locally: m.use_locally,
allow_internal_unstable: m.allow_internal_unstable,
- body: m.body.clone(),
+ body: m.body.clone().into(),
}
}
hir::Item {
id: i.id,
name: i.ident.name,
- attrs: i.attrs.clone(),
+ attrs: lower_attrs(lctx, &i.attrs),
node: node,
vis: lower_visibility(lctx, i.vis),
span: i.span,
hir::ForeignItem {
id: i.id,
name: i.ident.name,
- attrs: i.attrs.clone(),
+ attrs: lower_attrs(lctx, &i.attrs),
node: match i.node {
ForeignItemFn(ref fdec, ref generics) => {
hir::ForeignItemFn(lower_fn_decl(lctx, fdec), lower_generics(lctx, generics))
// let placer = <placer_expr> ;
let s1 = {
let placer_expr = signal_block_expr(lctx,
- vec![],
+ hir_vec![],
placer_expr,
e.span,
hir::PopUnstableBlock,
// let mut place = Placer::make_place(placer);
let s2 = {
let placer = expr_ident(lctx, e.span, placer_ident, None);
- let call = make_call(lctx, &make_place, vec![placer]);
+ let call = make_call(lctx, &make_place, hir_vec![placer]);
mk_stmt_let_mut(lctx, place_ident, call)
};
// let p_ptr = Place::pointer(&mut place);
let s3 = {
let agent = expr_ident(lctx, e.span, place_ident, None);
- let args = vec![expr_mut_addr_of(lctx, e.span, agent, None)];
+ let args = hir_vec![expr_mut_addr_of(lctx, e.span, agent, None)];
let call = make_call(lctx, &place_pointer, args);
mk_stmt_let(lctx, p_ptr_ident, call)
};
// pop_unsafe!(EXPR));
let pop_unsafe_expr = {
let value_expr = signal_block_expr(lctx,
- vec![],
+ hir_vec![],
value_expr,
e.span,
hir::PopUnstableBlock,
None);
signal_block_expr(lctx,
- vec![],
+ hir_vec![],
value_expr,
e.span,
hir::PopUnsafeBlock(hir::CompilerGenerated), None)
let ptr = expr_ident(lctx, e.span, p_ptr_ident, None);
let call_move_val_init =
hir::StmtSemi(
- make_call(lctx, &move_val_init, vec![ptr, pop_unsafe_expr]),
+ make_call(lctx, &move_val_init, hir_vec![ptr, pop_unsafe_expr]),
lctx.next_id());
let call_move_val_init = respan(e.span, call_move_val_init);
let place = expr_ident(lctx, e.span, place_ident, None);
- let call = make_call(lctx, &inplace_finalize, vec![place]);
+ let call = make_call(lctx, &inplace_finalize, hir_vec![place]);
signal_block_expr(lctx,
- vec![call_move_val_init],
+ hir_vec![call_move_val_init],
call,
e.span,
hir::PushUnsafeBlock(hir::CompilerGenerated), None)
};
signal_block_expr(lctx,
- vec![s1, s2, s3],
+ hir_vec![s1, s2, s3],
expr,
e.span,
hir::PushUnstableBlock,
let els = lower_expr(lctx, els);
let id = lctx.next_id();
let blk = P(hir::Block {
- stmts: vec![],
+ stmts: hir_vec![],
expr: Some(els),
id: id,
rules: hir::DefaultBlock,
.collect(),
asm: asm.clone(),
asm_str_style: asm_str_style,
- clobbers: clobbers.clone(),
+ clobbers: clobbers.clone().into(),
volatile: volatile,
alignstack: alignstack,
dialect: dialect,
let pat_arm = {
let body = lower_block(lctx, body);
let body_expr = expr_block(lctx, body, None);
- arm(vec![lower_pat(lctx, pat)], body_expr)
+ arm(hir_vec![lower_pat(lctx, pat)], body_expr)
};
// `[_ if <else_opt_if_cond> => <else_opt_if_body>,]`
hir::ExprIf(cond, then, else_opt) => {
let pat_under = pat_wild(lctx, e.span);
arms.push(hir::Arm {
- attrs: vec![],
- pats: vec![pat_under],
+ attrs: hir_vec![],
+ pats: hir_vec![pat_under],
guard: Some(cond),
body: expr_block(lctx, then, None),
});
let pat_under = pat_wild(lctx, e.span);
let else_expr =
else_opt.unwrap_or_else(
- || expr_tuple(lctx, e.span, vec![], None));
- arm(vec![pat_under], else_expr)
+ || expr_tuple(lctx, e.span, hir_vec![], None));
+ arm(hir_vec![pat_under], else_expr)
};
let mut arms = Vec::with_capacity(else_if_arms.len() + 2);
expr(lctx,
e.span,
hir::ExprMatch(sub_expr,
- arms,
+ arms.into(),
hir::MatchSource::IfLetDesugar {
contains_else_clause: contains_else_clause,
}),
let pat_arm = {
let body = lower_block(lctx, body);
let body_expr = expr_block(lctx, body, None);
- arm(vec![lower_pat(lctx, pat)], body_expr)
+ arm(hir_vec![lower_pat(lctx, pat)], body_expr)
};
// `_ => break`
let break_arm = {
let pat_under = pat_wild(lctx, e.span);
let break_expr = expr_break(lctx, e.span, None);
- arm(vec![pat_under], break_expr)
+ arm(hir_vec![pat_under], break_expr)
};
// `match <sub_expr> { ... }`
- let arms = vec![pat_arm, break_arm];
+ let arms = hir_vec![pat_arm, break_arm];
let sub_expr = lower_expr(lctx, sub_expr);
let match_expr = expr(lctx,
e.span,
let pat = lower_pat(lctx, pat);
let some_pat = pat_some(lctx, e.span, pat);
- arm(vec![some_pat], body_expr)
+ arm(hir_vec![some_pat], body_expr)
};
// `::std::option::Option::None => break`
let break_arm = {
let break_expr = expr_break(lctx, e.span, None);
- arm(vec![pat_none(lctx, e.span)], break_expr)
+ arm(hir_vec![pat_none(lctx, e.span)], break_expr)
};
// `match ::std::iter::Iterator::next(&mut iter) { ... }`
let next_expr = expr_call(lctx,
e.span,
next_path,
- vec![ref_mut_iter],
+ hir_vec![ref_mut_iter],
None);
- let arms = vec![pat_arm, break_arm];
+ let arms = hir_vec![pat_arm, break_arm];
expr(lctx,
e.span,
e.span,
iter,
hir::BindByValue(hir::MutMutable));
- arm(vec![iter_pat], loop_expr)
+ arm(hir_vec![iter_pat], loop_expr)
};
// `match ::std::iter::IntoIterator::into_iter(<head>) { ... }`
};
let into_iter = expr_path(lctx, into_iter_path, None);
- expr_call(lctx, e.span, into_iter, vec![head], None)
+ expr_call(lctx, e.span, into_iter, hir_vec![head], None)
};
let match_expr = expr_match(lctx,
e.span,
into_iter_expr,
- vec![iter_arm],
+ hir_vec![iter_arm],
hir::MatchSource::ForLoopDesugar,
None);
let result_ident = lctx.str_to_ident("result");
let let_stmt = stmt_let(lctx, e.span, false, result_ident, match_expr, None);
let result = expr_ident(lctx, e.span, result_ident, None);
- let block = block_all(lctx, e.span, vec![let_stmt], Some(result));
+ let block = block_all(lctx, e.span, hir_vec![let_stmt], Some(result));
// add the attributes to the outer returned expr node
expr_block(lctx, block, e.attrs.clone())
});
// Helper methods for building HIR.
-fn arm(pats: Vec<P<hir::Pat>>, expr: P<hir::Expr>) -> hir::Arm {
+fn arm(pats:
hir::HirVec<P<hir::Pat>>, expr: P<hir::Expr>) -> hir::Arm {
hir::Arm {
- attrs: vec![],
+ attrs: hir_vec![],
pats: pats,
guard: None,
body: expr,
fn expr_call(lctx: &LoweringContext,
span: Span,
e: P<hir::Expr>,
- args: Vec<P<hir::Expr>>,
+ args:
hir::HirVec<P<hir::Expr>>,
attrs: ThinAttributes)
-> P<hir::Expr> {
expr(lctx, span, hir::ExprCall(e, args), attrs)
fn expr_match(lctx: &LoweringContext,
span: Span,
arg: P<hir::Expr>,
- arms: Vec<hir::Arm>,
+ arms: hir::HirVec<hir::Arm>,
source: hir::MatchSource,
attrs: ThinAttributes)
-> P<hir::Expr> {
expr(lctx, b.span, hir::ExprBlock(b), attrs)
}
-fn expr_tuple(lctx: &LoweringContext, sp: Span, exprs: Vec<P<hir::Expr>>,
+fn expr_tuple(lctx: &LoweringContext, sp: Span, exprs:
hir::HirVec<P<hir::Expr>>,
attrs: ThinAttributes) -> P<hir::Expr> {
expr(lctx, sp, hir::ExprTup(exprs), attrs)
}
}
fn block_expr(lctx: &LoweringContext, expr: P<hir::Expr>) -> P<hir::Block> {
- block_all(lctx, expr.span, Vec::new(), Some(expr))
+ block_all(lctx, expr.span, hir::HirVec::new(), Some(expr))
}
fn block_all(lctx: &LoweringContext,
span: Span,
- stmts: Vec<hir::Stmt>,
+ stmts: hir::HirVec<hir::Stmt>,
expr: Option<P<hir::Expr>>)
-> P<hir::Block> {
P(hir::Block {
fn pat_some(lctx: &LoweringContext, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> {
let some = std_path(lctx, &["option", "Option", "Some"]);
let path = path_global(span, some);
- pat_enum(lctx, span, path, vec![pat])
+ pat_enum(lctx, span, path, hir_vec![pat])
}
fn pat_none(lctx: &LoweringContext, span: Span) -> P<hir::Pat> {
let none = std_path(lctx, &["option", "Option", "None"]);
let path = path_global(span, none);
- pat_enum(lctx, span, path, vec![])
+ pat_enum(lctx, span, path, hir_vec![])
}
fn pat_enum(lctx: &LoweringContext,
span: Span,
path: hir::Path,
- subpats: Vec<P<hir::Pat>>)
+ subpats:
hir::HirVec<P<hir::Pat>>)
-> P<hir::Pat> {
let pt = hir::PatEnum(path, Some(subpats));
pat(lctx, span, pt)
}
fn path(span: Span, strs: Vec<hir::Ident>) -> hir::Path {
- path_all(span, false, strs, Vec::new(), Vec::new(), Vec::new())
+ path_all(span, false, strs, hir::HirVec::new(), Vec::new(), Vec::new())
}
fn path_global(span: Span, strs: Vec<hir::Ident>) -> hir::Path {
- path_all(span, true, strs, Vec::new(), Vec::new(), Vec::new())
+ path_all(span, true, strs, hir::HirVec::new(), Vec::new(), Vec::new())
}
fn path_all(sp: Span,
global: bool,
mut idents: Vec<hir::Ident>,
- lifetimes: Vec<hir::Lifetime>,
+ lifetimes: hir::HirVec<hir::Lifetime>,
types: Vec<P<hir::Ty>>,
bindings: Vec<hir::TypeBinding>)
-> hir::Path {
identifier: last_identifier,
parameters: hir::AngleBracketedParameters(hir::AngleBracketedParameterData {
lifetimes: lifetimes,
- types: OwnedSlice::from_vec(types),
- bindings: OwnedSlice::from_vec(bindings),
+ types: P::from_vec(types),
+ bindings: P::from_vec(bindings),
}),
});
hir::Path {
span: sp,
global: global,
- segments: segments,
+ segments: segments.into(),
}
}
}
fn signal_block_expr(lctx: &LoweringContext,
- stmts: Vec<hir::Stmt>,
+ stmts: hir::HirVec<hir::Stmt>,
expr: P<hir::Expr>,
span: Span,
rule: hir::BlockCheckMode,
use syntax::abi;
use syntax::ast;
-use syntax::owned_slice::OwnedSlice;
use syntax::codemap::{self, CodeMap, BytePos, Spanned};
-use syntax::diagnostic;
+use syntax::errors;
use syntax::parse::token::{self, BinOpToken};
use syntax::parse::lexer::comments;
use syntax::parse;
/// it can scan the input text for comments and literals to
/// copy forward.
pub fn print_crate<'a>(cm: &'a CodeMap,
- span_diagnostic: &diagnostic::SpanHandler,
+ span_diagnostic: &errors::Handler,
krate: &hir::Crate,
filename: String,
input: &mut Read,
impl<'a> State<'a> {
pub fn new_from_input(cm: &'a CodeMap,
- span_diagnostic: &diagnostic::SpanHandler,
+ span_diagnostic: &errors::Handler,
filename: String,
input: &mut Read,
out: Box<Write + 'a>,
hir::TyBareFn(ref f) => {
let generics = hir::Generics {
lifetimes: f.lifetimes.clone(),
- ty_params: OwnedSlice::empty(),
+ ty_params: P::empty(),
where_clause: hir::WhereClause {
id: ast::DUMMY_NODE_ID,
- predicates: Vec::new(),
+ predicates: hir::HirVec::new(),
},
};
try!(self.print_ty_fn(f.abi, f.unsafety, &*f.decl, None, &generics, None));
try!(self.print_generics(generics));
}
let generics = hir::Generics {
- lifetimes: Vec::new(),
- ty_params: OwnedSlice::empty(),
+ lifetimes: hir::HirVec::new(),
+ ty_params: P::empty(),
where_clause: hir::WhereClause {
id: ast::DUMMY_NODE_ID,
- predicates: Vec::new(),
+ predicates: hir::HirVec::new(),
},
};
try!(self.print_fn(decl,
use syntax::ast::{Name, NodeId, DUMMY_NODE_ID};
use syntax::codemap::Span;
use syntax::ptr::P;
-use syntax::owned_slice::OwnedSlice;
pub fn walk_pat<F>(pat: &Pat, mut it: F) -> bool
where F: FnMut(&Pat) -> bool
pub fn empty_generics() -> Generics {
Generics {
- lifetimes: Vec::new(),
- ty_params: OwnedSlice::empty(),
+ lifetimes: HirVec::new(),
+ ty_params: P::empty(),
where_clause: WhereClause {
id: DUMMY_NODE_ID,
- predicates: Vec::new(),
+ predicates: HirVec::new(),
},
}
}
hir::Path {
span: s,
global: false,
- segments: vec!(hir::PathSegment {
+ segments: hir_vec![hir::PathSegment {
identifier: ident,
parameters: hir::AngleBracketedParameters(hir::AngleBracketedParameterData {
- lifetimes: Vec::new(),
- types: OwnedSlice::empty(),
- bindings: OwnedSlice::empty(),
+ lifetimes: HirVec::new(),
+ types: P::empty(),
+ bindings: P::empty(),
}),
- }),
+ }],
}
}
C: ContextRef)
-> ModuleRef;
pub fn LLVMGetModuleContext(M: ModuleRef) -> ContextRef;
+ pub fn LLVMCloneModule(M: ModuleRef) -> ModuleRef;
pub fn LLVMDisposeModule(M: ModuleRef);
/// Data layout. See Module::getDataLayout.
use syntax::ast::{self, NodeId, Name, CRATE_NODE_ID, CrateNum};
use syntax::attr;
use syntax::attr::AttrMetaMethods;
-use syntax::diagnostic::SpanHandler;
+use syntax::errors::Handler;
use syntax::parse::token::special_idents;
use syntax;
use rbml::writer::Encoder;
Box<FnMut(&EncodeContext, &mut Encoder, InlinedItemRef) + 'a>;
pub struct EncodeParams<'a, 'tcx: 'a> {
- pub diag: &'a SpanHandler,
+ pub diag: &'a Handler,
pub tcx: &'a ty::ctxt<'tcx>,
pub reexports: &'a def::ExportMap,
pub item_symbols: &'a RefCell<NodeMap<String>>,
}
pub struct EncodeContext<'a, 'tcx: 'a> {
- pub diag: &'a SpanHandler,
+ pub diag: &'a Handler,
pub tcx: &'a ty::ctxt<'tcx>,
pub reexports: &'a def::ExportMap,
pub item_symbols: &'a RefCell<NodeMap<String>>,
rbml_w.wr_tagged_str(tag_items_data_item_symbol, x);
}
None => {
- ecx.diag.handler().bug(
- &format!("encode_symbol: id not found {}", id));
+ ecx.diag.bug(&format!("encode_symbol: id not found {}", id));
}
}
}
use rustc_llvm::{False, ObjectFile, mk_section_iter};
use rustc_llvm::archive_ro::ArchiveRO;
use syntax::codemap::Span;
-use syntax::diagnostic::SpanHandler;
+use syntax::errors::Handler;
use rustc_back::target::Target;
use std::cmp;
}
}
-pub fn note_crate_name(diag: &SpanHandler, name: &str) {
- diag.handler().note(&format!("crate name: {}", name));
+pub fn note_crate_name(diag: &Handler, name: &str) {
+ diag.note(&format!("crate name: {}", name));
}
impl ArchiveMetadata {
use syntax::abi::Abi;
use syntax::ast;
-use syntax::diagnostic::SpanHandler;
+use syntax::errors::Handler;
use rbml::writer::{self, Encoder};
macro_rules! mywrite { ($w:expr, $($arg:tt)*) => ({ write!($w.writer, $($arg)*); }) }
pub struct ctxt<'a, 'tcx: 'a> {
- pub diag: &'a SpanHandler,
+ pub diag: &'a Handler,
// Def -> str Callback:
pub ds: fn(DefId) -> String,
// The type context.
enc_bare_fn_ty(w, cx, f);
}
ty::TyInfer(_) => {
- cx.diag.handler().bug("cannot encode inference variable types");
+ cx.diag.bug("cannot encode inference variable types");
}
ty::TyParam(ParamTy {space, idx, name}) => {
mywrite!(w, "p[{}|{}|{}]", idx, space.to_uint(), name)
}
ty::ReVar(_) | ty::ReSkolemized(..) => {
// these should not crop up after typeck
- cx.diag.handler().bug("cannot encode region variables");
+ cx.diag.bug("cannot encode region variables");
}
}
}
}
}
- fn to_pats(&mut self, pats: &'tcx
Vec<P<hir::Pat>>) -> Vec<Pattern<'tcx>> {
+ fn to_pats(&mut self, pats: &'tcx
[P<hir::Pat>]) -> Vec<Pattern<'tcx>> {
pats.iter().map(|p| self.to_pat(p)).collect()
}
fn slice_or_array_pattern(&mut self,
pat: &'tcx hir::Pat,
ty: Ty<'tcx>,
- prefix: &'tcx Vec<P<hir::Pat>>,
+ prefix: &'tcx [P<hir::Pat>],
slice: &'tcx Option<P<hir::Pat>>,
- suffix: &'tcx Vec<P<hir::Pat>>)
+ suffix: &'tcx [P<hir::Pat>])
-> PatternKind<'tcx> {
match ty.sty {
ty::TySlice(..) => {
use syntax::ast;
use syntax::attr;
use syntax::codemap::Span;
-use syntax::diagnostic;
+use syntax::errors;
use rustc_front::intravisit::Visitor;
use rustc_front::hir;
}
/// Find the function marked with `#[plugin_registrar]`, if any.
-pub fn find_plugin_registrar(diagnostic: &diagnostic::SpanHandler,
+pub fn find_plugin_registrar(diagnostic: &errors::Handler,
krate: &hir::Crate)
-> Option<ast::NodeId> {
let mut finder = RegistrarFinder { registrars: Vec::new() };
Some(node_id)
},
_ => {
- diagnostic.handler().err("multiple plugin registration functions found");
+ diagnostic.err("multiple plugin registration functions found");
for &(_, span) in &finder.registrars {
diagnostic.span_note(span, "one is here");
}
- diagnostic.handler().abort_if_errors();
+ diagnostic.abort_if_errors();
unreachable!();
}
}
if !llvm::LLVMRustLinkInExternalBitcode(llmod,
ptr as *const libc::c_char,
bc_decoded.len() as libc::size_t) {
- write::llvm_err(sess.diagnostic().handler(),
+ write::llvm_err(sess.diagnostic(),
format!("failed to load bc of `{}`",
&name[..]));
}
use util::common::time;
use util::common::path2cstr;
use syntax::codemap;
-use syntax::diagnostic;
-use syntax::diagnostic::{Emitter, Handler, Level};
+use syntax::errors::{self, Handler, Level};
+use syntax::errors::emitter::Emitter;
use std::collections::HashMap;
use std::ffi::{CStr, CString};
use std::thread;
use libc::{self, c_uint, c_int, c_void};
-pub fn llvm_err(handler: &diagnostic::Handler, msg: String) -> ! {
+pub fn llvm_err(handler: &errors::Handler, msg: String) -> ! {
unsafe {
let cstr = llvm::LLVMRustGetLastError();
if cstr == ptr::null() {
}
pub fn write_output_file(
- handler: &diagnostic::Handler,
+ handler: &errors::Handler,
target: llvm::TargetMachineRef,
pm: llvm::PassManagerRef,
m: ModuleRef,
}
impl Emitter for SharedEmitter {
- fn emit(&mut self, cmsp: Option<(&codemap::CodeMap, codemap::Span)>,
+ fn emit(&mut self, sp: Option<codemap::Span>,
msg: &str, code: Option<&str>, lvl: Level) {
- assert!(cmsp.is_none(), "SharedEmitter doesn't support spans");
+ assert!(sp.is_none(), "SharedEmitter doesn't support spans");
self.buffer.lock().unwrap().push(Diagnostic {
msg: msg.to_string(),
});
}
- fn custom_emit(&mut self, _cm: &codemap::CodeMap,
- _sp: diagnostic::RenderSpan, _msg: &str, _lvl: Level) {
+ fn custom_emit(&mut self, _sp: errors::RenderSpan, _msg: &str, _lvl: Level) {
panic!("SharedEmitter doesn't support custom_emit");
}
}
};
if tm.is_null() {
- llvm_err(sess.diagnostic().handler(),
+ llvm_err(sess.diagnostic(),
format!("Could not create LLVM TargetMachine for triple: {}",
triple).to_string());
} else {
fn new_with_session(sess: &'a Session, reachable: &'a [String]) -> CodegenContext<'a> {
CodegenContext {
lto_ctxt: Some((sess, reachable)),
- handler: sess.diagnostic().handler(),
+ handler: sess.diagnostic(),
plugin_passes: sess.plugin_llvm_passes.borrow().clone(),
remark: sess.opts.cg.remark.clone(),
worker: 0,
if config.emit_asm {
let path = output_names.with_extension(&format!("{}.s", name_extra));
+
+ // We can't use the same module for asm and binary output, because that triggers
+ // various errors like invalid IR or broken binaries, so we might have to clone the
+ // module to produce the asm output
+ let llmod = if config.emit_obj {
+ llvm::LLVMCloneModule(llmod)
+ } else {
+ llmod
+ };
with_codegen(tm, llmod, config.no_builtins, |cpm| {
write_output_file(cgcx.handler, tm, cpm, llmod, &path,
llvm::AssemblyFileType);
});
+ if config.emit_obj {
+ llvm::LLVMDisposeModule(llmod);
+ }
}
if config.emit_obj {
futures.push(rx);
thread::Builder::new().name(format!("codegen-{}", i)).spawn(move || {
- let diag_handler = Handler::with_emitter(true, box diag_emitter);
+ let diag_handler = Handler::with_emitter(true, false, box diag_emitter);
// Must construct cgcx inside the proc because it has non-Send
// fields.
},
}
// Display any new diagnostics.
- diag_emitter.dump(sess.diagnostic().handler());
+ diag_emitter.dump(sess.diagnostic());
}
if panicked {
sess.fatal("aborting due to worker thread panic");
use syntax::ast::{self, NodeId};
use syntax::codemap::*;
use syntax::parse::token::{self, keywords};
-use syntax::owned_slice::OwnedSlice;
use syntax::visit::{self, Visitor};
use syntax::print::pprust::{path_to_string, ty_to_string};
use syntax::ptr::P;
fn process_trait(&mut self,
item: &ast::Item,
generics: &ast::Generics,
- trait_refs: &OwnedSlice<ast::TyParamBound>,
+ trait_refs: &ast::TyParamBounds,
methods: &[P<ast::TraitItem>]) {
let qualname = format!("::{}", self.tcx.map.path_to_string(item.id));
let val = self.span.snippet(item.span);
let meta = val.meta;
- // Calculate the unaligned offset of the the unsized field.
+ // Calculate the unaligned offset of the unsized field.
let mut offset = 0;
for &ty in &st.fields[0..ix] {
let llty = type_of::sizing_type_of(ccx, ty);
use arena::TypedArena;
use back::link;
-use session;
use llvm::{self, ValueRef, get_params};
use middle::cstore::LOCAL_CRATE;
use middle::def;
use syntax::abi as synabi;
use syntax::ast;
+use syntax::errors;
use syntax::ptr::P;
#[derive(Copy, Clone)]
Some(n) => n,
None => { return false; }
};
- let map_node = session::expect(
- &tcx.sess,
+ let map_node = errors::expect(
+ &tcx.sess.diagnostic(),
tcx.map.find(node_id),
|| "local item should be in ast map".to_string());
m: hir::Mutability,
expr: &hir::Expr,
id: ast::NodeId,
- attrs: &Vec<ast::Attribute>)
+ attrs: &[ast::Attribute])
-> Result<ValueRef, ConstEvalErr> {
unsafe {
let _icx = push_ctxt("trans_static");
// except according to those terms.
use back::link::exported_name;
-use session;
use llvm::ValueRef;
use llvm;
use middle::def_id::DefId;
use syntax::abi;
use syntax::ast;
use syntax::attr;
+use syntax::errors;
use std::hash::{Hasher, Hash, SipHasher};
pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
hash_id);
- let map_node = session::expect(
- ccx.sess(),
+ let map_node = errors::expect(
+ ccx.sess().diagnostic(),
ccx.tcx().map.find(fn_node_id),
|| {
format!("while monomorphizing {:?}, couldn't find it in \
use syntax::attr;
use syntax::attr::AttrMetaMethods;
use syntax::codemap::{self, Span, Spanned};
-use syntax::owned_slice::OwnedSlice;
use syntax::parse::token::{self, InternedString};
use syntax::ptr::P;
use syntax::util::lev_distance::lev_distance;
}
pub fn check_bounds_are_used<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
- tps: &OwnedSlice<hir::TyParam>,
+ tps: &P<[hir::TyParam]>,
ty: Ty<'tcx>) {
debug!("check_bounds_are_used(n_tps={}, ty={:?})",
tps.len(), ty);
}
}
-impl<T: Clean<U>, U> Clean<Vec<U>> for syntax::owned_slice::OwnedSlice<T> {
+impl<T: Clean<U>, U> Clean<Vec<U>> for P<[T]> {
fn clean(&self, cx: &DocContext) -> Vec<U> {
self.iter().map(|x| x.clean(cx)).collect()
}
resolve_type(cx, p.clean(cx), self.id)
}
TyPath(Some(ref qself), ref p) => {
- let mut trait_path = p.clone();
- trait_path.segments.pop();
+ let mut segments: Vec<_> = p.segments.clone().into();
+ segments.pop();
+ let trait_path = hir::Path {
+ span: p.span,
+ global: p.global,
+ segments: segments.into(),
+ };
Type::QPath {
name: p.segments.last().unwrap().identifier.name.clean(cx),
self_type: box qself.ty.clean(cx),
use rustc_front::lowering::{lower_crate, LoweringContext};
use rustc_metadata::cstore::CStore;
-use syntax::{ast, codemap, diagnostic};
+use syntax::{ast, codemap, errors};
+use syntax::errors::emitter::ColorConfig;
use syntax::feature_gate::UnstableFeatures;
use syntax::parse::token;
..config::basic_options().clone()
};
- let codemap = codemap::CodeMap::new();
- let diagnostic_handler = diagnostic::Handler::new(diagnostic::Auto, None, true);
- let span_diagnostic_handler =
- diagnostic::SpanHandler::new(diagnostic_handler, codemap);
+ let codemap = Rc::new(codemap::CodeMap::new());
+ let diagnostic_handler = errors::Handler::new(ColorConfig::Auto,
+ None,
+ true,
+ false,
+ codemap.clone());
let cstore = Rc::new(CStore::new(token::get_ident_interner()));
let cstore_ = ::rustc_driver::cstore_to_cratestore(cstore.clone());
- let sess = session::build_session_(sessopts, cpath,
- span_diagnostic_handler, cstore_);
+ let sess = session::build_session_(sessopts, cpath, diagnostic_handler, codemap, cstore_);
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
let mut cfg = config::build_configuration(&sess);
pub struct Module {
pub name: Option<Name>,
- pub attrs: Vec<ast::Attribute>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
pub where_outer: Span,
pub where_inner: Span,
pub extern_crates: Vec<ExternCrate>,
depr: None,
where_outer: syntax::codemap::DUMMY_SP,
where_inner: syntax::codemap::DUMMY_SP,
- attrs : Vec::new(),
+ attrs : hir::HirVec::new(),
extern_crates: Vec::new(),
imports : Vec::new(),
structs : Vec::new(),
pub struct_type: StructType,
pub name: Name,
pub generics: hir::Generics,
- pub attrs: Vec<ast::Attribute>,
- pub fields: Vec<hir::StructField>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
+ pub fields: hir::HirVec<hir::StructField>,
pub whence: Span,
}
pub vis: hir::Visibility,
pub stab: Option<attr::Stability>,
pub depr: Option<attr::Deprecation>,
- pub variants: Vec<Variant>,
+ pub variants: hir::HirVec<Variant>,
pub generics: hir::Generics,
- pub attrs: Vec<ast::Attribute>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
pub id: NodeId,
pub whence: Span,
pub name: Name,
pub struct Variant {
pub name: Name,
- pub attrs: Vec<ast::Attribute>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
pub def: hir::VariantData,
pub stab: Option<attr::Stability>,
pub depr: Option<attr::Deprecation>,
pub struct Function {
pub decl: hir::FnDecl,
- pub attrs: Vec<ast::Attribute>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
pub id: NodeId,
pub name: Name,
pub vis: hir::Visibility,
pub gen: hir::Generics,
pub name: Name,
pub id: ast::NodeId,
- pub attrs: Vec<ast::Attribute>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
pub whence: Span,
pub vis: hir::Visibility,
pub stab: Option<attr::Stability>,
pub mutability: hir::Mutability,
pub expr: P<hir::Expr>,
pub name: Name,
- pub attrs: Vec<ast::Attribute>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
pub vis: hir::Visibility,
pub stab: Option<attr::Stability>,
pub depr: Option<attr::Deprecation>,
pub type_: P<hir::Ty>,
pub expr: P<hir::Expr>,
pub name: Name,
- pub attrs: Vec<ast::Attribute>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
pub vis: hir::Visibility,
pub stab: Option<attr::Stability>,
pub depr: Option<attr::Deprecation>,
pub struct Trait {
pub unsafety: hir::Unsafety,
pub name: Name,
- pub items: Vec<hir::TraitItem>,
+ pub items: hir::HirVec<hir::TraitItem>,
pub generics: hir::Generics,
- pub bounds: Vec<hir::TyParamBound>,
- pub attrs: Vec<ast::Attribute>,
+ pub bounds: hir::HirVec<hir::TyParamBound>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
pub id: ast::NodeId,
pub whence: Span,
pub vis: hir::Visibility,
pub generics: hir::Generics,
pub trait_: Option<hir::TraitRef>,
pub for_: P<hir::Ty>,
- pub items: Vec<hir::ImplItem>,
- pub attrs: Vec<ast::Attribute>,
+ pub items: hir::HirVec<hir::ImplItem>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
pub whence: Span,
pub vis: hir::Visibility,
pub stab: Option<attr::Stability>,
pub unsafety: hir::Unsafety,
pub trait_: hir::TraitRef,
pub id: ast::NodeId,
- pub attrs: Vec<ast::Attribute>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
pub whence: Span,
}
pub struct Macro {
pub name: Name,
pub id: ast::NodeId,
- pub attrs: Vec<ast::Attribute>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
pub whence: Span,
- pub matchers: Vec<Span>,
+ pub matchers: hir::HirVec<Span>,
pub stab: Option<attr::Stability>,
pub depr: Option<attr::Deprecation>,
pub imported_from: Option<Name>,
pub name: Name,
pub path: Option<String>,
pub vis: hir::Visibility,
- pub attrs: Vec<ast::Attribute>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
pub whence: Span,
}
pub struct Import {
pub id: NodeId,
pub vis: hir::Visibility,
- pub attrs: Vec<ast::Attribute>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
pub node: hir::ViewPath_,
pub whence: Span,
}
use serialize::Decodable;
use serialize::json::{self, Json};
use rustc::session::search_paths::SearchPaths;
-use syntax::diagnostic;
+use syntax::errors::emitter::ColorConfig;
// reexported from `clean` so it can be easily updated with the mod itself
pub use clean::SCHEMA_VERSION;
let mut libs = SearchPaths::new();
for s in &matches.opt_strs("L") {
- libs.add_path(s, diagnostic::Auto);
+ libs.add_path(s, ColorConfig::Auto);
}
let externs = match parse_externs(&matches) {
Ok(ex) => ex,
// First, parse the crate and extract all relevant information.
let mut paths = SearchPaths::new();
for s in &matches.opt_strs("L") {
- paths.add_path(s, diagnostic::Auto);
+ paths.add_path(s, ColorConfig::Auto);
}
let cfgs = matches.opt_strs("cfg");
let triple = matches.opt_str("target");
use rustc_driver::{driver, Compilation};
use rustc_metadata::cstore::CStore;
use syntax::codemap::CodeMap;
-use syntax::diagnostic;
+use syntax::errors;
+use syntax::errors::emitter::ColorConfig;
use syntax::parse::token;
use core;
..config::basic_options().clone()
};
- let codemap = CodeMap::new();
- let diagnostic_handler = diagnostic::Handler::new(diagnostic::Auto, None, true);
- let span_diagnostic_handler =
- diagnostic::SpanHandler::new(diagnostic_handler, codemap);
+ let codemap = Rc::new(CodeMap::new());
+ let diagnostic_handler = errors::Handler::new(ColorConfig::Auto,
+ None,
+ true,
+ false,
+ codemap.clone());
let cstore = Rc::new(CStore::new(token::get_ident_interner()));
let cstore_ = ::rustc_driver::cstore_to_cratestore(cstore.clone());
let sess = session::build_session_(sessopts,
Some(input_path.clone()),
- span_diagnostic_handler,
+ diagnostic_handler,
+ codemap,
cstore_);
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
}
}
let data = Arc::new(Mutex::new(Vec::new()));
- let emitter = diagnostic::EmitterWriter::new(box Sink(data.clone()), None);
+ let codemap = Rc::new(CodeMap::new());
+ let emitter = errors::emitter::EmitterWriter::new(box Sink(data.clone()),
+ None,
+ codemap.clone());
let old = io::set_panic(box Sink(data.clone()));
let _bomb = Bomb(data, old.unwrap_or(box io::stdout()));
// Compile the code
- let codemap = CodeMap::new();
- let diagnostic_handler = diagnostic::Handler::with_emitter(true, box emitter);
- let span_diagnostic_handler =
- diagnostic::SpanHandler::new(diagnostic_handler, codemap);
+ let diagnostic_handler = errors::Handler::with_emitter(true, false, box emitter);
let cstore = Rc::new(CStore::new(token::get_ident_interner()));
let cstore_ = ::rustc_driver::cstore_to_cratestore(cstore.clone());
let sess = session::build_session_(sessopts,
None,
- span_diagnostic_handler,
+ diagnostic_handler,
+ codemap,
cstore_);
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
pub struct RustdocVisitor<'a, 'tcx: 'a> {
pub module: Module,
- pub attrs: Vec<ast::Attribute>,
+ pub attrs:
hir::HirVec<ast::Attribute>,
pub cx: &'a core::DocContext<'a, 'tcx>,
pub analysis: Option<&'a core::CrateAnalysis>,
view_item_stack: HashSet<ast::NodeId>,
stack.insert(ast::CRATE_NODE_ID);
RustdocVisitor {
module: Module::new(None),
- attrs: Vec::new(),
+ attrs: hir::HirVec::new(),
cx: cx,
analysis: analysis,
view_item_stack: stack,
}
}
- pub fn visit_mod_contents(&mut self, span: Span, attrs: Vec<ast::Attribute> ,
+ pub fn visit_mod_contents(&mut self, span: Span, attrs: hir::HirVec<ast::Attribute>,
vis: hir::Visibility, id: ast::NodeId,
m: &hir::Mod,
name: Option<ast::Name>) -> Module {
let mine = paths.into_iter().filter(|path| {
!self.resolve_id(path.node.id(), None, false, om,
please_inline)
- }).collect::<Vec<hir::PathListItem>>();
+ }).collect::<hir::HirVec<hir::PathListItem>>();
if mine.is_empty() {
None
const NR_GETRANDOM: libc::c_long = 355;
#[cfg(any(target_arch = "arm", target_arch = "powerpc"))]
const NR_GETRANDOM: libc::c_long = 384;
- #[cfg(any(target_arch = "aarch64"))]
+ #[cfg(target_arch = "aarch64")]
const NR_GETRANDOM: libc::c_long = 278;
unsafe {
fn getrandom_fill_bytes(v: &mut [u8]) {
let mut read = 0;
- let len = v.len();
- while read < len {
+ while read < v.len() {
let result = getrandom(&mut v[read..]);
if result == -1 {
let err = errno() as libc::c_int;
use abi::Abi;
use ext::base;
use ext::tt::macro_parser;
-use owned_slice::OwnedSlice;
use parse::token::InternedString;
use parse::token;
use parse::lexer;
pub fn none() -> PathParameters {
AngleBracketedParameters(AngleBracketedParameterData {
lifetimes: Vec::new(),
- types: OwnedSlice::empty(),
- bindings: OwnedSlice::empty(),
+ types: P::empty(),
+ bindings: P::empty(),
})
}
/// The lifetime parameters for this path segment.
pub lifetimes: Vec<Lifetime>,
/// The type parameters for this path segment, if present.
- pub types: OwnedSlice<P<Ty>>,
+ pub types: P<[P<Ty>]>,
/// Bindings (equality constraints) on associated types, if present.
/// E.g., `Foo<A=Bar>`.
- pub bindings: OwnedSlice<P<TypeBinding>>,
+ pub bindings: P<[P<TypeBinding>]>,
}
impl AngleBracketedParameterData {
Maybe,
}
-pub type TyParamBounds = OwnedSlice<TyParamBound>;
+pub type TyParamBounds = P<[TyParamBound]>;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct TyParam {
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct Generics {
pub lifetimes: Vec<LifetimeDef>,
- pub ty_params: OwnedSlice<TyParam>,
+ pub ty_params: P<[TyParam]>,
pub where_clause: WhereClause,
}
fn default() -> Generics {
Generics {
lifetimes: Vec::new(),
- ty_params: OwnedSlice::empty(),
+ ty_params: P::empty(),
where_clause: WhereClause {
id: DUMMY_NODE_ID,
predicates: Vec::new(),
/// The type being bounded
pub bounded_ty: P<Ty>,
/// Trait and lifetime bounds (`Clone+Send+'static`)
- pub bounds: OwnedSlice<TyParamBound>,
+ pub bounds: TyParamBounds,
}
/// A lifetime predicate, e.g. `'a: 'b+'c`
use ast;
use codemap;
use codemap::Span;
-use owned_slice::OwnedSlice;
use parse::token;
use print::pprust;
use ptr::P;
identifier: identifier,
parameters: ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
lifetimes: Vec::new(),
- types: OwnedSlice::empty(),
- bindings: OwnedSlice::empty(),
+ types: P::empty(),
+ bindings: P::empty(),
})
}
),
use codemap::{Span, Spanned, spanned, dummy_spanned};
use codemap::BytePos;
use config::CfgDiag;
-use diagnostic::SpanHandler;
+use errors::Handler;
use feature_gate::{GatedCfg, GatedCfgAttr};
use parse::lexer::comments::{doc_comment_style, strip_doc_comment_decoration};
use parse::token::InternedString;
}
/// Find the value of #[export_name=*] attribute and check its validity.
-pub fn find_export_name_attr(diag: &SpanHandler, attrs: &[Attribute]) -> Option<InternedString> {
+pub fn find_export_name_attr(diag: &Handler, attrs: &[Attribute]) -> Option<InternedString> {
attrs.iter().fold(None, |ia,attr| {
if attr.check_name("export_name") {
if let s@Some(_) = attr.value_str() {
s
} else {
diag.span_err(attr.span, "export_name attribute has invalid format");
- diag.handler.help("use #[export_name=\"*\"]");
+ diag.help("use #[export_name=\"*\"]");
None
}
} else {
}
/// Determine what `#[inline]` attribute is present in `attrs`, if any.
-pub fn find_inline_attr(diagnostic: Option<&SpanHandler>, attrs: &[Attribute]) -> InlineAttr {
+pub fn find_inline_attr(diagnostic: Option<&Handler>, attrs: &[Attribute]) -> InlineAttr {
attrs.iter().fold(InlineAttr::None, |ia,attr| {
match attr.node.value.node {
MetaWord(ref n) if *n == "inline" => {
pub fn is_stable(&self) -> bool { if let Stable {..} = *self { true } else { false }}
}
-fn find_stability_generic<'a, I>(diagnostic: &SpanHandler,
+fn find_stability_generic<'a, I>(diagnostic: &Handler,
attrs_iter: I,
item_sp: Span)
-> Option<Stability>
stab
}
-fn find_deprecation_generic<'a, I>(diagnostic: &SpanHandler,
- attrs_iter: I,
- item_sp: Span)
- -> Option<Deprecation>
+fn find_deprecation_generic<'a, I>(diagnostic: &Handler,
+ attrs_iter: I,
+ item_sp: Span)
+ -> Option<Deprecation>
where I: Iterator<Item = &'a Attribute>
{
let mut depr: Option<Deprecation> = None;
}
/// Find the first stability attribute. `None` if none exists.
-pub fn find_stability(diagnostic: &SpanHandler, attrs: &[Attribute],
+pub fn find_stability(diagnostic: &Handler, attrs: &[Attribute],
item_sp: Span) -> Option<Stability> {
find_stability_generic(diagnostic, attrs.iter(), item_sp)
}
/// Find the deprecation attribute. `None` if none exists.
-pub fn find_deprecation(diagnostic: &SpanHandler, attrs: &[Attribute],
- item_sp: Span) -> Option<Deprecation> {
+pub fn find_deprecation(diagnostic: &Handler, attrs: &[Attribute],
+ item_sp: Span) -> Option<Deprecation> {
find_deprecation_generic(diagnostic, attrs.iter(), item_sp)
}
-pub fn require_unique_names(diagnostic: &SpanHandler, metas: &[P<MetaItem>]) {
+pub fn require_unique_names(diagnostic: &Handler, metas: &[P<MetaItem>]) {
let mut set = HashSet::new();
for meta in metas {
let name = meta.name();
/// `int_type_of_word`, below) to specify enum discriminant type; `C`, to use
/// the same discriminant size that the corresponding C enum would or C
/// structure layout, and `packed` to remove padding.
-pub fn find_repr_attrs(diagnostic: &SpanHandler, attr: &Attribute) -> Vec<ReprAttr> {
+pub fn find_repr_attrs(diagnostic: &Handler, attr: &Attribute) -> Vec<ReprAttr> {
let mut acc = Vec::new();
match attr.node.value.node {
ast::MetaList(ref s, ref items) if *s == "repr" => {
// except according to those terms.
use attr::AttrMetaMethods;
-use diagnostic::SpanHandler;
+use errors::Handler;
use feature_gate::GatedCfgAttr;
use fold::Folder;
use {ast, fold, attr};
/// configuration.
struct Context<'a, F> where F: FnMut(&[ast::Attribute]) -> bool {
in_cfg: F,
- diagnostic: &'a SpanHandler,
+ diagnostic: &'a Handler,
}
// Support conditional compilation by transforming the AST, stripping out
// any items that do not belong in the current configuration
-pub fn strip_unconfigured_items(diagnostic: &SpanHandler, krate: ast::Crate,
+pub fn strip_unconfigured_items(diagnostic: &Handler, krate: ast::Crate,
feature_gated_cfgs: &mut Vec<GatedCfgAttr>)
-> ast::Crate
{
}
}
-pub fn strip_items<'a, F>(diagnostic: &'a SpanHandler,
+pub fn strip_items<'a, F>(diagnostic: &'a Handler,
krate: ast::Crate, in_cfg: F) -> ast::Crate where
F: FnMut(&[ast::Attribute]) -> bool,
{
}
// Process `#[cfg_attr]`.
-fn process_cfg_attr(diagnostic: &SpanHandler, krate: ast::Crate,
+fn process_cfg_attr(diagnostic: &Handler, krate: ast::Crate,
feature_gated_cfgs: &mut Vec<GatedCfgAttr>) -> ast::Crate {
let mut fld = CfgAttrFolder {
diag: CfgDiagReal {
}
pub trait CfgDiag {
- fn emit_error<F>(&mut self, f: F) where F: FnMut(&SpanHandler);
+ fn emit_error<F>(&mut self, f: F) where F: FnMut(&Handler);
fn flag_gated<F>(&mut self, f: F) where F: FnMut(&mut Vec<GatedCfgAttr>);
}
pub struct CfgDiagReal<'a, 'b> {
- pub diag: &'a SpanHandler,
+ pub diag: &'a Handler,
pub feature_gated_cfgs: &'b mut Vec<GatedCfgAttr>,
}
impl<'a, 'b> CfgDiag for CfgDiagReal<'a, 'b> {
- fn emit_error<F>(&mut self, mut f: F) where F: FnMut(&SpanHandler) {
+ fn emit_error<F>(&mut self, mut f: F) where F: FnMut(&Handler) {
f(self.diag)
}
fn flag_gated<F>(&mut self, mut f: F) where F: FnMut(&mut Vec<GatedCfgAttr>) {
}
impl CfgDiag for CfgDiagSilent {
- fn emit_error<F>(&mut self, _: F) where F: FnMut(&SpanHandler) {
+ fn emit_error<F>(&mut self, _: F) where F: FnMut(&Handler) {
self.error = true;
}
fn flag_gated<F>(&mut self, _: F) where F: FnMut(&mut Vec<GatedCfgAttr>) {}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-pub use self::Level::*;
-pub use self::RenderSpan::*;
-pub use self::ColorConfig::*;
-use self::Destination::*;
-
-use codemap::{self, COMMAND_LINE_SP, COMMAND_LINE_EXPN, Pos, Span};
-use diagnostics;
-
-use std::cell::{RefCell, Cell};
-use std::{cmp, error, fmt};
-use std::io::prelude::*;
-use std::io;
-use term;
-
-/// maximum number of lines we will print for each error; arbitrary.
-const MAX_LINES: usize = 6;
-
-#[derive(Clone)]
-pub enum RenderSpan {
- /// A FullSpan renders with both with an initial line for the
- /// message, prefixed by file:linenum, followed by a summary of
- /// the source code covered by the span.
- FullSpan(Span),
-
- /// Similar to a FullSpan, but the cited position is the end of
- /// the span, instead of the start. Used, at least, for telling
- /// compiletest/runtest to look at the last line of the span
- /// (since `end_highlight_lines` displays an arrow to the end
- /// of the span).
- EndSpan(Span),
-
- /// A suggestion renders with both with an initial line for the
- /// message, prefixed by file:linenum, followed by a summary
- /// of hypothetical source code, where the `String` is spliced
- /// into the lines in place of the code covered by the span.
- Suggestion(Span, String),
-
- /// A FileLine renders with just a line for the message prefixed
- /// by file:linenum.
- FileLine(Span),
-}
-
-impl RenderSpan {
- fn span(&self) -> Span {
- match *self {
- FullSpan(s) |
- Suggestion(s, _) |
- EndSpan(s) |
- FileLine(s) =>
- s
- }
- }
-}
-
-#[derive(Clone, Copy)]
-pub enum ColorConfig {
- Auto,
- Always,
- Never
-}
-
-pub trait Emitter {
- fn emit(&mut self, cmsp: Option<(&codemap::CodeMap, Span)>,
- msg: &str, code: Option<&str>, lvl: Level);
- fn custom_emit(&mut self, cm: &codemap::CodeMap,
- sp: RenderSpan, msg: &str, lvl: Level);
-}
-
-/// Used as a return value to signify a fatal error occurred. (It is also
-/// used as the argument to panic at the moment, but that will eventually
-/// not be true.)
-#[derive(Copy, Clone, Debug)]
-#[must_use]
-pub struct FatalError;
-
-impl fmt::Display for FatalError {
- fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
- write!(f, "parser fatal error")
- }
-}
-
-impl error::Error for FatalError {
- fn description(&self) -> &str {
- "The parser has encountered a fatal error"
- }
-}
-
-/// Signifies that the compiler died with an explicit call to `.bug`
-/// or `.span_bug` rather than a failed assertion, etc.
-#[derive(Copy, Clone, Debug)]
-pub struct ExplicitBug;
-
-impl fmt::Display for ExplicitBug {
- fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
- write!(f, "parser internal bug")
- }
-}
-
-impl error::Error for ExplicitBug {
- fn description(&self) -> &str {
- "The parser has encountered an internal bug"
- }
-}
-
-/// A span-handler is like a handler but also
-/// accepts span information for source-location
-/// reporting.
-pub struct SpanHandler {
- pub handler: Handler,
- pub cm: codemap::CodeMap,
-}
-
-impl SpanHandler {
- pub fn new(handler: Handler, cm: codemap::CodeMap) -> SpanHandler {
- SpanHandler {
- handler: handler,
- cm: cm,
- }
- }
- pub fn span_fatal(&self, sp: Span, msg: &str) -> FatalError {
- self.handler.emit(Some((&self.cm, sp)), msg, Fatal);
- return FatalError;
- }
- pub fn span_fatal_with_code(&self, sp: Span, msg: &str, code: &str) -> FatalError {
- self.handler.emit_with_code(Some((&self.cm, sp)), msg, code, Fatal);
- return FatalError;
- }
- pub fn span_err(&self, sp: Span, msg: &str) {
- self.handler.emit(Some((&self.cm, sp)), msg, Error);
- self.handler.bump_err_count();
- }
- pub fn span_err_with_code(&self, sp: Span, msg: &str, code: &str) {
- self.handler.emit_with_code(Some((&self.cm, sp)), msg, code, Error);
- self.handler.bump_err_count();
- }
- pub fn span_warn(&self, sp: Span, msg: &str) {
- self.handler.emit(Some((&self.cm, sp)), msg, Warning);
- }
- pub fn span_warn_with_code(&self, sp: Span, msg: &str, code: &str) {
- self.handler.emit_with_code(Some((&self.cm, sp)), msg, code, Warning);
- }
- pub fn span_note(&self, sp: Span, msg: &str) {
- self.handler.emit(Some((&self.cm, sp)), msg, Note);
- }
- pub fn span_end_note(&self, sp: Span, msg: &str) {
- self.handler.custom_emit(&self.cm, EndSpan(sp), msg, Note);
- }
- pub fn span_help(&self, sp: Span, msg: &str) {
- self.handler.emit(Some((&self.cm, sp)), msg, Help);
- }
- /// Prints out a message with a suggested edit of the code.
- ///
- /// See `diagnostic::RenderSpan::Suggestion` for more information.
- pub fn span_suggestion(&self, sp: Span, msg: &str, suggestion: String) {
- self.handler.custom_emit(&self.cm, Suggestion(sp, suggestion), msg, Help);
- }
- pub fn fileline_note(&self, sp: Span, msg: &str) {
- self.handler.custom_emit(&self.cm, FileLine(sp), msg, Note);
- }
- pub fn fileline_help(&self, sp: Span, msg: &str) {
- self.handler.custom_emit(&self.cm, FileLine(sp), msg, Help);
- }
- pub fn span_bug(&self, sp: Span, msg: &str) -> ! {
- self.handler.emit(Some((&self.cm, sp)), msg, Bug);
- panic!(ExplicitBug);
- }
- pub fn span_bug_no_panic(&self, sp: Span, msg: &str) {
- self.handler.emit(Some((&self.cm, sp)), msg, Bug);
- self.handler.bump_err_count();
- }
- pub fn span_unimpl(&self, sp: Span, msg: &str) -> ! {
- self.span_bug(sp, &format!("unimplemented {}", msg));
- }
- pub fn handler<'a>(&'a self) -> &'a Handler {
- &self.handler
- }
-}
-
-/// A handler deals with errors; certain errors
-/// (fatal, bug, unimpl) may cause immediate exit,
-/// others log errors for later reporting.
-pub struct Handler {
- err_count: Cell<usize>,
- emit: RefCell<Box<Emitter + Send>>,
- pub can_emit_warnings: bool
-}
-
-impl Handler {
- pub fn new(color_config: ColorConfig,
- registry: Option<diagnostics::registry::Registry>,
- can_emit_warnings: bool) -> Handler {
- let emitter = Box::new(EmitterWriter::stderr(color_config, registry));
- Handler::with_emitter(can_emit_warnings, emitter)
- }
- pub fn with_emitter(can_emit_warnings: bool, e: Box<Emitter + Send>) -> Handler {
- Handler {
- err_count: Cell::new(0),
- emit: RefCell::new(e),
- can_emit_warnings: can_emit_warnings
- }
- }
- pub fn fatal(&self, msg: &str) -> FatalError {
- self.emit.borrow_mut().emit(None, msg, None, Fatal);
- FatalError
- }
- pub fn err(&self, msg: &str) {
- self.emit.borrow_mut().emit(None, msg, None, Error);
- self.bump_err_count();
- }
- pub fn bump_err_count(&self) {
- self.err_count.set(self.err_count.get() + 1);
- }
- pub fn err_count(&self) -> usize {
- self.err_count.get()
- }
- pub fn has_errors(&self) -> bool {
- self.err_count.get() > 0
- }
- pub fn abort_if_errors(&self) {
- let s;
- match self.err_count.get() {
- 0 => return,
- 1 => s = "aborting due to previous error".to_string(),
- _ => {
- s = format!("aborting due to {} previous errors",
- self.err_count.get());
- }
- }
-
- panic!(self.fatal(&s[..]));
- }
- pub fn warn(&self, msg: &str) {
- self.emit.borrow_mut().emit(None, msg, None, Warning);
- }
- pub fn note(&self, msg: &str) {
- self.emit.borrow_mut().emit(None, msg, None, Note);
- }
- pub fn help(&self, msg: &str) {
- self.emit.borrow_mut().emit(None, msg, None, Help);
- }
- pub fn bug(&self, msg: &str) -> ! {
- self.emit.borrow_mut().emit(None, msg, None, Bug);
- panic!(ExplicitBug);
- }
- pub fn unimpl(&self, msg: &str) -> ! {
- self.bug(&format!("unimplemented {}", msg));
- }
- pub fn emit(&self,
- cmsp: Option<(&codemap::CodeMap, Span)>,
- msg: &str,
- lvl: Level) {
- if lvl == Warning && !self.can_emit_warnings { return }
- self.emit.borrow_mut().emit(cmsp, msg, None, lvl);
- }
- pub fn emit_with_code(&self,
- cmsp: Option<(&codemap::CodeMap, Span)>,
- msg: &str,
- code: &str,
- lvl: Level) {
- if lvl == Warning && !self.can_emit_warnings { return }
- self.emit.borrow_mut().emit(cmsp, msg, Some(code), lvl);
- }
- pub fn custom_emit(&self, cm: &codemap::CodeMap,
- sp: RenderSpan, msg: &str, lvl: Level) {
- if lvl == Warning && !self.can_emit_warnings { return }
- self.emit.borrow_mut().custom_emit(cm, sp, msg, lvl);
- }
-}
-
-#[derive(Copy, PartialEq, Clone, Debug)]
-pub enum Level {
- Bug,
- Fatal,
- Error,
- Warning,
- Note,
- Help,
-}
-
-impl fmt::Display for Level {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- use std::fmt::Display;
-
- match *self {
- Bug => "error: internal compiler error".fmt(f),
- Fatal | Error => "error".fmt(f),
- Warning => "warning".fmt(f),
- Note => "note".fmt(f),
- Help => "help".fmt(f),
- }
- }
-}
-
-impl Level {
- fn color(self) -> term::color::Color {
- match self {
- Bug | Fatal | Error => term::color::BRIGHT_RED,
- Warning => term::color::BRIGHT_YELLOW,
- Note => term::color::BRIGHT_GREEN,
- Help => term::color::BRIGHT_CYAN,
- }
- }
-}
-
-pub struct EmitterWriter {
- dst: Destination,
- registry: Option<diagnostics::registry::Registry>
-}
-
-enum Destination {
- Terminal(Box<term::StderrTerminal>),
- Raw(Box<Write + Send>),
-}
-
-/// Do not use this for messages that end in `\n` – use `println_maybe_styled` instead. See
-/// `EmitterWriter::print_maybe_styled` for details.
-macro_rules! print_maybe_styled {
- ($writer: expr, $style: expr, $($arg: tt)*) => {
- $writer.print_maybe_styled(format_args!($($arg)*), $style, false)
- }
-}
-
-macro_rules! println_maybe_styled {
- ($writer: expr, $style: expr, $($arg: tt)*) => {
- $writer.print_maybe_styled(format_args!($($arg)*), $style, true)
- }
-}
-
-impl EmitterWriter {
- pub fn stderr(color_config: ColorConfig,
- registry: Option<diagnostics::registry::Registry>) -> EmitterWriter {
- let stderr = io::stderr();
-
- let use_color = match color_config {
- Always => true,
- Never => false,
- Auto => stderr_isatty(),
- };
-
- if use_color {
- let dst = match term::stderr() {
- Some(t) => Terminal(t),
- None => Raw(Box::new(stderr)),
- };
- EmitterWriter { dst: dst, registry: registry }
- } else {
- EmitterWriter { dst: Raw(Box::new(stderr)), registry: registry }
- }
- }
-
- pub fn new(dst: Box<Write + Send>,
- registry: Option<diagnostics::registry::Registry>) -> EmitterWriter {
- EmitterWriter { dst: Raw(dst), registry: registry }
- }
-
- fn print_maybe_styled(&mut self,
- args: fmt::Arguments,
- color: term::Attr,
- print_newline_at_end: bool) -> io::Result<()> {
- match self.dst {
- Terminal(ref mut t) => {
- try!(t.attr(color));
- // If `msg` ends in a newline, we need to reset the color before
- // the newline. We're making the assumption that we end up writing
- // to a `LineBufferedWriter`, which means that emitting the reset
- // after the newline ends up buffering the reset until we print
- // another line or exit. Buffering the reset is a problem if we're
- // sharing the terminal with any other programs (e.g. other rustc
- // instances via `make -jN`).
- //
- // Note that if `msg` contains any internal newlines, this will
- // result in the `LineBufferedWriter` flushing twice instead of
- // once, which still leaves the opportunity for interleaved output
- // to be miscolored. We assume this is rare enough that we don't
- // have to worry about it.
- try!(t.write_fmt(args));
- try!(t.reset());
- if print_newline_at_end {
- t.write_all(b"\n")
- } else {
- Ok(())
- }
- }
- Raw(ref mut w) => {
- try!(w.write_fmt(args));
- if print_newline_at_end {
- w.write_all(b"\n")
- } else {
- Ok(())
- }
- }
- }
- }
-
- fn print_diagnostic(&mut self, topic: &str, lvl: Level,
- msg: &str, code: Option<&str>) -> io::Result<()> {
- if !topic.is_empty() {
- try!(write!(&mut self.dst, "{} ", topic));
- }
-
- try!(print_maybe_styled!(self, term::Attr::ForegroundColor(lvl.color()),
- "{}: ", lvl.to_string()));
- try!(print_maybe_styled!(self, term::Attr::Bold, "{}", msg));
-
- match code {
- Some(code) => {
- let style = term::Attr::ForegroundColor(term::color::BRIGHT_MAGENTA);
- try!(print_maybe_styled!(self, style, " [{}]", code.clone()));
- }
- None => ()
- }
- try!(write!(&mut self.dst, "\n"));
- Ok(())
- }
-
- fn emit_(&mut self, cm: &codemap::CodeMap, rsp: RenderSpan,
- msg: &str, code: Option<&str>, lvl: Level) -> io::Result<()> {
- let sp = rsp.span();
-
- // We cannot check equality directly with COMMAND_LINE_SP
- // since PartialEq is manually implemented to ignore the ExpnId
- let ss = if sp.expn_id == COMMAND_LINE_EXPN {
- "<command line option>".to_string()
- } else if let EndSpan(_) = rsp {
- let span_end = Span { lo: sp.hi, hi: sp.hi, expn_id: sp.expn_id};
- cm.span_to_string(span_end)
- } else {
- cm.span_to_string(sp)
- };
-
- try!(self.print_diagnostic(&ss[..], lvl, msg, code));
-
- match rsp {
- FullSpan(_) => {
- try!(self.highlight_lines(cm, sp, lvl, cm.span_to_lines(sp)));
- try!(self.print_macro_backtrace(cm, sp));
- }
- EndSpan(_) => {
- try!(self.end_highlight_lines(cm, sp, lvl, cm.span_to_lines(sp)));
- try!(self.print_macro_backtrace(cm, sp));
- }
- Suggestion(_, ref suggestion) => {
- try!(self.highlight_suggestion(cm, sp, suggestion));
- try!(self.print_macro_backtrace(cm, sp));
- }
- FileLine(..) => {
- // no source text in this case!
- }
- }
-
- match code {
- Some(code) =>
- match self.registry.as_ref().and_then(|registry| registry.find_description(code)) {
- Some(_) => {
- try!(self.print_diagnostic(&ss[..], Help,
- &format!("run `rustc --explain {}` to see a \
- detailed explanation", code), None));
- }
- None => ()
- },
- None => (),
- }
- Ok(())
- }
-
- fn highlight_suggestion(&mut self,
- cm: &codemap::CodeMap,
- sp: Span,
- suggestion: &str)
- -> io::Result<()>
- {
- let lines = cm.span_to_lines(sp).unwrap();
- assert!(!lines.lines.is_empty());
-
- // To build up the result, we want to take the snippet from the first
- // line that precedes the span, prepend that with the suggestion, and
- // then append the snippet from the last line that trails the span.
- let fm = &lines.file;
-
- let first_line = &lines.lines[0];
- let prefix = fm.get_line(first_line.line_index)
- .map(|l| &l[..first_line.start_col.0])
- .unwrap_or("");
-
- let last_line = lines.lines.last().unwrap();
- let suffix = fm.get_line(last_line.line_index)
- .map(|l| &l[last_line.end_col.0..])
- .unwrap_or("");
-
- let complete = format!("{}{}{}", prefix, suggestion, suffix);
-
- // print the suggestion without any line numbers, but leave
- // space for them. This helps with lining up with previous
- // snippets from the actual error being reported.
- let fm = &*lines.file;
- let mut lines = complete.lines();
- for (line, line_index) in lines.by_ref().take(MAX_LINES).zip(first_line.line_index..) {
- let elided_line_num = format!("{}", line_index+1);
- try!(write!(&mut self.dst, "{0}:{1:2$} {3}\n",
- fm.name, "", elided_line_num.len(), line));
- }
-
- // if we elided some lines, add an ellipsis
- if lines.next().is_some() {
- let elided_line_num = format!("{}", first_line.line_index + MAX_LINES + 1);
- try!(write!(&mut self.dst, "{0:1$} {0:2$} ...\n",
- "", fm.name.len(), elided_line_num.len()));
- }
-
- Ok(())
- }
-
- fn highlight_lines(&mut self,
- cm: &codemap::CodeMap,
- sp: Span,
- lvl: Level,
- lines: codemap::FileLinesResult)
- -> io::Result<()>
- {
- let lines = match lines {
- Ok(lines) => lines,
- Err(_) => {
- try!(write!(&mut self.dst, "(internal compiler error: unprintable span)\n"));
- return Ok(());
- }
- };
-
- let fm = &*lines.file;
-
- let line_strings: Option<Vec<&str>> =
- lines.lines.iter()
- .map(|info| fm.get_line(info.line_index))
- .collect();
-
- let line_strings = match line_strings {
- None => { return Ok(()); }
- Some(line_strings) => line_strings
- };
-
- // Display only the first MAX_LINES lines.
- let all_lines = lines.lines.len();
- let display_lines = cmp::min(all_lines, MAX_LINES);
- let display_line_infos = &lines.lines[..display_lines];
- let display_line_strings = &line_strings[..display_lines];
-
- // Calculate the widest number to format evenly and fix #11715
- assert!(display_line_infos.len() > 0);
- let mut max_line_num = display_line_infos[display_line_infos.len() - 1].line_index + 1;
- let mut digits = 0;
- while max_line_num > 0 {
- max_line_num /= 10;
- digits += 1;
- }
-
- // Print the offending lines
- for (line_info, line) in display_line_infos.iter().zip(display_line_strings) {
- try!(write!(&mut self.dst, "{}:{:>width$} {}\n",
- fm.name,
- line_info.line_index + 1,
- line,
- width=digits));
- }
-
- // If we elided something, put an ellipsis.
- if display_lines < all_lines {
- let last_line_index = display_line_infos.last().unwrap().line_index;
- let s = format!("{}:{} ", fm.name, last_line_index + 1);
- try!(write!(&mut self.dst, "{0:1$}...\n", "", s.len()));
- }
-
- // FIXME (#3260)
- // If there's one line at fault we can easily point to the problem
- if lines.lines.len() == 1 {
- let lo = cm.lookup_char_pos(sp.lo);
- let mut digits = 0;
- let mut num = (lines.lines[0].line_index + 1) / 10;
-
- // how many digits must be indent past?
- while num > 0 { num /= 10; digits += 1; }
-
- let mut s = String::new();
- // Skip is the number of characters we need to skip because they are
- // part of the 'filename:line ' part of the previous line.
- let skip = fm.name.chars().count() + digits + 3;
- for _ in 0..skip {
- s.push(' ');
- }
- if let Some(orig) = fm.get_line(lines.lines[0].line_index) {
- let mut col = skip;
- let mut lastc = ' ';
- let mut iter = orig.chars().enumerate();
- for (pos, ch) in iter.by_ref() {
- lastc = ch;
- if pos >= lo.col.to_usize() { break; }
- // Whenever a tab occurs on the previous line, we insert one on
- // the error-point-squiggly-line as well (instead of a space).
- // That way the squiggly line will usually appear in the correct
- // position.
- match ch {
- '\t' => {
- col += 8 - col%8;
- s.push('\t');
- },
- _ => {
- col += 1;
- s.push(' ');
- },
- }
- }
-
- try!(write!(&mut self.dst, "{}", s));
- let mut s = String::from("^");
- let count = match lastc {
- // Most terminals have a tab stop every eight columns by default
- '\t' => 8 - col%8,
- _ => 1,
- };
- col += count;
- s.extend(::std::iter::repeat('~').take(count));
-
- let hi = cm.lookup_char_pos(sp.hi);
- if hi.col != lo.col {
- for (pos, ch) in iter {
- if pos >= hi.col.to_usize() { break; }
- let count = match ch {
- '\t' => 8 - col%8,
- _ => 1,
- };
- col += count;
- s.extend(::std::iter::repeat('~').take(count));
- }
- }
-
- if s.len() > 1 {
- // One extra squiggly is replaced by a "^"
- s.pop();
- }
-
- try!(println_maybe_styled!(self, term::Attr::ForegroundColor(lvl.color()),
- "{}", s));
- }
- }
- Ok(())
- }
-
- /// Here are the differences between this and the normal `highlight_lines`:
- /// `end_highlight_lines` will always put arrow on the last byte of the
- /// span (instead of the first byte). Also, when the span is too long (more
- /// than 6 lines), `end_highlight_lines` will print the first line, then
- /// dot dot dot, then last line, whereas `highlight_lines` prints the first
- /// six lines.
- #[allow(deprecated)]
- fn end_highlight_lines(&mut self,
- cm: &codemap::CodeMap,
- sp: Span,
- lvl: Level,
- lines: codemap::FileLinesResult)
- -> io::Result<()> {
- let lines = match lines {
- Ok(lines) => lines,
- Err(_) => {
- try!(write!(&mut self.dst, "(internal compiler error: unprintable span)\n"));
- return Ok(());
- }
- };
-
- let fm = &*lines.file;
-
- let lines = &lines.lines[..];
- if lines.len() > MAX_LINES {
- if let Some(line) = fm.get_line(lines[0].line_index) {
- try!(write!(&mut self.dst, "{}:{} {}\n", fm.name,
- lines[0].line_index + 1, line));
- }
- try!(write!(&mut self.dst, "...\n"));
- let last_line_index = lines[lines.len() - 1].line_index;
- if let Some(last_line) = fm.get_line(last_line_index) {
- try!(write!(&mut self.dst, "{}:{} {}\n", fm.name,
- last_line_index + 1, last_line));
- }
- } else {
- for line_info in lines {
- if let Some(line) = fm.get_line(line_info.line_index) {
- try!(write!(&mut self.dst, "{}:{} {}\n", fm.name,
- line_info.line_index + 1, line));
- }
- }
- }
- let last_line_start = format!("{}:{} ", fm.name, lines[lines.len()-1].line_index + 1);
- let hi = cm.lookup_char_pos(sp.hi);
- let skip = last_line_start.chars().count();
- let mut s = String::new();
- for _ in 0..skip {
- s.push(' ');
- }
- if let Some(orig) = fm.get_line(lines[0].line_index) {
- let iter = orig.chars().enumerate();
- for (pos, ch) in iter {
- // Span seems to use half-opened interval, so subtract 1
- if pos >= hi.col.to_usize() - 1 { break; }
- // Whenever a tab occurs on the previous line, we insert one on
- // the error-point-squiggly-line as well (instead of a space).
- // That way the squiggly line will usually appear in the correct
- // position.
- match ch {
- '\t' => s.push('\t'),
- _ => s.push(' '),
- }
- }
- }
- s.push('^');
- println_maybe_styled!(self, term::Attr::ForegroundColor(lvl.color()),
- "{}", s)
- }
-
- fn print_macro_backtrace(&mut self,
- cm: &codemap::CodeMap,
- sp: Span)
- -> io::Result<()> {
- let mut last_span = codemap::DUMMY_SP;
- let mut sp_opt = Some(sp);
-
- while let Some(sp) = sp_opt {
- sp_opt = try!(cm.with_expn_info(sp.expn_id, |expn_info| -> io::Result<_> {
- match expn_info {
- Some(ei) => {
- let (pre, post) = match ei.callee.format {
- codemap::MacroAttribute(..) => ("#[", "]"),
- codemap::MacroBang(..) => ("", "!"),
- };
- // Don't print recursive invocations
- if ei.call_site != last_span {
- last_span = ei.call_site;
-
- let mut diag_string = format!("in this expansion of {}{}{}",
- pre,
- ei.callee.name(),
- post);
-
- if let Some(def_site_span) = ei.callee.span {
- diag_string.push_str(&format!(" (defined in {})",
- cm.span_to_filename(def_site_span)));
- }
-
- try!(self.print_diagnostic(&cm.span_to_string(ei.call_site),
- Note,
- &diag_string,
- None));
- }
- Ok(Some(ei.call_site))
- }
- None => Ok(None)
- }
- }));
- }
-
- Ok(())
- }
-}
-
-#[cfg(unix)]
-fn stderr_isatty() -> bool {
- use libc;
- unsafe { libc::isatty(libc::STDERR_FILENO) != 0 }
-}
-#[cfg(windows)]
-fn stderr_isatty() -> bool {
- type DWORD = u32;
- type BOOL = i32;
- type HANDLE = *mut u8;
- const STD_ERROR_HANDLE: DWORD = -12i32 as DWORD;
- extern "system" {
- fn GetStdHandle(which: DWORD) -> HANDLE;
- fn GetConsoleMode(hConsoleHandle: HANDLE,
- lpMode: *mut DWORD) -> BOOL;
- }
- unsafe {
- let handle = GetStdHandle(STD_ERROR_HANDLE);
- let mut out = 0;
- GetConsoleMode(handle, &mut out) != 0
- }
-}
-
-impl Write for Destination {
- fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
- match *self {
- Terminal(ref mut t) => t.write(bytes),
- Raw(ref mut w) => w.write(bytes),
- }
- }
- fn flush(&mut self) -> io::Result<()> {
- match *self {
- Terminal(ref mut t) => t.flush(),
- Raw(ref mut w) => w.flush(),
- }
- }
-}
-
-impl Emitter for EmitterWriter {
- fn emit(&mut self,
- cmsp: Option<(&codemap::CodeMap, Span)>,
- msg: &str, code: Option<&str>, lvl: Level) {
- let error = match cmsp {
- Some((cm, COMMAND_LINE_SP)) => self.emit_(cm,
- FileLine(COMMAND_LINE_SP),
- msg, code, lvl),
- Some((cm, sp)) => self.emit_(cm, FullSpan(sp), msg, code, lvl),
- None => self.print_diagnostic("", lvl, msg, code),
- };
-
- match error {
- Ok(()) => {}
- Err(e) => panic!("failed to print diagnostics: {:?}", e),
- }
- }
-
- fn custom_emit(&mut self, cm: &codemap::CodeMap,
- sp: RenderSpan, msg: &str, lvl: Level) {
- match self.emit_(cm, sp, msg, None, lvl) {
- Ok(()) => {}
- Err(e) => panic!("failed to print diagnostics: {:?}", e),
- }
- }
-}
-
-pub fn expect<T, M>(diag: &SpanHandler, opt: Option<T>, msg: M) -> T where
- M: FnOnce() -> String,
-{
- match opt {
- Some(t) => t,
- None => diag.handler().bug(&msg()),
- }
-}
-
-#[cfg(test)]
-mod test {
- use super::{EmitterWriter, Level};
- use codemap::{mk_sp, CodeMap};
- use std::sync::{Arc, Mutex};
- use std::io::{self, Write};
- use std::str::from_utf8;
-
- // Diagnostic doesn't align properly in span where line number increases by one digit
- #[test]
- fn test_hilight_suggestion_issue_11715() {
- struct Sink(Arc<Mutex<Vec<u8>>>);
- impl Write for Sink {
- fn write(&mut self, data: &[u8]) -> io::Result<usize> {
- Write::write(&mut *self.0.lock().unwrap(), data)
- }
- fn flush(&mut self) -> io::Result<()> { Ok(()) }
- }
- let data = Arc::new(Mutex::new(Vec::new()));
- let mut ew = EmitterWriter::new(Box::new(Sink(data.clone())), None);
- let cm = CodeMap::new();
- let content = "abcdefg
- koksi
- line3
- line4
- cinq
- line6
- line7
- line8
- line9
- line10
- e-lä-vän
- tolv
- dreizehn
- ";
- let file = cm.new_filemap_and_lines("dummy.txt", content);
- let start = file.lines.borrow()[7];
- let end = file.lines.borrow()[11];
- let sp = mk_sp(start, end);
- let lvl = Level::Error;
- println!("span_to_lines");
- let lines = cm.span_to_lines(sp);
- println!("highlight_lines");
- ew.highlight_lines(&cm, sp, lvl, lines).unwrap();
- println!("done");
- let vec = data.lock().unwrap().clone();
- let vec: &[u8] = &vec;
- let str = from_utf8(vec).unwrap();
- println!("{}", str);
- assert_eq!(str, "dummy.txt: 8 line8\n\
- dummy.txt: 9 line9\n\
- dummy.txt:10 line10\n\
- dummy.txt:11 e-lä-vän\n\
- dummy.txt:12 tolv\n");
- }
-}
--- /dev/null
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use self::Destination::*;
+
+use codemap::{self, COMMAND_LINE_SP, COMMAND_LINE_EXPN, Pos, Span};
+use diagnostics;
+
+use errors::{Level, RenderSpan};
+use errors::RenderSpan::*;
+use errors::Level::*;
+
+use std::{cmp, fmt};
+use std::io::prelude::*;
+use std::io;
+use std::rc::Rc;
+use term;
+
+
+pub trait Emitter {
+ fn emit(&mut self, span: Option<Span>, msg: &str, code: Option<&str>, lvl: Level);
+ fn custom_emit(&mut self, sp: RenderSpan, msg: &str, lvl: Level);
+}
+
+/// maximum number of lines we will print for each error; arbitrary.
+const MAX_LINES: usize = 6;
+
+#[derive(Clone, Copy)]
+pub enum ColorConfig {
+ Auto,
+ Always,
+ Never,
+}
+
+impl ColorConfig {
+ fn use_color(&self) -> bool {
+ match *self {
+ ColorConfig::Always => true,
+ ColorConfig::Never => false,
+ ColorConfig::Auto => stderr_isatty(),
+ }
+ }
+}
+
+// A basic emitter for when we don't have access to a codemap or registry. Used
+// for reporting very early errors, etc.
+pub struct BasicEmitter {
+ dst: Destination,
+}
+
+impl Emitter for BasicEmitter {
+ fn emit(&mut self,
+ sp: Option<Span>,
+ msg: &str,
+ code: Option<&str>,
+ lvl: Level) {
+ assert!(sp.is_none(), "BasicEmitter can't handle spans");
+ if let Err(e) = print_diagnostic(&mut self.dst, "", lvl, msg, code) {
+ panic!("failed to print diagnostics: {:?}", e);
+ }
+
+ }
+
+ fn custom_emit(&mut self, _: RenderSpan, _: &str, _: Level) {
+ panic!("BasicEmitter can't handle custom_emit");
+ }
+}
+
+impl BasicEmitter {
+ pub fn stderr(color_config: ColorConfig) -> BasicEmitter {
+ if color_config.use_color() {
+ let dst = Destination::from_stderr();
+ BasicEmitter { dst: dst }
+ } else {
+ BasicEmitter { dst: Raw(Box::new(io::stderr())) }
+ }
+ }
+}
+
+pub struct EmitterWriter {
+ dst: Destination,
+ registry: Option<diagnostics::registry::Registry>,
+ cm: Rc<codemap::CodeMap>,
+}
+
+impl Emitter for EmitterWriter {
+ fn emit(&mut self,
+ sp: Option<Span>,
+ msg: &str,
+ code: Option<&str>,
+ lvl: Level) {
+ let error = match sp {
+ Some(COMMAND_LINE_SP) => self.emit_(FileLine(COMMAND_LINE_SP), msg, code, lvl),
+ Some(sp) => self.emit_(FullSpan(sp), msg, code, lvl),
+ None => print_diagnostic(&mut self.dst, "", lvl, msg, code),
+ };
+
+ if let Err(e) = error {
+ panic!("failed to print diagnostics: {:?}", e);
+ }
+ }
+
+ fn custom_emit(&mut self,
+ sp: RenderSpan,
+ msg: &str,
+ lvl: Level) {
+ match self.emit_(sp, msg, None, lvl) {
+ Ok(()) => {}
+ Err(e) => panic!("failed to print diagnostics: {:?}", e),
+ }
+ }
+}
+
+/// Do not use this for messages that end in `\n` – use `println_maybe_styled` instead. See
+/// `EmitterWriter::print_maybe_styled` for details.
+macro_rules! print_maybe_styled {
+ ($dst: expr, $style: expr, $($arg: tt)*) => {
+ $dst.print_maybe_styled(format_args!($($arg)*), $style, false)
+ }
+}
+
+macro_rules! println_maybe_styled {
+ ($dst: expr, $style: expr, $($arg: tt)*) => {
+ $dst.print_maybe_styled(format_args!($($arg)*), $style, true)
+ }
+}
+
+impl EmitterWriter {
+ pub fn stderr(color_config: ColorConfig,
+ registry: Option<diagnostics::registry::Registry>,
+ code_map: Rc<codemap::CodeMap>)
+ -> EmitterWriter {
+ if color_config.use_color() {
+ let dst = Destination::from_stderr();
+ EmitterWriter { dst: dst, registry: registry, cm: code_map }
+ } else {
+ EmitterWriter { dst: Raw(Box::new(io::stderr())), registry: registry, cm: code_map }
+ }
+ }
+
+ pub fn new(dst: Box<Write + Send>,
+ registry: Option<diagnostics::registry::Registry>,
+ code_map: Rc<codemap::CodeMap>)
+ -> EmitterWriter {
+ EmitterWriter { dst: Raw(dst), registry: registry, cm: code_map }
+ }
+
+ fn emit_(&mut self,
+ rsp: RenderSpan,
+ msg: &str,
+ code: Option<&str>,
+ lvl: Level)
+ -> io::Result<()> {
+ let sp = rsp.span();
+
+ // We cannot check equality directly with COMMAND_LINE_SP
+ // since PartialEq is manually implemented to ignore the ExpnId
+ let ss = if sp.expn_id == COMMAND_LINE_EXPN {
+ "<command line option>".to_string()
+ } else if let EndSpan(_) = rsp {
+ let span_end = Span { lo: sp.hi, hi: sp.hi, expn_id: sp.expn_id};
+ self.cm.span_to_string(span_end)
+ } else {
+ self.cm.span_to_string(sp)
+ };
+
+ try!(print_diagnostic(&mut self.dst, &ss[..], lvl, msg, code));
+
+ match rsp {
+ FullSpan(_) => {
+ let lines = self.cm.span_to_lines(sp);
+ try!(self.highlight_lines(sp, lvl, lines));
+ try!(self.print_macro_backtrace(sp));
+ }
+ EndSpan(_) => {
+ let lines = self.cm.span_to_lines(sp);
+ try!(self.end_highlight_lines(sp, lvl, lines));
+ try!(self.print_macro_backtrace(sp));
+ }
+ Suggestion(_, ref suggestion) => {
+ try!(self.highlight_suggestion(sp, suggestion));
+ try!(self.print_macro_backtrace(sp));
+ }
+ FileLine(..) => {
+ // no source text in this case!
+ }
+ }
+
+ match code {
+ Some(code) =>
+ match self.registry.as_ref().and_then(|registry| registry.find_description(code)) {
+ Some(_) => {
+ try!(print_diagnostic(&mut self.dst, &ss[..], Help,
+ &format!("run `rustc --explain {}` to see a \
+ detailed explanation", code), None));
+ }
+ None => ()
+ },
+ None => (),
+ }
+ Ok(())
+ }
+
+ fn highlight_suggestion(&mut self,
+ sp: Span,
+ suggestion: &str)
+ -> io::Result<()>
+ {
+ let lines = self.cm.span_to_lines(sp).unwrap();
+ assert!(!lines.lines.is_empty());
+
+ // To build up the result, we want to take the snippet from the first
+ // line that precedes the span, prepend that with the suggestion, and
+ // then append the snippet from the last line that trails the span.
+ let fm = &lines.file;
+
+ let first_line = &lines.lines[0];
+ let prefix = fm.get_line(first_line.line_index)
+ .map(|l| &l[..first_line.start_col.0])
+ .unwrap_or("");
+
+ let last_line = lines.lines.last().unwrap();
+ let suffix = fm.get_line(last_line.line_index)
+ .map(|l| &l[last_line.end_col.0..])
+ .unwrap_or("");
+
+ let complete = format!("{}{}{}", prefix, suggestion, suffix);
+
+ // print the suggestion without any line numbers, but leave
+ // space for them. This helps with lining up with previous
+ // snippets from the actual error being reported.
+ let fm = &*lines.file;
+ let mut lines = complete.lines();
+ for (line, line_index) in lines.by_ref().take(MAX_LINES).zip(first_line.line_index..) {
+ let elided_line_num = format!("{}", line_index+1);
+ try!(write!(&mut self.dst, "{0}:{1:2$} {3}\n",
+ fm.name, "", elided_line_num.len(), line));
+ }
+
+ // if we elided some lines, add an ellipsis
+ if lines.next().is_some() {
+ let elided_line_num = format!("{}", first_line.line_index + MAX_LINES + 1);
+ try!(write!(&mut self.dst, "{0:1$} {0:2$} ...\n",
+ "", fm.name.len(), elided_line_num.len()));
+ }
+
+ Ok(())
+ }
+
+ fn highlight_lines(&mut self,
+ sp: Span,
+ lvl: Level,
+ lines: codemap::FileLinesResult)
+ -> io::Result<()>
+ {
+ let lines = match lines {
+ Ok(lines) => lines,
+ Err(_) => {
+ try!(write!(&mut self.dst, "(internal compiler error: unprintable span)\n"));
+ return Ok(());
+ }
+ };
+
+ let fm = &*lines.file;
+
+ let line_strings: Option<Vec<&str>> =
+ lines.lines.iter()
+ .map(|info| fm.get_line(info.line_index))
+ .collect();
+
+ let line_strings = match line_strings {
+ None => { return Ok(()); }
+ Some(line_strings) => line_strings
+ };
+
+ // Display only the first MAX_LINES lines.
+ let all_lines = lines.lines.len();
+ let display_lines = cmp::min(all_lines, MAX_LINES);
+ let display_line_infos = &lines.lines[..display_lines];
+ let display_line_strings = &line_strings[..display_lines];
+
+ // Calculate the widest number to format evenly and fix #11715
+ assert!(display_line_infos.len() > 0);
+ let mut max_line_num = display_line_infos[display_line_infos.len() - 1].line_index + 1;
+ let mut digits = 0;
+ while max_line_num > 0 {
+ max_line_num /= 10;
+ digits += 1;
+ }
+
+ // Print the offending lines
+ for (line_info, line) in display_line_infos.iter().zip(display_line_strings) {
+ try!(write!(&mut self.dst, "{}:{:>width$} {}\n",
+ fm.name,
+ line_info.line_index + 1,
+ line,
+ width=digits));
+ }
+
+ // If we elided something, put an ellipsis.
+ if display_lines < all_lines {
+ let last_line_index = display_line_infos.last().unwrap().line_index;
+ let s = format!("{}:{} ", fm.name, last_line_index + 1);
+ try!(write!(&mut self.dst, "{0:1$}...\n", "", s.len()));
+ }
+
+ // FIXME (#3260)
+ // If there's one line at fault we can easily point to the problem
+ if lines.lines.len() == 1 {
+ let lo = self.cm.lookup_char_pos(sp.lo);
+ let mut digits = 0;
+ let mut num = (lines.lines[0].line_index + 1) / 10;
+
+ // how many digits must be indent past?
+ while num > 0 { num /= 10; digits += 1; }
+
+ let mut s = String::new();
+ // Skip is the number of characters we need to skip because they are
+ // part of the 'filename:line ' part of the previous line.
+ let skip = fm.name.chars().count() + digits + 3;
+ for _ in 0..skip {
+ s.push(' ');
+ }
+ if let Some(orig) = fm.get_line(lines.lines[0].line_index) {
+ let mut col = skip;
+ let mut lastc = ' ';
+ let mut iter = orig.chars().enumerate();
+ for (pos, ch) in iter.by_ref() {
+ lastc = ch;
+ if pos >= lo.col.to_usize() { break; }
+ // Whenever a tab occurs on the previous line, we insert one on
+ // the error-point-squiggly-line as well (instead of a space).
+ // That way the squiggly line will usually appear in the correct
+ // position.
+ match ch {
+ '\t' => {
+ col += 8 - col%8;
+ s.push('\t');
+ },
+ _ => {
+ col += 1;
+ s.push(' ');
+ },
+ }
+ }
+
+ try!(write!(&mut self.dst, "{}", s));
+ let mut s = String::from("^");
+ let count = match lastc {
+ // Most terminals have a tab stop every eight columns by default
+ '\t' => 8 - col%8,
+ _ => 1,
+ };
+ col += count;
+ s.extend(::std::iter::repeat('~').take(count));
+
+ let hi = self.cm.lookup_char_pos(sp.hi);
+ if hi.col != lo.col {
+ for (pos, ch) in iter {
+ if pos >= hi.col.to_usize() { break; }
+ let count = match ch {
+ '\t' => 8 - col%8,
+ _ => 1,
+ };
+ col += count;
+ s.extend(::std::iter::repeat('~').take(count));
+ }
+ }
+
+ if s.len() > 1 {
+ // One extra squiggly is replaced by a "^"
+ s.pop();
+ }
+
+ try!(println_maybe_styled!(&mut self.dst, term::Attr::ForegroundColor(lvl.color()),
+ "{}", s));
+ }
+ }
+ Ok(())
+ }
+
+ /// Here are the differences between this and the normal `highlight_lines`:
+ /// `end_highlight_lines` will always put arrow on the last byte of the
+ /// span (instead of the first byte). Also, when the span is too long (more
+ /// than 6 lines), `end_highlight_lines` will print the first line, then
+ /// dot dot dot, then last line, whereas `highlight_lines` prints the first
+ /// six lines.
+ #[allow(deprecated)]
+ fn end_highlight_lines(&mut self,
+ sp: Span,
+ lvl: Level,
+ lines: codemap::FileLinesResult)
+ -> io::Result<()> {
+ let lines = match lines {
+ Ok(lines) => lines,
+ Err(_) => {
+ try!(write!(&mut self.dst, "(internal compiler error: unprintable span)\n"));
+ return Ok(());
+ }
+ };
+
+ let fm = &*lines.file;
+
+ let lines = &lines.lines[..];
+ if lines.len() > MAX_LINES {
+ if let Some(line) = fm.get_line(lines[0].line_index) {
+ try!(write!(&mut self.dst, "{}:{} {}\n", fm.name,
+ lines[0].line_index + 1, line));
+ }
+ try!(write!(&mut self.dst, "...\n"));
+ let last_line_index = lines[lines.len() - 1].line_index;
+ if let Some(last_line) = fm.get_line(last_line_index) {
+ try!(write!(&mut self.dst, "{}:{} {}\n", fm.name,
+ last_line_index + 1, last_line));
+ }
+ } else {
+ for line_info in lines {
+ if let Some(line) = fm.get_line(line_info.line_index) {
+ try!(write!(&mut self.dst, "{}:{} {}\n", fm.name,
+ line_info.line_index + 1, line));
+ }
+ }
+ }
+ let last_line_start = format!("{}:{} ", fm.name, lines[lines.len()-1].line_index + 1);
+ let hi = self.cm.lookup_char_pos(sp.hi);
+ let skip = last_line_start.chars().count();
+ let mut s = String::new();
+ for _ in 0..skip {
+ s.push(' ');
+ }
+ if let Some(orig) = fm.get_line(lines[0].line_index) {
+ let iter = orig.chars().enumerate();
+ for (pos, ch) in iter {
+ // Span seems to use half-opened interval, so subtract 1
+ if pos >= hi.col.to_usize() - 1 { break; }
+ // Whenever a tab occurs on the previous line, we insert one on
+ // the error-point-squiggly-line as well (instead of a space).
+ // That way the squiggly line will usually appear in the correct
+ // position.
+ match ch {
+ '\t' => s.push('\t'),
+ _ => s.push(' '),
+ }
+ }
+ }
+ s.push('^');
+ println_maybe_styled!(&mut self.dst, term::Attr::ForegroundColor(lvl.color()),
+ "{}", s)
+ }
+
+ fn print_macro_backtrace(&mut self,
+ sp: Span)
+ -> io::Result<()> {
+ let mut last_span = codemap::DUMMY_SP;
+ let mut span = sp;
+
+ loop {
+ let span_name_span = self.cm.with_expn_info(span.expn_id, |expn_info| {
+ expn_info.map(|ei| {
+ let (pre, post) = match ei.callee.format {
+ codemap::MacroAttribute(..) => ("#[", "]"),
+ codemap::MacroBang(..) => ("", "!"),
+ };
+ let macro_decl_name = format!("in this expansion of {}{}{}",
+ pre,
+ ei.callee.name(),
+ post);
+ let def_site_span = ei.callee.span;
+ (ei.call_site, macro_decl_name, def_site_span)
+ })
+ });
+ let (macro_decl_name, def_site_span) = match span_name_span {
+ None => break,
+ Some((sp, macro_decl_name, def_site_span)) => {
+ span = sp;
+ (macro_decl_name, def_site_span)
+ }
+ };
+
+ // Don't print recursive invocations
+ if span != last_span {
+ let mut diag_string = macro_decl_name;
+ if let Some(def_site_span) = def_site_span {
+ diag_string.push_str(&format!(" (defined in {})",
+ self.cm.span_to_filename(def_site_span)));
+ }
+
+ let snippet = self.cm.span_to_string(span);
+ try!(print_diagnostic(&mut self.dst, &snippet, Note, &diag_string, None));
+ }
+ last_span = span;
+ }
+
+ Ok(())
+ }
+}
+
+fn print_diagnostic(dst: &mut Destination,
+ topic: &str,
+ lvl: Level,
+ msg: &str,
+ code: Option<&str>)
+ -> io::Result<()> {
+ if !topic.is_empty() {
+ try!(write!(dst, "{} ", topic));
+ }
+
+ try!(print_maybe_styled!(dst, term::Attr::ForegroundColor(lvl.color()),
+ "{}: ", lvl.to_string()));
+ try!(print_maybe_styled!(dst, term::Attr::Bold, "{}", msg));
+
+ match code {
+ Some(code) => {
+ let style = term::Attr::ForegroundColor(term::color::BRIGHT_MAGENTA);
+ try!(print_maybe_styled!(dst, style, " [{}]", code.clone()));
+ }
+ None => ()
+ }
+ try!(write!(dst, "\n"));
+ Ok(())
+}
+
+#[cfg(unix)]
+fn stderr_isatty() -> bool {
+ use libc;
+ unsafe { libc::isatty(libc::STDERR_FILENO) != 0 }
+}
+#[cfg(windows)]
+fn stderr_isatty() -> bool {
+ type DWORD = u32;
+ type BOOL = i32;
+ type HANDLE = *mut u8;
+ const STD_ERROR_HANDLE: DWORD = -12i32 as DWORD;
+ extern "system" {
+ fn GetStdHandle(which: DWORD) -> HANDLE;
+ fn GetConsoleMode(hConsoleHandle: HANDLE,
+ lpMode: *mut DWORD) -> BOOL;
+ }
+ unsafe {
+ let handle = GetStdHandle(STD_ERROR_HANDLE);
+ let mut out = 0;
+ GetConsoleMode(handle, &mut out) != 0
+ }
+}
+
+enum Destination {
+ Terminal(Box<term::StderrTerminal>),
+ Raw(Box<Write + Send>),
+}
+
+impl Destination {
+ fn from_stderr() -> Destination {
+ match term::stderr() {
+ Some(t) => Terminal(t),
+ None => Raw(Box::new(io::stderr())),
+ }
+ }
+
+ fn print_maybe_styled(&mut self,
+ args: fmt::Arguments,
+ color: term::Attr,
+ print_newline_at_end: bool)
+ -> io::Result<()> {
+ match *self {
+ Terminal(ref mut t) => {
+ try!(t.attr(color));
+ // If `msg` ends in a newline, we need to reset the color before
+ // the newline. We're making the assumption that we end up writing
+ // to a `LineBufferedWriter`, which means that emitting the reset
+ // after the newline ends up buffering the reset until we print
+ // another line or exit. Buffering the reset is a problem if we're
+ // sharing the terminal with any other programs (e.g. other rustc
+ // instances via `make -jN`).
+ //
+ // Note that if `msg` contains any internal newlines, this will
+ // result in the `LineBufferedWriter` flushing twice instead of
+ // once, which still leaves the opportunity for interleaved output
+ // to be miscolored. We assume this is rare enough that we don't
+ // have to worry about it.
+ try!(t.write_fmt(args));
+ try!(t.reset());
+ if print_newline_at_end {
+ t.write_all(b"\n")
+ } else {
+ Ok(())
+ }
+ }
+ Raw(ref mut w) => {
+ try!(w.write_fmt(args));
+ if print_newline_at_end {
+ w.write_all(b"\n")
+ } else {
+ Ok(())
+ }
+ }
+ }
+ }
+}
+
+impl Write for Destination {
+ fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
+ match *self {
+ Terminal(ref mut t) => t.write(bytes),
+ Raw(ref mut w) => w.write(bytes),
+ }
+ }
+ fn flush(&mut self) -> io::Result<()> {
+ match *self {
+ Terminal(ref mut t) => t.flush(),
+ Raw(ref mut w) => w.flush(),
+ }
+ }
+}
+
+
+#[cfg(test)]
+mod test {
+ use errors::Level;
+ use super::EmitterWriter;
+ use codemap::{mk_sp, CodeMap};
+ use std::sync::{Arc, Mutex};
+ use std::io::{self, Write};
+ use std::str::from_utf8;
+ use std::rc::Rc;
+
+ // Diagnostic doesn't align properly in span where line number increases by one digit
+ #[test]
+ fn test_hilight_suggestion_issue_11715() {
+ struct Sink(Arc<Mutex<Vec<u8>>>);
+ impl Write for Sink {
+ fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+ Write::write(&mut *self.0.lock().unwrap(), data)
+ }
+ fn flush(&mut self) -> io::Result<()> { Ok(()) }
+ }
+ let data = Arc::new(Mutex::new(Vec::new()));
+ let cm = Rc::new(CodeMap::new());
+ let mut ew = EmitterWriter::new(Box::new(Sink(data.clone())), None, cm.clone());
+ let content = "abcdefg
+ koksi
+ line3
+ line4
+ cinq
+ line6
+ line7
+ line8
+ line9
+ line10
+ e-lä-vän
+ tolv
+ dreizehn
+ ";
+ let file = cm.new_filemap_and_lines("dummy.txt", content);
+ let start = file.lines.borrow()[7];
+ let end = file.lines.borrow()[11];
+ let sp = mk_sp(start, end);
+ let lvl = Level::Error;
+ println!("span_to_lines");
+ let lines = cm.span_to_lines(sp);
+ println!("highlight_lines");
+ ew.highlight_lines(sp, lvl, lines).unwrap();
+ println!("done");
+ let vec = data.lock().unwrap().clone();
+ let vec: &[u8] = &vec;
+ let str = from_utf8(vec).unwrap();
+ println!("{}", str);
+ assert_eq!(str, "dummy.txt: 8 line8\n\
+ dummy.txt: 9 line9\n\
+ dummy.txt:10 line10\n\
+ dummy.txt:11 e-lä-vän\n\
+ dummy.txt:12 tolv\n");
+ }
+}
--- /dev/null
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub use errors::emitter::ColorConfig;
+
+use self::Level::*;
+use self::RenderSpan::*;
+
+use codemap::{self, Span};
+use diagnostics;
+use errors::emitter::{Emitter, EmitterWriter};
+
+use std::cell::{RefCell, Cell};
+use std::{error, fmt};
+use std::io::prelude::*;
+use std::rc::Rc;
+use term;
+
+pub mod emitter;
+
+#[derive(Clone)]
+pub enum RenderSpan {
+ /// A FullSpan renders with both with an initial line for the
+ /// message, prefixed by file:linenum, followed by a summary of
+ /// the source code covered by the span.
+ FullSpan(Span),
+
+ /// Similar to a FullSpan, but the cited position is the end of
+ /// the span, instead of the start. Used, at least, for telling
+ /// compiletest/runtest to look at the last line of the span
+ /// (since `end_highlight_lines` displays an arrow to the end
+ /// of the span).
+ EndSpan(Span),
+
+ /// A suggestion renders with both with an initial line for the
+ /// message, prefixed by file:linenum, followed by a summary
+ /// of hypothetical source code, where the `String` is spliced
+ /// into the lines in place of the code covered by the span.
+ Suggestion(Span, String),
+
+ /// A FileLine renders with just a line for the message prefixed
+ /// by file:linenum.
+ FileLine(Span),
+}
+
+impl RenderSpan {
+ fn span(&self) -> Span {
+ match *self {
+ FullSpan(s) |
+ Suggestion(s, _) |
+ EndSpan(s) |
+ FileLine(s) =>
+ s
+ }
+ }
+}
+
+/// Used as a return value to signify a fatal error occurred. (It is also
+/// used as the argument to panic at the moment, but that will eventually
+/// not be true.)
+#[derive(Copy, Clone, Debug)]
+#[must_use]
+pub struct FatalError;
+
+impl fmt::Display for FatalError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+ write!(f, "parser fatal error")
+ }
+}
+
+impl error::Error for FatalError {
+ fn description(&self) -> &str {
+ "The parser has encountered a fatal error"
+ }
+}
+
+/// Signifies that the compiler died with an explicit call to `.bug`
+/// or `.span_bug` rather than a failed assertion, etc.
+#[derive(Copy, Clone, Debug)]
+pub struct ExplicitBug;
+
+impl fmt::Display for ExplicitBug {
+ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+ write!(f, "parser internal bug")
+ }
+}
+
+impl error::Error for ExplicitBug {
+ fn description(&self) -> &str {
+ "The parser has encountered an internal bug"
+ }
+}
+
+/// A handler deals with errors; certain errors
+/// (fatal, bug, unimpl) may cause immediate exit,
+/// others log errors for later reporting.
+pub struct Handler {
+ err_count: Cell<usize>,
+ emit: RefCell<Box<Emitter>>,
+ pub can_emit_warnings: bool,
+ treat_err_as_bug: bool,
+ delayed_span_bug: RefCell<Option<(codemap::Span, String)>>,
+}
+
+impl Handler {
+ pub fn new(color_config: ColorConfig,
+ registry: Option<diagnostics::registry::Registry>,
+ can_emit_warnings: bool,
+ treat_err_as_bug: bool,
+ cm: Rc<codemap::CodeMap>)
+ -> Handler {
+ let emitter = Box::new(EmitterWriter::stderr(color_config, registry, cm));
+ Handler::with_emitter(can_emit_warnings, treat_err_as_bug, emitter)
+ }
+
+ pub fn with_emitter(can_emit_warnings: bool,
+ treat_err_as_bug: bool,
+ e: Box<Emitter>) -> Handler {
+ Handler {
+ err_count: Cell::new(0),
+ emit: RefCell::new(e),
+ can_emit_warnings: can_emit_warnings,
+ treat_err_as_bug: treat_err_as_bug,
+ delayed_span_bug: RefCell::new(None),
+ }
+ }
+
+ pub fn span_fatal(&self, sp: Span, msg: &str) -> FatalError {
+ if self.treat_err_as_bug {
+ self.span_bug(sp, msg);
+ }
+ self.emit(Some(sp), msg, Fatal);
+ return FatalError;
+ }
+ pub fn span_fatal_with_code(&self, sp: Span, msg: &str, code: &str) -> FatalError {
+ if self.treat_err_as_bug {
+ self.span_bug(sp, msg);
+ }
+ self.emit_with_code(Some(sp), msg, code, Fatal);
+ return FatalError;
+ }
+ pub fn span_err(&self, sp: Span, msg: &str) {
+ if self.treat_err_as_bug {
+ self.span_bug(sp, msg);
+ }
+ self.emit(Some(sp), msg, Error);
+ self.bump_err_count();
+ }
+ pub fn span_err_with_code(&self, sp: Span, msg: &str, code: &str) {
+ if self.treat_err_as_bug {
+ self.span_bug(sp, msg);
+ }
+ self.emit_with_code(Some(sp), msg, code, Error);
+ self.bump_err_count();
+ }
+ pub fn span_warn(&self, sp: Span, msg: &str) {
+ self.emit(Some(sp), msg, Warning);
+ }
+ pub fn span_warn_with_code(&self, sp: Span, msg: &str, code: &str) {
+ self.emit_with_code(Some(sp), msg, code, Warning);
+ }
+ pub fn span_note(&self, sp: Span, msg: &str) {
+ self.emit(Some(sp), msg, Note);
+ }
+ pub fn span_end_note(&self, sp: Span, msg: &str) {
+ self.custom_emit(EndSpan(sp), msg, Note);
+ }
+ pub fn span_help(&self, sp: Span, msg: &str) {
+ self.emit(Some(sp), msg, Help);
+ }
+ /// Prints out a message with a suggested edit of the code.
+ ///
+ /// See `diagnostic::RenderSpan::Suggestion` for more information.
+ pub fn span_suggestion(&self, sp: Span, msg: &str, suggestion: String) {
+ self.custom_emit(Suggestion(sp, suggestion), msg, Help);
+ }
+ pub fn fileline_note(&self, sp: Span, msg: &str) {
+ self.custom_emit(FileLine(sp), msg, Note);
+ }
+ pub fn fileline_help(&self, sp: Span, msg: &str) {
+ self.custom_emit(FileLine(sp), msg, Help);
+ }
+ pub fn span_bug(&self, sp: Span, msg: &str) -> ! {
+ self.emit(Some(sp), msg, Bug);
+ panic!(ExplicitBug);
+ }
+ pub fn delay_span_bug(&self, sp: Span, msg: &str) {
+ let mut delayed = self.delayed_span_bug.borrow_mut();
+ *delayed = Some((sp, msg.to_string()));
+ }
+ pub fn span_bug_no_panic(&self, sp: Span, msg: &str) {
+ self.emit(Some(sp), msg, Bug);
+ self.bump_err_count();
+ }
+ pub fn span_unimpl(&self, sp: Span, msg: &str) -> ! {
+ self.span_bug(sp, &format!("unimplemented {}", msg));
+ }
+ pub fn fatal(&self, msg: &str) -> FatalError {
+ if self.treat_err_as_bug {
+ self.bug(msg);
+ }
+ self.emit.borrow_mut().emit(None, msg, None, Fatal);
+ FatalError
+ }
+ pub fn err(&self, msg: &str) {
+ if self.treat_err_as_bug {
+ self.bug(msg);
+ }
+ self.emit.borrow_mut().emit(None, msg, None, Error);
+ self.bump_err_count();
+ }
+ pub fn warn(&self, msg: &str) {
+ self.emit.borrow_mut().emit(None, msg, None, Warning);
+ }
+ pub fn note(&self, msg: &str) {
+ self.emit.borrow_mut().emit(None, msg, None, Note);
+ }
+ pub fn help(&self, msg: &str) {
+ self.emit.borrow_mut().emit(None, msg, None, Help);
+ }
+ pub fn bug(&self, msg: &str) -> ! {
+ self.emit.borrow_mut().emit(None, msg, None, Bug);
+ panic!(ExplicitBug);
+ }
+ pub fn unimpl(&self, msg: &str) -> ! {
+ self.bug(&format!("unimplemented {}", msg));
+ }
+
+ pub fn bump_err_count(&self) {
+ self.err_count.set(self.err_count.get() + 1);
+ }
+
+ pub fn err_count(&self) -> usize {
+ self.err_count.get()
+ }
+
+ pub fn has_errors(&self) -> bool {
+ self.err_count.get() > 0
+ }
+
+ pub fn abort_if_errors(&self) {
+ let s;
+ match self.err_count.get() {
+ 0 => {
+ let delayed_bug = self.delayed_span_bug.borrow();
+ match *delayed_bug {
+ Some((span, ref errmsg)) => {
+ self.span_bug(span, errmsg);
+ },
+ _ => {}
+ }
+
+ return;
+ }
+ 1 => s = "aborting due to previous error".to_string(),
+ _ => {
+ s = format!("aborting due to {} previous errors",
+ self.err_count.get());
+ }
+ }
+
+ panic!(self.fatal(&s[..]));
+ }
+
+ pub fn emit(&self,
+ sp: Option<Span>,
+ msg: &str,
+ lvl: Level) {
+ if lvl == Warning && !self.can_emit_warnings { return }
+ self.emit.borrow_mut().emit(sp, msg, None, lvl);
+ }
+
+ pub fn emit_with_code(&self,
+ sp: Option<Span>,
+ msg: &str,
+ code: &str,
+ lvl: Level) {
+ if lvl == Warning && !self.can_emit_warnings { return }
+ self.emit.borrow_mut().emit(sp, msg, Some(code), lvl);
+ }
+
+ pub fn custom_emit(&self, sp: RenderSpan, msg: &str, lvl: Level) {
+ if lvl == Warning && !self.can_emit_warnings { return }
+ self.emit.borrow_mut().custom_emit(sp, msg, lvl);
+ }
+}
+
+
+#[derive(Copy, PartialEq, Clone, Debug)]
+pub enum Level {
+ Bug,
+ Fatal,
+ Error,
+ Warning,
+ Note,
+ Help,
+}
+
+impl fmt::Display for Level {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ use std::fmt::Display;
+
+ match *self {
+ Bug => "error: internal compiler error".fmt(f),
+ Fatal | Error => "error".fmt(f),
+ Warning => "warning".fmt(f),
+ Note => "note".fmt(f),
+ Help => "help".fmt(f),
+ }
+ }
+}
+
+impl Level {
+ fn color(self) -> term::color::Color {
+ match self {
+ Bug | Fatal | Error => term::color::BRIGHT_RED,
+ Warning => term::color::BRIGHT_YELLOW,
+ Note => term::color::BRIGHT_GREEN,
+ Help => term::color::BRIGHT_CYAN,
+ }
+ }
+}
+
+pub fn expect<T, M>(diag: &Handler, opt: Option<T>, msg: M) -> T where
+ M: FnOnce() -> String,
+{
+ match opt {
+ Some(t) => t,
+ None => diag.bug(&msg()),
+ }
+}
self.parse_sess.span_diagnostic.fileline_help(sp, msg);
}
pub fn bug(&self, msg: &str) -> ! {
- self.parse_sess.span_diagnostic.handler().bug(msg);
+ self.parse_sess.span_diagnostic.bug(msg);
}
pub fn trace_macros(&self) -> bool {
self.ecfg.trace_mac
use attr;
use codemap::{Span, respan, Spanned, DUMMY_SP, Pos};
use ext::base::ExtCtxt;
-use owned_slice::OwnedSlice;
use parse::token::special_idents;
use parse::token::InternedString;
use parse::token;
fn ty(&self, span: Span, ty: ast::Ty_) -> P<ast::Ty>;
fn ty_path(&self, ast::Path) -> P<ast::Ty>;
- fn ty_sum(&self, ast::Path,
OwnedSlice<ast::TyParamBound>) -> P<ast::Ty>;
+ fn ty_sum(&self, ast::Path,
ast::TyParamBounds) -> P<ast::Ty>;
fn ty_ident(&self, span: Span, idents: ast::Ident) -> P<ast::Ty>;
fn ty_rptr(&self, span: Span,
fn ty_option(&self, ty: P<ast::Ty>) -> P<ast::Ty>;
fn ty_infer(&self, sp: Span) -> P<ast::Ty>;
- fn ty_vars(&self, ty_params: &
OwnedSlice<ast::TyParam>) -> Vec<P<ast::Ty>> ;
- fn ty_vars_global(&self, ty_params: &
OwnedSlice<ast::TyParam>) -> Vec<P<ast::Ty>> ;
+ fn ty_vars(&self, ty_params: &
P<[ast::TyParam]>) -> Vec<P<ast::Ty>> ;
+ fn ty_vars_global(&self, ty_params: &
P<[ast::TyParam]>) -> Vec<P<ast::Ty>> ;
fn typaram(&self,
span: Span,
id: ast::Ident,
- bounds: OwnedSlice<ast::TyParamBound>,
+ bounds: ast::TyParamBounds,
default: Option<P<ast::Ty>>) -> ast::TyParam;
fn trait_ref(&self, path: ast::Path) -> ast::TraitRef;
identifier: last_identifier,
parameters: ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
lifetimes: lifetimes,
- types: OwnedSlice::from_vec(types),
- bindings: OwnedSlice::from_vec(bindings),
+ types: P::from_vec(types),
+ bindings: P::from_vec(bindings),
})
});
ast::Path {
identifier: ident,
parameters: ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
lifetimes: lifetimes,
- types: OwnedSlice::from_vec(types),
- bindings: OwnedSlice::from_vec(bindings),
+ types: P::from_vec(types),
+ bindings: P::from_vec(bindings),
})
});
self.ty(path.span, ast::TyPath(None, path))
}
- fn ty_sum(&self, path: ast::Path, bounds:
OwnedSlice<ast::TyParamBound>) -> P<ast::Ty> {
+ fn ty_sum(&self, path: ast::Path, bounds:
ast::TyParamBounds) -> P<ast::Ty> {
self.ty(path.span,
ast::TyObjectSum(self.ty_path(path),
bounds))
fn typaram(&self,
span: Span,
id: ast::Ident,
- bounds: OwnedSlice<ast::TyParamBound>,
+ bounds: ast::TyParamBounds,
default: Option<P<ast::Ty>>) -> ast::TyParam {
ast::TyParam {
ident: id,
// these are strange, and probably shouldn't be used outside of
// pipes. Specifically, the global version possible generates
// incorrect code.
- fn ty_vars(&self, ty_params: &
OwnedSlice<ast::TyParam>) -> Vec<P<ast::Ty>> {
+ fn ty_vars(&self, ty_params: &
P<[ast::TyParam]>) -> Vec<P<ast::Ty>> {
ty_params.iter().map(|p| self.ty_ident(DUMMY_SP, p.ident)).collect()
}
- fn ty_vars_global(&self, ty_params: &
OwnedSlice<ast::TyParam>) -> Vec<P<ast::Ty>> {
+ fn ty_vars_global(&self, ty_params: &
P<[ast::TyParam]>) -> Vec<P<ast::Ty>> {
ty_params
.iter()
.map(|p| self.ty_path(self.path_global(DUMMY_SP, vec!(p.ident))))
let mut ret = expander.fold_crate(c);
ret.exported_macros = expander.cx.exported_macros.clone();
- cx.parse_sess.span_diagnostic.handler().abort_if_errors();
+ cx.parse_sess.span_diagnostic.abort_if_errors();
ret
};
return (ret, cx.syntax_env.names);
use ast;
use ast::{TokenTree, Ident, Name};
use codemap::{Span, DUMMY_SP};
-use diagnostic::SpanHandler;
+use errors::Handler;
use ext::tt::macro_parser::{NamedMatch, MatchedSeq, MatchedNonterminal};
use parse::token::{DocComment, MatchNt, SubstNt};
use parse::token::{Token, NtIdent, SpecialMacroVar};
#[derive(Clone)]
pub struct TtReader<'a> {
- pub sp_diag: &'a SpanHandler,
+ pub sp_diag: &'a Handler,
/// the unzipped tree:
stack: Vec<TtFrame>,
/* for MBE-style macro transcription */
/// This can do Macro-By-Example transcription. On the other hand, if
/// `src` contains no `TokenTree::Sequence`s, `MatchNt`s or `SubstNt`s, `interp` can
/// (and should) be None.
-pub fn new_tt_reader<'a>(sp_diag: &'a SpanHandler,
+pub fn new_tt_reader<'a>(sp_diag: &'a Handler,
interp: Option<HashMap<Name, Rc<NamedMatch>>>,
imported_from: Option<Ident>,
src: Vec<ast::TokenTree>)
/// This can do Macro-By-Example transcription. On the other hand, if
/// `src` contains no `TokenTree::Sequence`s, `MatchNt`s or `SubstNt`s, `interp` can
/// (and should) be None.
-pub fn new_tt_reader_with_doc_flag<'a>(sp_diag: &'a SpanHandler,
+pub fn new_tt_reader_with_doc_flag<'a>(sp_diag: &'a Handler,
interp: Option<HashMap<Name, Rc<NamedMatch>>>,
imported_from: Option<Ident>,
src: Vec<ast::TokenTree>,
use attr;
use attr::AttrMetaMethods;
use codemap::{CodeMap, Span};
-use diagnostic::SpanHandler;
+use errors::Handler;
use visit;
use visit::{FnKind, Visitor};
use parse::token::InternedString;
}
impl GatedCfgAttr {
- pub fn check_and_emit(&self, diagnostic: &SpanHandler, features: &Features) {
+ pub fn check_and_emit(&self, diagnostic: &Handler, features: &Features) {
match *self {
GatedCfgAttr::GatedCfg(ref cfg) => {
cfg.check_and_emit(diagnostic, features);
}
})
}
- fn check_and_emit(&self, diagnostic: &SpanHandler, features: &Features) {
+ fn check_and_emit(&self, diagnostic: &Handler, features: &Features) {
let (cfg, feature, has_feature) = GATED_CFGS[self.index];
if !has_feature(features) {
let explain = format!("`cfg({})` is experimental and subject to change", cfg);
const EXPLAIN_STMT_ATTR_SYNTAX: &'static str =
"attributes on non-item statements and expressions are experimental.";
-pub fn check_for_box_syntax(f: Option<&Features>, diag: &SpanHandler, span: Span) {
+pub fn check_for_box_syntax(f: Option<&Features>, diag: &Handler, span: Span) {
if let Some(&Features { allow_box: true, .. }) = f {
return;
}
emit_feature_err(diag, "box_syntax", span, GateIssue::Language, EXPLAIN_BOX_SYNTAX);
}
-pub fn check_for_placement_in(f: Option<&Features>, diag: &SpanHandler, span: Span) {
+pub fn check_for_placement_in(f: Option<&Features>, diag: &Handler, span: Span) {
if let Some(&Features { allow_placement_in: true, .. }) = f {
return;
}
emit_feature_err(diag, "placement_in_syntax", span, GateIssue::Language, EXPLAIN_PLACEMENT_IN);
}
-pub fn check_for_pushpop_syntax(f: Option<&Features>, diag: &SpanHandler, span: Span) {
+pub fn check_for_pushpop_syntax(f: Option<&Features>, diag: &Handler, span: Span) {
if let Some(&Features { allow_pushpop_unsafe: true, .. }) = f {
return;
}
struct Context<'a> {
features: Vec<&'static str>,
- span_handler: &'a SpanHandler,
+ span_handler: &'a Handler,
cm: &'a CodeMap,
plugin_attributes: &'a [(String, AttributeType)],
}
Library(Option<u32>)
}
-pub fn emit_feature_err(diag: &SpanHandler, feature: &str, span: Span, issue: GateIssue,
+pub fn emit_feature_err(diag: &Handler, feature: &str, span: Span, issue: GateIssue,
explain: &str) {
let issue = match issue {
GateIssue::Language => find_lang_feature_issue(feature),
}
}
-fn check_crate_inner<F>(cm: &CodeMap, span_handler: &SpanHandler,
+fn check_crate_inner<F>(cm: &CodeMap, span_handler: &Handler,
krate: &ast::Crate,
plugin_attributes: &[(String, AttributeType)],
check: F)
}
}
-pub fn check_crate_macros(cm: &CodeMap, span_handler: &SpanHandler, krate: &ast::Crate)
+pub fn check_crate_macros(cm: &CodeMap, span_handler: &Handler, krate: &ast::Crate)
-> Features {
check_crate_inner(cm, span_handler, krate, &[] as &'static [_],
|ctx, krate| visit::walk_crate(&mut MacroVisitor { context: ctx }, krate))
}
-pub fn check_crate(cm: &CodeMap, span_handler: &SpanHandler, krate: &ast::Crate,
+pub fn check_crate(cm: &CodeMap, span_handler: &Handler, krate: &ast::Crate,
plugin_attributes: &[(String, AttributeType)],
unstable: UnstableFeatures) -> Features
{
Cheat
}
-fn maybe_stage_features(span_handler: &SpanHandler, krate: &ast::Crate,
+fn maybe_stage_features(span_handler: &Handler, krate: &ast::Crate,
unstable: UnstableFeatures) {
let allow_features = match unstable {
UnstableFeatures::Allow => true,
use attr::{ThinAttributes, ThinAttributesExt};
use ast_util;
use codemap::{respan, Span, Spanned};
-use owned_slice::OwnedSlice;
use parse::token;
use ptr::P;
use util::small_vector::SmallVector;
noop_fold_ty_param(tp, self)
}
- fn fold_ty_params(&mut self, tps: OwnedSlice<TyParam>) -> OwnedSlice<TyParam> {
+ fn fold_ty_params(&mut self, tps: P<[TyParam]>) -> P<[TyParam]> {
noop_fold_ty_params(tps, self)
}
noop_fold_opt_lifetime(o_lt, self)
}
- fn fold_opt_bounds(&mut self, b: Option<OwnedSlice<TyParamBound>>)
- -> Option<OwnedSlice<TyParamBound>> {
+ fn fold_opt_bounds(&mut self, b: Option<TyParamBounds>)
+ -> Option<TyParamBounds> {
noop_fold_opt_bounds(b, self)
}
- fn fold_bounds(&mut self, b: OwnedSlice<TyParamBound>)
- -> OwnedSlice<TyParamBound> {
+ fn fold_bounds(&mut self, b: TyParamBounds)
+ -> TyParamBounds {
noop_fold_bounds(b, self)
}
}
}
-pub fn noop_fold_ty_params<T: Folder>(tps: OwnedSlice<TyParam>, fld: &mut T)
- -> OwnedSlice<TyParam> {
+pub fn noop_fold_ty_params<T: Folder>(tps: P<[TyParam]>, fld: &mut T)
+ -> P<[TyParam]> {
tps.move_map(|tp| fld.fold_ty_param(tp))
}
}
}
-pub fn noop_fold_opt_bounds<T: Folder>(b: Option<OwnedSlice<TyParamBound>>, folder: &mut T)
- -> Option<OwnedSlice<TyParamBound>> {
+pub fn noop_fold_opt_bounds<T: Folder>(b: Option<TyParamBounds>, folder: &mut T)
+ -> Option<TyParamBounds> {
b.map(|bounds| folder.fold_bounds(bounds))
}
macro_rules! panictry {
($e:expr) => ({
use std::result::Result::{Ok, Err};
- use diagnostic::FatalError;
+ use errors::FatalError;
match $e {
Ok(e) => e,
Err(FatalError) => panic!(FatalError)
pub mod metadata;
}
+pub mod errors;
+
pub mod syntax {
pub use ext;
pub use parse;
pub mod attr;
pub mod codemap;
pub mod config;
-pub mod diagnostic;
pub mod entry;
pub mod feature_gate;
pub mod fold;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::default::Default;
-use std::fmt;
-use std::iter::{IntoIterator, FromIterator};
-use std::ops::Deref;
-use std::slice;
-use std::vec;
-use serialize::{Encodable, Decodable, Encoder, Decoder};
-
-/// A non-growable owned slice. This is a separate type to allow the
-/// representation to change.
-#[derive(Hash, PartialEq, Eq, PartialOrd, Ord)]
-pub struct OwnedSlice<T> {
- data: Box<[T]>
-}
-
-impl<T:fmt::Debug> fmt::Debug for OwnedSlice<T> {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- self.data.fmt(fmt)
- }
-}
-
-impl<T> OwnedSlice<T> {
- pub fn empty() -> OwnedSlice<T> {
- OwnedSlice { data: Box::new([]) }
- }
-
- #[inline(never)]
- pub fn from_vec(v: Vec<T>) -> OwnedSlice<T> {
- OwnedSlice { data: v.into_boxed_slice() }
- }
-
- #[inline(never)]
- pub fn into_vec(self) -> Vec<T> {
- self.data.into_vec()
- }
-
- pub fn as_slice<'a>(&'a self) -> &'a [T] {
- &*self.data
- }
-
- pub fn move_iter(self) -> vec::IntoIter<T> {
- self.into_vec().into_iter()
- }
-
- pub fn map<U, F: FnMut(&T) -> U>(&self, f: F) -> OwnedSlice<U> {
- self.iter().map(f).collect()
- }
-}
-
-impl<T> Deref for OwnedSlice<T> {
- type Target = [T];
-
- fn deref(&self) -> &[T] {
- self.as_slice()
- }
-}
-
-impl<T> Default for OwnedSlice<T> {
- fn default() -> OwnedSlice<T> {
- OwnedSlice::empty()
- }
-}
-
-impl<T: Clone> Clone for OwnedSlice<T> {
- fn clone(&self) -> OwnedSlice<T> {
- OwnedSlice::from_vec(self.to_vec())
- }
-}
-
-impl<T> FromIterator<T> for OwnedSlice<T> {
- fn from_iter<I: IntoIterator<Item=T>>(iter: I) -> OwnedSlice<T> {
- OwnedSlice::from_vec(iter.into_iter().collect())
- }
-}
-
-impl<'a, T> IntoIterator for &'a OwnedSlice<T> {
- type Item = &'a T;
- type IntoIter = slice::Iter<'a, T>;
- fn into_iter(self) -> Self::IntoIter {
- self.data.into_iter()
- }
-}
-
-impl<T: Encodable> Encodable for OwnedSlice<T> {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- Encodable::encode(&**self, s)
- }
-}
-
-impl<T: Decodable> Decodable for OwnedSlice<T> {
- fn decode<D: Decoder>(d: &mut D) -> Result<OwnedSlice<T>, D::Error> {
- Ok(OwnedSlice::from_vec(match Decodable::decode(d) {
- Ok(t) => t,
- Err(e) => return Err(e)
- }))
- }
-}
+/// A non-growable owned slice.
+#[unstable(feature = "rustc_private", issue = "0")]
+#[rustc_deprecated(since = "1.7.0", reason = "use `ptr::P<[T]>` instead")]
+pub type OwnedSlice<T> = ::ptr::P<[T]>;
use ast;
use codemap::{BytePos, CharPos, CodeMap, Pos};
-use diagnostic;
+use errors;
use parse::lexer::is_block_doc_comment;
use parse::lexer::{StringReader, TokenAndSpan};
use parse::lexer::{is_whitespace, Reader};
// it appears this function is called only from pprust... that's
// probably not a good thing.
-pub fn gather_comments_and_literals(span_diagnostic: &diagnostic::SpanHandler,
+pub fn gather_comments_and_literals(span_diagnostic: &errors::Handler,
path: String,
srdr: &mut Read)
-> (Vec<Comment>, Vec<Literal>) {
use ast;
use codemap::{BytePos, CharPos, CodeMap, Pos, Span};
use codemap;
-use diagnostic::FatalError;
-use diagnostic::SpanHandler;
+use errors::{FatalError, Handler};
use ext::tt::transcribe::tt_next_token;
use parse::token::str_to_ident;
use parse::token;
}
pub struct StringReader<'a> {
- pub span_diagnostic: &'a SpanHandler,
+ pub span_diagnostic: &'a Handler,
/// The absolute offset within the codemap of the next character to read
pub pos: BytePos,
/// The absolute offset within the codemap of the last character read(curr)
impl<'a> StringReader<'a> {
/// For comments.rs, which hackily pokes into pos and curr
- pub fn new_raw<'b>(span_diagnostic: &'b SpanHandler,
+ pub fn new_raw<'b>(span_diagnostic: &'b Handler,
filemap: Rc<codemap::FileMap>) -> StringReader<'b> {
if filemap.src.is_none() {
- span_diagnostic.handler.bug(&format!("Cannot lex filemap without source: {}",
+ span_diagnostic.bug(&format!("Cannot lex filemap without source: {}",
filemap.name)[..]);
}
sr
}
- pub fn new<'b>(span_diagnostic: &'b SpanHandler,
+ pub fn new<'b>(span_diagnostic: &'b Handler,
filemap: Rc<codemap::FileMap>) -> StringReader<'b> {
let mut sr = StringReader::new_raw(span_diagnostic, filemap);
sr.advance_token();
use super::*;
use codemap::{BytePos, CodeMap, Span, NO_EXPANSION};
- use diagnostic;
+ use errors;
use parse::token;
use parse::token::{str_to_ident};
use std::io;
+ use std::rc::Rc;
- fn mk_sh() -> diagnostic::SpanHandler {
+ fn mk_sh(cm: Rc<CodeMap>) -> errors::Handler {
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
- let emitter = diagnostic::EmitterWriter::new(Box::new(io::sink()), None);
- let handler = diagnostic::Handler::with_emitter(true, Box::new(emitter));
- diagnostic::SpanHandler::new(handler, CodeMap::new())
+ let emitter = errors::emitter::EmitterWriter::new(Box::new(io::sink()), None, cm);
+ errors::Handler::with_emitter(true, false, Box::new(emitter))
}
// open a string reader for the given string
- fn setup<'a>(span_handler: &'a diagnostic::SpanHandler,
+ fn setup<'a>(cm: &CodeMap,
+ span_handler: &'a errors::Handler,
teststr: String) -> StringReader<'a> {
- let fm = span_handler.cm.new_filemap("zebra.rs".to_string(), teststr);
+ let fm = cm.new_filemap("zebra.rs".to_string(), teststr);
StringReader::new(span_handler, fm)
}
#[test] fn t1 () {
- let span_handler = mk_sh();
- let mut string_reader = setup(&span_handler,
+ let cm = Rc::new(CodeMap::new());
+ let sh = mk_sh(cm.clone());
+ let mut string_reader = setup(&cm, &sh,
"/* my source file */ \
fn main() { println!(\"zebra\"); }\n".to_string());
let id = str_to_ident("fn");
}
#[test] fn doublecolonparsing () {
- check_tokenization(setup(&mk_sh(), "a b".to_string()),
+ let cm = Rc::new(CodeMap::new());
+ let sh = mk_sh(cm.clone());
+ check_tokenization(setup(&cm, &sh, "a b".to_string()),
vec![mk_ident("a", token::Plain),
token::Whitespace,
mk_ident("b", token::Plain)]);
}
#[test] fn dcparsing_2 () {
- check_tokenization(setup(&mk_sh(), "a::b".to_string()),
+ let cm = Rc::new(CodeMap::new());
+ let sh = mk_sh(cm.clone());
+ check_tokenization(setup(&cm, &sh, "a::b".to_string()),
vec![mk_ident("a",token::ModName),
token::ModSep,
mk_ident("b", token::Plain)]);
}
#[test] fn dcparsing_3 () {
- check_tokenization(setup(&mk_sh(), "a ::b".to_string()),
+ let cm = Rc::new(CodeMap::new());
+ let sh = mk_sh(cm.clone());
+ check_tokenization(setup(&cm, &sh, "a ::b".to_string()),
vec![mk_ident("a", token::Plain),
token::Whitespace,
token::ModSep,
}
#[test] fn dcparsing_4 () {
- check_tokenization(setup(&mk_sh(), "a:: b".to_string()),
+ let cm = Rc::new(CodeMap::new());
+ let sh = mk_sh(cm.clone());
+ check_tokenization(setup(&cm, &sh, "a:: b".to_string()),
vec![mk_ident("a",token::ModName),
token::ModSep,
token::Whitespace,
}
#[test] fn character_a() {
- assert_eq!(setup(&mk_sh(), "'a'".to_string()).next_token().tok,
+ let cm = Rc::new(CodeMap::new());
+ let sh = mk_sh(cm.clone());
+ assert_eq!(setup(&cm, &sh, "'a'".to_string()).next_token().tok,
token::Literal(token::Char(token::intern("a")), None));
}
#[test] fn character_space() {
- assert_eq!(setup(&mk_sh(), "' '".to_string()).next_token().tok,
+ let cm = Rc::new(CodeMap::new());
+ let sh = mk_sh(cm.clone());
+ assert_eq!(setup(&cm, &sh, "' '".to_string()).next_token().tok,
token::Literal(token::Char(token::intern(" ")), None));
}
#[test] fn character_escaped() {
- assert_eq!(setup(&mk_sh(), "'\\n'".to_string()).next_token().tok,
+ let cm = Rc::new(CodeMap::new());
+ let sh = mk_sh(cm.clone());
+ assert_eq!(setup(&cm, &sh, "'\\n'".to_string()).next_token().tok,
token::Literal(token::Char(token::intern("\\n")), None));
}
#[test] fn lifetime_name() {
- assert_eq!(setup(&mk_sh(), "'abc".to_string()).next_token().tok,
+ let cm = Rc::new(CodeMap::new());
+ let sh = mk_sh(cm.clone());
+ assert_eq!(setup(&cm, &sh, "'abc".to_string()).next_token().tok,
token::Lifetime(token::str_to_ident("'abc")));
}
#[test] fn raw_string() {
- assert_eq!(setup(&mk_sh(),
+ let cm = Rc::new(CodeMap::new());
+ let sh = mk_sh(cm.clone());
+ assert_eq!(setup(&cm, &sh,
"r###\"\"#a\\b\x00c\"\"###".to_string()).next_token()
.tok,
token::Literal(token::StrRaw(token::intern("\"#a\\b\x00c\""), 3), None));
}
#[test] fn literal_suffixes() {
+ let cm = Rc::new(CodeMap::new());
+ let sh = mk_sh(cm.clone());
macro_rules! test {
($input: expr, $tok_type: ident, $tok_contents: expr) => {{
- assert_eq!(setup(&mk_sh(), format!("{}suffix", $input)).next_token().tok,
+ assert_eq!(setup(&cm, &sh, format!("{}suffix", $input)).next_token().tok,
token::Literal(token::$tok_type(token::intern($tok_contents)),
Some(token::intern("suffix"))));
// with a whitespace separator:
- assert_eq!(setup(&mk_sh(), format!("{} suffix", $input)).next_token().tok,
+ assert_eq!(setup(&cm, &sh, format!("{} suffix", $input)).next_token().tok,
token::Literal(token::$tok_type(token::intern($tok_contents)),
None));
}}
test!("1.0", Float, "1.0");
test!("1.0e10", Float, "1.0e10");
- assert_eq!(setup(&mk_sh(), "2us".to_string()).next_token().tok,
+ assert_eq!(setup(&cm, &sh, "2us".to_string()).next_token().tok,
token::Literal(token::Integer(token::intern("2")),
Some(token::intern("us"))));
- assert_eq!(setup(&mk_sh(), "r###\"raw\"###suffix".to_string()).next_token().tok,
+ assert_eq!(setup(&cm, &sh, "r###\"raw\"###suffix".to_string()).next_token().tok,
token::Literal(token::StrRaw(token::intern("raw"), 3),
Some(token::intern("suffix"))));
- assert_eq!(setup(&mk_sh(), "br###\"raw\"###suffix".to_string()).next_token().tok,
+ assert_eq!(setup(&cm, &sh, "br###\"raw\"###suffix".to_string()).next_token().tok,
token::Literal(token::ByteStrRaw(token::intern("raw"), 3),
Some(token::intern("suffix"))));
}
}
#[test] fn nested_block_comments() {
- let sh = mk_sh();
- let mut lexer = setup(&sh, "/* /* */ */'a'".to_string());
+ let cm = Rc::new(CodeMap::new());
+ let sh = mk_sh(cm.clone());
+ let mut lexer = setup(&cm, &sh, "/* /* */ */'a'".to_string());
match lexer.next_token().tok {
token::Comment => { },
_ => panic!("expected a comment!")
}
#[test] fn crlf_comments() {
- let sh = mk_sh();
- let mut lexer = setup(&sh, "// test\r\n/// test\r\n".to_string());
+ let cm = Rc::new(CodeMap::new());
+ let sh = mk_sh(cm.clone());
+ let mut lexer = setup(&cm, &sh, "// test\r\n/// test\r\n".to_string());
let comment = lexer.next_token();
assert_eq!(comment.tok, token::Comment);
assert_eq!(comment.sp, ::codemap::mk_sp(BytePos(0), BytePos(7)));
use ast;
use codemap::{self, Span, CodeMap, FileMap};
-use diagnostic::{SpanHandler, Handler, Auto, FatalError};
+use errors::{Handler, ColorConfig, FatalError};
use parse::parser::Parser;
use parse::token::InternedString;
use ptr::P;
/// Info about a parsing session.
pub struct ParseSess {
- pub span_diagnostic: SpanHandler, // better be the same as the one in the reader!
+ pub span_diagnostic: Handler, // better be the same as the one in the reader!
/// Used to determine and report recursive mod inclusions
included_mod_stack: RefCell<Vec<PathBuf>>,
+ code_map: Rc<CodeMap>,
}
impl ParseSess {
pub fn new() -> ParseSess {
- let handler = SpanHandler::new(Handler::new(Auto, None, true), CodeMap::new());
- ParseSess::with_span_handler(handler)
+ let cm = Rc::new(CodeMap::new());
+ let handler = Handler::new(ColorConfig::Auto, None, true, false, cm.clone());
+ ParseSess::with_span_handler(handler, cm)
}
- pub fn with_span_handler(sh: SpanHandler) -> ParseSess {
+ pub fn with_span_handler(handler: Handler, code_map: Rc<CodeMap>) -> ParseSess {
ParseSess {
- span_diagnostic: sh,
- included_mod_stack: RefCell::new(vec![])
+ span_diagnostic: handler,
+ included_mod_stack: RefCell::new(vec![]),
+ code_map: code_map
}
}
pub fn codemap(&self) -> &CodeMap {
- &self.span_diagnostic.cm
+ &self.code_map
}
}
let msg = format!("couldn't read {:?}: {}", path.display(), e);
match spanopt {
Some(sp) => panic!(sess.span_diagnostic.span_fatal(sp, &msg)),
- None => panic!(sess.span_diagnostic.handler().fatal(&msg))
+ None => panic!(sess.span_diagnostic.fatal(&msg))
}
}
}
}
fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>,
- sd: &SpanHandler, sp: Span) -> ast::Lit_ {
+ sd: &Handler, sp: Span) -> ast::Lit_ {
debug!("filtered_float_lit: {}, {:?}", data, suffix);
match suffix.as_ref().map(|s| &**s) {
Some("f32") => ast::LitFloat(data, ast::TyF32),
}
}
pub fn float_lit(s: &str, suffix: Option<InternedString>,
- sd: &SpanHandler, sp: Span) -> ast::Lit_ {
+ sd: &Handler, sp: Span) -> ast::Lit_ {
debug!("float_lit: {:?}, {:?}", s, suffix);
// FIXME #2252: bounds checking float literals is deferred until trans
let s = s.chars().filter(|&c| c != '_').collect::<String>();
pub fn integer_lit(s: &str,
suffix: Option<InternedString>,
- sd: &SpanHandler,
+ sd: &Handler,
sp: Span)
-> ast::Lit_ {
// s can only be ascii, byte indexing is fine
use super::*;
use std::rc::Rc;
use codemap::{Span, BytePos, Pos, Spanned, NO_EXPANSION};
- use owned_slice::OwnedSlice;
use ast::{self, TokenTree};
use abi;
use attr::{first_attr_value_str_by_name, AttrMetaMethods};
abi::Rust,
ast::Generics{ // no idea on either of these:
lifetimes: Vec::new(),
- ty_params: OwnedSlice::empty(),
+ ty_params: P::empty(),
where_clause: ast::WhereClause {
id: ast::DUMMY_NODE_ID,
predicates: Vec::new(),
}
if !self.obsolete_set.contains(&kind) &&
- (error || self.sess.span_diagnostic.handler().can_emit_warnings) {
+ (error || self.sess.span_diagnostic.can_emit_warnings) {
self.sess
.span_diagnostic
- .handler()
.note(&format!("{}", desc));
self.obsolete_set.insert(kind);
}
use ast::{Delimited, SequenceRepetition, TokenTree, TraitItem, TraitRef};
use ast::{Ty, Ty_, TypeBinding, TyMac};
use ast::{TyFixedLengthVec, TyBareFn, TyTypeof, TyInfer};
-use ast::{TyParam, TyParamBound, TyParen, TyPath, TyPtr};
+use ast::{TyParam, TyParamBounds, TyParen, TyPath, TyPtr};
use ast::{TyRptr, TyTup, TyU32, TyVec};
use ast::TypeTraitItem;
use ast::{UnnamedField, UnsafeBlock};
use ast;
use ast_util::{self, ident_to_path};
use codemap::{self, Span, BytePos, Spanned, spanned, mk_sp, CodeMap};
-use diagnostic;
+use errors::{self, FatalError};
use ext::tt::macro_parser;
use parse;
use parse::classify;
use util::parser::{AssocOp, Fixity};
use print::pprust;
use ptr::P;
-use owned_slice::OwnedSlice;
use parse::PResult;
-use diagnostic::FatalError;
use std::collections::HashSet;
use std::io::prelude::*;
pub fn parse_seq_to_before_gt_or_return<T, F>(&mut self,
sep: Option<token::Token>,
mut f: F)
- -> PResult<(OwnedSlice<T>, bool)> where
+ -> PResult<(P<[T]>, bool)> where
F: FnMut(&mut Parser) -> PResult<Option<T>>,
{
let mut v = Vec::new();
if i % 2 == 0 {
match try!(f(self)) {
Some(result) => v.push(result),
- None => return Ok((OwnedSlice::from_vec(v), true))
+ None => return Ok((P::from_vec(v), true))
}
} else {
if let Some(t) = sep.as_ref() {
}
}
- return Ok((OwnedSlice::from_vec(v), false));
+ return Ok((P::from_vec(v), false));
}
/// Parse a sequence bracketed by '<' and '>', stopping
pub fn parse_seq_to_before_gt<T, F>(&mut self,
sep: Option<token::Token>,
mut f: F)
- -> PResult<OwnedSlice<T>> where
+ -> PResult<P<[T]>> where
F: FnMut(&mut Parser) -> PResult<T>,
{
let (result, returned) = try!(self.parse_seq_to_before_gt_or_return(sep,
pub fn parse_seq_to_gt<T, F>(&mut self,
sep: Option<token::Token>,
f: F)
- -> PResult<OwnedSlice<T>> where
+ -> PResult<P<[T]>> where
F: FnMut(&mut Parser) -> PResult<T>,
{
let v = try!(self.parse_seq_to_before_gt(sep, f));
pub fn parse_seq_to_gt_or_return<T, F>(&mut self,
sep: Option<token::Token>,
f: F)
- -> PResult<(OwnedSlice<T>, bool)> where
+ -> PResult<(P<[T]>, bool)> where
F: FnMut(&mut Parser) -> PResult<Option<T>>,
{
let (v, returned) = try!(self.parse_seq_to_before_gt_or_return(sep, f));
}
f(&self.buffer[((self.buffer_start + dist - 1) & 3) as usize].tok)
}
- pub fn fatal(&self, m: &str) -> diagnostic::FatalError {
+ pub fn fatal(&self, m: &str) -> errors::FatalError {
self.sess.span_diagnostic.span_fatal(self.span, m)
}
- pub fn span_fatal(&self, sp: Span, m: &str) -> diagnostic::FatalError {
+ pub fn span_fatal(&self, sp: Span, m: &str) -> errors::FatalError {
self.sess.span_diagnostic.span_fatal(sp, m)
}
- pub fn span_fatal_help(&self, sp: Span, m: &str, help: &str) -> diagnostic::FatalError {
+ pub fn span_fatal_help(&self, sp: Span, m: &str, help: &str) -> errors::FatalError {
self.span_err(sp, m);
self.fileline_help(sp, help);
- diagnostic::FatalError
+ errors::FatalError
}
pub fn span_note(&self, sp: Span, m: &str) {
self.sess.span_diagnostic.span_note(sp, m)
self.sess.span_diagnostic.span_bug(sp, m)
}
pub fn abort_if_errors(&self) {
- self.sess.span_diagnostic.handler().abort_if_errors();
+ self.sess.span_diagnostic.abort_if_errors();
}
pub fn id_to_interned_str(&mut self, id: Ident) -> InternedString {
let other_bounds = if try!(self.eat(&token::BinOp(token::Plus)) ){
try!(self.parse_ty_param_bounds(BoundParsingMode::Bare))
} else {
- OwnedSlice::empty()
+ P::empty()
};
let all_bounds =
Some(TraitTyParamBound(poly_trait_ref, TraitBoundModifier::None)).into_iter()
ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
lifetimes: lifetimes,
- types: OwnedSlice::from_vec(types),
- bindings: OwnedSlice::from_vec(bindings),
+ types: P::from_vec(types),
+ bindings: P::from_vec(bindings),
})
} else if try!(self.eat(&token::OpenDelim(token::Paren)) ){
let lo = self.last_span.lo;
identifier: identifier,
parameters: ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
lifetimes: lifetimes,
- types: OwnedSlice::from_vec(types),
- bindings: OwnedSlice::from_vec(bindings),
+ types: P::from_vec(types),
+ bindings: P::from_vec(bindings),
}),
});
// otherwise returns empty list.
fn parse_colon_then_ty_param_bounds(&mut self,
mode: BoundParsingMode)
- -> PResult<OwnedSlice<TyParamBound>>
+ -> PResult<TyParamBounds>
{
if !try!(self.eat(&token::Colon) ){
- Ok(OwnedSlice::empty())
+ Ok(P::empty())
} else {
self.parse_ty_param_bounds(mode)
}
// and bound = 'region | trait_ref
fn parse_ty_param_bounds(&mut self,
mode: BoundParsingMode)
- -> PResult<OwnedSlice<TyParamBound>>
+ -> PResult<TyParamBounds>
{
let mut result = vec!();
loop {
}
}
- return Ok(OwnedSlice::from_vec(result));
+ return Ok(P::from_vec(result));
}
/// Matches typaram = IDENT (`?` unbound)? optbounds ( EQ ty )?
use attr::ThinAttributesExt;
use util::parser::AssocOp;
use attr;
-use owned_slice::OwnedSlice;
use attr::{AttrMetaMethods, AttributeMethods};
use codemap::{self, CodeMap, BytePos};
-use diagnostic;
+use errors;
use parse::token::{self, BinOpToken, Token, InternedString};
use parse::lexer::comments;
use parse;
/// it can scan the input text for comments and literals to
/// copy forward.
pub fn print_crate<'a>(cm: &'a CodeMap,
- span_diagnostic: &diagnostic::SpanHandler,
+ span_diagnostic: &errors::Handler,
krate: &ast::Crate,
filename: String,
input: &mut Read,
impl<'a> State<'a> {
pub fn new_from_input(cm: &'a CodeMap,
- span_diagnostic: &diagnostic::SpanHandler,
+ span_diagnostic: &errors::Handler,
filename: String,
input: &mut Read,
out: Box<Write+'a>,
ast::TyBareFn(ref f) => {
let generics = ast::Generics {
lifetimes: f.lifetimes.clone(),
- ty_params: OwnedSlice::empty(),
+ ty_params: P::empty(),
where_clause: ast::WhereClause {
id: ast::DUMMY_NODE_ID,
predicates: Vec::new(),
}
let generics = ast::Generics {
lifetimes: Vec::new(),
- ty_params: OwnedSlice::empty(),
+ ty_params: P::empty(),
where_clause: ast::WhereClause {
id: ast::DUMMY_NODE_ID,
predicates: Vec::new(),
//! Moreover, a switch to, e.g. `P<'a, T>` would be easy and mostly automated.
use std::fmt::{self, Display, Debug};
-use std::hash::{Hash, Hasher};
+use std::iter::FromIterator;
use std::ops::Deref;
-use std::ptr;
+use std::{ptr, slice, vec};
use serialize::{Encodable, Decodable, Encoder, Decoder};
/// An owned smart pointer.
-pub struct P<T> {
+#[derive(Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub struct P<T: ?Sized> {
ptr: Box<T>
}
}
}
-impl<T: PartialEq> PartialEq for P<T> {
- fn eq(&self, other: &P<T>) -> bool {
- **self == **other
- }
-}
-
-impl<T: Eq> Eq for P<T> {}
-
impl<T: Debug> Debug for P<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
Debug::fmt(&**self, f)
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<T> fmt::Pointer for P<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Pointer::fmt(&self.ptr, f)
}
}
-impl<T: Hash> Hash for P<T> {
- fn hash<H: Hasher>(&self, state: &mut H) {
- (**self).hash(state);
- }
-}
-
impl<T: 'static + Decodable> Decodable for P<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<P<T>, D::Error> {
Decodable::decode(d).map(P)
(**self).encode(s)
}
}
+
+
+impl<T:fmt::Debug> fmt::Debug for P<[T]> {
+ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ self.ptr.fmt(fmt)
+ }
+}
+
+impl<T> P<[T]> {
+ pub fn empty() -> P<[T]> {
+ P { ptr: Default::default() }
+ }
+
+ #[inline(never)]
+ pub fn from_vec(v: Vec<T>) -> P<[T]> {
+ P { ptr: v.into_boxed_slice() }
+ }
+
+ #[inline(never)]
+ pub fn into_vec(self) -> Vec<T> {
+ self.ptr.into_vec()
+ }
+
+ pub fn as_slice<'a>(&'a self) -> &'a [T] {
+ &*self.ptr
+ }
+
+ pub fn move_iter(self) -> vec::IntoIter<T> {
+ self.into_vec().into_iter()
+ }
+
+ pub fn map<U, F: FnMut(&T) -> U>(&self, f: F) -> P<[U]> {
+ self.iter().map(f).collect()
+ }
+}
+
+impl<T> Deref for P<[T]> {
+ type Target = [T];
+
+ fn deref(&self) -> &[T] {
+ self.as_slice()
+ }
+}
+
+impl<T> Default for P<[T]> {
+ fn default() -> P<[T]> {
+ P::empty()
+ }
+}
+
+impl<T: Clone> Clone for P<[T]> {
+ fn clone(&self) -> P<[T]> {
+ P::from_vec(self.to_vec())
+ }
+}
+
+impl<T> FromIterator<T> for P<[T]> {
+ fn from_iter<I: IntoIterator<Item=T>>(iter: I) -> P<[T]> {
+ P::from_vec(iter.into_iter().collect())
+ }
+}
+
+impl<'a, T> IntoIterator for &'a P<[T]> {
+ type Item = &'a T;
+ type IntoIter = slice::Iter<'a, T>;
+ fn into_iter(self) -> Self::IntoIter {
+ self.ptr.into_iter()
+ }
+}
+
+impl<T: Encodable> Encodable for P<[T]> {
+ fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+ Encodable::encode(&**self, s)
+ }
+}
+
+impl<T: Decodable> Decodable for P<[T]> {
+ fn decode<D: Decoder>(d: &mut D) -> Result<P<[T]>, D::Error> {
+ Ok(P::from_vec(match Decodable::decode(d) {
+ Ok(t) => t,
+ Err(e) => return Err(e)
+ }))
+ }
+}
use std::str::FromStr;
use ast;
-use diagnostic;
+use errors;
use visit;
use visit::Visitor;
}
struct ShowSpanVisitor<'a> {
- span_diagnostic: &'a diagnostic::SpanHandler,
+ span_diagnostic: &'a errors::Handler,
mode: Mode,
}
}
}
-pub fn run(span_diagnostic: &diagnostic::SpanHandler,
+pub fn run(span_diagnostic: &errors::Handler,
mode: &str,
krate: &ast::Crate) {
let mode = match mode.parse().ok() {
use attr;
use codemap::{DUMMY_SP, Span, ExpnInfo, NameAndSpan, MacroAttribute};
use codemap;
-use diagnostic;
+use errors;
use config;
use entry::{self, EntryPointType};
use ext::base::ExtCtxt;
use fold::Folder;
use util::move_map::MoveMap;
use fold;
-use owned_slice::OwnedSlice;
use parse::token::{intern, InternedString};
use parse::{token, ParseSess};
use print::pprust;
struct TestCtxt<'a> {
sess: &'a ParseSess,
- span_diagnostic: &'a diagnostic::SpanHandler,
+ span_diagnostic: &'a errors::Handler,
path: Vec<ast::Ident>,
ext_cx: ExtCtxt<'a>,
testfns: Vec<Test>,
pub fn modify_for_testing(sess: &ParseSess,
cfg: &ast::CrateConfig,
krate: ast::Crate,
- span_diagnostic: &diagnostic::SpanHandler) -> ast::Crate {
+ span_diagnostic: &errors::Handler) -> ast::Crate {
// We generate the test harness when building in the 'test'
// configuration, either with the '--test' or '--cfg test'
// command line options.
reexport_test_harness_main: Option<InternedString>,
krate: ast::Crate,
cfg: &ast::CrateConfig,
- sd: &diagnostic::SpanHandler) -> ast::Crate {
+ sd: &errors::Handler) -> ast::Crate {
// Remove the entry points
let mut cleaner = EntryPointCleaner { depth: 0 };
let krate = cleaner.fold_crate(krate);
return res;
}
-fn strip_test_functions(diagnostic: &diagnostic::SpanHandler, krate: ast::Crate)
+fn strip_test_functions(diagnostic: &errors::Handler, krate: ast::Crate)
-> ast::Crate {
// When not compiling with --test we should not compile the
// #[test] functions
Some(id) => vec![id],
None => {
let diag = cx.span_diagnostic;
- diag.handler.bug("expected to find top-level re-export name, but found None");
+ diag.bug("expected to find top-level re-export name, but found None");
}
};
visible_path.extend(path);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use owned_slice::OwnedSlice;
-
use std::ptr;
pub trait MoveMap<T>: Sized {
}
}
-impl<T> MoveMap<T> for OwnedSlice<T> {
+impl<T> MoveMap<T> for ::ptr::P<[T]> {
fn move_flat_map<F, I>(self, f: F) -> Self
where F: FnMut(T) -> I,
I: IntoIterator<Item=T>
{
- OwnedSlice::from_vec(self.into_vec().move_flat_map(f))
+ ::ptr::P::from_vec(self.into_vec().move_flat_map(f))
}
}
use syntax::ext::build::AstBuilder;
use syntax::codemap::{self, DUMMY_SP};
use syntax::codemap::Span;
-use syntax::diagnostic::SpanHandler;
+use syntax::errors::Handler;
use syntax::util::move_map::MoveMap;
-use syntax::owned_slice::OwnedSlice;
use syntax::parse::token::{intern, InternedString};
use syntax::parse::token::special_idents;
use syntax::ptr::P;
cx.typaram(self.span,
ty_param.ident,
- OwnedSlice::from_vec(bounds),
+ P::from_vec(bounds),
None)
}));
span: self.span,
bound_lifetimes: wb.bound_lifetimes.clone(),
bounded_ty: wb.bounded_ty.clone(),
- bounds: OwnedSlice::from_vec(wb.bounds.iter().cloned().collect())
+ bounds: P::from_vec(wb.bounds.iter().cloned().collect())
})
}
ast::WherePredicate::RegionPredicate(ref rb) => {
span: self.span,
bound_lifetimes: vec![],
bounded_ty: ty,
- bounds: OwnedSlice::from_vec(bounds),
+ bounds: P::from_vec(bounds),
};
let predicate = ast::WherePredicate::BoundPredicate(predicate);
let trait_generics = Generics {
lifetimes: lifetimes,
- ty_params: OwnedSlice::from_vec(ty_params),
+ ty_params: P::from_vec(ty_params),
where_clause: where_clause
};
}
}
-fn find_repr_type_name(diagnostic: &SpanHandler,
+fn find_repr_type_name(diagnostic: &Handler,
type_attrs: &[ast::Attribute]) -> &'static str {
let mut repr_type_name = "i32";
for a in type_attrs {
use syntax::ext::base::ExtCtxt;
use syntax::ext::build::AstBuilder;
use syntax::codemap::{Span,respan};
-use syntax::owned_slice::OwnedSlice;
use syntax::parse::token::special_idents;
use syntax::ptr::P;
-> Generics {
Generics {
lifetimes: lifetimes,
- ty_params: OwnedSlice::from_vec(ty_params),
+ ty_params: P::from_vec(ty_params),
where_clause: ast::WhereClause {
id: ast::DUMMY_NODE_ID,
predicates: Vec::new(),
macro_rules! panictry {
($e:expr) => ({
use std::result::Result::{Ok, Err};
- use syntax::diagnostic::FatalError;
+ use syntax::errors::FatalError;
match $e {
Ok(e) => e,
Err(FatalError) => panic!(FatalError)
--- /dev/null
+-include ../tools.mk
+
+all:
+ $(RUSTC) -Copt-level=0 --emit=llvm-bc,llvm-ir,asm,obj,link test-24876.rs
+ $(RUSTC) -Copt-level=1 --emit=llvm-bc,llvm-ir,asm,obj,link test-24876.rs
+ $(RUSTC) -Copt-level=2 --emit=llvm-bc,llvm-ir,asm,obj,link test-24876.rs
+ $(RUSTC) -Copt-level=3 --emit=llvm-bc,llvm-ir,asm,obj,link test-24876.rs
+ $(RUSTC) -Copt-level=0 --emit=llvm-bc,llvm-ir,asm,obj,link test-26235.rs
+ $(call RUN,test-26235) || exit 1
+ $(RUSTC) -Copt-level=1 --emit=llvm-bc,llvm-ir,asm,obj,link test-26235.rs
+ $(call RUN,test-26235) || exit 1
+ $(RUSTC) -Copt-level=2 --emit=llvm-bc,llvm-ir,asm,obj,link test-26235.rs
+ $(call RUN,test-26235) || exit 1
+ $(RUSTC) -Copt-level=3 --emit=llvm-bc,llvm-ir,asm,obj,link test-26235.rs
+ $(call RUN,test-26235) || exit 1
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Checks for issue #24876
+
+fn main() {
+ let mut v = 0;
+ for i in 0..0 {
+ v += i;
+ }
+ println!("{}", v)
+}
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Checks for issue #26235
+
+fn main() {
+ use std::thread;
+
+ type Key = u32;
+ const NUM_THREADS: usize = 2;
+
+ #[derive(Clone,Copy)]
+ struct Stats<S> {
+ upsert: S,
+ delete: S,
+ insert: S,
+ update: S
+ };
+
+ impl<S> Stats<S> where S: Copy {
+ fn dot<B, F, T>(self, s: Stats<T>, f: F) -> Stats<B> where F: Fn(S, T) -> B {
+ let Stats { upsert: u1, delete: d1, insert: i1, update: p1 } = self;
+ let Stats { upsert: u2, delete: d2, insert: i2, update: p2 } = s;
+ Stats { upsert: f(u1, u2), delete: f(d1, d2), insert: f(i1, i2), update: f(p1, p2) }
+ }
+
+ fn new(init: S) -> Self {
+ Stats { upsert: init, delete: init, insert: init, update: init }
+ }
+ }
+
+ fn make_threads() -> Vec<thread::JoinHandle<()>> {
+ let mut t = Vec::with_capacity(NUM_THREADS);
+ for _ in 0..NUM_THREADS {
+ t.push(thread::spawn(move || {}));
+ }
+ t
+ }
+
+ let stats = [Stats::new(0); NUM_THREADS];
+ make_threads();
+
+ {
+ let Stats { ref upsert, ref delete, ref insert, ref update } = stats.iter().fold(
+ Stats::new(0), |res, &s| res.dot(s, |x: Key, y: Key| x.wrapping_add(y)));
+ println!("upserts: {}, deletes: {}, inserts: {}, updates: {}",
+ upsert, delete, insert, update);
+ }
+}
let mut p = string_to_parser(&ps, s);
let x = f(&mut p);
- if ps.span_diagnostic.handler().has_errors() || p.token != token::Eof {
+ if ps.span_diagnostic.has_errors() || p.token != token::Eof {
return Err(p.fatal("parse error"));
}
use rustc::session::Session;
use rustc::session::config::{self, Input};
use rustc_driver::{driver, CompilerCalls, Compilation};
-use syntax::{diagnostics, diagnostic};
+use syntax::{diagnostics, errors};
use std::path::PathBuf;
fn early_callback(&mut self,
_: &getopts::Matches,
_: &diagnostics::registry::Registry,
- _: diagnostic::ColorConfig)
+ _: errors::emitter::ColorConfig)
-> Compilation {
self.count *= 2;
Compilation::Continue
projects / rust.git / commitdiff