src/imports.rs

   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.
   4 //
   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.
  10
  11 use visitor::FmtVisitor;
  12 use lists::{write_list, ListFormatting, SeparatorTactic, ListTactic};
  13
  14 use syntax::ast;
  15 use syntax::parse::token;
  16 use syntax::print::pprust;
  17
  18 // TODO (some day) remove unused imports, expand globs, compress many single imports into a list import
  19
  20 fn rewrite_single_use_list(path_str: String, vpi: ast::PathListItem, vis: &str) -> String {
  21     if let ast::PathListItem_::PathListIdent{ name, .. } = vpi.node {
  22         let name_str = token::get_ident(name).to_string();
  23         if path_str.len() == 0 {
  24             format!("{}use {};", vis, name_str)
  25         } else {
  26             format!("{}use {}::{};", vis, path_str, name_str)
  27         }
  28     } else {
  29         if path_str.len() != 0 {
  30             format!("{}use {};", vis, path_str)
  31         } else {
  32             // This catches the import: use {self}, which is a compiler error, so we just
  33             // leave it alone.
  34             format!("{}use {{self}};", vis)
  35         }
  36     }
  37 }
  38
  39 impl<'a> FmtVisitor<'a> {
  40     // Basically just pretty prints a multi-item import.
  41     // Returns None when the import can be removed.
  42     pub fn rewrite_use_list(&mut self,
  43                             block_indent: usize,
  44                             one_line_budget: usize, // excluding indentation
  45                             multi_line_budget: usize,
  46                             path: &ast::Path,
  47                             path_list: &[ast::PathListItem],
  48                             visibility: ast::Visibility) -> Option<String> {
  49         let path_str = pprust::path_to_string(path);
  50
  51         let vis = match visibility {
  52             ast::Public => "pub ",
  53             _ => ""
  54         };
  55
  56         match path_list.len() {
  57             0 => return None,
  58             1 => return Some(rewrite_single_use_list(path_str, path_list[0], vis)),
  59             _ => ()
  60         }
  61
  62         // 2 = ::
  63         let path_separation_w = if path_str.len() > 0 { 2 } else { 0 };
  64         // 5 = "use " + {
  65         let indent = path_str.len() + 5 + path_separation_w + vis.len();
  66
  67         // 2 = } + ;
  68         let used_width = indent + 2;
  69
  70         // Break as early as possible when we've blown our budget.
  71         let remaining_line_budget = if used_width > one_line_budget {
  72             0
  73         } else {
  74             one_line_budget - used_width
  75         };
  76         let remaining_multi_budget = if used_width > multi_line_budget {
  77             0
  78         } else {
  79             multi_line_budget - used_width
  80         };
  81
  82         let fmt = ListFormatting {
  83             tactic: ListTactic::Mixed,
  84             separator: ",",
  85             trailing_separator: SeparatorTactic::Never,
  86             indent: block_indent + indent,
  87             h_width: remaining_line_budget,
  88             v_width: remaining_multi_budget,
  89         };
  90
  91         // TODO handle any comments inbetween items.
  92         // If `self` is in the list, put it first.
  93         let head = if path_list.iter().any(|vpi|
  94             if let ast::PathListItem_::PathListMod{ .. } = vpi.node {
  95                 true
  96             } else {
  97                 false
  98             }
  99         ) {
 100             Some(("self".to_owned(), String::new()))
 101         } else {
 102             None
 103         };
 104
 105         let items: Vec<_> = head.into_iter().chain(path_list.iter().filter_map(|vpi| {
 106             match vpi.node {
 107                 ast::PathListItem_::PathListIdent{ name, .. } => {
 108                     Some((token::get_ident(name).to_string(), String::new()))
 109                 }
 110                 // Skip `self`, because we added it above.
 111                 ast::PathListItem_::PathListMod{ .. } => None,
 112             }
 113         })).collect();
 114         Some(if path_str.len() == 0 {
 115             format!("{}use {{{}}};", vis, write_list(&items, &fmt))
 116         } else {
 117             format!("{}use {}::{{{}}};", vis, path_str, write_list(&items, &fmt))
 118         })
 119     }
 120 }