use config::lists::*;
use syntax::ast::{self, UseTreeKind};
-use syntax::codemap::{self, BytePos, Span, DUMMY_SP};
+use syntax::source_map::{self, BytePos, Span, DUMMY_SP};
-use codemap::SpanUtils;
use comment::combine_strs_with_missing_comments;
use config::IndentStyle;
use lists::{definitive_tactic, itemize_list, write_list, ListFormatting, ListItem, Separator};
use rewrite::{Rewrite, RewriteContext};
use shape::Shape;
+use source_map::SpanUtils;
use spanned::Spanned;
-use utils::{mk_sp, rewrite_ident};
+use utils::{is_same_visibility, mk_sp, rewrite_ident};
use visitor::FmtVisitor;
use std::borrow::Cow;
if name.is_empty() || name == "{{root}}" {
return None;
}
- Some(if name == "self" {
- UseSegment::Slf(None)
- } else if name == "super" {
- UseSegment::Super(None)
- } else {
- UseSegment::Ident((*name).to_owned(), None)
+ Some(match name {
+ "self" => UseSegment::Slf(None),
+ "super" => UseSegment::Super(None),
+ _ => UseSegment::Ident((*name).to_owned(), None),
})
}
}
.zip(items.into_iter())
.map(|(t, list_item)| {
Self::from_ast(context, &t.0, Some(list_item), None, None, None)
- })
- .collect(),
+ }).collect(),
));
}
UseTreeKind::Simple(ref rename, ..) => {
- let mut name = rewrite_ident(context, path_to_imported_ident(&a.prefix)).to_owned();
+ let name = rewrite_ident(context, path_to_imported_ident(&a.prefix)).to_owned();
let alias = rename.and_then(|ident| {
- if ident == path_to_imported_ident(&a.prefix) {
+ if ident.name == "_" {
+ // for impl-only-use
+ Some("_".to_owned())
+ } else if ident == path_to_imported_ident(&a.prefix) {
None
} else {
Some(rewrite_ident(context, ident).to_owned())
}
});
-
- let segment = if &name == "self" {
- UseSegment::Slf(alias)
- } else if &name == "super" {
- UseSegment::Super(alias)
- } else {
- UseSegment::Ident(name, alias)
+ let segment = match name.as_ref() {
+ "self" => UseSegment::Slf(alias),
+ "super" => UseSegment::Super(alias),
+ _ => UseSegment::Ident(name, alias),
};
// `name` is already in result.
fn same_visibility(&self, other: &UseTree) -> bool {
match (&self.visibility, &other.visibility) {
(
- Some(codemap::Spanned {
+ Some(source_map::Spanned {
node: ast::VisibilityKind::Inherited,
..
}),
)
| (
None,
- Some(codemap::Spanned {
+ Some(source_map::Spanned {
node: ast::VisibilityKind::Inherited,
..
}),
)
| (None, None) => true,
- (
- Some(codemap::Spanned { node: lnode, .. }),
- Some(codemap::Spanned { node: rnode, .. }),
- ) => lnode == rnode,
+ (Some(ref a), Some(ref b)) => is_same_visibility(a, b),
_ => false,
}
}
let prefix = &self.path[..self.path.len() - 1];
let mut result = vec![];
for nested_use_tree in list {
- for mut flattend in &mut nested_use_tree.clone().flatten() {
+ for flattend in &mut nested_use_tree.clone().flatten() {
let mut new_path = prefix.to_vec();
new_path.append(&mut flattend.path);
result.push(UseTree {
fn merge(&mut self, other: UseTree) {
let mut new_path = vec![];
- for (mut a, b) in self
+ for (a, b) in self
.path
.clone()
.iter_mut()
use self::UseSegment::*;
fn is_upper_snake_case(s: &str) -> bool {
- s.chars().all(|c| c.is_uppercase() || c == '_')
+ s.chars()
+ .all(|c| c.is_uppercase() || c == '_' || c.is_numeric())
}
match (self, other) {
let ends_with_newline = context.config.imports_indent() == IndentStyle::Block
&& tactic != DefinitiveListTactic::Horizontal;
- let fmt = ListFormatting {
- tactic,
- separator: ",",
- trailing_separator: if ends_with_newline {
- context.config.trailing_comma()
- } else {
- SeparatorTactic::Never
- },
- separator_place: SeparatorPlace::Back,
- shape: nested_shape,
- ends_with_newline,
- preserve_newline: true,
- nested: has_nested_list,
- config: context.config,
+ let trailing_separator = if ends_with_newline {
+ context.config.trailing_comma()
+ } else {
+ SeparatorTactic::Never
};
+ let fmt = ListFormatting::new(nested_shape, context.config)
+ .tactic(tactic)
+ .trailing_separator(trailing_separator)
+ .ends_with_newline(ends_with_newline)
+ .preserve_newline(true)
+ .nested(has_nested_list);
let list_str = write_list(&list_items, &fmt)?;
impl Rewrite for UseSegment {
fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
- Some(match *self {
+ Some(match self {
UseSegment::Ident(ref ident, Some(ref rename)) => format!("{} as {}", ident, rename),
UseSegment::Ident(ref ident, None) => ident.clone(),
UseSegment::Slf(Some(ref rename)) => format!("self as {}", rename),
#[cfg(test)]
mod test {
use super::*;
- use syntax::codemap::DUMMY_SP;
+ use syntax::source_map::DUMMY_SP;
// Parse the path part of an import. This parser is not robust and is only
// suitable for use in a test harness.