rust/src/lib.rs

649 lines
20 KiB
Rust
Raw Normal View History

// 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.
2017-06-13 20:57:31 -05:00
#![feature(rustc_private)]
2015-04-13 20:00:46 -05:00
2017-11-06 06:44:59 -06:00
#[macro_use]
extern crate derive_new;
2017-08-08 10:16:35 -05:00
extern crate diff;
#[macro_use]
extern crate log;
2017-08-08 10:16:35 -05:00
extern crate regex;
extern crate rustc_errors as errors;
extern crate serde;
#[macro_use]
extern crate serde_derive;
extern crate serde_json;
2017-08-08 10:16:35 -05:00
extern crate syntax;
extern crate term;
2017-08-08 10:16:35 -05:00
extern crate unicode_segmentation;
2015-09-03 22:38:12 -05:00
use std::collections::HashMap;
use std::fmt;
use std::io::{self, stdout, Write};
use std::iter::repeat;
2016-04-02 13:56:37 -05:00
use std::path::{Path, PathBuf};
2016-03-01 16:27:19 -06:00
use std::rc::Rc;
use errors::{DiagnosticBuilder, Handler};
use errors::emitter::{ColorConfig, EmitterWriter};
use syntax::ast;
2017-09-17 01:32:00 -05:00
use syntax::codemap::{CodeMap, FilePathMapping};
use syntax::parse::{self, ParseSess};
use checkstyle::{output_footer, output_header};
use comment::{CharClasses, FullCodeCharKind};
use config::Config;
use filemap::FileMap;
use issues::{BadIssueSeeker, Issue};
use utils::use_colored_tty;
use visitor::{FmtVisitor, SnippetProvider};
pub use self::summary::Summary;
2015-06-08 13:23:24 -05:00
#[macro_use]
mod utils;
mod shape;
2017-09-17 01:32:00 -05:00
mod spanned;
2015-07-20 16:29:25 -05:00
pub mod config;
pub mod codemap;
pub mod filemap;
pub mod file_lines;
pub mod visitor;
mod checkstyle;
2017-11-12 20:26:33 -06:00
mod closures;
2015-05-24 18:03:26 -05:00
mod items;
mod missed_spans;
mod lists;
2015-04-21 04:01:19 -05:00
mod types;
mod expr;
mod imports;
mod issues;
2015-06-16 10:29:05 -05:00
mod rewrite;
2015-06-23 08:58:58 -05:00
mod string;
mod comment;
pub mod modules;
pub mod rustfmt_diff;
2015-09-10 17:52:16 -05:00
mod chains;
2015-09-14 15:53:30 -05:00
mod macros;
2015-10-17 08:56:53 -05:00
mod patterns;
mod summary;
mod vertical;
#[derive(Clone, Copy)]
pub enum ErrorKind {
// Line has exceeded character limit (found, maximum)
LineOverflow(usize, usize),
// Line ends in whitespace
TrailingWhitespace,
// TO-DO or FIX-ME item without an issue number
BadIssue(Issue),
}
impl fmt::Display for ErrorKind {
fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
match *self {
2017-07-11 07:53:10 -05:00
ErrorKind::LineOverflow(found, maximum) => write!(
fmt,
"line exceeded maximum width (maximum: {}, found: {})",
2017-11-30 22:30:21 -06:00
maximum, found
2017-07-11 07:53:10 -05:00
),
ErrorKind::TrailingWhitespace => write!(fmt, "left behind trailing whitespace"),
ErrorKind::BadIssue(issue) => write!(fmt, "found {}", issue),
}
}
}
// Formatting errors that are identified *after* rustfmt has run.
pub struct FormattingError {
line: usize,
kind: ErrorKind,
is_comment: bool,
is_string: bool,
line_buffer: String,
}
impl FormattingError {
fn msg_prefix(&self) -> &str {
match self.kind {
ErrorKind::LineOverflow(..) | ErrorKind::TrailingWhitespace => "error:",
ErrorKind::BadIssue(_) => "WARNING:",
}
}
fn msg_suffix(&self) -> &str {
if self.is_comment || self.is_string {
"set `error_on_unformatted = false` to suppress \
the warning against comments or string literals\n"
} else {
""
}
}
// (space, target)
pub fn format_len(&self) -> (usize, usize) {
match self.kind {
ErrorKind::LineOverflow(found, max) => (max, found - max),
ErrorKind::TrailingWhitespace => {
let trailing_ws_len = self.line_buffer
.chars()
.rev()
.take_while(|c| c.is_whitespace())
.count();
(self.line_buffer.len() - trailing_ws_len, trailing_ws_len)
}
_ => unreachable!(),
}
}
}
pub struct FormatReport {
// Maps stringified file paths to their associated formatting errors.
file_error_map: HashMap<String, Vec<FormattingError>>,
}
impl FormatReport {
fn new() -> FormatReport {
2017-07-03 04:54:26 -05:00
FormatReport {
file_error_map: HashMap::new(),
}
}
pub fn warning_count(&self) -> usize {
self.file_error_map
.iter()
.map(|(_, errors)| errors.len())
.fold(0, |acc, x| acc + x)
}
pub fn has_warnings(&self) -> bool {
self.warning_count() > 0
}
pub fn print_warnings_fancy(
&self,
mut t: Box<term::Terminal<Output = io::Stderr>>,
) -> Result<(), term::Error> {
for (file, errors) in &self.file_error_map {
for error in errors {
let prefix_space_len = error.line.to_string().len();
let prefix_spaces: String = repeat(" ").take(1 + prefix_space_len).collect();
// First line: the overview of error
t.fg(term::color::RED)?;
t.attr(term::Attr::Bold)?;
write!(t, "{} ", error.msg_prefix())?;
t.reset()?;
t.attr(term::Attr::Bold)?;
write!(t, "{}\n", error.kind)?;
// Second line: file info
write!(t, "{}--> ", &prefix_spaces[1..])?;
t.reset()?;
write!(t, "{}:{}\n", file, error.line)?;
// Third to fifth lines: show the line which triggered error, if available.
if !error.line_buffer.is_empty() {
let (space_len, target_len) = error.format_len();
t.attr(term::Attr::Bold)?;
write!(t, "{}|\n{} | ", prefix_spaces, error.line)?;
t.reset()?;
write!(t, "{}\n", error.line_buffer)?;
t.attr(term::Attr::Bold)?;
write!(t, "{}| ", prefix_spaces)?;
t.fg(term::color::RED)?;
write!(t, "{}\n", target_str(space_len, target_len))?;
t.reset()?;
}
// The last line: show note if available.
let msg_suffix = error.msg_suffix();
if !msg_suffix.is_empty() {
t.attr(term::Attr::Bold)?;
write!(t, "{}= note: ", prefix_spaces)?;
t.reset()?;
write!(t, "{}\n", error.msg_suffix())?;
} else {
write!(t, "\n")?;
}
t.reset()?;
}
}
if !self.file_error_map.is_empty() {
t.attr(term::Attr::Bold)?;
write!(t, "warning: ")?;
t.reset()?;
write!(
t,
"rustfmt may have failed to format. See previous {} errors.\n\n",
self.warning_count(),
)?;
}
Ok(())
}
}
fn target_str(space_len: usize, target_len: usize) -> String {
let empty_line: String = repeat(" ").take(space_len).collect();
let overflowed: String = repeat("^").take(target_len).collect();
empty_line + &overflowed
}
impl fmt::Display for FormatReport {
// Prints all the formatting errors.
fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
2015-09-04 16:39:33 -05:00
for (file, errors) in &self.file_error_map {
for error in errors {
let prefix_space_len = error.line.to_string().len();
let prefix_spaces: String = repeat(" ").take(1 + prefix_space_len).collect();
let error_line_buffer = if error.line_buffer.is_empty() {
String::from(" ")
} else {
let (space_len, target_len) = error.format_len();
format!(
"{}|\n{} | {}\n{}| {}",
prefix_spaces,
error.line,
error.line_buffer,
prefix_spaces,
target_str(space_len, target_len)
)
};
let error_info = format!("{} {}", error.msg_prefix(), error.kind);
let file_info = format!("{}--> {}:{}", &prefix_spaces[1..], file, error.line);
let msg_suffix = error.msg_suffix();
let note = if msg_suffix.is_empty() {
String::new()
} else {
format!("{}note= ", prefix_spaces)
};
write!(
fmt,
"{}\n{}\n{}\n{}{}\n",
error_info,
file_info,
error_line_buffer,
note,
error.msg_suffix()
)?;
}
}
if !self.file_error_map.is_empty() {
write!(
fmt,
"warning: rustfmt may have failed to format. See previous {} errors.\n",
self.warning_count(),
)?;
}
Ok(())
}
}
// Formatting which depends on the AST.
fn format_ast<F>(
krate: &ast::Crate,
2017-08-11 03:54:38 -05:00
parse_session: &mut ParseSess,
main_file: &Path,
config: &Config,
mut after_file: F,
) -> Result<(FileMap, bool), io::Error>
where
2017-12-10 02:40:51 -06:00
F: FnMut(&str, &mut String, &[(usize, usize)]) -> Result<bool, io::Error>,
{
let mut result = FileMap::new();
// diff mode: check if any files are differing
let mut has_diff = false;
// We always skip children for the "Plain" write mode, since there is
// nothing to distinguish the nested module contents.
let skip_children = config.skip_children() || config.write_mode() == config::WriteMode::Plain;
2017-11-06 06:45:54 -06:00
for (path, module) in modules::list_files(krate, parse_session.codemap())? {
if skip_children && path.as_path() != main_file {
continue;
}
let path_str = path.to_str().unwrap();
if config.verbose() {
println!("Formatting {}", path_str);
2015-11-15 00:41:41 -06:00
}
let filemap = parse_session
.codemap()
.lookup_char_pos(module.inner.lo())
.file;
let big_snippet = filemap.src.as_ref().unwrap();
let snippet_provider = SnippetProvider::new(filemap.start_pos, big_snippet);
let mut visitor = FmtVisitor::from_codemap(parse_session, config, &snippet_provider);
2017-08-29 22:00:10 -05:00
// Format inner attributes if available.
if !krate.attrs.is_empty() && path == main_file {
visitor.skip_empty_lines(filemap.end_pos);
if visitor.visit_attrs(&krate.attrs, ast::AttrStyle::Inner) {
visitor.push_rewrite(module.inner, None);
} else {
visitor.format_separate_mod(module, &*filemap);
}
2017-08-29 22:00:10 -05:00
} else {
visitor.last_pos = filemap.start_pos;
visitor.skip_empty_lines(filemap.end_pos);
visitor.format_separate_mod(module, &*filemap);
};
2017-12-08 01:59:04 -06:00
assert_eq!(
visitor.line_number,
::utils::count_newlines(&format!("{}", visitor.buffer))
);
has_diff |= match after_file(path_str, &mut visitor.buffer, &visitor.skipped_range) {
Ok(result) => result,
Err(e) => {
// Create a new error with path_str to help users see which files failed
let err_msg = path_str.to_string() + &": ".to_string() + &e.to_string();
return Err(io::Error::new(e.kind(), err_msg));
}
};
2017-08-29 22:00:10 -05:00
result.push((path_str.to_owned(), visitor.buffer));
}
Ok((result, has_diff))
}
/// Returns true if the line with the given line number was skipped by `#[rustfmt_skip]`.
fn is_skipped_line(line_number: usize, skipped_range: &[(usize, usize)]) -> bool {
skipped_range
.iter()
.any(|&(lo, hi)| lo <= line_number && line_number <= hi)
}
fn should_report_error(
config: &Config,
char_kind: FullCodeCharKind,
is_string: bool,
error_kind: ErrorKind,
) -> bool {
let allow_error_report = if char_kind.is_comment() || is_string {
config.error_on_unformatted()
} else {
true
};
match error_kind {
ErrorKind::LineOverflow(..) => config.error_on_line_overflow() && allow_error_report,
ErrorKind::TrailingWhitespace => allow_error_report,
_ => true,
}
}
2015-04-21 05:50:43 -05:00
// Formatting done on a char by char or line by line basis.
// FIXME(#209) warn on bad license
// FIXME(#20) other stuff for parity with make tidy
fn format_lines(
2017-12-10 02:40:51 -06:00
text: &mut String,
name: &str,
skipped_range: &[(usize, usize)],
config: &Config,
report: &mut FormatReport,
) {
// Iterate over the chars in the file map.
let mut trims = vec![];
let mut last_wspace: Option<usize> = None;
let mut line_len = 0;
let mut cur_line = 1;
let mut newline_count = 0;
let mut errors = vec![];
let mut issue_seeker = BadIssueSeeker::new(config.report_todo(), config.report_fixme());
let mut line_buffer = String::with_capacity(config.max_width() * 2);
let mut is_string = false; // true if the current line contains a string literal.
let mut format_line = config.file_lines().contains_line(name, cur_line);
2017-12-10 20:50:11 -06:00
for (kind, (b, c)) in CharClasses::new(text.chars().enumerate()) {
if c == '\r' {
continue;
}
if format_line {
// Add warnings for bad todos/ fixmes
if let Some(issue) = issue_seeker.inspect(c) {
2015-09-26 01:29:48 -05:00
errors.push(FormattingError {
line: cur_line,
kind: ErrorKind::BadIssue(issue),
is_comment: false,
is_string: false,
line_buffer: String::new(),
});
}
}
if c == '\n' {
if format_line {
// Check for (and record) trailing whitespace.
if let Some(..) = last_wspace {
if should_report_error(config, kind, is_string, ErrorKind::TrailingWhitespace) {
trims.push((cur_line, kind, line_buffer.clone()));
}
line_len -= 1;
}
// Check for any line width errors we couldn't correct.
let error_kind = ErrorKind::LineOverflow(line_len, config.max_width());
if line_len > config.max_width() && !is_skipped_line(cur_line, skipped_range)
&& should_report_error(config, kind, is_string, error_kind)
{
errors.push(FormattingError {
line: cur_line,
kind: error_kind,
is_comment: kind.is_comment(),
is_string: is_string,
line_buffer: line_buffer.clone(),
});
}
}
line_len = 0;
cur_line += 1;
format_line = config.file_lines().contains_line(name, cur_line);
newline_count += 1;
last_wspace = None;
line_buffer.clear();
is_string = false;
} else {
newline_count = 0;
line_len += 1;
if c.is_whitespace() {
if last_wspace.is_none() {
last_wspace = Some(b);
}
} else {
last_wspace = None;
}
line_buffer.push(c);
if kind.is_string() {
is_string = true;
}
}
}
if newline_count > 1 {
2017-12-10 02:40:51 -06:00
debug!("track truncate: {} {}", text.len(), newline_count);
let line = text.len() - newline_count + 1;
text.truncate(line);
}
2015-04-23 01:02:55 -05:00
for &(l, kind, ref b) in &trims {
if !is_skipped_line(l, skipped_range) {
errors.push(FormattingError {
line: l,
kind: ErrorKind::TrailingWhitespace,
is_comment: kind.is_comment(),
is_string: kind.is_string(),
line_buffer: b.clone(),
});
}
2015-04-23 01:02:55 -05:00
}
2017-03-27 17:25:59 -05:00
report.file_error_map.insert(name.to_owned(), errors);
}
fn parse_input(
input: Input,
parse_session: &ParseSess,
) -> Result<ast::Crate, Option<DiagnosticBuilder>> {
let result = match input {
Input::File(file) => {
let mut parser = parse::new_parser_from_file(parse_session, &file);
parser.cfg_mods = false;
parser.parse_crate_mod()
}
2016-04-11 11:49:56 -05:00
Input::Text(text) => {
let mut parser =
parse::new_parser_from_source_str(parse_session, "stdin".to_owned(), text);
parser.cfg_mods = false;
parser.parse_crate_mod()
2016-04-11 11:49:56 -05:00
}
};
2016-05-17 16:58:51 -05:00
match result {
Ok(c) => {
if parse_session.span_diagnostic.has_errors() {
// Bail out if the parser recovered from an error.
Err(None)
} else {
Ok(c)
}
}
Err(e) => Err(Some(e)),
}
}
pub fn format_input<T: Write>(
input: Input,
config: &Config,
mut out: Option<&mut T>,
) -> Result<(Summary, FileMap, FormatReport), (io::Error, Summary)> {
2017-08-29 08:16:04 -05:00
let mut summary = Summary::default();
if config.disable_all_formatting() {
// When the input is from stdin, echo back the input.
if let Input::Text(ref buf) = input {
if let Err(e) = io::stdout().write_all(buf.as_bytes()) {
return Err((e, summary));
}
}
return Ok((summary, FileMap::new(), FormatReport::new()));
}
let codemap = Rc::new(CodeMap::new(FilePathMapping::empty()));
2016-03-01 16:27:19 -06:00
2016-05-12 14:50:43 -05:00
let tty_handler =
Handler::with_tty_emitter(ColorConfig::Auto, true, false, Some(codemap.clone()));
2016-03-01 16:27:19 -06:00
let mut parse_session = ParseSess::with_span_handler(tty_handler, codemap.clone());
2016-04-11 11:49:56 -05:00
let main_file = match input {
Input::File(ref file) => file.clone(),
Input::Text(..) => PathBuf::from("stdin"),
};
let krate = match parse_input(input, &parse_session) {
Ok(krate) => krate,
Err(diagnostic) => {
if let Some(mut diagnostic) = diagnostic {
diagnostic.emit();
}
summary.add_parsing_error();
return Ok((summary, FileMap::new(), FormatReport::new()));
2016-04-11 11:49:56 -05:00
}
};
if parse_session.span_diagnostic.has_errors() {
summary.add_parsing_error();
}
// Suppress error output after parsing.
let silent_emitter = Box::new(EmitterWriter::new(
Box::new(Vec::new()),
Some(codemap.clone()),
2017-10-20 08:53:06 -05:00
false,
));
2016-03-01 16:27:19 -06:00
parse_session.span_diagnostic = Handler::with_emitter(true, false, silent_emitter);
let mut report = FormatReport::new();
2017-05-31 22:08:09 -05:00
match format_ast(
&krate,
&mut parse_session,
2017-05-31 22:08:09 -05:00
&main_file,
config,
|file_name, file, skipped_range| {
2017-05-31 22:08:09 -05:00
// For some reason, the codemap does not include terminating
// newlines so we must add one on for each file. This is sad.
filemap::append_newline(file);
format_lines(file, file_name, skipped_range, config, &mut report);
2017-05-31 22:08:09 -05:00
if let Some(ref mut out) = out {
return filemap::write_file(file, file_name, out, config);
}
Ok(false)
2017-06-03 08:50:44 -05:00
},
2017-05-31 22:08:09 -05:00
) {
Ok((file_map, has_diff)) => {
if report.has_warnings() {
summary.add_formatting_error();
}
if has_diff {
summary.add_diff();
}
Ok((summary, file_map, report))
}
Err(e) => Err((e, summary)),
}
2016-04-02 13:56:37 -05:00
}
2016-05-25 13:41:26 -05:00
#[derive(Debug)]
2016-04-02 13:56:37 -05:00
pub enum Input {
File(PathBuf),
Text(String),
}
pub fn run(input: Input, config: &Config) -> Summary {
2017-08-11 03:54:38 -05:00
let out = &mut stdout();
output_header(out, config.write_mode()).ok();
match format_input(input, config, Some(out)) {
Ok((summary, _, report)) => {
output_footer(out, config.write_mode()).ok();
if report.has_warnings() {
match term::stderr() {
Some(ref t)
if use_colored_tty(config.color()) && t.supports_color()
2017-11-09 14:23:12 -06:00
&& t.supports_attr(term::Attr::Bold) =>
{
match report.print_warnings_fancy(term::stderr().unwrap()) {
Ok(..) => (),
Err(..) => panic!("Unable to write to stderr: {}", report),
}
}
_ => msg!("{}", report),
}
}
summary
}
Err((msg, mut summary)) => {
msg!("Error writing files: {}", msg);
summary.add_operational_error();
summary
}
}
}