| use std::borrow::Cow; |
| use std::cmp::Ordering; |
| use std::fmt; |
| |
| use core::hash::{Hash, Hasher}; |
| |
| use itertools::Itertools; |
| |
| 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::*; |
| use crate::config::ImportGranularity; |
| use crate::config::{Edition, IndentStyle, Version}; |
| use crate::lists::{ |
| definitive_tactic, itemize_list, write_list, ListFormatting, ListItem, Separator, |
| }; |
| use crate::rewrite::{Rewrite, RewriteContext}; |
| use crate::shape::Shape; |
| use crate::source_map::SpanUtils; |
| use crate::spanned::Spanned; |
| use crate::utils::{is_same_visibility, mk_sp, rewrite_ident}; |
| use crate::visitor::FmtVisitor; |
| |
| /// 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) -> symbol::Ident { |
| path.segments.last().unwrap().ident |
| } |
| |
| impl<'a> FmtVisitor<'a> { |
| pub(crate) fn format_import(&mut self, item: &ast::Item, tree: &ast::UseTree) { |
| let span = item.span(); |
| let shape = self.shape(); |
| let rw = UseTree::from_ast( |
| &self.get_context(), |
| tree, |
| None, |
| Some(item.vis.clone()), |
| Some(item.span.lo()), |
| Some(item.attrs.clone()), |
| ) |
| .rewrite_top_level(&self.get_context(), shape); |
| match rw { |
| Some(ref s) if s.is_empty() => { |
| // Format up to last newline |
| let prev_span = mk_sp(self.last_pos, source!(self, span).lo()); |
| let trimmed_snippet = self.snippet(prev_span).trim_end(); |
| let span_end = self.last_pos + BytePos(trimmed_snippet.len() as u32); |
| self.format_missing(span_end); |
| // We have an excessive newline from the removed import. |
| if self.buffer.ends_with('\n') { |
| self.buffer.pop(); |
| self.line_number -= 1; |
| } |
| self.last_pos = source!(self, span).hi(); |
| } |
| Some(ref s) => { |
| self.format_missing_with_indent(source!(self, span).lo()); |
| self.push_str(s); |
| self.last_pos = source!(self, span).hi(); |
| } |
| None => { |
| self.format_missing_with_indent(source!(self, span).lo()); |
| self.format_missing(source!(self, span).hi()); |
| } |
| } |
| } |
| } |
| |
| // Ordering of imports |
| |
| // We order imports by translating to our own representation and then sorting. |
| // The Rust AST data structures are really bad for this. Rustfmt applies a bunch |
| // of normalisations to imports and since we want to sort based on the result |
| // of these (and to maintain idempotence) we must apply the same normalisations |
| // to the data structures for sorting. |
| // |
| // We sort `self` and `super` before other imports, then identifier imports, |
| // then glob imports, then lists of imports. We do not take aliases into account |
| // when ordering unless the imports are identical except for the alias (rare in |
| // practice). |
| |
| // FIXME(#2531): we should unify the comparison code here with the formatting |
| // code elsewhere since we are essentially string-ifying twice. Furthermore, by |
| // parsing to our own format on comparison, we repeat a lot of work when |
| // sorting. |
| |
| // FIXME we do a lot of allocation to make our own representation. |
| #[derive(Clone, Eq, Hash, PartialEq)] |
| pub(crate) enum UseSegmentKind { |
| Ident(String, Option<String>), |
| Slf(Option<String>), |
| Super(Option<String>), |
| Crate(Option<String>), |
| Glob, |
| List(Vec<UseTree>), |
| } |
| |
| #[derive(Clone, Eq, PartialEq)] |
| pub(crate) struct UseSegment { |
| pub(crate) kind: UseSegmentKind, |
| pub(crate) version: Version, |
| } |
| |
| #[derive(Clone)] |
| pub(crate) struct UseTree { |
| pub(crate) path: Vec<UseSegment>, |
| pub(crate) span: Span, |
| // Comment information within nested use tree. |
| pub(crate) list_item: Option<ListItem>, |
| // Additional fields for top level use items. |
| // Should we have another struct for top-level use items rather than reusing this? |
| visibility: Option<ast::Visibility>, |
| attrs: Option<ast::AttrVec>, |
| } |
| |
| impl PartialEq for UseTree { |
| fn eq(&self, other: &UseTree) -> bool { |
| self.path == other.path |
| } |
| } |
| impl Eq for UseTree {} |
| |
| impl Spanned for UseTree { |
| fn span(&self) -> Span { |
| let lo = if let Some(ref attrs) = self.attrs { |
| attrs.iter().next().map_or(self.span.lo(), |a| a.span.lo()) |
| } else { |
| self.span.lo() |
| }; |
| mk_sp(lo, self.span.hi()) |
| } |
| } |
| |
| impl UseSegment { |
| // Clone a version of self with any top-level alias removed. |
| fn remove_alias(&self) -> UseSegment { |
| let kind = match self.kind { |
| UseSegmentKind::Ident(ref s, _) => UseSegmentKind::Ident(s.clone(), None), |
| UseSegmentKind::Slf(_) => UseSegmentKind::Slf(None), |
| UseSegmentKind::Super(_) => UseSegmentKind::Super(None), |
| UseSegmentKind::Crate(_) => UseSegmentKind::Crate(None), |
| _ => return self.clone(), |
| }; |
| UseSegment { |
| kind, |
| version: self.version, |
| } |
| } |
| |
| // Check if self == other with their aliases removed. |
| fn equal_except_alias(&self, other: &Self) -> bool { |
| match (&self.kind, &other.kind) { |
| (UseSegmentKind::Ident(ref s1, _), UseSegmentKind::Ident(ref s2, _)) => s1 == s2, |
| (UseSegmentKind::Slf(_), UseSegmentKind::Slf(_)) |
| | (UseSegmentKind::Super(_), UseSegmentKind::Super(_)) |
| | (UseSegmentKind::Crate(_), UseSegmentKind::Crate(_)) |
| | (UseSegmentKind::Glob, UseSegmentKind::Glob) => true, |
| (UseSegmentKind::List(ref list1), UseSegmentKind::List(ref list2)) => list1 == list2, |
| _ => false, |
| } |
| } |
| |
| fn get_alias(&self) -> Option<&str> { |
| match &self.kind { |
| UseSegmentKind::Ident(_, a) |
| | UseSegmentKind::Slf(a) |
| | UseSegmentKind::Super(a) |
| | UseSegmentKind::Crate(a) => a.as_deref(), |
| _ => None, |
| } |
| } |
| |
| fn from_path_segment( |
| context: &RewriteContext<'_>, |
| path_seg: &ast::PathSegment, |
| modsep: bool, |
| ) -> Option<UseSegment> { |
| let name = rewrite_ident(context, path_seg.ident); |
| if name.is_empty() || name == "{{root}}" { |
| return None; |
| } |
| let kind = match name { |
| "self" => UseSegmentKind::Slf(None), |
| "super" => UseSegmentKind::Super(None), |
| "crate" => UseSegmentKind::Crate(None), |
| _ => { |
| let mod_sep = if modsep { "::" } else { "" }; |
| UseSegmentKind::Ident(format!("{mod_sep}{name}"), None) |
| } |
| }; |
| |
| Some(UseSegment { |
| kind, |
| version: context.config.version(), |
| }) |
| } |
| |
| fn contains_comment(&self) -> bool { |
| if let UseSegmentKind::List(list) = &self.kind { |
| list.iter().any(|subtree| subtree.contains_comment()) |
| } else { |
| false |
| } |
| } |
| } |
| |
| pub(crate) fn normalize_use_trees_with_granularity( |
| use_trees: Vec<UseTree>, |
| import_granularity: ImportGranularity, |
| ) -> Vec<UseTree> { |
| let merge_by = match import_granularity { |
| ImportGranularity::Item => return flatten_use_trees(use_trees, ImportGranularity::Item), |
| ImportGranularity::Preserve => return use_trees, |
| ImportGranularity::Crate => SharedPrefix::Crate, |
| ImportGranularity::Module => SharedPrefix::Module, |
| ImportGranularity::One => SharedPrefix::One, |
| }; |
| |
| let mut result = Vec::with_capacity(use_trees.len()); |
| for use_tree in use_trees { |
| if use_tree.contains_comment() || use_tree.attrs.is_some() { |
| result.push(use_tree); |
| continue; |
| } |
| |
| for mut flattened in use_tree.flatten(import_granularity) { |
| if let Some(tree) = result |
| .iter_mut() |
| .find(|tree| tree.share_prefix(&flattened, merge_by)) |
| { |
| tree.merge(&flattened, merge_by); |
| } else { |
| // If this is the first tree with this prefix, handle potential trailing ::self |
| if merge_by == SharedPrefix::Module { |
| flattened = flattened.nest_trailing_self(); |
| } |
| result.push(flattened); |
| } |
| } |
| } |
| result |
| } |
| |
| fn flatten_use_trees( |
| use_trees: Vec<UseTree>, |
| import_granularity: ImportGranularity, |
| ) -> Vec<UseTree> { |
| // Return non-sorted single occurrence of the use-trees text string; |
| // order is by first occurrence of the use-tree. |
| use_trees |
| .into_iter() |
| .flat_map(|tree| tree.flatten(import_granularity)) |
| .map(UseTree::nest_trailing_self) |
| .unique() |
| .collect() |
| } |
| |
| impl fmt::Debug for UseTree { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| fmt::Display::fmt(self, f) |
| } |
| } |
| |
| impl fmt::Debug for UseSegment { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| fmt::Display::fmt(&self.kind, f) |
| } |
| } |
| |
| impl fmt::Display for UseSegment { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| fmt::Display::fmt(&self.kind, f) |
| } |
| } |
| |
| impl Hash for UseSegment { |
| fn hash<H: Hasher>(&self, state: &mut H) { |
| self.kind.hash(state); |
| } |
| } |
| |
| impl fmt::Debug for UseSegmentKind { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| fmt::Display::fmt(self, f) |
| } |
| } |
| |
| impl fmt::Display for UseSegmentKind { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| match *self { |
| UseSegmentKind::Glob => write!(f, "*"), |
| UseSegmentKind::Ident(ref s, Some(ref alias)) => write!(f, "{s} as {alias}"), |
| UseSegmentKind::Ident(ref s, None) => write!(f, "{s}"), |
| UseSegmentKind::Slf(..) => write!(f, "self"), |
| UseSegmentKind::Super(..) => write!(f, "super"), |
| UseSegmentKind::Crate(..) => write!(f, "crate"), |
| UseSegmentKind::List(ref list) => { |
| write!(f, "{{")?; |
| for (i, item) in list.iter().enumerate() { |
| if i != 0 { |
| write!(f, ", ")?; |
| } |
| write!(f, "{item}")?; |
| } |
| write!(f, "}}") |
| } |
| } |
| } |
| } |
| impl fmt::Display for UseTree { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| for (i, segment) in self.path.iter().enumerate() { |
| if i != 0 { |
| write!(f, "::")?; |
| } |
| write!(f, "{segment}")?; |
| } |
| Ok(()) |
| } |
| } |
| |
| impl UseTree { |
| // Rewrite use tree with `use ` and a trailing `;`. |
| pub(crate) fn rewrite_top_level( |
| &self, |
| context: &RewriteContext<'_>, |
| shape: Shape, |
| ) -> Option<String> { |
| let vis = self.visibility.as_ref().map_or(Cow::from(""), |vis| { |
| crate::utils::format_visibility(context, vis) |
| }); |
| let use_str = self |
| .rewrite(context, shape.offset_left(vis.len())?) |
| .map(|s| { |
| if s.is_empty() { |
| s |
| } else { |
| format!("{}use {};", vis, s) |
| } |
| })?; |
| match self.attrs { |
| Some(ref attrs) if !attrs.is_empty() => { |
| let attr_str = attrs.rewrite(context, shape)?; |
| let lo = attrs.last().as_ref()?.span.hi(); |
| let hi = self.span.lo(); |
| let span = mk_sp(lo, hi); |
| |
| let allow_extend = if attrs.len() == 1 { |
| let line_len = attr_str.len() + 1 + use_str.len(); |
| !attrs.first().unwrap().is_doc_comment() |
| && context.config.inline_attribute_width() >= line_len |
| } else { |
| false |
| }; |
| |
| combine_strs_with_missing_comments( |
| context, |
| &attr_str, |
| &use_str, |
| span, |
| shape, |
| allow_extend, |
| ) |
| } |
| _ => Some(use_str), |
| } |
| } |
| |
| // FIXME: Use correct span? |
| // The given span is essentially incorrect, since we are reconstructing |
| // use-statements. This should not be a problem, though, since we have |
| // already tried to extract comment and observed that there are no comment |
| // around the given use item, and the span will not be used afterward. |
| fn from_path(path: Vec<UseSegment>, span: Span) -> UseTree { |
| UseTree { |
| path, |
| span, |
| list_item: None, |
| visibility: None, |
| attrs: None, |
| } |
| } |
| |
| pub(crate) fn from_ast_with_normalization( |
| context: &RewriteContext<'_>, |
| item: &ast::Item, |
| ) -> Option<UseTree> { |
| match item.kind { |
| ast::ItemKind::Use(ref use_tree) => Some( |
| UseTree::from_ast( |
| context, |
| use_tree, |
| None, |
| Some(item.vis.clone()), |
| Some(item.span.lo()), |
| if item.attrs.is_empty() { |
| None |
| } else { |
| Some(item.attrs.clone()) |
| }, |
| ) |
| .normalize(), |
| ), |
| _ => None, |
| } |
| } |
| |
| fn from_ast( |
| context: &RewriteContext<'_>, |
| a: &ast::UseTree, |
| list_item: Option<ListItem>, |
| visibility: Option<ast::Visibility>, |
| opt_lo: Option<BytePos>, |
| attrs: Option<ast::AttrVec>, |
| ) -> UseTree { |
| let span = if let Some(lo) = opt_lo { |
| mk_sp(lo, a.span.hi()) |
| } else { |
| a.span |
| }; |
| let mut result = UseTree { |
| path: vec![], |
| span, |
| list_item, |
| visibility, |
| attrs, |
| }; |
| |
| let leading_modsep = |
| context.config.edition() >= Edition::Edition2018 && a.prefix.is_global(); |
| |
| let mut modsep = leading_modsep; |
| |
| for p in &a.prefix.segments { |
| if let Some(use_segment) = UseSegment::from_path_segment(context, p, modsep) { |
| result.path.push(use_segment); |
| modsep = false; |
| } |
| } |
| |
| let version = context.config.version(); |
| |
| match a.kind { |
| UseTreeKind::Glob => { |
| // in case of a global path and the glob starts at the root, e.g., "::*" |
| if a.prefix.segments.len() == 1 && leading_modsep { |
| let kind = UseSegmentKind::Ident("".to_owned(), None); |
| result.path.push(UseSegment { kind, version }); |
| } |
| result.path.push(UseSegment { |
| kind: UseSegmentKind::Glob, |
| version, |
| }); |
| } |
| UseTreeKind::Nested(ref list) => { |
| // Extract comments between nested use items. |
| // This needs to be done before sorting use items. |
| let items = itemize_list( |
| context.snippet_provider, |
| list.iter().map(|(tree, _)| tree), |
| "}", |
| ",", |
| |tree| tree.span.lo(), |
| |tree| tree.span.hi(), |
| |_| Some("".to_owned()), // We only need comments for now. |
| context.snippet_provider.span_after(a.span, "{"), |
| a.span.hi(), |
| false, |
| ); |
| |
| // in case of a global path and the nested list starts at the root, |
| // e.g., "::{foo, bar}" |
| if a.prefix.segments.len() == 1 && leading_modsep { |
| let kind = UseSegmentKind::Ident("".to_owned(), None); |
| result.path.push(UseSegment { kind, version }); |
| } |
| let kind = UseSegmentKind::List( |
| list.iter() |
| .zip(items) |
| .map(|(t, list_item)| { |
| Self::from_ast(context, &t.0, Some(list_item), None, None, None) |
| }) |
| .collect(), |
| ); |
| result.path.push(UseSegment { kind, version }); |
| } |
| UseTreeKind::Simple(ref rename) => { |
| // If the path has leading double colons and is composed of only 2 segments, then we |
| // bypass the call to path_to_imported_ident which would get only the ident and |
| // lose the path root, e.g., `that` in `::that`. |
| // The span of `a.prefix` contains the leading colons. |
| let name = if a.prefix.segments.len() == 2 && leading_modsep { |
| context.snippet(a.prefix.span).to_owned() |
| } else { |
| rewrite_ident(context, path_to_imported_ident(&a.prefix)).to_owned() |
| }; |
| let alias = rename.and_then(|ident| { |
| if ident.name == sym::underscore_imports { |
| // 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 kind = match name.as_ref() { |
| "self" => UseSegmentKind::Slf(alias), |
| "super" => UseSegmentKind::Super(alias), |
| "crate" => UseSegmentKind::Crate(alias), |
| _ => UseSegmentKind::Ident(name, alias), |
| }; |
| |
| let segment = UseSegment { kind, version }; |
| |
| // `name` is already in result. |
| result.path.pop(); |
| result.path.push(segment); |
| } |
| } |
| result |
| } |
| |
| // Do the adjustments that rustfmt does elsewhere to use paths. |
| pub(crate) fn normalize(mut self) -> UseTree { |
| let mut last = self.path.pop().expect("Empty use tree?"); |
| // Hack around borrow checker. |
| let mut normalize_sole_list = false; |
| let mut aliased_self = false; |
| |
| // Remove foo::{} or self without attributes. |
| match last.kind { |
| _ if self.attrs.is_some() => (), |
| UseSegmentKind::List(ref list) if list.is_empty() => { |
| self.path = vec![]; |
| return self; |
| } |
| UseSegmentKind::Slf(None) if self.path.is_empty() && self.visibility.is_some() => { |
| self.path = vec![]; |
| return self; |
| } |
| _ => (), |
| } |
| |
| // Normalise foo::self -> foo. |
| if let UseSegmentKind::Slf(None) = last.kind { |
| if !self.path.is_empty() { |
| return self; |
| } |
| } |
| |
| // Normalise foo::self as bar -> foo as bar. |
| if let UseSegmentKind::Slf(_) = last.kind { |
| if let Some(UseSegment { |
| kind: UseSegmentKind::Ident(_, None), |
| .. |
| }) = self.path.last() |
| { |
| aliased_self = true; |
| } |
| } |
| |
| let mut done = false; |
| if aliased_self { |
| match self.path.last_mut() { |
| Some(UseSegment { |
| kind: UseSegmentKind::Ident(_, ref mut old_rename), |
| .. |
| }) => { |
| assert!(old_rename.is_none()); |
| if let UseSegmentKind::Slf(Some(rename)) = last.clone().kind { |
| *old_rename = Some(rename); |
| done = true; |
| } |
| } |
| _ => unreachable!(), |
| } |
| } |
| |
| if done { |
| return self; |
| } |
| |
| // Normalise foo::{bar} -> foo::bar |
| if let UseSegmentKind::List(ref list) = last.kind { |
| if list.len() == 1 && list[0].to_string() != "self" && !list[0].has_comment() { |
| normalize_sole_list = true; |
| } |
| } |
| |
| if normalize_sole_list { |
| match last.kind { |
| UseSegmentKind::List(list) => { |
| for seg in &list[0].path { |
| self.path.push(seg.clone()); |
| } |
| return self.normalize(); |
| } |
| _ => unreachable!(), |
| } |
| } |
| |
| // Recursively normalize elements of a list use (including sorting the list). |
| if let UseSegmentKind::List(list) = last.kind { |
| let mut list = list.into_iter().map(UseTree::normalize).collect::<Vec<_>>(); |
| list.sort(); |
| last = UseSegment { |
| kind: UseSegmentKind::List(list), |
| version: last.version, |
| }; |
| } |
| |
| self.path.push(last); |
| self |
| } |
| |
| fn has_comment(&self) -> bool { |
| self.list_item.as_ref().map_or(false, ListItem::has_comment) |
| } |
| |
| fn contains_comment(&self) -> bool { |
| self.has_comment() || self.path.iter().any(|path| path.contains_comment()) |
| } |
| |
| fn same_visibility(&self, other: &UseTree) -> bool { |
| match (&self.visibility, &other.visibility) { |
| ( |
| Some(ast::Visibility { |
| kind: ast::VisibilityKind::Inherited, |
| .. |
| }), |
| None, |
| ) |
| | ( |
| None, |
| Some(ast::Visibility { |
| kind: ast::VisibilityKind::Inherited, |
| .. |
| }), |
| ) |
| | (None, None) => true, |
| (Some(ref a), Some(ref b)) => is_same_visibility(a, b), |
| _ => false, |
| } |
| } |
| |
| fn share_prefix(&self, other: &UseTree, shared_prefix: SharedPrefix) -> bool { |
| if self.path.is_empty() |
| || other.path.is_empty() |
| || self.attrs.is_some() |
| || self.contains_comment() |
| || !self.same_visibility(other) |
| { |
| false |
| } else { |
| 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] |
| } |
| SharedPrefix::One => true, |
| } |
| } |
| } |
| |
| fn flatten(self, import_granularity: ImportGranularity) -> Vec<UseTree> { |
| if self.path.is_empty() || self.contains_comment() { |
| return vec![self]; |
| } |
| match &self.path.clone().last().unwrap().kind { |
| UseSegmentKind::List(list) => { |
| if list.len() == 1 && list[0].path.len() == 1 { |
| if let UseSegmentKind::Slf(..) = list[0].path[0].kind { |
| return vec![self]; |
| }; |
| } |
| let prefix = &self.path[..self.path.len() - 1]; |
| let mut result = vec![]; |
| for nested_use_tree in list { |
| for flattend in &mut nested_use_tree.clone().flatten(import_granularity) { |
| let mut new_path = prefix.to_vec(); |
| new_path.append(&mut flattend.path); |
| result.push(UseTree { |
| path: new_path, |
| span: self.span, |
| list_item: None, |
| visibility: self.visibility.clone(), |
| // only retain attributes for `ImportGranularity::Item` |
| attrs: match import_granularity { |
| ImportGranularity::Item => self.attrs.clone(), |
| _ => None, |
| }, |
| }); |
| } |
| } |
| |
| result |
| } |
| _ => vec![self], |
| } |
| } |
| |
| fn merge(&mut self, other: &UseTree, merge_by: SharedPrefix) { |
| let mut prefix = 0; |
| for (a, b) in self.path.iter().zip(other.path.iter()) { |
| // only discard the alias at the root of the tree |
| if (prefix == 0 && a.equal_except_alias(b)) || a == b { |
| prefix += 1; |
| } else { |
| break; |
| } |
| } |
| 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); |
| } |
| } |
| |
| /// If this tree ends in `::self`, rewrite it to `::{self}`. |
| fn nest_trailing_self(mut self) -> UseTree { |
| if let Some(UseSegment { |
| kind: UseSegmentKind::Slf(..), |
| .. |
| }) = self.path.last() |
| { |
| let self_segment = self.path.pop().unwrap(); |
| let version = self_segment.version; |
| let kind = UseSegmentKind::List(vec![UseTree::from_path(vec![self_segment], DUMMY_SP)]); |
| self.path.push(UseSegment { kind, version }); |
| } |
| self |
| } |
| } |
| |
| 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.len() != len && b.len() != len { |
| let version = a[len].version; |
| if let UseSegmentKind::List(ref list) = a[len].kind { |
| 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(); |
| let kind = UseSegmentKind::List(list); |
| new_path.push(UseSegment { kind, version }); |
| return Some(new_path); |
| } |
| } else if len == 1 { |
| let (common, rest) = if a.len() == len { |
| (&a[0], &b[1..]) |
| } else { |
| (&b[0], &a[1..]) |
| }; |
| let kind = UseSegmentKind::Slf(common.get_alias().map(ToString::to_string)); |
| let version = a[0].version; |
| let mut list = vec![UseTree::from_path( |
| vec![UseSegment { kind, version }], |
| DUMMY_SP, |
| )]; |
| match rest { |
| [ |
| UseSegment { |
| kind: UseSegmentKind::List(rest_list), |
| .. |
| }, |
| ] => list.extend(rest_list.clone()), |
| _ => list.push(UseTree::from_path(rest.to_vec(), DUMMY_SP)), |
| } |
| return Some(vec![ |
| b[0].clone(), |
| UseSegment { |
| kind: UseSegmentKind::List(list), |
| version, |
| }, |
| ]); |
| } else { |
| len -= 1; |
| } |
| let mut list = vec![ |
| UseTree::from_path(a[len..].to_vec(), DUMMY_SP), |
| UseTree::from_path(b[len..].to_vec(), DUMMY_SP), |
| ]; |
| list.sort(); |
| let mut new_path = b[..len].to_vec(); |
| let kind = UseSegmentKind::List(list); |
| let version = a[0].version; |
| new_path.push(UseSegment { kind, version }); |
| Some(new_path) |
| } |
| |
| fn merge_use_trees_inner(trees: &mut Vec<UseTree>, use_tree: UseTree, merge_by: SharedPrefix) { |
| struct SimilarTree<'a> { |
| similarity: usize, |
| path_len: usize, |
| tree: &'a mut UseTree, |
| } |
| |
| let similar_trees = trees.iter_mut().filter_map(|tree| { |
| if tree.share_prefix(&use_tree, merge_by) { |
| // In the case of `SharedPrefix::One`, `similarity` is used for deciding with which |
| // tree `use_tree` should be merge. |
| // In other cases `similarity` won't be used, so set it to `0` as a dummy value. |
| let similarity = if merge_by == SharedPrefix::One { |
| tree.path |
| .iter() |
| .zip(&use_tree.path) |
| .take_while(|(a, b)| a.equal_except_alias(b)) |
| .count() |
| } else { |
| 0 |
| }; |
| |
| let path_len = tree.path.len(); |
| Some(SimilarTree { |
| similarity, |
| tree, |
| path_len, |
| }) |
| } else { |
| None |
| } |
| }); |
| |
| 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 merge_by == SharedPrefix::One { |
| if let Some(sim_tree) = similar_trees.max_by_key(|tree| tree.similarity) { |
| if sim_tree.similarity > 0 { |
| sim_tree.tree.merge(&use_tree, merge_by); |
| return; |
| } |
| } |
| } else if let Some(sim_tree) = similar_trees.max_by_key(|tree| tree.path_len) { |
| if sim_tree.path_len > 1 { |
| sim_tree.tree.merge(&use_tree, merge_by); |
| return; |
| } |
| } |
| trees.push(use_tree); |
| trees.sort(); |
| } |
| |
| impl Hash for UseTree { |
| fn hash<H: Hasher>(&self, state: &mut H) { |
| self.path.hash(state); |
| } |
| } |
| |
| impl PartialOrd for UseSegment { |
| fn partial_cmp(&self, other: &UseSegment) -> Option<Ordering> { |
| Some(self.cmp(other)) |
| } |
| } |
| impl PartialOrd for UseTree { |
| fn partial_cmp(&self, other: &UseTree) -> Option<Ordering> { |
| Some(self.cmp(other)) |
| } |
| } |
| impl Ord for UseSegment { |
| fn cmp(&self, other: &UseSegment) -> Ordering { |
| use self::UseSegmentKind::*; |
| |
| fn is_upper_snake_case(s: &str) -> bool { |
| s.chars() |
| .all(|c| c.is_uppercase() || c == '_' || c.is_numeric()) |
| } |
| |
| match (&self.kind, &other.kind) { |
| (Slf(ref a), Slf(ref b)) |
| | (Super(ref a), Super(ref b)) |
| | (Crate(ref a), Crate(ref b)) => match (a, b) { |
| (Some(sa), Some(sb)) => { |
| if self.version == Version::Two { |
| sa.trim_start_matches("r#").cmp(sb.trim_start_matches("r#")) |
| } else { |
| a.cmp(b) |
| } |
| } |
| (_, _) => a.cmp(b), |
| }, |
| (Glob, Glob) => Ordering::Equal, |
| (Ident(ref pia, ref aa), Ident(ref pib, ref ab)) => { |
| let (ia, ib) = if self.version == Version::Two { |
| (pia.trim_start_matches("r#"), pib.trim_start_matches("r#")) |
| } else { |
| (pia.as_str(), pib.as_str()) |
| }; |
| // snake_case < CamelCase < UPPER_SNAKE_CASE |
| if ia.starts_with(char::is_uppercase) && ib.starts_with(char::is_lowercase) { |
| return Ordering::Greater; |
| } |
| if ia.starts_with(char::is_lowercase) && ib.starts_with(char::is_uppercase) { |
| return Ordering::Less; |
| } |
| if is_upper_snake_case(ia) && !is_upper_snake_case(ib) { |
| return Ordering::Greater; |
| } |
| if !is_upper_snake_case(ia) && is_upper_snake_case(ib) { |
| return Ordering::Less; |
| } |
| let ident_ord = ia.cmp(ib); |
| if ident_ord != Ordering::Equal { |
| return ident_ord; |
| } |
| match (aa, ab) { |
| (None, Some(_)) => Ordering::Less, |
| (Some(_), None) => Ordering::Greater, |
| (Some(aas), Some(abs)) => { |
| if self.version == Version::Two { |
| aas.trim_start_matches("r#") |
| .cmp(abs.trim_start_matches("r#")) |
| } else { |
| aas.cmp(abs) |
| } |
| } |
| (None, None) => Ordering::Equal, |
| } |
| } |
| (List(ref a), List(ref b)) => { |
| for (a, b) in a.iter().zip(b.iter()) { |
| let ord = a.cmp(b); |
| if ord != Ordering::Equal { |
| return ord; |
| } |
| } |
| |
| a.len().cmp(&b.len()) |
| } |
| (Slf(_), _) => Ordering::Less, |
| (_, Slf(_)) => Ordering::Greater, |
| (Super(_), _) => Ordering::Less, |
| (_, Super(_)) => Ordering::Greater, |
| (Crate(_), _) => Ordering::Less, |
| (_, Crate(_)) => Ordering::Greater, |
| (Ident(..), _) => Ordering::Less, |
| (_, Ident(..)) => Ordering::Greater, |
| (Glob, _) => Ordering::Less, |
| (_, Glob) => Ordering::Greater, |
| } |
| } |
| } |
| impl Ord for UseTree { |
| fn cmp(&self, other: &UseTree) -> Ordering { |
| for (a, b) in self.path.iter().zip(other.path.iter()) { |
| let ord = a.cmp(b); |
| // The comparison without aliases is a hack to avoid situations like |
| // comparing `a::b` to `a as c` - where the latter should be ordered |
| // first since it is shorter. |
| if ord != Ordering::Equal && a.remove_alias().cmp(&b.remove_alias()) != Ordering::Equal |
| { |
| return ord; |
| } |
| } |
| |
| self.path.len().cmp(&other.path.len()) |
| } |
| } |
| |
| fn rewrite_nested_use_tree( |
| context: &RewriteContext<'_>, |
| use_tree_list: &[UseTree], |
| shape: Shape, |
| ) -> Option<String> { |
| let mut list_items = Vec::with_capacity(use_tree_list.len()); |
| let nested_shape = match context.config.imports_indent() { |
| IndentStyle::Block => shape |
| .block_indent(context.config.tab_spaces()) |
| .with_max_width(context.config) |
| .sub_width(1)?, |
| IndentStyle::Visual => shape.visual_indent(0), |
| }; |
| for use_tree in use_tree_list { |
| if let Some(mut list_item) = use_tree.list_item.clone() { |
| list_item.item = use_tree.rewrite(context, nested_shape); |
| list_items.push(list_item); |
| } else { |
| list_items.push(ListItem::from_str(use_tree.rewrite(context, nested_shape)?)); |
| } |
| } |
| let has_nested_list = use_tree_list.iter().any(|use_segment| { |
| use_segment.path.last().map_or(false, |last_segment| { |
| matches!(last_segment.kind, UseSegmentKind::List(..)) |
| }) |
| }); |
| |
| let remaining_width = if has_nested_list { |
| 0 |
| } else { |
| shape.width.saturating_sub(2) |
| }; |
| |
| let tactic = definitive_tactic( |
| &list_items, |
| context.config.imports_layout(), |
| Separator::Comma, |
| remaining_width, |
| ); |
| |
| let ends_with_newline = context.config.imports_indent() == IndentStyle::Block |
| && tactic != DefinitiveListTactic::Horizontal; |
| 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)?; |
| |
| let result = if (list_str.contains('\n') |
| || list_str.len() > remaining_width |
| || tactic == DefinitiveListTactic::Vertical) |
| && context.config.imports_indent() == IndentStyle::Block |
| { |
| format!( |
| "{{\n{}{}\n{}}}", |
| nested_shape.indent.to_string(context.config), |
| list_str, |
| shape.indent.to_string(context.config) |
| ) |
| } else { |
| format!("{{{list_str}}}") |
| }; |
| |
| Some(result) |
| } |
| |
| impl Rewrite for UseSegment { |
| fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> { |
| Some(match self.kind { |
| UseSegmentKind::Ident(ref ident, Some(ref rename)) => { |
| format!("{ident} as {rename}") |
| } |
| UseSegmentKind::Ident(ref ident, None) => ident.clone(), |
| UseSegmentKind::Slf(Some(ref rename)) => format!("self as {rename}"), |
| UseSegmentKind::Slf(None) => "self".to_owned(), |
| UseSegmentKind::Super(Some(ref rename)) => format!("super as {rename}"), |
| UseSegmentKind::Super(None) => "super".to_owned(), |
| UseSegmentKind::Crate(Some(ref rename)) => format!("crate as {rename}"), |
| UseSegmentKind::Crate(None) => "crate".to_owned(), |
| UseSegmentKind::Glob => "*".to_owned(), |
| UseSegmentKind::List(ref use_tree_list) => rewrite_nested_use_tree( |
| context, |
| use_tree_list, |
| // 1 = "{" and "}" |
| shape.offset_left(1)?.sub_width(1)?, |
| )?, |
| }) |
| } |
| } |
| |
| impl Rewrite for UseTree { |
| // This does NOT format attributes and visibility or add a trailing `;`. |
| fn rewrite(&self, context: &RewriteContext<'_>, mut shape: Shape) -> Option<String> { |
| let mut result = String::with_capacity(256); |
| let mut iter = self.path.iter().peekable(); |
| while let Some(segment) = iter.next() { |
| let segment_str = segment.rewrite(context, shape)?; |
| result.push_str(&segment_str); |
| if iter.peek().is_some() { |
| result.push_str("::"); |
| // 2 = "::" |
| shape = shape.offset_left(2 + segment_str.len())?; |
| } |
| } |
| Some(result) |
| } |
| } |
| |
| #[derive(Copy, Clone, Debug, PartialEq, Eq)] |
| enum SharedPrefix { |
| Crate, |
| Module, |
| One, |
| } |
| |
| #[cfg(test)] |
| mod test { |
| use super::*; |
| 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. |
| fn parse_use_tree(s: &str) -> UseTree { |
| use std::iter::Peekable; |
| use std::mem::swap; |
| use std::str::Chars; |
| |
| struct Parser<'a> { |
| input: Peekable<Chars<'a>>, |
| version: Version, |
| } |
| |
| impl<'a> Parser<'a> { |
| fn bump(&mut self) { |
| self.input.next().unwrap(); |
| } |
| |
| fn eat(&mut self, c: char) { |
| assert_eq!(self.input.next().unwrap(), c); |
| } |
| |
| fn push_segment( |
| &self, |
| result: &mut Vec<UseSegment>, |
| buf: &mut String, |
| alias_buf: &mut Option<String>, |
| ) { |
| let version = self.version; |
| if !buf.is_empty() { |
| let mut alias = None; |
| swap(alias_buf, &mut alias); |
| |
| match buf.as_ref() { |
| "self" => { |
| let kind = UseSegmentKind::Slf(alias); |
| result.push(UseSegment { kind, version }); |
| *buf = String::new(); |
| *alias_buf = None; |
| } |
| "super" => { |
| let kind = UseSegmentKind::Super(alias); |
| result.push(UseSegment { kind, version }); |
| *buf = String::new(); |
| *alias_buf = None; |
| } |
| "crate" => { |
| let kind = UseSegmentKind::Crate(alias); |
| result.push(UseSegment { kind, version }); |
| *buf = String::new(); |
| *alias_buf = None; |
| } |
| _ => { |
| let mut name = String::new(); |
| swap(buf, &mut name); |
| let kind = UseSegmentKind::Ident(name, alias); |
| result.push(UseSegment { kind, version }); |
| } |
| } |
| } |
| } |
| |
| fn parse_in_list(&mut self) -> UseTree { |
| let mut result = vec![]; |
| let mut buf = String::new(); |
| let mut alias_buf = None; |
| while let Some(&c) = self.input.peek() { |
| match c { |
| '{' => { |
| assert!(buf.is_empty()); |
| self.bump(); |
| let kind = UseSegmentKind::List(self.parse_list()); |
| result.push(UseSegment { |
| kind, |
| version: self.version, |
| }); |
| self.eat('}'); |
| } |
| '*' => { |
| assert!(buf.is_empty()); |
| self.bump(); |
| let kind = UseSegmentKind::Glob; |
| result.push(UseSegment { |
| kind, |
| version: self.version, |
| }); |
| } |
| ':' => { |
| self.bump(); |
| self.eat(':'); |
| self.push_segment(&mut result, &mut buf, &mut alias_buf); |
| } |
| '}' | ',' => { |
| self.push_segment(&mut result, &mut buf, &mut alias_buf); |
| return UseTree { |
| path: result, |
| span: DUMMY_SP, |
| list_item: None, |
| visibility: None, |
| attrs: None, |
| }; |
| } |
| ' ' => { |
| self.bump(); |
| self.eat('a'); |
| self.eat('s'); |
| self.eat(' '); |
| alias_buf = Some(String::new()); |
| } |
| c => { |
| self.bump(); |
| if let Some(ref mut buf) = alias_buf { |
| buf.push(c); |
| } else { |
| buf.push(c); |
| } |
| } |
| } |
| } |
| self.push_segment(&mut result, &mut buf, &mut alias_buf); |
| UseTree { |
| path: result, |
| span: DUMMY_SP, |
| list_item: None, |
| visibility: None, |
| attrs: None, |
| } |
| } |
| |
| fn parse_list(&mut self) -> Vec<UseTree> { |
| let mut result = vec![]; |
| loop { |
| match self.input.peek().unwrap() { |
| ',' | ' ' => self.bump(), |
| '}' => { |
| return result; |
| } |
| _ => result.push(self.parse_in_list()), |
| } |
| } |
| } |
| } |
| |
| let mut parser = Parser { |
| input: s.chars().peekable(), |
| version: Version::One, |
| }; |
| parser.parse_in_list() |
| } |
| |
| macro_rules! parse_use_trees { |
| ($($s:expr),* $(,)*) => { |
| vec![ |
| $(parse_use_tree($s),)* |
| ] |
| } |
| } |
| |
| macro_rules! test_merge { |
| ($by:ident, [$($input:expr),* $(,)*], [$($output:expr),* $(,)*]) => { |
| assert_eq!( |
| normalize_use_trees_with_granularity( |
| parse_use_trees!($($input,)*), |
| ImportGranularity::$by, |
| ), |
| parse_use_trees!($($output,)*), |
| ); |
| } |
| } |
| |
| #[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_use_tree_merge_one() { |
| test_merge!(One, ["a", "b"], ["{a, b}"]); |
| |
| test_merge!(One, ["a::{aa, ab}", "b", "a"], ["{a::{self, aa, ab}, b}"]); |
| |
| test_merge!(One, ["a as x", "b as y"], ["{a as x, b as y}"]); |
| |
| test_merge!( |
| One, |
| ["a::{aa as xa, ab}", "b", "a"], |
| ["{a::{self, aa as xa, ab}, b}"] |
| ); |
| |
| test_merge!( |
| One, |
| ["a", "a::{aa, ab::{aba, abb}}"], |
| ["a::{self, aa, ab::{aba, abb}}"] |
| ); |
| |
| test_merge!(One, ["a", "b::{ba, *}"], ["{a, b::{ba, *}}"]); |
| |
| test_merge!(One, ["a", "b", "a::aa"], ["{a::{self, aa}, b}"]); |
| |
| test_merge!( |
| One, |
| ["a::aa::aaa", "a::ac::aca", "a::aa::*"], |
| ["a::{aa::{aaa, *}, ac::aca}"] |
| ); |
| |
| test_merge!( |
| One, |
| ["a", "b::{ba, bb}", "a::{aa::*, ab::aba}"], |
| ["{a::{self, aa::*, ab::aba}, b::{ba, bb}}"] |
| ); |
| |
| test_merge!( |
| One, |
| ["b", "a::ac::{aca, acb}", "a::{aa::*, ab}"], |
| ["{a::{aa::*, ab, ac::{aca, acb}}, b}"] |
| ); |
| } |
| |
| #[test] |
| fn test_flatten_use_trees() { |
| assert_eq!( |
| flatten_use_trees( |
| parse_use_trees!["foo::{a::{b, c}, d::e}"], |
| ImportGranularity::Item |
| ), |
| 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::*}"], |
| ImportGranularity::Item |
| ), |
| parse_use_trees![ |
| "foo::{self}", |
| "foo::a", |
| "foo::b::c", |
| "foo::b::d", |
| "foo::e::*" |
| ] |
| ); |
| } |
| |
| #[test] |
| fn test_use_tree_flatten() { |
| assert_eq!( |
| parse_use_tree("a::b::{c, d, e, f}").flatten(ImportGranularity::Item), |
| parse_use_trees!("a::b::c", "a::b::d", "a::b::e", "a::b::f",) |
| ); |
| |
| assert_eq!( |
| parse_use_tree("a::b::{c::{d, e, f}, g, h::{i, j, k}}") |
| .flatten(ImportGranularity::Item), |
| parse_use_trees![ |
| "a::b::c::d", |
| "a::b::c::e", |
| "a::b::c::f", |
| "a::b::g", |
| "a::b::h::i", |
| "a::b::h::j", |
| "a::b::h::k", |
| ] |
| ); |
| } |
| |
| #[test] |
| fn test_use_tree_normalize() { |
| assert_eq!(parse_use_tree("a::self").normalize(), parse_use_tree("a")); |
| assert_eq!( |
| parse_use_tree("a::self as foo").normalize(), |
| parse_use_tree("a as foo") |
| ); |
| assert_eq!( |
| parse_use_tree("a::{self}").normalize(), |
| parse_use_tree("a::{self}") |
| ); |
| assert_eq!(parse_use_tree("a::{b}").normalize(), parse_use_tree("a::b")); |
| assert_eq!( |
| parse_use_tree("a::{b, c::self}").normalize(), |
| parse_use_tree("a::{b, c}") |
| ); |
| assert_eq!( |
| parse_use_tree("a::{b as bar, c::self}").normalize(), |
| parse_use_tree("a::{b as bar, c}") |
| ); |
| } |
| |
| #[test] |
| fn test_use_tree_ord() { |
| assert!(parse_use_tree("a").normalize() < parse_use_tree("aa").normalize()); |
| assert!(parse_use_tree("a").normalize() < parse_use_tree("a::a").normalize()); |
| assert!(parse_use_tree("a").normalize() < parse_use_tree("*").normalize()); |
| assert!(parse_use_tree("a").normalize() < parse_use_tree("{a, b}").normalize()); |
| assert!(parse_use_tree("*").normalize() < parse_use_tree("{a, b}").normalize()); |
| |
| assert!( |
| parse_use_tree("aaaaaaaaaaaaaaa::{bb, cc, dddddddd}").normalize() |
| < parse_use_tree("aaaaaaaaaaaaaaa::{bb, cc, ddddddddd}").normalize() |
| ); |
| assert!( |
| parse_use_tree("serde::de::{Deserialize}").normalize() |
| < parse_use_tree("serde_json").normalize() |
| ); |
| assert!(parse_use_tree("a::b::c").normalize() < parse_use_tree("a::b::*").normalize()); |
| assert!( |
| parse_use_tree("foo::{Bar, Baz}").normalize() |
| < parse_use_tree("{Bar, Baz}").normalize() |
| ); |
| |
| assert!( |
| parse_use_tree("foo::{qux as bar}").normalize() |
| < parse_use_tree("foo::{self as bar}").normalize() |
| ); |
| assert!( |
| parse_use_tree("foo::{qux as bar}").normalize() |
| < parse_use_tree("foo::{baz, qux as bar}").normalize() |
| ); |
| assert!( |
| parse_use_tree("foo::{self as bar, baz}").normalize() |
| < parse_use_tree("foo::{baz, qux as bar}").normalize() |
| ); |
| |
| assert!(parse_use_tree("foo").normalize() < parse_use_tree("Foo").normalize()); |
| assert!(parse_use_tree("foo").normalize() < parse_use_tree("foo::Bar").normalize()); |
| |
| assert!( |
| parse_use_tree("std::cmp::{d, c, b, a}").normalize() |
| < parse_use_tree("std::cmp::{b, e, g, f}").normalize() |
| ); |
| } |
| |
| #[test] |
| fn test_use_tree_nest_trailing_self() { |
| assert_eq!( |
| parse_use_tree("a::b::self").nest_trailing_self(), |
| parse_use_tree("a::b::{self}") |
| ); |
| assert_eq!( |
| parse_use_tree("a::b::c").nest_trailing_self(), |
| parse_use_tree("a::b::c") |
| ); |
| assert_eq!( |
| parse_use_tree("a::b::{c, d}").nest_trailing_self(), |
| parse_use_tree("a::b::{c, d}") |
| ); |
| assert_eq!( |
| parse_use_tree("a::b::{self, c}").nest_trailing_self(), |
| parse_use_tree("a::b::{self, c}") |
| ); |
| } |
| } |
