From dba2d8afd553bd18806c4f674b0d6bcd925cb78e Mon Sep 17 00:00:00 2001
From: Connor Brewster <brewsterc@my.caspercollege.edu>
Date: Mon, 11 Jan 2016 12:26:57 -0700
Subject: [PATCH] Added option for tighter punctuation in types. fixes #489

---
 src/config.rs |  9 +++++++++
 src/types.rs  | 17 +++++++++++++++--
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/src/config.rs b/src/config.rs
index 7e1172e1b9ad..63fb4f760efb 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -73,6 +73,13 @@ configuration_option_enum! { Density:
     CompressedIfEmpty,
 }
 
+configuration_option_enum! { TypeDensity:
+    // No spaces around "=" and "+"
+    Compressed,
+    // Spaces around " = " and " + "
+    WhiteSpace,
+}
+
 impl Density {
     pub fn to_list_tactic(self) -> ListTactic {
         match self {
@@ -278,6 +285,8 @@ create_config! {
     fn_args_density: Density, Density::Tall, "Argument density in functions";
     fn_args_layout: StructLitStyle, StructLitStyle::Visual, "Layout of function arguments";
     fn_arg_indent: BlockIndentStyle, BlockIndentStyle::Visual, "Indent on function arguments";
+    type_punctuation_density: TypeDensity, TypeDensity::WhiteSpace,
+        "Determines if '+' or '=' are wrapped in spaces in the punctuation of types";
     // Should we at least try to put the where clause on the same line as the rest of the
     // function decl?
     where_density: Density, Density::CompressedIfEmpty, "Density of a where clause";
diff --git a/src/types.rs b/src/types.rs
index 82a335c30124..5500cdecfc0a 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -21,6 +21,7 @@ use lists::{format_item_list, itemize_list, format_fn_args};
 use rewrite::{Rewrite, RewriteContext};
 use utils::{extra_offset, span_after, format_mutability, wrap_str};
 use expr::{rewrite_unary_prefix, rewrite_pair, rewrite_tuple};
+use config::TypeDensity;
 
 // Does not wrap on simple segments.
 pub fn rewrite_path(context: &RewriteContext,
@@ -424,7 +425,12 @@ impl Rewrite for ast::TyParam {
             result.push_str(&bounds);
         }
         if let Some(ref def) = self.default {
-            result.push_str(" = ");
+            let eq_str = if context.config.type_punctuation_density == TypeDensity::Compressed {
+                "="
+            } else {
+                " = "
+            };
+            result.push_str(eq_str);
             let budget = try_opt!(width.checked_sub(result.len()));
             let rewrite = try_opt!(def.rewrite(context, budget, offset + result.len()));
             result.push_str(&rewrite);
@@ -467,8 +473,15 @@ impl Rewrite for ast::Ty {
             ast::TyObjectSum(ref ty, ref bounds) => {
                 let ty_str = try_opt!(ty.rewrite(context, width, offset));
                 let overhead = ty_str.len() + 3;
-                Some(format!("{} + {}",
+                let plus_str = if context.config.type_punctuation_density ==
+                                  TypeDensity::Compressed {
+                    "+"
+                } else {
+                    " + "
+                };
+                Some(format!("{}{}{}",
                              ty_str,
+                             plus_str,
                              try_opt!(bounds.rewrite(context,
                                                      try_opt!(width.checked_sub(overhead)),
                                                      offset + overhead))))