use std::cmp::Ordering;
use std::fmt;
-use syntax::ast::{self, UseTreeKind};
-use syntax::source_map::{self, BytePos, Span, DUMMY_SP};
-use syntax::symbol::sym;
+use rustc_ast::ast::{self, UseTreeKind};
+use rustc_span::{
+ symbol::{self, sym},
+ BytePos, Span, DUMMY_SP,
+};
use crate::comment::combine_strs_with_missing_comments;
use crate::config::lists::*;
/// Returns a name imported by a `use` declaration.
/// E.g., returns `Ordering` for `std::cmp::Ordering` and `self` for `std::cmp::self`.
-pub(crate) fn path_to_imported_ident(path: &ast::Path) -> ast::Ident {
+pub(crate) fn path_to_imported_ident(path: &ast::Path) -> symbol::Ident {
path.segments.last().unwrap().ident
}
}
}
-pub(crate) fn merge_use_trees(use_trees: Vec<UseTree>) -> Vec<UseTree> {
+pub(crate) fn merge_use_trees(use_trees: Vec<UseTree>, merge_by: SharedPrefix) -> Vec<UseTree> {
let mut result = Vec::with_capacity(use_trees.len());
for use_tree in use_trees {
if use_tree.has_comment() || use_tree.attrs.is_some() {
}
for flattened in use_tree.flatten() {
- merge_use_trees_inner(&mut result, flattened);
+ if let Some(tree) = result
+ .iter_mut()
+ .find(|tree| tree.share_prefix(&flattened, merge_by))
+ {
+ tree.merge(&flattened, merge_by);
+ } else {
+ result.push(flattened);
+ }
}
}
result
}
-fn merge_use_trees_inner(trees: &mut Vec<UseTree>, use_tree: UseTree) {
- for tree in trees.iter_mut() {
- if tree.share_prefix(&use_tree) {
- tree.merge(&use_tree);
- return;
- }
- }
-
- trees.push(use_tree);
+pub(crate) fn flatten_use_trees(use_trees: Vec<UseTree>) -> Vec<UseTree> {
+ use_trees
+ .into_iter()
+ .flat_map(UseTree::flatten)
+ .map(|mut tree| {
+ // If a path ends in `::self`, rewrite it to `::{self}`.
+ if let Some(UseSegment::Slf(..)) = tree.path.last() {
+ let self_segment = tree.path.pop().unwrap();
+ tree.path.push(UseSegment::List(vec![UseTree::from_path(
+ vec![self_segment],
+ DUMMY_SP,
+ )]));
+ }
+ tree
+ })
+ .collect()
}
impl fmt::Debug for UseTree {
let allow_extend = if attrs.len() == 1 {
let line_len = attr_str.len() + 1 + use_str.len();
- !attrs.first().unwrap().is_sugared_doc
+ !attrs.first().unwrap().is_doc_comment()
&& context.config.inline_attribute_width() >= line_len
} else {
false
context: &RewriteContext<'_>,
item: &ast::Item,
) -> Option<UseTree> {
- match item.node {
+ match item.kind {
ast::ItemKind::Use(ref use_tree) => Some(
UseTree::from_ast(
context,
};
let leading_modsep =
- context.config.edition() == Edition::Edition2018 && a.prefix.is_global();
+ context.config.edition() >= Edition::Edition2018 && a.prefix.is_global();
let mut modsep = leading_modsep;
fn same_visibility(&self, other: &UseTree) -> bool {
match (&self.visibility, &other.visibility) {
(
- Some(source_map::Spanned {
- node: ast::VisibilityKind::Inherited,
+ Some(ast::Visibility {
+ kind: ast::VisibilityKind::Inherited,
..
}),
None,
)
| (
None,
- Some(source_map::Spanned {
- node: ast::VisibilityKind::Inherited,
+ Some(ast::Visibility {
+ kind: ast::VisibilityKind::Inherited,
..
}),
)
}
}
- fn share_prefix(&self, other: &UseTree) -> bool {
+ fn share_prefix(&self, other: &UseTree, shared_prefix: SharedPrefix) -> bool {
if self.path.is_empty()
|| other.path.is_empty()
|| self.attrs.is_some()
{
false
} else {
- self.path[0] == other.path[0]
+ match shared_prefix {
+ SharedPrefix::Crate => self.path[0] == other.path[0],
+ SharedPrefix::Module => {
+ self.path[..self.path.len() - 1] == other.path[..other.path.len() - 1]
+ }
+ }
}
}
}
match self.path.clone().last().unwrap() {
UseSegment::List(list) => {
+ if list.len() == 1 && list[0].path.len() == 1 {
+ match list[0].path[0] {
+ UseSegment::Slf(..) => return vec![self],
+ _ => (),
+ };
+ }
let prefix = &self.path[..self.path.len() - 1];
let mut result = vec![];
for nested_use_tree in list {
}
}
- fn merge(&mut self, other: &UseTree) {
- let mut new_path = vec![];
- for (a, b) in self
- .path
- .clone()
- .iter_mut()
- .zip(other.path.clone().into_iter())
- {
- if *a == b {
- new_path.push(b);
+ fn merge(&mut self, other: &UseTree, merge_by: SharedPrefix) {
+ let mut prefix = 0;
+ for (a, b) in self.path.iter().zip(other.path.iter()) {
+ if *a == *b {
+ prefix += 1;
} else {
break;
}
}
- if let Some(merged) = merge_rest(&self.path, &other.path, new_path.len()) {
- new_path.push(merged);
+ if let Some(new_path) = merge_rest(&self.path, &other.path, prefix, merge_by) {
+ self.path = new_path;
self.span = self.span.to(other.span);
}
- self.path = new_path;
}
}
-fn merge_rest(a: &[UseSegment], b: &[UseSegment], len: usize) -> Option<UseSegment> {
- let a_rest = &a[len..];
- let b_rest = &b[len..];
- if a_rest.is_empty() && b_rest.is_empty() {
+fn merge_rest(
+ a: &[UseSegment],
+ b: &[UseSegment],
+ mut len: usize,
+ merge_by: SharedPrefix,
+) -> Option<Vec<UseSegment>> {
+ if a.len() == len && b.len() == len {
return None;
}
- if a_rest.is_empty() {
- return Some(UseSegment::List(vec![
- UseTree::from_path(vec![UseSegment::Slf(None)], DUMMY_SP),
- UseTree::from_path(b_rest.to_vec(), DUMMY_SP),
- ]));
- }
- if b_rest.is_empty() {
- return Some(UseSegment::List(vec![
- UseTree::from_path(vec![UseSegment::Slf(None)], DUMMY_SP),
- UseTree::from_path(a_rest.to_vec(), DUMMY_SP),
- ]));
- }
- if let UseSegment::List(mut list) = a_rest[0].clone() {
- merge_use_trees_inner(&mut list, UseTree::from_path(b_rest.to_vec(), DUMMY_SP));
- list.sort();
- return Some(UseSegment::List(list));
+ if a.len() != len && b.len() != len {
+ if let UseSegment::List(ref list) = a[len] {
+ let mut list = list.clone();
+ merge_use_trees_inner(
+ &mut list,
+ UseTree::from_path(b[len..].to_vec(), DUMMY_SP),
+ merge_by,
+ );
+ let mut new_path = b[..len].to_vec();
+ new_path.push(UseSegment::List(list));
+ return Some(new_path);
+ }
+ } else if len == 1 {
+ let rest = if a.len() == len { &b[1..] } else { &a[1..] };
+ return Some(vec![
+ b[0].clone(),
+ UseSegment::List(vec![
+ UseTree::from_path(vec![UseSegment::Slf(None)], DUMMY_SP),
+ UseTree::from_path(rest.to_vec(), DUMMY_SP),
+ ]),
+ ]);
+ } else {
+ len -= 1;
}
let mut list = vec![
- UseTree::from_path(a_rest.to_vec(), DUMMY_SP),
- UseTree::from_path(b_rest.to_vec(), DUMMY_SP),
+ UseTree::from_path(a[len..].to_vec(), DUMMY_SP),
+ UseTree::from_path(b[len..].to_vec(), DUMMY_SP),
];
list.sort();
- Some(UseSegment::List(list))
+ let mut new_path = b[..len].to_vec();
+ new_path.push(UseSegment::List(list));
+ Some(new_path)
+}
+
+fn merge_use_trees_inner(trees: &mut Vec<UseTree>, use_tree: UseTree, merge_by: SharedPrefix) {
+ let similar_trees = trees
+ .iter_mut()
+ .filter(|tree| tree.share_prefix(&use_tree, merge_by));
+ if use_tree.path.len() == 1 && merge_by == SharedPrefix::Crate {
+ if let Some(tree) = similar_trees.min_by_key(|tree| tree.path.len()) {
+ if tree.path.len() == 1 {
+ return;
+ }
+ }
+ } else if let Some(tree) = similar_trees.max_by_key(|tree| tree.path.len()) {
+ if tree.path.len() > 1 {
+ tree.merge(&use_tree, merge_by);
+ return;
+ }
+ }
+ trees.push(use_tree);
+ trees.sort();
}
impl PartialOrd for UseSegment {
}
}
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum SharedPrefix {
+ Crate,
+ Module,
+}
+
#[cfg(test)]
mod test {
use super::*;
- use syntax::source_map::DUMMY_SP;
+ use rustc_span::DUMMY_SP;
// Parse the path part of an import. This parser is not robust and is only
// suitable for use in a test harness.
}
}
- #[test]
- fn test_use_tree_merge() {
- macro_rules! test_merge {
- ([$($input:expr),* $(,)*], [$($output:expr),* $(,)*]) => {
- assert_eq!(
- merge_use_trees(parse_use_trees!($($input,)*)),
- parse_use_trees!($($output,)*),
- );
- }
+ macro_rules! test_merge {
+ ($by:ident, [$($input:expr),* $(,)*], [$($output:expr),* $(,)*]) => {
+ assert_eq!(
+ merge_use_trees(parse_use_trees!($($input,)*), SharedPrefix::$by),
+ parse_use_trees!($($output,)*),
+ );
}
+ }
- test_merge!(["a::b::{c, d}", "a::b::{e, f}"], ["a::b::{c, d, e, f}"]);
- test_merge!(["a::b::c", "a::b"], ["a::b::{self, c}"]);
- test_merge!(["a::b", "a::b"], ["a::b"]);
- test_merge!(["a", "a::b", "a::b::c"], ["a::{self, b::{self, c}}"]);
+ #[test]
+ fn test_use_tree_merge_crate() {
+ test_merge!(
+ Crate,
+ ["a::b::{c, d}", "a::b::{e, f}"],
+ ["a::b::{c, d, e, f}"]
+ );
+ test_merge!(Crate, ["a::b::c", "a::b"], ["a::{b, b::c}"]);
+ test_merge!(Crate, ["a::b", "a::b"], ["a::b"]);
+ test_merge!(Crate, ["a", "a::b", "a::b::c"], ["a::{self, b, b::c}"]);
+ test_merge!(
+ Crate,
+ ["a", "a::b", "a::b::c", "a::b::c::d"],
+ ["a::{self, b, b::{c, c::d}}"]
+ );
test_merge!(
+ Crate,
+ ["a", "a::b", "a::b::c", "a::b"],
+ ["a::{self, b, b::c}"]
+ );
+ test_merge!(
+ Crate,
["a::{b::{self, c}, d::e}", "a::d::f"],
["a::{b::{self, c}, d::{e, f}}"]
);
test_merge!(
+ Crate,
["a::d::f", "a::{b::{self, c}, d::e}"],
["a::{b::{self, c}, d::{e, f}}"]
);
test_merge!(
+ Crate,
["a::{c, d, b}", "a::{d, e, b, a, f}", "a::{f, g, c}"],
["a::{a, b, c, d, e, f, g}"]
);
+ test_merge!(
+ Crate,
+ ["a::{self}", "b::{self as foo}"],
+ ["a::{self}", "b::{self as foo}"]
+ );
+ }
+
+ #[test]
+ fn test_use_tree_merge_module() {
+ test_merge!(
+ Module,
+ ["foo::b", "foo::{a, c, d::e}"],
+ ["foo::{a, b, c}", "foo::d::e"]
+ );
+
+ test_merge!(
+ Module,
+ ["foo::{a::b, a::c, d::e, d::f}"],
+ ["foo::a::{b, c}", "foo::d::{e, f}"]
+ );
+ }
+
+ #[test]
+ fn test_flatten_use_trees() {
+ assert_eq!(
+ flatten_use_trees(parse_use_trees!["foo::{a::{b, c}, d::e}"]),
+ parse_use_trees!["foo::a::b", "foo::a::c", "foo::d::e"]
+ );
+
+ assert_eq!(
+ flatten_use_trees(parse_use_trees!["foo::{self, a, b::{c, d}, e::*}"]),
+ parse_use_trees![
+ "foo::{self}",
+ "foo::a",
+ "foo::b::c",
+ "foo::b::d",
+ "foo::e::*"
+ ]
+ );
}
#[test]
projects / rust.git / blobdiff