OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rollup merge of #37257 - srinivasreddy:librustc_errors, r=eddyb

Browse Source 
run rustfmt on librustc_errors folder
This commit is contained in:
Eduard-Mihai Burtescu 2016-10-19 08:00:04 +03:00 committed by GitHub
commit 903e1f9657
6 changed files with 172 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

174
src/librustc_errors/emitter.rs
View File

@ -51,8 +51,8 @@ impl ColorConfig {
fn use_color(&self) -> bool {
match *self {
ColorConfig::Always => true,
ColorConfig::Never => false,
ColorConfig::Auto => stderr_isatty(),
ColorConfig::Never => false,
ColorConfig::Auto => stderr_isatty(),
}
}
}
@ -83,22 +83,22 @@ macro_rules! println_maybe_styled {
}
impl EmitterWriter {
pub fn stderr(color_config: ColorConfig,
code_map: Option<Rc<CodeMapper>>)
-> EmitterWriter {
pub fn stderr(color_config: ColorConfig, code_map: Option<Rc<CodeMapper>>) -> EmitterWriter {
if color_config.use_color() {
let dst = Destination::from_stderr();
EmitterWriter { dst: dst,
cm: code_map}
EmitterWriter {
dst: dst,
cm: code_map,
}
} else {
EmitterWriter { dst: Raw(Box::new(io::stderr())),
cm: code_map}
EmitterWriter {
dst: Raw(Box::new(io::stderr())),
cm: code_map,
}
}
}
pub fn new(dst: Box<Write + Send>,
code_map: Option<Rc<CodeMapper>>)
-> EmitterWriter {
pub fn new(dst: Box<Write + Send>, code_map: Option<Rc<CodeMapper>>) -> EmitterWriter {
EmitterWriter {
dst: Raw(dst),
cm: code_map,
@ -107,9 +107,9 @@ impl EmitterWriter {
fn preprocess_annotations(&self, msp: &MultiSpan) -> Vec<FileWithAnnotatedLines> {
fn add_annotation_to_file(file_vec: &mut Vec<FileWithAnnotatedLines>,
file: Rc<FileMap>,
line_index: usize,
ann: Annotation) {
file: Rc<FileMap>,
line_index: usize,
ann: Annotation) {
for slot in file_vec.iter_mut() {
// Look through each of our files for the one we're adding to
@ -168,15 +168,15 @@ impl EmitterWriter {
}
add_annotation_to_file(&mut output,
lo.file,
lo.line,
Annotation {
start_col: lo.col.0,
end_col: hi.col.0,
is_primary: span_label.is_primary,
is_minimized: is_minimized,
label: span_label.label.clone(),
});
lo.file,
lo.line,
Annotation {
start_col: lo.col.0,
end_col: hi.col.0,
is_primary: span_label.is_primary,
is_minimized: is_minimized,
label: span_label.label.clone(),
});
}
}
output
@ -237,9 +237,7 @@ impl EmitterWriter {
'^',
Style::UnderlinePrimary);
if !annotation.is_minimized {
buffer.set_style(line_offset,
width_offset + p,
Style::UnderlinePrimary);
buffer.set_style(line_offset, width_offset + p, Style::UnderlinePrimary);
}
} else {
buffer.putc(line_offset + 1,
@ -247,9 +245,7 @@ impl EmitterWriter {
'-',
Style::UnderlineSecondary);
if !annotation.is_minimized {
buffer.set_style(line_offset,
width_offset + p,
Style::UnderlineSecondary);
buffer.set_style(line_offset, width_offset + p, Style::UnderlineSecondary);
}
}
}
@ -429,8 +425,7 @@ impl EmitterWriter {
}
// Check to make sure we're not in any <*macros>
if !cm.span_to_filename(def_site).contains("macros>") &&
!trace.macro_decl_name.starts_with("#[")
{
!trace.macro_decl_name.starts_with("#[") {
new_labels.push((trace.call_site,
"in this macro invocation".to_string()));
break;
@ -475,10 +470,10 @@ impl EmitterWriter {
if spans_updated {
children.push(SubDiagnostic {
level: Level::Note,
message:"this error originates in a macro outside of the current \
crate".to_string(),
message: "this error originates in a macro outside of the current crate"
.to_string(),
span: MultiSpan::new(),
render_span: None
render_span: None,
});
}
}
@ -502,8 +497,7 @@ impl EmitterWriter {
buffer.append(0, &level.to_string(), Style::HeaderMsg);
buffer.append(0, ": ", Style::NoStyle);
buffer.append(0, msg, Style::NoStyle);
}
else {
} else {
buffer.append(0, &level.to_string(), Style::Level(level.clone()));
match code {
&Some(ref code) => {
@ -522,23 +516,21 @@ impl EmitterWriter {
let mut annotated_files = self.preprocess_annotations(msp);
// Make sure our primary file comes first
let primary_lo =
if let (Some(ref cm), Some(ref primary_span)) = (self.cm.as_ref(),
msp.primary_span().as_ref()) {
if primary_span != &&DUMMY_SP && primary_span != &&COMMAND_LINE_SP {
cm.lookup_char_pos(primary_span.lo)
}
else {
emit_to_destination(&buffer.render(), level, &mut self.dst)?;
return Ok(());
}
let primary_lo = if let (Some(ref cm), Some(ref primary_span)) =
(self.cm.as_ref(), msp.primary_span().as_ref()) {
if primary_span != &&DUMMY_SP && primary_span != &&COMMAND_LINE_SP {
cm.lookup_char_pos(primary_span.lo)
} else {
// If we don't have span information, emit and exit
emit_to_destination(&buffer.render(), level, &mut self.dst)?;
return Ok(());
};
}
} else {
// If we don't have span information, emit and exit
emit_to_destination(&buffer.render(), level, &mut self.dst)?;
return Ok(());
};
if let Ok(pos) =
annotated_files.binary_search_by(|x| x.file.name.cmp(&primary_lo.file.name)) {
annotated_files.binary_search_by(|x| x.file.name.cmp(&primary_lo.file.name)) {
annotated_files.swap(0, pos);
}
@ -554,8 +546,8 @@ impl EmitterWriter {
buffer.prepend(buffer_msg_line_offset, "--> ", Style::LineNumber);
let loc = primary_lo.clone();
buffer.append(buffer_msg_line_offset,
&format!("{}:{}:{}", loc.file.name, loc.line, loc.col.0 + 1),
Style::LineAndColumn);
&format!("{}:{}:{}", loc.file.name, loc.line, loc.col.0 + 1),
Style::LineAndColumn);
for _ in 0..max_line_num_len {
buffer.prepend(buffer_msg_line_offset, " ", Style::NoStyle);
}
@ -569,8 +561,8 @@ impl EmitterWriter {
// Then, the secondary file indicator
buffer.prepend(buffer_msg_line_offset + 1, "::: ", Style::LineNumber);
buffer.append(buffer_msg_line_offset + 1,
&annotated_file.file.name,
Style::LineAndColumn);
&annotated_file.file.name,
Style::LineAndColumn);
for _ in 0..max_line_num_len {
buffer.prepend(buffer_msg_line_offset + 1, " ", Style::NoStyle);
}
@ -591,7 +583,7 @@ impl EmitterWriter {
// this annotated line and the next one
if line_idx < (annotated_file.lines.len() - 1) {
let line_idx_delta = annotated_file.lines[line_idx + 1].line_index -
annotated_file.lines[line_idx].line_index;
annotated_file.lines[line_idx].line_index;
if line_idx_delta > 2 {
let last_buffer_line_num = buffer.num_lines();
buffer.puts(last_buffer_line_num, 0, "...", Style::LineNumber);
@ -672,12 +664,7 @@ impl EmitterWriter {
let max_line_num = self.get_max_line_num(span, children);
let max_line_num_len = max_line_num.to_string().len();
match self.emit_message_default(span,
message,
code,
level,
max_line_num_len,
false) {
match self.emit_message_default(span, message, code, level, max_line_num_len, false) {
Ok(()) => {
if !children.is_empty() {
let mut buffer = StyledBuffer::new();
@ -723,13 +710,15 @@ impl EmitterWriter {
}
}
}
Err(e) => panic!("failed to emit error: {}", e)
Err(e) => panic!("failed to emit error: {}", e),
}
match write!(&mut self.dst, "\n") {
Err(e) => panic!("failed to emit error: {}", e),
_ => match self.dst.flush() {
Err(e) => panic!("failed to emit error: {}", e),
_ => ()
_ => {
match self.dst.flush() {
Err(e) => panic!("failed to emit error: {}", e),
_ => (),
}
}
}
}
@ -753,8 +742,9 @@ fn overlaps(a1: &Annotation, a2: &Annotation) -> bool {
}
fn emit_to_destination(rendered_buffer: &Vec<Vec<StyledString>>,
lvl: &Level,
dst: &mut Destination) -> io::Result<()> {
lvl: &Level,
dst: &mut Destination)
-> io::Result<()> {
use lock;
// In order to prevent error message interleaving, where multiple error lines get intermixed
@ -795,8 +785,7 @@ fn stderr_isatty() -> bool {
const STD_ERROR_HANDLE: DWORD = -12i32 as DWORD;
extern "system" {
fn GetStdHandle(which: DWORD) -> HANDLE;
fn GetConsoleMode(hConsoleHandle: HANDLE,
lpMode: *mut DWORD) -> BOOL;
fn GetConsoleMode(hConsoleHandle: HANDLE, lpMode: *mut DWORD) -> BOOL;
}
unsafe {
let handle = GetStdHandle(STD_ERROR_HANDLE);
@ -824,9 +813,7 @@ impl BufferedWriter {
// note: we use _new because the conditional compilation at its use site may make this
// this function unused on some platforms
fn _new() -> BufferedWriter {
BufferedWriter {
buffer: vec![]
}
BufferedWriter { buffer: vec![] }
}
}
@ -853,35 +840,34 @@ impl Destination {
/// When not on Windows, prefer the buffered terminal so that we can buffer an entire error
/// to be emitted at one time.
fn from_stderr() -> Destination {
let stderr: Option<Box<BufferedStderr>> =
let stderr: Option<Box<BufferedStderr>> =
term::TerminfoTerminal::new(BufferedWriter::_new())
.map(|t| Box::new(t) as Box<BufferedStderr>);
match stderr {
Some(t) => BufferedTerminal(t),
None => Raw(Box::new(io::stderr())),
None => Raw(Box::new(io::stderr())),
}
}
#[cfg(windows)]
/// Return a normal, unbuffered terminal when on Windows.
fn from_stderr() -> Destination {
let stderr: Option<Box<term::StderrTerminal>> =
term::TerminfoTerminal::new(io::stderr())
.map(|t| Box::new(t) as Box<term::StderrTerminal>)
.or_else(|| term::WinConsole::new(io::stderr()).ok()
.map(|t| Box::new(t) as Box<term::StderrTerminal>));
let stderr: Option<Box<term::StderrTerminal>> = term::TerminfoTerminal::new(io::stderr())
.map(|t| Box::new(t) as Box<term::StderrTerminal>)
.or_else(|| {
term::WinConsole::new(io::stderr())
.ok()
.map(|t| Box::new(t) as Box<term::StderrTerminal>)
});
match stderr {
Some(t) => Terminal(t),
None => Raw(Box::new(io::stderr())),
None => Raw(Box::new(io::stderr())),
}
}
fn apply_style(&mut self,
lvl: Level,
style: Style)
-> io::Result<()> {
fn apply_style(&mut self, lvl: Level, style: Style) -> io::Result<()> {
match style {
Style::FileNameStyle | Style::LineAndColumn => {}
Style::LineNumber => {
@ -931,18 +917,26 @@ impl Destination {
fn start_attr(&mut self, attr: term::Attr) -> io::Result<()> {
match *self {
Terminal(ref mut t) => { t.attr(attr)?; }
BufferedTerminal(ref mut t) => { t.attr(attr)?; }
Raw(_) => { }
Terminal(ref mut t) => {
t.attr(attr)?;
}
BufferedTerminal(ref mut t) => {
t.attr(attr)?;
}
Raw(_) => {}
}
Ok(())
}
fn reset_attrs(&mut self) -> io::Result<()> {
match *self {
Terminal(ref mut t) => { t.reset()?; }
BufferedTerminal(ref mut t) => { t.reset()?; }
Raw(_) => { }
Terminal(ref mut t) => {
t.reset()?;
}
BufferedTerminal(ref mut t) => {
t.reset()?;
}
Raw(_) => {}
}
Ok(())
}

148
src/librustc_errors/lib.rs
View File

@ -28,8 +28,10 @@
extern crate serialize;
extern crate term;
#[macro_use] extern crate log;
#[macro_use] extern crate libc;
#[macro_use]
extern crate log;
#[macro_use]
extern crate libc;
extern crate rustc_unicode;
extern crate serialize as rustc_serialize; // used by deriving
extern crate syntax_pos;
@ -52,8 +54,8 @@ pub mod registry;
pub mod styled_buffer;
mod lock;
use syntax_pos::{BytePos, Loc, FileLinesResult, FileName, MultiSpan, Span, NO_EXPANSION };
use syntax_pos::{MacroBacktrace};
use syntax_pos::{BytePos, Loc, FileLinesResult, FileName, MultiSpan, Span, NO_EXPANSION};
use syntax_pos::MacroBacktrace;
#[derive(Clone)]
pub enum RenderSpan {
@ -89,9 +91,11 @@ impl CodeSuggestion {
pub fn splice_lines(&self, cm: &CodeMapper) -> String {
use syntax_pos::{CharPos, Loc, Pos};
fn push_trailing(buf: &mut String, line_opt: Option<&str>,
lo: &Loc, hi_opt: Option<&Loc>) {
let (lo, hi_opt) = (lo.col.to_usize(), hi_opt.map(|hi|hi.col.to_usize()));
fn push_trailing(buf: &mut String,
line_opt: Option<&str>,
lo: &Loc,
hi_opt: Option<&Loc>) {
let (lo, hi_opt) = (lo.col.to_usize(), hi_opt.map(|hi| hi.col.to_usize()));
if let Some(line) = line_opt {
if line.len() > lo {
buf.push_str(match hi_opt {
@ -119,7 +123,11 @@ impl CodeSuggestion {
// Find the bounding span.
let lo = primary_spans.iter().map(|sp| sp.lo).min().unwrap();
let hi = primary_spans.iter().map(|sp| sp.hi).min().unwrap();
let bounding_span = Span { lo: lo, hi: hi, expn_id: NO_EXPANSION };
let bounding_span = Span {
lo: lo,
hi: hi,
expn_id: NO_EXPANSION,
};
let lines = cm.span_to_lines(bounding_span).unwrap();
assert!(!lines.lines.is_empty());
@ -153,7 +161,7 @@ impl CodeSuggestion {
}
}
if let Some(cur_line) = fm.get_line(cur_lo.line - 1) {
buf.push_str(&cur_line[.. cur_lo.col.to_usize()]);
buf.push_str(&cur_line[..cur_lo.col.to_usize()]);
}
}
buf.push_str(substitute);
@ -263,8 +271,7 @@ impl<'a> DiagnosticBuilder<'a> {
/// all, and you just supplied a `Span` to create the diagnostic,
/// then the snippet will just include that `Span`, which is
/// called the primary span.
pub fn span_label(&mut self, span: Span, label: &fmt::Display)
-> &mut DiagnosticBuilder<'a> {
pub fn span_label(&mut self, span: Span, label: &fmt::Display) -> &mut DiagnosticBuilder<'a> {
self.span.push_span_label(span, format!("{}", label));
self
}
@ -273,8 +280,7 @@ impl<'a> DiagnosticBuilder<'a> {
label: &fmt::Display,
expected: &fmt::Display,
found: &fmt::Display)
-> &mut DiagnosticBuilder<'a>
{
-> &mut DiagnosticBuilder<'a> {
self.note_expected_found_extra(label, expected, found, &"", &"")
}
@ -284,8 +290,7 @@ impl<'a> DiagnosticBuilder<'a> {
found: &fmt::Display,
expected_extra: &fmt::Display,
found_extra: &fmt::Display)
-> &mut DiagnosticBuilder<'a>
{
-> &mut DiagnosticBuilder<'a> {
// For now, just attach these as notes
self.note(&format!("expected {} `{}`{}", label, expected, expected_extra));
self.note(&format!(" found {} `{}`{}", label, found, found_extra));
@ -314,7 +319,7 @@ impl<'a> DiagnosticBuilder<'a> {
self.sub(Level::Warning, msg, sp.into(), None);
self
}
pub fn help(&mut self , msg: &str) -> &mut DiagnosticBuilder<'a> {
pub fn help(&mut self, msg: &str) -> &mut DiagnosticBuilder<'a> {
self.sub(Level::Help, msg, MultiSpan::new(), None);
self
}
@ -333,10 +338,13 @@ impl<'a> DiagnosticBuilder<'a> {
msg: &str,
suggestion: String)
-> &mut DiagnosticBuilder<'a> {
self.sub(Level::Help, msg, MultiSpan::new(), Some(Suggestion(CodeSuggestion {
msp: sp.into(),
substitutes: vec![suggestion],
})));
self.sub(Level::Help,
msg,
MultiSpan::new(),
Some(Suggestion(CodeSuggestion {
msp: sp.into(),
substitutes: vec![suggestion],
})));
self
}
@ -360,18 +368,17 @@ impl<'a> DiagnosticBuilder<'a> {
/// Convenience function for internal use, clients should use one of the
/// struct_* methods on Handler.
fn new(handler: &'a Handler,
level: Level,
message: &str) -> DiagnosticBuilder<'a> {
fn new(handler: &'a Handler, level: Level, message: &str) -> DiagnosticBuilder<'a> {
DiagnosticBuilder::new_with_code(handler, level, None, message)
}
/// Convenience function for internal use, clients should use one of the
/// struct_* methods on Handler.
fn new_with_code(handler: &'a Handler,
level: Level,
code: Option<String>,
message: &str) -> DiagnosticBuilder<'a> {
level: Level,
code: Option<String>,
message: &str)
-> DiagnosticBuilder<'a> {
DiagnosticBuilder {
handler: handler,
level: level,
@ -410,9 +417,8 @@ impl<'a> fmt::Debug for DiagnosticBuilder<'a> {
impl<'a> Drop for DiagnosticBuilder<'a> {
fn drop(&mut self) {
if !panicking() && !self.cancelled() {
let mut db = DiagnosticBuilder::new(self.handler,
Bug,
"Error constructed but not emitted");
let mut db =
DiagnosticBuilder::new(self.handler, Bug, "Error constructed but not emitted");
db.emit();
panic!();
}
@ -443,7 +449,8 @@ impl Handler {
pub fn with_emitter(can_emit_warnings: bool,
treat_err_as_bug: bool,
e: Box<Emitter>) -> Handler {
e: Box<Emitter>)
-> Handler {
Handler {
err_count: Cell::new(0),
emitter: RefCell::new(e),
@ -544,10 +551,10 @@ impl Handler {
pub fn cancel(&self, err: &mut DiagnosticBuilder) {
if err.level == Level::Error || err.level == Level::Fatal {
self.err_count.set(
self.err_count.get().checked_sub(1)
.expect("cancelled an error but err_count is 0")
);
self.err_count.set(self.err_count
.get()
.checked_sub(1)
.expect("cancelled an error but err_count is 0"));
}
err.cancel();
}
@ -558,14 +565,16 @@ impl Handler {
}
}
pub fn span_fatal<S: Into<MultiSpan>>(&self, sp: S, msg: &str)
-> FatalError {
pub fn span_fatal<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> FatalError {
self.emit(&sp.into(), msg, Fatal);
self.bump_err_count();
self.panic_if_treat_err_as_bug();
return FatalError;
}
pub fn span_fatal_with_code<S: Into<MultiSpan>>(&self, sp: S, msg: &str, code: &str)
pub fn span_fatal_with_code<S: Into<MultiSpan>>(&self,
sp: S,
msg: &str,
code: &str)
-> FatalError {
self.emit_with_code(&sp.into(), msg, code, Fatal);
self.bump_err_count();
@ -619,9 +628,7 @@ impl Handler {
if self.treat_err_as_bug {
self.bug(msg);
}
let mut db = DiagnosticBuilder::new(self,
Fatal,
msg);
let mut db = DiagnosticBuilder::new(self, Fatal, msg);
db.emit();
self.bump_err_count();
FatalError
@ -630,28 +637,20 @@ impl Handler {
if self.treat_err_as_bug {
self.bug(msg);
}
let mut db = DiagnosticBuilder::new(self,
Error,
msg);
let mut db = DiagnosticBuilder::new(self, Error, msg);
db.emit();
self.bump_err_count();
}
pub fn warn(&self, msg: &str) {
let mut db = DiagnosticBuilder::new(self,
Warning,
msg);
let mut db = DiagnosticBuilder::new(self, Warning, msg);
db.emit();
}
pub fn note_without_error(&self, msg: &str) {
let mut db = DiagnosticBuilder::new(self,
Note,
msg);
let mut db = DiagnosticBuilder::new(self, Note, msg);
db.emit();
}
pub fn bug(&self, msg: &str) -> ! {
let mut db = DiagnosticBuilder::new(self,
Bug,
msg);
let mut db = DiagnosticBuilder::new(self, Bug, msg);
db.emit();
panic!(ExplicitBug);
}
@ -678,44 +677,41 @@ impl Handler {
match *delayed_bug {
Some((ref span, ref errmsg)) => {
self.span_bug(span.clone(), errmsg);
},
}
_ => {}
}
return;
}
1 => s = "aborting due to previous error".to_string(),
_ => {
s = format!("aborting due to {} previous errors",
self.err_count.get());
_ => {
s = format!("aborting due to {} previous errors", self.err_count.get());
}
}
panic!(self.fatal(&s));
}
pub fn emit(&self,
msp: &MultiSpan,
msg: &str,
lvl: Level) {
if lvl == Warning && !self.can_emit_warnings { return }
pub fn emit(&self, msp: &MultiSpan, msg: &str, lvl: Level) {
if lvl == Warning && !self.can_emit_warnings {
return;
}
let mut db = DiagnosticBuilder::new(self, lvl, msg);
db.set_span(msp.clone());
db.emit();
if !self.continue_after_error.get() { self.abort_if_errors(); }
if !self.continue_after_error.get() {
self.abort_if_errors();
}
}
pub fn emit_with_code(&self,
msp: &MultiSpan,
msg: &str,
code: &str,
lvl: Level) {
if lvl == Warning && !self.can_emit_warnings { return }
let mut db = DiagnosticBuilder::new_with_code(self,
lvl,
Some(code.to_owned()),
msg);
pub fn emit_with_code(&self, msp: &MultiSpan, msg: &str, code: &str, lvl: Level) {
if lvl == Warning && !self.can_emit_warnings {
return;
}
let mut db = DiagnosticBuilder::new_with_code(self, lvl, Some(code.to_owned()), msg);
db.set_span(msp.clone());
db.emit();
if !self.continue_after_error.get() { self.abort_if_errors(); }
if !self.continue_after_error.get() {
self.abort_if_errors();
}
}
}
@ -750,7 +746,7 @@ impl Level {
} else {
term::color::YELLOW
}
},
}
Note => term::color::BRIGHT_GREEN,
Help => term::color::BRIGHT_CYAN,
Cancelled => unreachable!(),
@ -769,8 +765,8 @@ impl Level {
}
}
pub fn expect<T, M>(diag: &Handler, opt: Option<T>, msg: M) -> T where
M: FnOnce() -> String,
pub fn expect<T, M>(diag: &Handler, opt: Option<T>, msg: M) -> T
where M: FnOnce() -> String
{
match opt {
Some(t) => t,

15
src/librustc_errors/lock.rs
View File

@ -40,9 +40,9 @@ pub fn acquire_global_lock(name: &str) -> Box<Any> {
extern "system" {
fn CreateMutexA(lpMutexAttributes: LPSECURITY_ATTRIBUTES,
bInitialOwner: BOOL,
lpName: LPCSTR) -> HANDLE;
fn WaitForSingleObject(hHandle: HANDLE,
dwMilliseconds: DWORD) -> DWORD;
lpName: LPCSTR)
-> HANDLE;
fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) -> DWORD;
fn ReleaseMutex(hMutex: HANDLE) -> BOOL;
fn CloseHandle(hObject: HANDLE) -> BOOL;
}
@ -76,7 +76,8 @@ pub fn acquire_global_lock(name: &str) -> Box<Any> {
// open up a handle to one if it already exists.
let mutex = CreateMutexA(0 as *mut _, 0, cname.as_ptr() as *const u8);
if mutex.is_null() {
panic!("failed to create global mutex named `{}`: {}", name,
panic!("failed to create global mutex named `{}`: {}",
name,
io::Error::last_os_error());
}
let mutex = Handle(mutex);
@ -96,8 +97,10 @@ pub fn acquire_global_lock(name: &str) -> Box<Any> {
WAIT_OBJECT_0 | WAIT_ABANDONED => {}
code => {
panic!("WaitForSingleObject failed on global mutex named \
`{}`: {} (ret={:x})", name,
io::Error::last_os_error(), code);
`{}`: {} (ret={:x})",
name,
io::Error::last_os_error(),
code);
}
}

2
src/librustc_errors/registry.rs
View File

@ -12,7 +12,7 @@ use std::collections::HashMap;
#[derive(Clone)]
pub struct Registry {
descriptions: HashMap<&'static str, &'static str>
descriptions: HashMap<&'static str, &'static str>,
}
impl Registry {

6
src/librustc_errors/snippet.rs
View File

@ -13,12 +13,12 @@
use syntax_pos::{Span, FileMap};
use CodeMapper;
use std::rc::Rc;
use {Level};
use Level;
#[derive(Clone)]
pub struct SnippetData {
codemap: Rc<CodeMapper>,
files: Vec<FileInfo>
files: Vec<FileInfo>,
}
#[derive(Clone)]
@ -84,4 +84,4 @@ pub enum Style {
NoStyle,
ErrorCode,
Level(Level),
}
}

7
src/librustc_errors/styled_buffer.rs
View File

@ -28,10 +28,9 @@ impl StyledBuffer {
pub fn copy_tabs(&mut self, row: usize) {
if row < self.text.len() {
for i in row+1..self.text.len() {
for i in row + 1..self.text.len() {
for j in 0..self.text[i].len() {
if self.text[row].len() > j &&
self.text[row][j] == '\t' &&
if self.text[row].len() > j && self.text[row][j] == '\t' &&
self.text[i][j] == ' ' {
self.text[i][j] = '\t';
}
@ -44,7 +43,7 @@ impl StyledBuffer {
let mut output: Vec<Vec<StyledString>> = vec![];
let mut styled_vec: Vec<StyledString> = vec![];
//before we render, do a little patch-up work to support tabs
// before we render, do a little patch-up work to support tabs
self.copy_tabs(3);
for (row, row_style) in self.text.iter().zip(&self.styles) {