src/lib.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 #![feature(box_syntax)]
  12 #![feature(box_patterns)]
  13 #![feature(rustc_private)]
  14 #![feature(collections)]
  15 #![feature(str_char)]
  16
  17 // TODO we're going to allocate a whole bunch of temp Strings, is it worth
  18 // keeping some scratch mem for this and running our own StrPool?
  19 // TODO for lint violations of names, emit a refactor script
  20
  21
  22 #[macro_use]
  23 extern crate log;
  24
  25 extern crate getopts;
  26 extern crate rustc;
  27 extern crate rustc_driver;
  28 extern crate syntax;
  29
  30 extern crate strings;
  31
  32 use rustc::session::Session;
  33 use rustc::session::config::{self, Input};
  34 use rustc_driver::{driver, CompilerCalls, Compilation};
  35
  36 use syntax::ast;
  37 use syntax::codemap::CodeMap;
  38 use syntax::diagnostics;
  39 use syntax::visit;
  40
  41 use std::path::PathBuf;
  42 use std::collections::HashMap;
  43
  44 use changes::ChangeSet;
  45 use visitor::FmtVisitor;
  46
  47 mod changes;
  48 mod visitor;
  49 mod functions;
  50 mod missed_spans;
  51 mod lists;
  52 mod utils;
  53 mod types;
  54 mod expr;
  55 mod imports;
  56
  57 const IDEAL_WIDTH: usize = 80;
  58 const LEEWAY: usize = 5;
  59 const MAX_WIDTH: usize = 100;
  60 const MIN_STRING: usize = 10;
  61 const TAB_SPACES: usize = 4;
  62 const NEWLINE_STYLE: NewlineStyle = NewlineStyle::Unix;
  63 const FN_BRACE_STYLE: BraceStyle = BraceStyle::SameLineWhere;
  64 const FN_RETURN_INDENT: ReturnIndent = ReturnIndent::WithArgs;
  65 // When we get scoped annotations, we should have rustfmt::skip.
  66 const SKIP_ANNOTATION: &'static str = "rustfmt_skip";
  67
  68 #[derive(Copy, Clone)]
  69 pub enum WriteMode {
  70     Overwrite,
  71     // str is the extension of the new file
  72     NewFile(&'static str),
  73     // Write the output to stdout.
  74     Display,
  75     // Return the result as a mapping from filenames to StringBuffers.
  76     Return(&'static Fn(HashMap<String, String>)),
  77 }
  78
  79 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
  80 enum NewlineStyle {
  81     Windows, // \r\n
  82     Unix, // \n
  83 }
  84
  85 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
  86 enum BraceStyle {
  87     AlwaysNextLine,
  88     PreferSameLine,
  89     // Prefer same line except where there is a where clause, in which case force
  90     // the brace to the next line.
  91     SameLineWhere,
  92 }
  93
  94 // How to indent a function's return type.
  95 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
  96 enum ReturnIndent {
  97     // Aligned with the arguments
  98     WithArgs,
  99     // Aligned with the where clause
 100     WithWhereClause,
 101 }
 102
 103 // Formatting which depends on the AST.
 104 fn fmt_ast<'a>(krate: &ast::Crate, codemap: &'a CodeMap) -> ChangeSet<'a> {
 105     let mut visitor = FmtVisitor::from_codemap(codemap);
 106     visit::walk_crate(&mut visitor, krate);
 107     let files = codemap.files.borrow();
 108     if let Some(last) = files.last() {
 109         visitor.format_missing(last.end_pos);
 110     }
 111
 112     visitor.changes
 113 }
 114
 115 // Formatting done on a char by char or line by line basis.
 116 // TODO warn on TODOs and FIXMEs without an issue number
 117 // TODO warn on bad license
 118 // TODO other stuff for parity with make tidy
 119 fn fmt_lines(changes: &mut ChangeSet) {
 120     let mut truncate_todo = Vec::new();
 121
 122     // Iterate over the chars in the change set.
 123     for (f, text) in changes.text() {
 124         let mut trims = vec![];
 125         let mut last_wspace: Option<usize> = None;
 126         let mut line_len = 0;
 127         let mut cur_line = 1;
 128         let mut newline_count = 0;
 129         for (c, b) in text.chars() {
 130             if c == '\r' { continue; }
 131             if c == '\n' {
 132                 // Check for (and record) trailing whitespace.
 133                 if let Some(lw) = last_wspace {
 134                     trims.push((cur_line, lw, b));
 135                     line_len -= b - lw;
 136                 }
 137                 // Check for any line width errors we couldn't correct.
 138                 if line_len > MAX_WIDTH {
 139                     // TODO store the error rather than reporting immediately.
 140                     println!("Rustfmt couldn't fix (sorry). {}:{}: line longer than {} characters",
 141                              f, cur_line, MAX_WIDTH);
 142                 }
 143                 line_len = 0;
 144                 cur_line += 1;
 145                 newline_count += 1;
 146                 last_wspace = None;
 147             } else {
 148                 newline_count = 0;
 149                 line_len += 1;
 150                 if c.is_whitespace() {
 151                     if last_wspace.is_none() {
 152                         last_wspace = Some(b);
 153                     }
 154                 } else {
 155                     last_wspace = None;
 156                 }
 157             }
 158         }
 159
 160         if newline_count > 1 {
 161             debug!("track truncate: {} {} {}", f, text.len, newline_count);
 162             truncate_todo.push((f.to_string(), text.len - newline_count + 1))
 163         }
 164
 165         for &(l, _, _) in trims.iter() {
 166             // TODO store the error rather than reporting immediately.
 167             println!("Rustfmt left trailing whitespace at {}:{} (sorry)", f, l);
 168         }
 169     }
 170
 171     for (f, l) in truncate_todo {
 172         changes.get_mut(&f).truncate(l);
 173     }
 174 }
 175
 176 struct RustFmtCalls {
 177     input_path: Option<PathBuf>,
 178     write_mode: WriteMode,
 179 }
 180
 181 impl<'a> CompilerCalls<'a> for RustFmtCalls {
 182     fn early_callback(&mut self,
 183                       _: &getopts::Matches,
 184                       _: &diagnostics::registry::Registry)
 185                       -> Compilation {
 186         Compilation::Continue
 187     }
 188
 189     fn some_input(&mut self,
 190                   input: Input,
 191                   input_path: Option<PathBuf>)
 192                   -> (Input, Option<PathBuf>) {
 193         match input_path {
 194             Some(ref ip) => self.input_path = Some(ip.clone()),
 195             _ => {
 196                 // FIXME should handle string input and write to stdout or something
 197                 panic!("No input path");
 198             }
 199         }
 200         (input, input_path)
 201     }
 202
 203     fn no_input(&mut self,
 204                 _: &getopts::Matches,
 205                 _: &config::Options,
 206                 _: &Option<PathBuf>,
 207                 _: &Option<PathBuf>,
 208                 _: &diagnostics::registry::Registry)
 209                 -> Option<(Input, Option<PathBuf>)> {
 210         panic!("No input supplied to RustFmt");
 211     }
 212
 213     fn late_callback(&mut self,
 214                      _: &getopts::Matches,
 215                      _: &Session,
 216                      _: &Input,
 217                      _: &Option<PathBuf>,
 218                      _: &Option<PathBuf>)
 219                      -> Compilation {
 220         Compilation::Continue
 221     }
 222
 223     fn build_controller(&mut self, _: &Session) -> driver::CompileController<'a> {
 224         let write_mode = self.write_mode;
 225         let mut control = driver::CompileController::basic();
 226         control.after_parse.stop = Compilation::Stop;
 227         control.after_parse.callback = box move |state| {
 228             let krate = state.krate.unwrap();
 229             let codemap = state.session.codemap();
 230             let mut changes = fmt_ast(krate, codemap);
 231             // For some reason, the codemap does not include terminating newlines
 232             // so we must add one on for each file. This is sad.
 233             changes.append_newlines();
 234             fmt_lines(&mut changes);
 235
 236             // FIXME(#5) Should be user specified whether to show or replace.
 237             let result = changes.write_all_files(write_mode);
 238
 239             match result {
 240                 Err(msg) => println!("Error writing files: {}", msg),
 241                 Ok(result) => {
 242                     if let WriteMode::Return(callback) = write_mode {
 243                         callback(result);
 244                     }
 245                 }
 246             }
 247         };
 248
 249         control
 250     }
 251 }
 252
 253 pub fn run(args: Vec<String>, write_mode: WriteMode) {
 254     let mut call_ctxt = RustFmtCalls { input_path: None, write_mode: write_mode };
 255     rustc_driver::run_compiler(&args, &mut call_ctxt);
 256 }