2 use std::cmp::Ordering;
5 use rustc_ast::ast::{self, UseTreeKind};
8 BytePos, Span, DUMMY_SP,
11 use crate::comment::combine_strs_with_missing_comments;
12 use crate::config::lists::*;
13 use crate::config::ImportGranularity;
14 use crate::config::{Edition, IndentStyle};
16 definitive_tactic, itemize_list, write_list, ListFormatting, ListItem, Separator,
18 use crate::rewrite::{Rewrite, RewriteContext};
19 use crate::shape::Shape;
20 use crate::source_map::SpanUtils;
21 use crate::spanned::Spanned;
22 use crate::utils::{is_same_visibility, mk_sp, rewrite_ident};
23 use crate::visitor::FmtVisitor;
25 /// Returns a name imported by a `use` declaration.
26 /// E.g., returns `Ordering` for `std::cmp::Ordering` and `self` for `std::cmp::self`.
27 pub(crate) fn path_to_imported_ident(path: &ast::Path) -> symbol::Ident {
28 path.segments.last().unwrap().ident
31 impl<'a> FmtVisitor<'a> {
32 pub(crate) fn format_import(&mut self, item: &ast::Item, tree: &ast::UseTree) {
33 let span = item.span();
34 let shape = self.shape();
35 let rw = UseTree::from_ast(
39 Some(item.vis.clone()),
41 Some(item.attrs.clone()),
43 .rewrite_top_level(&self.get_context(), shape);
45 Some(ref s) if s.is_empty() => {
46 // Format up to last newline
47 let prev_span = mk_sp(self.last_pos, source!(self, span).lo());
48 let trimmed_snippet = self.snippet(prev_span).trim_end();
49 let span_end = self.last_pos + BytePos(trimmed_snippet.len() as u32);
50 self.format_missing(span_end);
51 // We have an excessive newline from the removed import.
52 if self.buffer.ends_with('\n') {
54 self.line_number -= 1;
56 self.last_pos = source!(self, span).hi();
59 self.format_missing_with_indent(source!(self, span).lo());
61 self.last_pos = source!(self, span).hi();
64 self.format_missing_with_indent(source!(self, span).lo());
65 self.format_missing(source!(self, span).hi());
71 // Ordering of imports
73 // We order imports by translating to our own representation and then sorting.
74 // The Rust AST data structures are really bad for this. Rustfmt applies a bunch
75 // of normalisations to imports and since we want to sort based on the result
76 // of these (and to maintain idempotence) we must apply the same normalisations
77 // to the data structures for sorting.
79 // We sort `self` and `super` before other imports, then identifier imports,
80 // then glob imports, then lists of imports. We do not take aliases into account
81 // when ordering unless the imports are identical except for the alias (rare in
84 // FIXME(#2531): we should unify the comparison code here with the formatting
85 // code elsewhere since we are essentially string-ifying twice. Furthermore, by
86 // parsing to our own format on comparison, we repeat a lot of work when
89 // FIXME we do a lot of allocation to make our own representation.
90 #[derive(Clone, Eq, PartialEq)]
91 pub(crate) enum UseSegment {
92 Ident(String, Option<String>),
94 Super(Option<String>),
95 Crate(Option<String>),
101 pub(crate) struct UseTree {
102 pub(crate) path: Vec<UseSegment>,
103 pub(crate) span: Span,
104 // Comment information within nested use tree.
105 pub(crate) list_item: Option<ListItem>,
106 // Additional fields for top level use items.
107 // Should we have another struct for top-level use items rather than reusing this?
108 visibility: Option<ast::Visibility>,
109 attrs: Option<Vec<ast::Attribute>>,
112 impl PartialEq for UseTree {
113 fn eq(&self, other: &UseTree) -> bool {
114 self.path == other.path
117 impl Eq for UseTree {}
119 impl Spanned for UseTree {
120 fn span(&self) -> Span {
121 let lo = if let Some(ref attrs) = self.attrs {
122 attrs.iter().next().map_or(self.span.lo(), |a| a.span.lo())
126 mk_sp(lo, self.span.hi())
131 // Clone a version of self with any top-level alias removed.
132 fn remove_alias(&self) -> UseSegment {
134 UseSegment::Ident(ref s, _) => UseSegment::Ident(s.clone(), None),
135 UseSegment::Slf(_) => UseSegment::Slf(None),
136 UseSegment::Super(_) => UseSegment::Super(None),
137 UseSegment::Crate(_) => UseSegment::Crate(None),
142 // Check if self == other with their aliases removed.
143 fn equal_except_alias(&self, other: &Self) -> bool {
144 match (self, other) {
145 (UseSegment::Ident(ref s1, _), UseSegment::Ident(ref s2, _)) => s1 == s2,
146 (UseSegment::Slf(_), UseSegment::Slf(_))
147 | (UseSegment::Super(_), UseSegment::Super(_))
148 | (UseSegment::Crate(_), UseSegment::Crate(_))
149 | (UseSegment::Glob, UseSegment::Glob) => true,
150 (UseSegment::List(ref list1), UseSegment::List(ref list2)) => list1 == list2,
155 fn get_alias(&self) -> Option<&str> {
157 UseSegment::Ident(_, a)
159 | UseSegment::Super(a)
160 | UseSegment::Crate(a) => a.as_deref(),
165 fn from_path_segment(
166 context: &RewriteContext<'_>,
167 path_seg: &ast::PathSegment,
169 ) -> Option<UseSegment> {
170 let name = rewrite_ident(context, path_seg.ident);
171 if name.is_empty() || name == "{{root}}" {
175 "self" => UseSegment::Slf(None),
176 "super" => UseSegment::Super(None),
177 "crate" => UseSegment::Crate(None),
179 let mod_sep = if modsep { "::" } else { "" };
180 UseSegment::Ident(format!("{}{}", mod_sep, name), None)
186 pub(crate) fn normalize_use_trees_with_granularity(
187 use_trees: Vec<UseTree>,
188 import_granularity: ImportGranularity,
190 let merge_by = match import_granularity {
191 ImportGranularity::Item => return flatten_use_trees(use_trees, ImportGranularity::Item),
192 ImportGranularity::Preserve => return use_trees,
193 ImportGranularity::Crate => SharedPrefix::Crate,
194 ImportGranularity::Module => SharedPrefix::Module,
195 ImportGranularity::One => SharedPrefix::One,
198 let mut result = Vec::with_capacity(use_trees.len());
199 for use_tree in use_trees {
200 if use_tree.has_comment() || use_tree.attrs.is_some() {
201 result.push(use_tree);
205 for mut flattened in use_tree.flatten(import_granularity) {
206 if let Some(tree) = result
208 .find(|tree| tree.share_prefix(&flattened, merge_by))
210 tree.merge(&flattened, merge_by);
212 // If this is the first tree with this prefix, handle potential trailing ::self
213 if merge_by == SharedPrefix::Module {
214 flattened = flattened.nest_trailing_self();
216 result.push(flattened);
223 fn flatten_use_trees(
224 use_trees: Vec<UseTree>,
225 import_granularity: ImportGranularity,
229 .flat_map(|tree| tree.flatten(import_granularity))
230 .map(UseTree::nest_trailing_self)
234 impl fmt::Debug for UseTree {
235 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
236 fmt::Display::fmt(self, f)
240 impl fmt::Debug for UseSegment {
241 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
242 fmt::Display::fmt(self, f)
246 impl fmt::Display for UseSegment {
247 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
249 UseSegment::Glob => write!(f, "*"),
250 UseSegment::Ident(ref s, Some(ref alias)) => write!(f, "{} as {}", s, alias),
251 UseSegment::Ident(ref s, None) => write!(f, "{}", s),
252 UseSegment::Slf(..) => write!(f, "self"),
253 UseSegment::Super(..) => write!(f, "super"),
254 UseSegment::Crate(..) => write!(f, "crate"),
255 UseSegment::List(ref list) => {
257 for (i, item) in list.iter().enumerate() {
261 write!(f, "{}", item)?;
268 impl fmt::Display for UseTree {
269 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
270 for (i, segment) in self.path.iter().enumerate() {
274 write!(f, "{}", segment)?;
281 // Rewrite use tree with `use ` and a trailing `;`.
282 pub(crate) fn rewrite_top_level(
284 context: &RewriteContext<'_>,
286 ) -> Option<String> {
287 let vis = self.visibility.as_ref().map_or(Cow::from(""), |vis| {
288 crate::utils::format_visibility(context, vis)
291 .rewrite(context, shape.offset_left(vis.len())?)
296 format!("{}use {};", vis, s)
300 Some(ref attrs) if !attrs.is_empty() => {
301 let attr_str = attrs.rewrite(context, shape)?;
302 let lo = attrs.last().as_ref()?.span.hi();
303 let hi = self.span.lo();
304 let span = mk_sp(lo, hi);
306 let allow_extend = if attrs.len() == 1 {
307 let line_len = attr_str.len() + 1 + use_str.len();
308 !attrs.first().unwrap().is_doc_comment()
309 && context.config.inline_attribute_width() >= line_len
314 combine_strs_with_missing_comments(
327 // FIXME: Use correct span?
328 // The given span is essentially incorrect, since we are reconstructing
329 // use-statements. This should not be a problem, though, since we have
330 // already tried to extract comment and observed that there are no comment
331 // around the given use item, and the span will not be used afterward.
332 fn from_path(path: Vec<UseSegment>, span: Span) -> UseTree {
342 pub(crate) fn from_ast_with_normalization(
343 context: &RewriteContext<'_>,
345 ) -> Option<UseTree> {
347 ast::ItemKind::Use(ref use_tree) => Some(
352 Some(item.vis.clone()),
353 Some(item.span.lo()),
354 if item.attrs.is_empty() {
357 Some(item.attrs.clone())
367 context: &RewriteContext<'_>,
369 list_item: Option<ListItem>,
370 visibility: Option<ast::Visibility>,
371 opt_lo: Option<BytePos>,
372 attrs: Option<Vec<ast::Attribute>>,
374 let span = if let Some(lo) = opt_lo {
375 mk_sp(lo, a.span.hi())
379 let mut result = UseTree {
388 context.config.edition() >= Edition::Edition2018 && a.prefix.is_global();
390 let mut modsep = leading_modsep;
392 for p in &a.prefix.segments {
393 if let Some(use_segment) = UseSegment::from_path_segment(context, p, modsep) {
394 result.path.push(use_segment);
400 UseTreeKind::Glob => {
401 // in case of a global path and the glob starts at the root, e.g., "::*"
402 if a.prefix.segments.len() == 1 && leading_modsep {
403 result.path.push(UseSegment::Ident("".to_owned(), None));
405 result.path.push(UseSegment::Glob);
407 UseTreeKind::Nested(ref list) => {
408 // Extract comments between nested use items.
409 // This needs to be done before sorting use items.
410 let items = itemize_list(
411 context.snippet_provider,
412 list.iter().map(|(tree, _)| tree),
415 |tree| tree.span.lo(),
416 |tree| tree.span.hi(),
417 |_| Some("".to_owned()), // We only need comments for now.
418 context.snippet_provider.span_after(a.span, "{"),
423 // in case of a global path and the nested list starts at the root,
424 // e.g., "::{foo, bar}"
425 if a.prefix.segments.len() == 1 && leading_modsep {
426 result.path.push(UseSegment::Ident("".to_owned(), None));
428 result.path.push(UseSegment::List(
431 .map(|(t, list_item)| {
432 Self::from_ast(context, &t.0, Some(list_item), None, None, None)
437 UseTreeKind::Simple(ref rename, ..) => {
438 // If the path has leading double colons and is composed of only 2 segments, then we
439 // bypass the call to path_to_imported_ident which would get only the ident and
440 // lose the path root, e.g., `that` in `::that`.
441 // The span of `a.prefix` contains the leading colons.
442 let name = if a.prefix.segments.len() == 2 && leading_modsep {
443 context.snippet(a.prefix.span).to_owned()
445 rewrite_ident(context, path_to_imported_ident(&a.prefix)).to_owned()
447 let alias = rename.and_then(|ident| {
448 if ident.name == sym::underscore_imports {
451 } else if ident == path_to_imported_ident(&a.prefix) {
454 Some(rewrite_ident(context, ident).to_owned())
457 let segment = match name.as_ref() {
458 "self" => UseSegment::Slf(alias),
459 "super" => UseSegment::Super(alias),
460 "crate" => UseSegment::Crate(alias),
461 _ => UseSegment::Ident(name, alias),
464 // `name` is already in result.
466 result.path.push(segment);
472 // Do the adjustments that rustfmt does elsewhere to use paths.
473 pub(crate) fn normalize(mut self) -> UseTree {
474 let mut last = self.path.pop().expect("Empty use tree?");
475 // Hack around borrow checker.
476 let mut normalize_sole_list = false;
477 let mut aliased_self = false;
479 // Remove foo::{} or self without attributes.
481 _ if self.attrs.is_some() => (),
482 UseSegment::List(ref list) if list.is_empty() => {
486 UseSegment::Slf(None) if self.path.is_empty() && self.visibility.is_some() => {
493 // Normalise foo::self -> foo.
494 if let UseSegment::Slf(None) = last {
495 if !self.path.is_empty() {
500 // Normalise foo::self as bar -> foo as bar.
501 if let UseSegment::Slf(_) = last {
502 if let Some(UseSegment::Ident(_, None)) = self.path.last() {
507 let mut done = false;
509 match self.path.last_mut() {
510 Some(UseSegment::Ident(_, ref mut old_rename)) => {
511 assert!(old_rename.is_none());
512 if let UseSegment::Slf(Some(rename)) = last.clone() {
513 *old_rename = Some(rename);
525 // Normalise foo::{bar} -> foo::bar
526 if let UseSegment::List(ref list) = last {
527 if list.len() == 1 && list[0].to_string() != "self" {
528 normalize_sole_list = true;
532 if normalize_sole_list {
534 UseSegment::List(list) => {
535 for seg in &list[0].path {
536 self.path.push(seg.clone());
538 return self.normalize();
544 // Recursively normalize elements of a list use (including sorting the list).
545 if let UseSegment::List(list) = last {
546 let mut list = list.into_iter().map(UseTree::normalize).collect::<Vec<_>>();
548 last = UseSegment::List(list);
551 self.path.push(last);
555 fn has_comment(&self) -> bool {
556 self.list_item.as_ref().map_or(false, ListItem::has_comment)
559 fn same_visibility(&self, other: &UseTree) -> bool {
560 match (&self.visibility, &other.visibility) {
562 Some(ast::Visibility {
563 kind: ast::VisibilityKind::Inherited,
570 Some(ast::Visibility {
571 kind: ast::VisibilityKind::Inherited,
575 | (None, None) => true,
576 (Some(ref a), Some(ref b)) => is_same_visibility(a, b),
581 fn share_prefix(&self, other: &UseTree, shared_prefix: SharedPrefix) -> bool {
582 if self.path.is_empty()
583 || other.path.is_empty()
584 || self.attrs.is_some()
585 || !self.same_visibility(other)
589 match shared_prefix {
590 SharedPrefix::Crate => self.path[0] == other.path[0],
591 SharedPrefix::Module => {
592 self.path[..self.path.len() - 1] == other.path[..other.path.len() - 1]
594 SharedPrefix::One => true,
599 fn flatten(self, import_granularity: ImportGranularity) -> Vec<UseTree> {
600 if self.path.is_empty() {
603 match self.path.clone().last().unwrap() {
604 UseSegment::List(list) => {
605 if list.len() == 1 && list[0].path.len() == 1 {
606 if let UseSegment::Slf(..) = list[0].path[0] {
610 let prefix = &self.path[..self.path.len() - 1];
611 let mut result = vec![];
612 for nested_use_tree in list {
613 for flattend in &mut nested_use_tree.clone().flatten(import_granularity) {
614 let mut new_path = prefix.to_vec();
615 new_path.append(&mut flattend.path);
616 result.push(UseTree {
620 visibility: self.visibility.clone(),
621 // only retain attributes for `ImportGranularity::Item`
622 attrs: match import_granularity {
623 ImportGranularity::Item => self.attrs.clone(),
636 fn merge(&mut self, other: &UseTree, merge_by: SharedPrefix) {
638 for (a, b) in self.path.iter().zip(other.path.iter()) {
639 // only discard the alias at the root of the tree
640 if (prefix == 0 && a.equal_except_alias(b)) || a == b {
646 if let Some(new_path) = merge_rest(&self.path, &other.path, prefix, merge_by) {
647 self.path = new_path;
648 self.span = self.span.to(other.span);
652 /// If this tree ends in `::self`, rewrite it to `::{self}`.
653 fn nest_trailing_self(mut self) -> UseTree {
654 if let Some(UseSegment::Slf(..)) = self.path.last() {
655 let self_segment = self.path.pop().unwrap();
656 self.path.push(UseSegment::List(vec![UseTree::from_path(
669 merge_by: SharedPrefix,
670 ) -> Option<Vec<UseSegment>> {
671 if a.len() == len && b.len() == len {
674 if a.len() != len && b.len() != len {
675 if let UseSegment::List(ref list) = a[len] {
676 let mut list = list.clone();
677 merge_use_trees_inner(
679 UseTree::from_path(b[len..].to_vec(), DUMMY_SP),
682 let mut new_path = b[..len].to_vec();
683 new_path.push(UseSegment::List(list));
684 return Some(new_path);
687 let (common, rest) = if a.len() == len {
692 let mut list = vec![UseTree::from_path(
693 vec![UseSegment::Slf(common.get_alias().map(ToString::to_string))],
697 [UseSegment::List(rest_list)] => list.extend(rest_list.clone()),
698 _ => list.push(UseTree::from_path(rest.to_vec(), DUMMY_SP)),
700 return Some(vec![b[0].clone(), UseSegment::List(list)]);
705 UseTree::from_path(a[len..].to_vec(), DUMMY_SP),
706 UseTree::from_path(b[len..].to_vec(), DUMMY_SP),
709 let mut new_path = b[..len].to_vec();
710 new_path.push(UseSegment::List(list));
714 fn merge_use_trees_inner(trees: &mut Vec<UseTree>, use_tree: UseTree, merge_by: SharedPrefix) {
715 struct SimilarTree<'a> {
718 tree: &'a mut UseTree,
721 let similar_trees = trees.iter_mut().filter_map(|tree| {
722 if tree.share_prefix(&use_tree, merge_by) {
723 // In the case of `SharedPrefix::One`, `similarity` is used for deciding with which
724 // tree `use_tree` should be merge.
725 // In other cases `similarity` won't be used, so set it to `0` as a dummy value.
726 let similarity = if merge_by == SharedPrefix::One {
730 .take_while(|(a, b)| a.equal_except_alias(b))
736 let path_len = tree.path.len();
747 if use_tree.path.len() == 1 && merge_by == SharedPrefix::Crate {
748 if let Some(tree) = similar_trees.min_by_key(|tree| tree.path_len) {
749 if tree.path_len == 1 {
753 } else if merge_by == SharedPrefix::One {
754 if let Some(sim_tree) = similar_trees.max_by_key(|tree| tree.similarity) {
755 if sim_tree.similarity > 0 {
756 sim_tree.tree.merge(&use_tree, merge_by);
760 } else if let Some(sim_tree) = similar_trees.max_by_key(|tree| tree.path_len) {
761 if sim_tree.path_len > 1 {
762 sim_tree.tree.merge(&use_tree, merge_by);
766 trees.push(use_tree);
770 impl PartialOrd for UseSegment {
771 fn partial_cmp(&self, other: &UseSegment) -> Option<Ordering> {
772 Some(self.cmp(other))
775 impl PartialOrd for UseTree {
776 fn partial_cmp(&self, other: &UseTree) -> Option<Ordering> {
777 Some(self.cmp(other))
780 impl Ord for UseSegment {
781 fn cmp(&self, other: &UseSegment) -> Ordering {
782 use self::UseSegment::*;
784 fn is_upper_snake_case(s: &str) -> bool {
786 .all(|c| c.is_uppercase() || c == '_' || c.is_numeric())
789 match (self, other) {
790 (&Slf(ref a), &Slf(ref b))
791 | (&Super(ref a), &Super(ref b))
792 | (&Crate(ref a), &Crate(ref b)) => a.cmp(b),
793 (&Glob, &Glob) => Ordering::Equal,
794 (&Ident(ref ia, ref aa), &Ident(ref ib, ref ab)) => {
795 // snake_case < CamelCase < UPPER_SNAKE_CASE
796 if ia.starts_with(char::is_uppercase) && ib.starts_with(char::is_lowercase) {
797 return Ordering::Greater;
799 if ia.starts_with(char::is_lowercase) && ib.starts_with(char::is_uppercase) {
800 return Ordering::Less;
802 if is_upper_snake_case(ia) && !is_upper_snake_case(ib) {
803 return Ordering::Greater;
805 if !is_upper_snake_case(ia) && is_upper_snake_case(ib) {
806 return Ordering::Less;
808 let ident_ord = ia.cmp(ib);
809 if ident_ord != Ordering::Equal {
812 if aa.is_none() && ab.is_some() {
813 return Ordering::Less;
815 if aa.is_some() && ab.is_none() {
816 return Ordering::Greater;
820 (&List(ref a), &List(ref b)) => {
821 for (a, b) in a.iter().zip(b.iter()) {
823 if ord != Ordering::Equal {
828 a.len().cmp(&b.len())
830 (&Slf(_), _) => Ordering::Less,
831 (_, &Slf(_)) => Ordering::Greater,
832 (&Super(_), _) => Ordering::Less,
833 (_, &Super(_)) => Ordering::Greater,
834 (&Crate(_), _) => Ordering::Less,
835 (_, &Crate(_)) => Ordering::Greater,
836 (&Ident(..), _) => Ordering::Less,
837 (_, &Ident(..)) => Ordering::Greater,
838 (&Glob, _) => Ordering::Less,
839 (_, &Glob) => Ordering::Greater,
843 impl Ord for UseTree {
844 fn cmp(&self, other: &UseTree) -> Ordering {
845 for (a, b) in self.path.iter().zip(other.path.iter()) {
847 // The comparison without aliases is a hack to avoid situations like
848 // comparing `a::b` to `a as c` - where the latter should be ordered
849 // first since it is shorter.
850 if ord != Ordering::Equal && a.remove_alias().cmp(&b.remove_alias()) != Ordering::Equal
856 self.path.len().cmp(&other.path.len())
860 fn rewrite_nested_use_tree(
861 context: &RewriteContext<'_>,
862 use_tree_list: &[UseTree],
864 ) -> Option<String> {
865 let mut list_items = Vec::with_capacity(use_tree_list.len());
866 let nested_shape = match context.config.imports_indent() {
867 IndentStyle::Block => shape
868 .block_indent(context.config.tab_spaces())
869 .with_max_width(context.config)
871 IndentStyle::Visual => shape.visual_indent(0),
873 for use_tree in use_tree_list {
874 if let Some(mut list_item) = use_tree.list_item.clone() {
875 list_item.item = use_tree.rewrite(context, nested_shape);
876 list_items.push(list_item);
878 list_items.push(ListItem::from_str(use_tree.rewrite(context, nested_shape)?));
881 let has_nested_list = use_tree_list.iter().any(|use_segment| {
882 use_segment.path.last().map_or(false, |last_segment| {
883 matches!(last_segment, UseSegment::List(..))
887 let remaining_width = if has_nested_list {
890 shape.width.saturating_sub(2)
893 let tactic = definitive_tactic(
895 context.config.imports_layout(),
900 let ends_with_newline = context.config.imports_indent() == IndentStyle::Block
901 && tactic != DefinitiveListTactic::Horizontal;
902 let trailing_separator = if ends_with_newline {
903 context.config.trailing_comma()
905 SeparatorTactic::Never
907 let fmt = ListFormatting::new(nested_shape, context.config)
909 .trailing_separator(trailing_separator)
910 .ends_with_newline(ends_with_newline)
911 .preserve_newline(true)
912 .nested(has_nested_list);
914 let list_str = write_list(&list_items, &fmt)?;
916 let result = if (list_str.contains('\n') || list_str.len() > remaining_width)
917 && context.config.imports_indent() == IndentStyle::Block
921 nested_shape.indent.to_string(context.config),
923 shape.indent.to_string(context.config)
926 format!("{{{}}}", list_str)
932 impl Rewrite for UseSegment {
933 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
935 UseSegment::Ident(ref ident, Some(ref rename)) => format!("{} as {}", ident, rename),
936 UseSegment::Ident(ref ident, None) => ident.clone(),
937 UseSegment::Slf(Some(ref rename)) => format!("self as {}", rename),
938 UseSegment::Slf(None) => "self".to_owned(),
939 UseSegment::Super(Some(ref rename)) => format!("super as {}", rename),
940 UseSegment::Super(None) => "super".to_owned(),
941 UseSegment::Crate(Some(ref rename)) => format!("crate as {}", rename),
942 UseSegment::Crate(None) => "crate".to_owned(),
943 UseSegment::Glob => "*".to_owned(),
944 UseSegment::List(ref use_tree_list) => rewrite_nested_use_tree(
948 shape.offset_left(1)?.sub_width(1)?,
954 impl Rewrite for UseTree {
955 // This does NOT format attributes and visibility or add a trailing `;`.
956 fn rewrite(&self, context: &RewriteContext<'_>, mut shape: Shape) -> Option<String> {
957 let mut result = String::with_capacity(256);
958 let mut iter = self.path.iter().peekable();
959 while let Some(segment) = iter.next() {
960 let segment_str = segment.rewrite(context, shape)?;
961 result.push_str(&segment_str);
962 if iter.peek().is_some() {
963 result.push_str("::");
965 shape = shape.offset_left(2 + segment_str.len())?;
972 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
982 use rustc_span::DUMMY_SP;
984 // Parse the path part of an import. This parser is not robust and is only
985 // suitable for use in a test harness.
986 fn parse_use_tree(s: &str) -> UseTree {
987 use std::iter::Peekable;
992 input: Peekable<Chars<'a>>,
995 impl<'a> Parser<'a> {
997 self.input.next().unwrap();
1000 fn eat(&mut self, c: char) {
1001 assert_eq!(self.input.next().unwrap(), c);
1005 result: &mut Vec<UseSegment>,
1007 alias_buf: &mut Option<String>,
1009 if !buf.is_empty() {
1010 let mut alias = None;
1011 swap(alias_buf, &mut alias);
1013 match buf.as_ref() {
1015 result.push(UseSegment::Slf(alias));
1016 *buf = String::new();
1020 result.push(UseSegment::Super(alias));
1021 *buf = String::new();
1025 result.push(UseSegment::Crate(alias));
1026 *buf = String::new();
1030 let mut name = String::new();
1031 swap(buf, &mut name);
1032 result.push(UseSegment::Ident(name, alias));
1038 fn parse_in_list(&mut self) -> UseTree {
1039 let mut result = vec![];
1040 let mut buf = String::new();
1041 let mut alias_buf = None;
1042 while let Some(&c) = self.input.peek() {
1045 assert!(buf.is_empty());
1047 result.push(UseSegment::List(self.parse_list()));
1051 assert!(buf.is_empty());
1053 result.push(UseSegment::Glob);
1058 Self::push_segment(&mut result, &mut buf, &mut alias_buf);
1061 Self::push_segment(&mut result, &mut buf, &mut alias_buf);
1075 alias_buf = Some(String::new());
1079 if let Some(ref mut buf) = alias_buf {
1087 Self::push_segment(&mut result, &mut buf, &mut alias_buf);
1097 fn parse_list(&mut self) -> Vec<UseTree> {
1098 let mut result = vec![];
1100 match self.input.peek().unwrap() {
1101 ',' | ' ' => self.bump(),
1105 _ => result.push(self.parse_in_list()),
1111 let mut parser = Parser {
1112 input: s.chars().peekable(),
1114 parser.parse_in_list()
1117 macro_rules! parse_use_trees {
1118 ($($s:expr),* $(,)*) => {
1120 $(parse_use_tree($s),)*
1125 macro_rules! test_merge {
1126 ($by:ident, [$($input:expr),* $(,)*], [$($output:expr),* $(,)*]) => {
1128 normalize_use_trees_with_granularity(
1129 parse_use_trees!($($input,)*),
1130 ImportGranularity::$by,
1132 parse_use_trees!($($output,)*),
1138 fn test_use_tree_merge_crate() {
1141 ["a::b::{c, d}", "a::b::{e, f}"],
1142 ["a::b::{c, d, e, f}"]
1144 test_merge!(Crate, ["a::b::c", "a::b"], ["a::{b, b::c}"]);
1145 test_merge!(Crate, ["a::b", "a::b"], ["a::b"]);
1146 test_merge!(Crate, ["a", "a::b", "a::b::c"], ["a::{self, b, b::c}"]);
1149 ["a", "a::b", "a::b::c", "a::b::c::d"],
1150 ["a::{self, b, b::{c, c::d}}"]
1154 ["a", "a::b", "a::b::c", "a::b"],
1155 ["a::{self, b, b::c}"]
1159 ["a::{b::{self, c}, d::e}", "a::d::f"],
1160 ["a::{b::{self, c}, d::{e, f}}"]
1164 ["a::d::f", "a::{b::{self, c}, d::e}"],
1165 ["a::{b::{self, c}, d::{e, f}}"]
1169 ["a::{c, d, b}", "a::{d, e, b, a, f}", "a::{f, g, c}"],
1170 ["a::{a, b, c, d, e, f, g}"]
1174 ["a::{self}", "b::{self as foo}"],
1175 ["a::{self}", "b::{self as foo}"]
1180 fn test_use_tree_merge_module() {
1183 ["foo::b", "foo::{a, c, d::e}"],
1184 ["foo::{a, b, c}", "foo::d::e"]
1189 ["foo::{a::b, a::c, d::e, d::f}"],
1190 ["foo::a::{b, c}", "foo::d::{e, f}"]
1195 fn test_use_tree_merge_one() {
1196 test_merge!(One, ["a", "b"], ["{a, b}"]);
1198 test_merge!(One, ["a::{aa, ab}", "b", "a"], ["{a::{self, aa, ab}, b}"]);
1200 test_merge!(One, ["a as x", "b as y"], ["{a as x, b as y}"]);
1204 ["a::{aa as xa, ab}", "b", "a"],
1205 ["{a::{self, aa as xa, ab}, b}"]
1210 ["a", "a::{aa, ab::{aba, abb}}"],
1211 ["a::{self, aa, ab::{aba, abb}}"]
1214 test_merge!(One, ["a", "b::{ba, *}"], ["{a, b::{ba, *}}"]);
1216 test_merge!(One, ["a", "b", "a::aa"], ["{a::{self, aa}, b}"]);
1220 ["a::aa::aaa", "a::ac::aca", "a::aa::*"],
1221 ["a::{aa::{aaa, *}, ac::aca}"]
1226 ["a", "b::{ba, bb}", "a::{aa::*, ab::aba}"],
1227 ["{a::{self, aa::*, ab::aba}, b::{ba, bb}}"]
1232 ["b", "a::ac::{aca, acb}", "a::{aa::*, ab}"],
1233 ["{a::{aa::*, ab, ac::{aca, acb}}, b}"]
1238 fn test_flatten_use_trees() {
1241 parse_use_trees!["foo::{a::{b, c}, d::e}"],
1242 ImportGranularity::Item
1244 parse_use_trees!["foo::a::b", "foo::a::c", "foo::d::e"]
1249 parse_use_trees!["foo::{self, a, b::{c, d}, e::*}"],
1250 ImportGranularity::Item
1263 fn test_use_tree_flatten() {
1265 parse_use_tree("a::b::{c, d, e, f}").flatten(ImportGranularity::Item),
1266 parse_use_trees!("a::b::c", "a::b::d", "a::b::e", "a::b::f",)
1270 parse_use_tree("a::b::{c::{d, e, f}, g, h::{i, j, k}}")
1271 .flatten(ImportGranularity::Item),
1285 fn test_use_tree_normalize() {
1286 assert_eq!(parse_use_tree("a::self").normalize(), parse_use_tree("a"));
1288 parse_use_tree("a::self as foo").normalize(),
1289 parse_use_tree("a as foo")
1292 parse_use_tree("a::{self}").normalize(),
1293 parse_use_tree("a::{self}")
1295 assert_eq!(parse_use_tree("a::{b}").normalize(), parse_use_tree("a::b"));
1297 parse_use_tree("a::{b, c::self}").normalize(),
1298 parse_use_tree("a::{b, c}")
1301 parse_use_tree("a::{b as bar, c::self}").normalize(),
1302 parse_use_tree("a::{b as bar, c}")
1307 fn test_use_tree_ord() {
1308 assert!(parse_use_tree("a").normalize() < parse_use_tree("aa").normalize());
1309 assert!(parse_use_tree("a").normalize() < parse_use_tree("a::a").normalize());
1310 assert!(parse_use_tree("a").normalize() < parse_use_tree("*").normalize());
1311 assert!(parse_use_tree("a").normalize() < parse_use_tree("{a, b}").normalize());
1312 assert!(parse_use_tree("*").normalize() < parse_use_tree("{a, b}").normalize());
1315 parse_use_tree("aaaaaaaaaaaaaaa::{bb, cc, dddddddd}").normalize()
1316 < parse_use_tree("aaaaaaaaaaaaaaa::{bb, cc, ddddddddd}").normalize()
1319 parse_use_tree("serde::de::{Deserialize}").normalize()
1320 < parse_use_tree("serde_json").normalize()
1322 assert!(parse_use_tree("a::b::c").normalize() < parse_use_tree("a::b::*").normalize());
1324 parse_use_tree("foo::{Bar, Baz}").normalize()
1325 < parse_use_tree("{Bar, Baz}").normalize()
1329 parse_use_tree("foo::{qux as bar}").normalize()
1330 < parse_use_tree("foo::{self as bar}").normalize()
1333 parse_use_tree("foo::{qux as bar}").normalize()
1334 < parse_use_tree("foo::{baz, qux as bar}").normalize()
1337 parse_use_tree("foo::{self as bar, baz}").normalize()
1338 < parse_use_tree("foo::{baz, qux as bar}").normalize()
1341 assert!(parse_use_tree("foo").normalize() < parse_use_tree("Foo").normalize());
1342 assert!(parse_use_tree("foo").normalize() < parse_use_tree("foo::Bar").normalize());
1345 parse_use_tree("std::cmp::{d, c, b, a}").normalize()
1346 < parse_use_tree("std::cmp::{b, e, g, f}").normalize()
1351 fn test_use_tree_nest_trailing_self() {
1353 parse_use_tree("a::b::self").nest_trailing_self(),
1354 parse_use_tree("a::b::{self}")
1357 parse_use_tree("a::b::c").nest_trailing_self(),
1358 parse_use_tree("a::b::c")
1361 parse_use_tree("a::b::{c, d}").nest_trailing_self(),
1362 parse_use_tree("a::b::{c, d}")
1365 parse_use_tree("a::b::{self, c}").nest_trailing_self(),
1366 parse_use_tree("a::b::{self, c}")