squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Merge pull request #158 from marcusklaas/modules

Browse source 
Use new module code from libsyntax
This commit is contained in:
Nick Cameron 2015-07-25 09:48:58 +12:00
parent 0fc8c37836 3aa03dcc25
commit 4aa24f5962
5 changed files with 49 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/comment.rs
View file

@ -101,10 +101,10 @@ fn format_comments() {
12));
let input = "// comment";
let expected_output = "/* com\n \
* men\n \
* t */";
assert_eq!(expected_output, rewrite_comment(input, true, 9, 69));
let expected = "/* com\n \
* men\n * \
t */";
assert_eq!(expected, rewrite_comment(input, true, 9, 69));
assert_eq!("/* trimmed */", rewrite_comment("/* trimmed */", true, 100, 100));
}

6
src/expr.rs
View file

@ -347,9 +347,11 @@ fn rewrite_binary_op(context: &RewriteContext,
result.push(' ');
result.push_str(&operator_str);
// 1 = space between operator and rhs
let used_width = result.len() + operator_str.len() + 1;
let remaining_width = match result.rfind('\n') {
Some(idx) => (offset + width + idx).checked_sub(result.len()).unwrap_or(0),
None => width.checked_sub(result.len()).unwrap_or(0)
Some(idx) => (offset + width + idx).checked_sub(used_width).unwrap_or(0),
None => width.checked_sub(used_width).unwrap_or(0)
};
// Get "full width" rhs and see if it fits on the current line. This

94
src/visitor.rs
View file

@ -11,13 +11,11 @@
use syntax::ast;
use syntax::codemap::{self, CodeMap, Span, BytePos};
use syntax::visit;
use syntax::parse::token;
use syntax::attr;
use syntax::parse::{token, parser};
use std::path::PathBuf;
use utils;
use config::Config;
use comment::FindUncommented;
use changes::ChangeSet;
use rewrite::{Rewrite, RewriteContext};
@ -363,68 +361,48 @@ impl<'a> FmtVisitor<'a> {
fn format_mod(&mut self, m: &ast::Mod, s: Span, ident: ast::Ident, attrs: &[ast::Attribute]) {
debug!("FmtVisitor::format_mod: ident: {:?}, span: {:?}", ident, s);
// Decide whether this is an inline mod or an external mod.
// There isn't any difference between inline and external mod in AST,
// so we use the trick of searching for an opening brace.
// We can't use the inner span of the mod since it is weird when it
// is empty (no items).
// FIXME Use the inner span once rust-lang/rust#26755 is fixed.
let open_brace = self.codemap.span_to_snippet(s).unwrap().find_uncommented("{");
match open_brace {
None => {
debug!("FmtVisitor::format_mod: external mod");
let file_path = self.module_file(ident, attrs, s);
let filename = file_path.to_str().unwrap();
if self.changes.is_changed(filename) {
// The file has already been reformatted, do nothing
} else {
self.format_separate_mod(m, filename);
}
// TODO Should rewrite properly `mod X;`
}
Some(open_brace) => {
debug!("FmtVisitor::format_mod: internal mod");
debug!("... open_brace: {}, str: {:?}",
open_brace,
self.codemap.span_to_snippet(s));
// Format everything until opening brace
// TODO Shoud rewrite properly
self.format_missing(s.lo + BytePos(open_brace as u32));
self.block_indent += self.config.tab_spaces;
visit::walk_mod(self, m);
debug!("... last_pos after: {:?}", self.last_pos);
self.block_indent -= self.config.tab_spaces;
let local_file_name = self.codemap.span_to_filename(s);
let is_internal = local_file_name == self.codemap.span_to_filename(m.inner);
// TODO Should rewrite properly `mod X;`
if is_internal {
debug!("FmtVisitor::format_mod: internal mod");
self.block_indent += self.config.tab_spaces;
visit::walk_mod(self, m);
debug!("... last_pos after: {:?}", self.last_pos);
self.block_indent -= self.config.tab_spaces;
} else {
debug!("FmtVisitor::format_mod: external mod");
let file_path = self.module_file(ident, attrs, local_file_name);
let filename = file_path.to_str().unwrap();
if self.changes.is_changed(filename) {
// The file has already been reformatted, do nothing
} else {
self.format_separate_mod(m, filename);
}
}
self.format_missing(s.hi);
debug!("FmtVisitor::format_mod: exit");
}
/// Find the file corresponding to an external mod
/// Same algorithm as syntax::parse::eval_src_mod
fn module_file(&self, id: ast::Ident, outer_attrs: &[ast::Attribute], id_sp: Span) -> PathBuf {
// FIXME use libsyntax once rust-lang/rust#26750 is merged
let mut prefix = PathBuf::from(&self.codemap.span_to_filename(id_sp));
prefix.pop();
let mod_string = token::get_ident(id);
match attr::first_attr_value_str_by_name(outer_attrs, "path") {
Some(d) => prefix.join(&*d),
None => {
let default_path_str = format!("{}.rs", mod_string);
let secondary_path_str = format!("{}/mod.rs", mod_string);
let default_path = prefix.join(&default_path_str);
let secondary_path = prefix.join(&secondary_path_str);
let default_exists = self.codemap.file_exists(&default_path);
let secondary_exists = self.codemap.file_exists(&secondary_path);
if default_exists {
default_path
} else if secondary_exists {
secondary_path
} else {
// Should never appens since rustc parsed everything sucessfully
panic!("Didn't found module {}", mod_string);
}
}
fn module_file(&self, id: ast::Ident, attrs: &[ast::Attribute], filename: String) -> PathBuf {
let dir_path = {
let mut path = PathBuf::from(&filename);
path.pop();
path
};
if let Some(path) = parser::Parser::submod_path_from_attr(attrs, &dir_path) {
return path;
}
match parser::Parser::default_submod_path(id, &dir_path, &self.codemap).result {
Ok(parser::ModulePathSuccess { path, .. }) => path,
_ => panic!("Couldn't find module {}", token::get_ident(id))
}
}

2
tests/source/expr.rs
View file

@ -7,6 +7,8 @@ fn foo() -> bool {
let very_long_variable_name = ( a + first + simple + test );
let very_long_variable_name = (a + first + simple + test + AAAAAAAAAAAAA + BBBBBBBBBBBBBBBBB + b + c);
let is_internalxxxx = self.codemap.span_to_filename(s) == self.codemap.span_to_filename(m.inner);
let some_val = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbb / (bbbbbb -
function_call(x, *very_long_pointer, y))
+ 1000;

3
tests/target/expr.rs
View file

@ -8,6 +8,9 @@ fn foo() -> bool {
let very_long_variable_name = (a + first + simple + test + AAAAAAAAAAAAA + BBBBBBBBBBBBBBBBB +
b + c);
let is_internalxxxx = self.codemap.span_to_filename(s) ==
self.codemap.span_to_filename(m.inner);
let some_val = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbb /
(bbbbbb - function_call(x, *very_long_pointer, y)) + 1000;