Merge pull request #3144 from otavio/issues-3143

[rust.git] / src / types.rs

diff --git a/src/types.rs b/src/types.rs
index dd7f60a60b4fd671f9f7fffdee1835333613d625..f1d89ab9aedda268563f50e81389ae4bb5b6ec40 100644 (file)
--- a/src/types.rs
+++ b/src/types.rs
@@ -17,7 +17,7 @@
 use syntax::symbol::keywords;
 
 use config::{IndentStyle, TypeDensity};
-use expr::{rewrite_assign_rhs, rewrite_tuple, rewrite_unary_prefix, ToExpr};
+use expr::{rewrite_assign_rhs, rewrite_tuple, rewrite_unary_prefix};
 use lists::{definitive_tactic, itemize_list, write_list, ListFormatting, Separator};
 use macros::{rewrite_macro, MacroPosition};
 use overflow;
@@ -141,7 +141,7 @@ fn rewrite_path_segments<'a, I>(
 }
 
 #[derive(Debug)]
-enum SegmentParam<'a> {
+pub enum SegmentParam<'a> {
     LifeTime(&'a ast::Lifetime),
     Type(&'a ast::Ty),
     Binding(&'a ast::TypeBinding),
@@ -166,19 +166,6 @@ fn span(&self) -> Span {
     }
 }
 
-impl<'a> ToExpr for SegmentParam<'a> {
-    fn to_expr(&self) -> Option<&ast::Expr> {
-        None
-    }
-
-    fn can_be_overflowed(&self, context: &RewriteContext, len: usize) -> bool {
-        match *self {
-            SegmentParam::Type(ty) => ty.can_be_overflowed(context, len),
-            _ => false,
-        }
-    }
-}
-
 impl<'a> Rewrite for SegmentParam<'a> {
     fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
         match *self {
@@ -242,7 +229,9 @@ fn rewrite_segment(
                     .chain(data.bindings.iter().map(|x| SegmentParam::Binding(&*x)))
                     .collect::<Vec<_>>();
 
-                let separator = if path_context == PathContext::Expr {
+                let force_separator =
+                    context.inside_macro() && context.snippet(data.span).starts_with("::");
+                let separator = if path_context == PathContext::Expr || force_separator {
                     "::"
                 } else {
                     ""
@@ -252,7 +241,7 @@ fn rewrite_segment(
                 let generics_str = overflow::rewrite_with_angle_brackets(
                     context,
                     "",
-                    &param_list.iter().map(|e| &*e).collect::<Vec<_>>(),
+                    param_list.iter(),
                     shape,
                     mk_sp(*span_lo, span_hi),
                 )?;
@@ -298,6 +287,8 @@ fn format_function_type<'a, I>(
     <I as Iterator>::Item: Deref,
     <I::Item as Deref>::Target: Rewrite + Spanned + 'a,
 {
+    debug!("format_function_type {:#?}", shape);
+
     // Code for handling variadics is somewhat duplicated for items, but they
     // are different enough to need some serious refactoring to share code.
     enum ArgumentKind<T>
@@ -398,7 +389,7 @@ enum ArgumentKind<T>
             shape.block().indent.to_string_with_newline(context.config),
         )
     };
-    if last_line_width(&args) + first_line_width(&output) <= shape.width {
+    if output.is_empty() || last_line_width(&args) + first_line_width(&output) <= shape.width {
         Some(format!("{}{}", args, output))
     } else {
         Some(format!(
@@ -500,13 +491,15 @@ impl Rewrite for ast::GenericBound {
     fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
         match *self {
             ast::GenericBound::Trait(ref poly_trait_ref, trait_bound_modifier) => {
-                match trait_bound_modifier {
+                let snippet = context.snippet(self.span());
+                let has_paren = snippet.starts_with("(") && snippet.ends_with(")");
+                let rewrite = match trait_bound_modifier {
                     ast::TraitBoundModifier::None => poly_trait_ref.rewrite(context, shape),
-                    ast::TraitBoundModifier::Maybe => {
-                        let rw = poly_trait_ref.rewrite(context, shape.offset_left(1)?)?;
-                        Some(format!("?{}", rw))
-                    }
-                }
+                    ast::TraitBoundModifier::Maybe => poly_trait_ref
+                        .rewrite(context, shape.offset_left(1)?)
+                        .map(|s| format!("?{}", s)),
+                };
+                rewrite.map(|s| if has_paren { format!("({})", s) } else { s })
             }
             ast::GenericBound::Outlives(ref lifetime) => lifetime.rewrite(context, shape),
         }
@@ -519,20 +512,7 @@ fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
             return Some(String::new());
         }
 
-        let span = mk_sp(self.get(0)?.span().lo(), self.last()?.span().hi());
-        let has_paren = context.snippet(span).starts_with("(");
-        let bounds_shape = if has_paren {
-            shape.offset_left(1)?.sub_width(1)?
-        } else {
-            shape
-        };
-        join_bounds(context, bounds_shape, self, true).map(|s| {
-            if has_paren {
-                format!("({})", s)
-            } else {
-                s
-            }
-        })
+        join_bounds(context, shape, self, true)
     }
 }
 
@@ -662,12 +642,9 @@ fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
                 ty.rewrite(context, Shape::legacy(budget, shape.indent + 1))
                     .map(|ty_str| format!("[{}]", ty_str))
             }
-            ast::TyKind::Tup(ref items) => rewrite_tuple(
-                context,
-                &::utils::ptr_vec_to_ref_vec(items),
-                self.span,
-                shape,
-            ),
+            ast::TyKind::Tup(ref items) => {
+                rewrite_tuple(context, items.iter(), self.span, shape, items.len() == 1)
+            }
             ast::TyKind::Path(ref q_self, ref path) => {
                 rewrite_path(context, PathContext::Type, q_self.as_ref(), path, shape)
             }
@@ -706,6 +683,8 @@ fn rewrite_bare_fn(
     context: &RewriteContext,
     shape: Shape,
 ) -> Option<String> {
+    debug!("rewrite_bare_fn {:#?}", shape);
+
     let mut result = String::with_capacity(128);
 
     if let Some(ref lifetime_str) = rewrite_lifetime_param(context, shape, &bare_fn.generic_params)
@@ -728,7 +707,11 @@ fn rewrite_bare_fn(
 
     result.push_str("fn");
 
-    let func_ty_shape = shape.offset_left(result.len())?;
+    let func_ty_shape = if context.use_block_indent() {
+        shape.offset_left(result.len())?
+    } else {
+        shape.visual_indent(result.len()).sub_width(result.len())?
+    };
 
     let rewrite = format_function_type(
         bare_fn.decl.inputs.iter(),
@@ -766,6 +749,8 @@ fn join_bounds(
     items: &[ast::GenericBound],
     need_indent: bool,
 ) -> Option<String> {
+    debug_assert!(!items.is_empty());
+
     // Try to join types in a single line
     let joiner = match context.config.type_punctuation_density() {
         TypeDensity::Compressed => "+",
@@ -836,7 +821,8 @@ fn rewrite_lifetime_param(
         .filter(|p| match p.kind {
             ast::GenericParamKind::Lifetime => true,
             _ => false,
-        }).map(|lt| lt.rewrite(context, shape))
+        })
+        .map(|lt| lt.rewrite(context, shape))
         .collect::<Option<Vec<_>>>()?
         .join(", ");
     if result.is_empty() {