1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
13 use syntax::codemap::{self, BytePos, Span};
14 use codemap::SpanUtils;
15 use lists::{write_list, itemize_list, ListItem, ListFormatting, SeparatorTactic, definitive_tactic};
16 use types::rewrite_path;
17 use rewrite::{Rewrite, RewriteContext};
18 use visitor::FmtVisitor;
19 use std::cmp::Ordering;
21 use syntax::{ast, ptr};
23 fn path_of(a: &ast::ViewPath_) -> &ast::Path {
25 &ast::ViewPath_::ViewPathSimple(_, ref p) => p,
26 &ast::ViewPath_::ViewPathGlob(ref p) => p,
27 &ast::ViewPath_::ViewPathList(ref p, _) => p,
31 fn compare_path_segments(a: &ast::PathSegment, b: &ast::PathSegment) -> Ordering {
32 a.identifier.name.as_str().cmp(&b.identifier.name.as_str())
35 fn compare_paths(a: &ast::Path, b: &ast::Path) -> Ordering {
36 for segment in a.segments.iter().zip(b.segments.iter()) {
37 let ord = compare_path_segments(segment.0, segment.1);
38 if ord != Ordering::Equal {
42 a.segments.len().cmp(&b.segments.len())
45 fn compare_path_list_items(a: &ast::PathListItem, b: &ast::PathListItem) -> Ordering {
46 let name_ordering = match a.node.name() {
49 Some(b_name) => a_name.name.as_str().cmp(&b_name.name.as_str()),
50 None => Ordering::Greater,
55 Some(_) => Ordering::Less,
56 None => Ordering::Equal,
60 if name_ordering == Ordering::Equal {
61 match a.node.rename() {
63 match b.node.rename() {
64 Some(b_rename) => a_rename.name.as_str().cmp(&b_rename.name.as_str()),
65 None => Ordering::Greater,
70 Some(_) => Ordering::Less,
71 None => Ordering::Equal,
80 fn compare_path_list_item_lists(a_items: &Vec<ast::PathListItem>,
81 b_items: &Vec<ast::PathListItem>)
83 let mut a = a_items.clone();
84 let mut b = b_items.clone();
85 a.sort_by(|a, b| compare_path_list_items(a, b));
86 b.sort_by(|a, b| compare_path_list_items(a, b));
87 for comparison_pair in a.iter().zip(b.iter()) {
88 let ord = compare_path_list_items(comparison_pair.0, comparison_pair.1);
89 if ord != Ordering::Equal {
96 fn compare_view_path_types(a: &ast::ViewPath_, b: &ast::ViewPath_) -> Ordering {
97 use syntax::ast::ViewPath_::*;
99 (&ViewPathSimple(..), &ViewPathSimple(..)) => Ordering::Equal,
100 (&ViewPathSimple(..), _) => Ordering::Less,
101 (&ViewPathGlob(_), &ViewPathSimple(..)) => Ordering::Greater,
102 (&ViewPathGlob(_), &ViewPathGlob(_)) => Ordering::Equal,
103 (&ViewPathGlob(_), &ViewPathList(..)) => Ordering::Less,
104 (&ViewPathList(_, ref a_items), &ViewPathList(_, ref b_items)) => {
105 compare_path_list_item_lists(a_items, b_items)
107 (&ViewPathList(..), _) => Ordering::Greater,
111 fn compare_view_paths(a: &ast::ViewPath_, b: &ast::ViewPath_) -> Ordering {
112 match compare_paths(path_of(a), path_of(b)) {
113 Ordering::Equal => compare_view_path_types(a, b),
118 fn compare_use_items(a: &ast::Item, b: &ast::Item) -> Option<Ordering> {
119 match (&a.node, &b.node) {
120 (&ast::ItemKind::Use(ref a_vp), &ast::ItemKind::Use(ref b_vp)) => {
121 Some(compare_view_paths(&a_vp.node, &b_vp.node))
127 // TODO (some day) remove unused imports, expand globs, compress many single
128 // imports into a list import.
130 impl Rewrite for ast::ViewPath {
131 // Returns an empty string when the ViewPath is empty (like foo::bar::{})
132 fn rewrite(&self, context: &RewriteContext, width: usize, offset: Indent) -> Option<String> {
134 ast::ViewPath_::ViewPathList(_, ref path_list) if path_list.is_empty() => {
137 ast::ViewPath_::ViewPathList(ref path, ref path_list) => {
138 rewrite_use_list(width, offset, path, path_list, self.span, context)
140 ast::ViewPath_::ViewPathGlob(_) => {
141 // FIXME convert to list?
144 ast::ViewPath_::ViewPathSimple(ident, ref path) => {
145 let ident_str = ident.to_string();
147 let budget = try_opt!(width.checked_sub(ident_str.len() + 4));
148 let path_str = try_opt!(rewrite_path(context, false, None, path, budget, offset));
150 Some(if path.segments.last().unwrap().identifier == ident {
153 format!("{} as {}", path_str, ident_str)
160 impl<'a> FmtVisitor<'a> {
161 pub fn format_imports(&mut self, use_items: &[ptr::P<ast::Item>]) {
162 let mut last_pos = use_items.first()
163 .and_then(|p_i| p_i.span.lo.0.checked_sub(1))
164 .map(|span_lo| BytePos(span_lo))
165 .unwrap_or(self.last_pos);
166 let prefix = codemap::mk_sp(self.last_pos, last_pos);
167 let mut ordered_use_items = use_items.iter()
169 let new_item = (&*p_i, last_pos);
170 last_pos = p_i.span.hi;
173 .collect::<Vec<_>>();
174 // Order the imports by view-path & other import path properties
175 ordered_use_items.sort_by(|a, b| compare_use_items(a.0, b.0).unwrap());
176 // First, output the span before the first import
177 self.format_missing(prefix.hi);
178 for ordered in ordered_use_items {
179 // Fake out the formatter by setting `self.last_pos` to the appropriate location before
180 // each item before visiting it.
181 self.last_pos = ordered.1;
182 self.visit_item(&ordered.0);
184 self.last_pos = last_pos;
187 pub fn format_import(&mut self, vis: &ast::Visibility, vp: &ast::ViewPath, span: Span) {
188 let vis = utils::format_visibility(vis);
189 let mut offset = self.block_indent;
190 offset.alignment += vis.len() + "use ".len();
192 match vp.rewrite(&self.get_context(),
193 self.config.max_width - offset.width() - 1,
195 Some(ref s) if s.is_empty() => {
196 // Format up to last newline
197 let prev_span = codemap::mk_sp(self.last_pos, source!(self, span).lo);
198 let span_end = match self.snippet(prev_span).rfind('\n') {
199 Some(offset) => self.last_pos + BytePos(offset as u32),
200 None => source!(self, span).lo,
202 self.format_missing(span_end);
203 self.last_pos = source!(self, span).hi;
206 let s = format!("{}use {};", vis, s);
207 self.format_missing_with_indent(source!(self, span).lo);
208 self.buffer.push_str(&s);
209 self.last_pos = source!(self, span).hi;
212 self.format_missing_with_indent(source!(self, span).lo);
213 self.format_missing(source!(self, span).hi);
219 fn rewrite_single_use_list(path_str: Option<String>, vpi: &ast::PathListItem) -> String {
220 let path_item_str = if let ast::PathListItemKind::Ident { name, .. } = vpi.node {
223 Some(path_str) => format!("{}::{}", path_str, name),
224 None => name.to_string(),
229 Some(path_str) => path_str,
230 // This catches the import: use {self}, which is a compiler error, so we just
232 None => "{self}".to_owned(),
236 append_alias(path_item_str, vpi)
239 fn rewrite_path_item(vpi: &&ast::PathListItem) -> Option<String> {
240 let path_item_str = match vpi.node {
241 ast::PathListItemKind::Ident { name, .. } => name.to_string(),
242 ast::PathListItemKind::Mod { .. } => "self".to_owned(),
245 Some(append_alias(path_item_str, vpi))
248 fn append_alias(path_item_str: String, vpi: &ast::PathListItem) -> String {
250 ast::PathListItemKind::Ident { rename: Some(rename), .. } |
251 ast::PathListItemKind::Mod { rename: Some(rename), .. } => {
252 format!("{} as {}", path_item_str, rename)
258 // Pretty prints a multi-item import.
259 // Assumes that path_list.len() > 0.
260 pub fn rewrite_use_list(width: usize,
263 path_list: &[ast::PathListItem],
265 context: &RewriteContext)
267 // Returns a different option to distinguish `::foo` and `foo`
268 let opt_path_str = if !path.to_string().is_empty() {
269 Some(path.to_string())
270 } else if path.global {
271 // path is absolute, we return an empty String to avoid a double `::`
277 match path_list.len() {
279 1 => return Some(rewrite_single_use_list(opt_path_str, &path_list[0])),
284 let path_separation_w = if opt_path_str.is_some() { 2 } else { 0 };
286 let supp_indent = path.to_string().len() + path_separation_w + 1;
288 let remaining_width = width.checked_sub(supp_indent + 1).unwrap_or(0);
291 // Dummy value, see explanation below.
292 let mut items = vec![ListItem::from_str("")];
293 let iter = itemize_list(context.codemap,
299 context.codemap.span_after(span, "{"),
305 // We prefixed the item list with a dummy value so that we can
306 // potentially move "self" to the front of the vector without touching
307 // the rest of the items.
308 let has_self = move_self_to_front(&mut items);
309 let first_index = if has_self { 0 } else { 1 };
311 if context.config.reorder_imported_names {
312 items[1..].sort_by(|a, b| a.item.cmp(&b.item));
315 let tactic = definitive_tactic(&items[first_index..],
316 ::lists::ListTactic::Mixed,
318 let fmt = ListFormatting {
321 trailing_separator: SeparatorTactic::Never,
322 indent: offset + supp_indent,
323 // FIXME This is too conservative, and will not use all width
325 // (loose 1 column (";"))
326 width: remaining_width,
327 ends_with_newline: false,
328 config: context.config,
330 let list_str = try_opt!(write_list(&items[first_index..], &fmt));
332 Some(match opt_path_str {
333 Some(opt_path_str) => format!("{}::{{{}}}", opt_path_str, list_str),
334 None => format!("{{{}}}", list_str),
338 // Returns true when self item was found.
339 fn move_self_to_front(items: &mut Vec<ListItem>) -> bool {
340 match items.iter().position(|item| item.item.as_ref().map(|x| &x[..]) == Some("self")) {
342 items[0] = items.remove(pos);