feat: preferHanging - add onlySingleItem option for some config (#472)

Author: Jack Zezula

deployment/schema.json

@@ -240,6 +240,21 @@
         "description": ""
       }]
     },
+    "preferHangingGranular": {
+      "description": "Set to prefer hanging indentation when exceeding the line width instead of making code split up on multiple lines.",
+      "type": "string",
+      "default": "never",
+      "oneOf": [{
+        "const": "always",
+        "description": "Always prefers hanging regardless of the number of elements."
+      }, {
+        "const": "onlySingleItem",
+        "description": "Only prefers hanging if there is a single item."
+      }, {
+        "const": "never",
+        "description": "Never prefers hanging."
+      }]
+    },
     "preferSingleLine": {
       "description": "If code should revert back from being on multiple lines to being on a single line when able.",
       "type": "boolean",
@@ -1137,10 +1152,10 @@
       "$ref": "#/definitions/operatorPosition"
     },
     "arguments.preferHanging": {
-      "$ref": "#/definitions/preferHanging"
+      "$ref": "#/definitions/preferHangingGranular"
     },
     "arrayExpression.preferHanging": {
-      "$ref": "#/definitions/preferHanging"
+      "$ref": "#/definitions/preferHangingGranular"
     },
     "arrayPattern.preferHanging": {
       "$ref": "#/definitions/preferHanging"
@@ -1182,7 +1197,7 @@
       "$ref": "#/definitions/preferHanging"
     },
     "parameters.preferHanging": {
-      "$ref": "#/definitions/preferHanging"
+      "$ref": "#/definitions/preferHangingGranular"
     },
     "sequenceExpression.preferHanging": {
       "$ref": "#/definitions/preferHanging"
@@ -1191,13 +1206,13 @@
       "$ref": "#/definitions/preferHanging"
     },
     "tupleType.preferHanging": {
-      "$ref": "#/definitions/preferHanging"
+      "$ref": "#/definitions/preferHangingGranular"
     },
     "typeLiteral.preferHanging": {
       "$ref": "#/definitions/preferHanging"
     },
     "typeParameters.preferHanging": {
-      "$ref": "#/definitions/preferHanging"
+      "$ref": "#/definitions/preferHangingGranular"
     },
     "unionAndIntersectionType.preferHanging": {
       "$ref": "#/definitions/preferHanging"

src/configuration/builder.rs

@@ -651,12 +651,12 @@ impl ConfigurationBuilder {
 
   /* prefer hanging */
 
-  pub fn arguments_prefer_hanging(&mut self, value: bool) -> &mut Self {
-    self.insert("arguments.preferHanging", value.into())
+  pub fn arguments_prefer_hanging(&mut self, value: PreferHanging) -> &mut Self {
+    self.insert("arguments.preferHanging", value.to_string().into())
   }
 
-  pub fn array_expression_prefer_hanging(&mut self, value: bool) -> &mut Self {
-    self.insert("arrayExpression.preferHanging", value.into())
+  pub fn array_expression_prefer_hanging(&mut self, value: PreferHanging) -> &mut Self {
+    self.insert("arrayExpression.preferHanging", value.to_string().into())
   }
 
   pub fn array_pattern_prefer_hanging(&mut self, value: bool) -> &mut Self {
@@ -711,8 +711,8 @@ impl ConfigurationBuilder {
     self.insert("objectPattern.preferHanging", value.into())
   }
 
-  pub fn parameters_prefer_hanging(&mut self, value: bool) -> &mut Self {
-    self.insert("parameters.preferHanging", value.into())
+  pub fn parameters_prefer_hanging(&mut self, value: PreferHanging) -> &mut Self {
+    self.insert("parameters.preferHanging", value.to_string().into())
   }
 
   pub fn sequence_expression_prefer_hanging(&mut self, value: bool) -> &mut Self {
@@ -723,16 +723,16 @@ impl ConfigurationBuilder {
     self.insert("switchStatement.preferHanging", value.into())
   }
 
-  pub fn tuple_type_prefer_hanging(&mut self, value: bool) -> &mut Self {
-    self.insert("tupleType.preferHanging", value.into())
+  pub fn tuple_type_prefer_hanging(&mut self, value: PreferHanging) -> &mut Self {
+    self.insert("tupleType.preferHanging", value.to_string().into())
   }
 
   pub fn type_literal_prefer_hanging(&mut self, value: bool) -> &mut Self {
     self.insert("typeLiteral.preferHanging", value.into())
   }
 
-  pub fn type_parameters_prefer_hanging(&mut self, value: bool) -> &mut Self {
-    self.insert("typeParameters.preferHanging", value.into())
+  pub fn type_parameters_prefer_hanging(&mut self, value: PreferHanging) -> &mut Self {
+    self.insert("typeParameters.preferHanging", value.to_string().into())
   }
 
   pub fn union_and_intersection_type_prefer_hanging(&mut self, value: bool) -> &mut Self {
@@ -1124,8 +1124,8 @@ mod tests {
       .try_statement_brace_position(BracePosition::NextLine)
       .while_statement_brace_position(BracePosition::NextLine)
       /* prefer hanging */
-      .arguments_prefer_hanging(true)
-      .array_expression_prefer_hanging(true)
+      .arguments_prefer_hanging(PreferHanging::OnlySingleItem)
+      .array_expression_prefer_hanging(PreferHanging::OnlySingleItem)
       .array_pattern_prefer_hanging(true)
       .do_while_statement_prefer_hanging(true)
       .export_declaration_prefer_hanging(true)
@@ -1139,12 +1139,12 @@ mod tests {
       .jsx_attributes_prefer_hanging(true)
       .object_expression_prefer_hanging(true)
       .object_pattern_prefer_hanging(true)
-      .parameters_prefer_hanging(true)
+      .parameters_prefer_hanging(PreferHanging::OnlySingleItem)
       .sequence_expression_prefer_hanging(true)
       .switch_statement_prefer_hanging(true)
-      .tuple_type_prefer_hanging(true)
+      .tuple_type_prefer_hanging(PreferHanging::OnlySingleItem)
       .type_literal_prefer_hanging(true)
-      .type_parameters_prefer_hanging(true)
+      .type_parameters_prefer_hanging(PreferHanging::OnlySingleItem)
       .union_and_intersection_type_prefer_hanging(true)
       .variable_statement_prefer_hanging(true)
       .while_statement_prefer_hanging(true)

src/configuration/resolve_config.rs

@@ -54,6 +54,7 @@ pub fn resolve_config(config: ConfigKeyMap, global_config: &GlobalConfiguration)
   let trailing_commas = get_value(&mut config, "trailingCommas", TrailingCommas::OnlyMultiLine, &mut diagnostics);
   let use_braces = get_value(&mut config, "useBraces", UseBraces::WhenNotSingleLine, &mut diagnostics);
   let prefer_hanging = get_value(&mut config, "preferHanging", false, &mut diagnostics);
+  let prefer_hanging_granular = if prefer_hanging { PreferHanging::Always } else { PreferHanging::Never };
   let prefer_single_line_nullable = get_nullable_value(&mut config, "preferSingleLine", &mut diagnostics);
   let prefer_single_line = prefer_single_line_nullable.unwrap_or(false);
   let space_surrounding_properties = get_value(&mut config, "spaceSurroundingProperties", true, &mut diagnostics);
@@ -145,8 +146,8 @@ pub fn resolve_config(config: ConfigKeyMap, global_config: &GlobalConfiguration)
     try_statement_brace_position: get_value(&mut config, "tryStatement.bracePosition", brace_position, &mut diagnostics),
     while_statement_brace_position: get_value(&mut config, "whileStatement.bracePosition", brace_position, &mut diagnostics),
     /* prefer hanging */
-    arguments_prefer_hanging: get_value(&mut config, "arguments.preferHanging", prefer_hanging, &mut diagnostics),
-    array_expression_prefer_hanging: get_value(&mut config, "arrayExpression.preferHanging", prefer_hanging, &mut diagnostics),
+    arguments_prefer_hanging: get_value(&mut config, "arguments.preferHanging", prefer_hanging_granular, &mut diagnostics),
+    array_expression_prefer_hanging: get_value(&mut config, "arrayExpression.preferHanging", prefer_hanging_granular, &mut diagnostics),
     array_pattern_prefer_hanging: get_value(&mut config, "arrayPattern.preferHanging", prefer_hanging, &mut diagnostics),
     do_while_statement_prefer_hanging: get_value(&mut config, "doWhileStatement.preferHanging", prefer_hanging, &mut diagnostics),
     export_declaration_prefer_hanging: get_value(&mut config, "exportDeclaration.preferHanging", prefer_hanging, &mut diagnostics),
@@ -160,12 +161,12 @@ pub fn resolve_config(config: ConfigKeyMap, global_config: &GlobalConfiguration)
     jsx_attributes_prefer_hanging: get_value(&mut config, "jsxAttributes.preferHanging", prefer_hanging, &mut diagnostics),
     object_expression_prefer_hanging: get_value(&mut config, "objectExpression.preferHanging", prefer_hanging, &mut diagnostics),
     object_pattern_prefer_hanging: get_value(&mut config, "objectPattern.preferHanging", prefer_hanging, &mut diagnostics),
-    parameters_prefer_hanging: get_value(&mut config, "parameters.preferHanging", prefer_hanging, &mut diagnostics),
+    parameters_prefer_hanging: get_value(&mut config, "parameters.preferHanging", prefer_hanging_granular, &mut diagnostics),
     sequence_expression_prefer_hanging: get_value(&mut config, "sequenceExpression.preferHanging", prefer_hanging, &mut diagnostics),
     switch_statement_prefer_hanging: get_value(&mut config, "switchStatement.preferHanging", prefer_hanging, &mut diagnostics),
-    tuple_type_prefer_hanging: get_value(&mut config, "tupleType.preferHanging", prefer_hanging, &mut diagnostics),
+    tuple_type_prefer_hanging: get_value(&mut config, "tupleType.preferHanging", prefer_hanging_granular, &mut diagnostics),
     type_literal_prefer_hanging: get_value(&mut config, "typeLiteral.preferHanging", prefer_hanging, &mut diagnostics),
-    type_parameters_prefer_hanging: get_value(&mut config, "typeParameters.preferHanging", prefer_hanging, &mut diagnostics),
+    type_parameters_prefer_hanging: get_value(&mut config, "typeParameters.preferHanging", prefer_hanging_granular, &mut diagnostics),
     union_and_intersection_type_prefer_hanging: get_value(&mut config, "unionAndIntersectionType.preferHanging", prefer_hanging, &mut diagnostics),
     variable_statement_prefer_hanging: get_value(&mut config, "variableStatement.preferHanging", prefer_hanging, &mut diagnostics),
     while_statement_prefer_hanging: get_value(&mut config, "whileStatement.preferHanging", prefer_hanging, &mut diagnostics),

src/configuration/types.rs

@@ -3,6 +3,20 @@ use dprint_core::generate_str_to_from;
 use serde::Deserialize;
 use serde::Serialize;
 
+#[derive(Clone, PartialEq, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum PreferHanging {
+  /// Always prefer multi-line indentation
+  Never,
+  /// Prefer hanging indentation for sequences with only a single item, but if there are multiple
+  /// items then use multi-line indentation
+  OnlySingleItem,
+  /// Always prefer hanging indentation
+  Always,
+}
+
+generate_str_to_from![PreferHanging, [Never, "never"], [OnlySingleItem, "onlySingleItem"], [Always, "always"]];
+
 /// Semi colon possibilities.
 #[derive(Clone, PartialEq, Copy, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -358,9 +372,9 @@ pub struct Configuration {
   pub while_statement_brace_position: BracePosition,
   /* prefer hanging */
   #[serde(rename = "arguments.preferHanging")]
-  pub arguments_prefer_hanging: bool,
+  pub arguments_prefer_hanging: PreferHanging,
   #[serde(rename = "arrayExpression.preferHanging")]
-  pub array_expression_prefer_hanging: bool,
+  pub array_expression_prefer_hanging: PreferHanging,
   #[serde(rename = "arrayPattern.preferHanging")]
   pub array_pattern_prefer_hanging: bool,
   #[serde(rename = "doWhileStatement.preferHanging")]
@@ -388,17 +402,17 @@ pub struct Configuration {
   #[serde(rename = "objectPattern.preferHanging")]
   pub object_pattern_prefer_hanging: bool,
   #[serde(rename = "parameters.preferHanging")]
-  pub parameters_prefer_hanging: bool,
+  pub parameters_prefer_hanging: PreferHanging,
   #[serde(rename = "sequenceExpression.preferHanging")]
   pub sequence_expression_prefer_hanging: bool,
   #[serde(rename = "switchStatement.preferHanging")]
   pub switch_statement_prefer_hanging: bool,
   #[serde(rename = "tupleType.preferHanging")]
-  pub tuple_type_prefer_hanging: bool,
+  pub tuple_type_prefer_hanging: PreferHanging,
   #[serde(rename = "typeLiteral.preferHanging")]
   pub type_literal_prefer_hanging: bool,
   #[serde(rename = "typeParameters.preferHanging")]
-  pub type_parameters_prefer_hanging: bool,
+  pub type_parameters_prefer_hanging: PreferHanging,
   #[serde(rename = "unionAndIntersectionType.preferHanging")]
   pub union_and_intersection_type_prefer_hanging: bool,
   #[serde(rename = "variableStatement.preferHanging")]

src/generation/generate.rs

@@ -1464,11 +1464,16 @@ fn gen_named_import_or_export_specifiers<'a>(opts: GenNamedImportOrExportSpecifi
 /* expressions */
 
 fn gen_array_expr<'a>(node: &'a ArrayLit, context: &mut Context<'a>) -> PrintItems {
+  let prefer_hanging = match context.config.array_expression_prefer_hanging {
+    PreferHanging::Never => false,
+    PreferHanging::OnlySingleItem => node.elems.len() == 1,
+    PreferHanging::Always => true,
+  };
   gen_array_like_nodes(
     GenArrayLikeNodesOptions {
       node: node.into(),
       nodes: node.elems.iter().map(|&x| x.map(|elem| elem.into())).collect(),
-      prefer_hanging: context.config.array_expression_prefer_hanging,
+      prefer_hanging,
       prefer_single_line: context.config.array_expression_prefer_single_line,
       trailing_commas: context.config.array_expression_trailing_commas,
       space_around: context.config.array_expression_space_around,
@@ -5789,11 +5794,16 @@ fn gen_tpl_lit_type<'a>(node: &'a TsTplLitType, context: &mut Context<'a>) -> Pr
 }
 
 fn gen_tuple_type<'a>(node: &'a TsTupleType, context: &mut Context<'a>) -> PrintItems {
+  let prefer_hanging = match context.config.tuple_type_prefer_hanging {
+    PreferHanging::Never => false,
+    PreferHanging::OnlySingleItem => node.elem_types.len() == 1,
+    PreferHanging::Always => true,
+  };
   gen_array_like_nodes(
     GenArrayLikeNodesOptions {
       node: node.into(),
       nodes: node.elem_types.iter().map(|&x| Some(x.into())).collect(),
-      prefer_hanging: context.config.tuple_type_prefer_hanging,
+      prefer_hanging,
       prefer_single_line: context.config.tuple_type_prefer_single_line,
       trailing_commas: context.config.tuple_type_trailing_commas,
       space_around: context.config.tuple_type_space_around,
@@ -5851,12 +5861,18 @@ fn gen_type_parameters<'a>(node: TypeParamNode<'a>, context: &mut Context<'a>) -
   let params = node.params();
   let force_use_new_lines = get_use_new_lines(&node, &params, context);
   let mut items = PrintItems::new();
+  let prefer_hanging_config = context.config.type_parameters_prefer_hanging;
+  let prefer_hanging = match prefer_hanging_config {
+    PreferHanging::Never => false,
+    PreferHanging::OnlySingleItem => params.len() == 1,
+    PreferHanging::Always => true,
+  };
 
   items.push_str("<");
   items.extend(gen_separated_values(
     GenSeparatedValuesParams {
       nodes: params.into_iter().map(NodeOrSeparator::Node).collect(),
-      prefer_hanging: context.config.type_parameters_prefer_hanging,
+      prefer_hanging,
       force_use_new_lines,
       allow_blank_lines: false,
       separator: get_trailing_commas(&node, context).into(),
@@ -7015,19 +7031,26 @@ fn gen_parameters_or_arguments<'a, F>(opts: GenParametersOrArgumentsOptions<'a,
 where
   F: FnOnce(&mut Context<'a>) -> Option<PrintItems>,
 {
-  let is_parameters = opts.is_parameters;
-  let prefer_single_line = is_parameters && context.config.parameters_prefer_single_line || !is_parameters && context.config.arguments_prefer_single_line;
-  let force_use_new_lines = get_use_new_lines_for_nodes_with_preceeding_token("(", &opts.nodes, prefer_single_line, context);
-  let range = opts.range;
-  let custom_close_paren = opts.custom_close_paren;
-  let first_member_range = opts.nodes.iter().map(|n| n.range()).next();
   let nodes = opts.nodes;
-  let nodes_length = nodes.len();
-  let prefer_hanging = if is_parameters {
+  let is_parameters = opts.is_parameters;
+  let prefer_hanging_config = if is_parameters {
     context.config.parameters_prefer_hanging
   } else {
     context.config.arguments_prefer_hanging
   };
+  let prefer_hanging = match prefer_hanging_config {
+    PreferHanging::Never => false,
+    PreferHanging::OnlySingleItem => only_single_item_and_no_comments(&nodes, context.program),
+    PreferHanging::Always => true,
+  };
+  let prefer_single_item_hanging = prefer_hanging_config == PreferHanging::OnlySingleItem && prefer_hanging;
+  let prefer_single_line = prefer_single_item_hanging
+    || (is_parameters && context.config.parameters_prefer_single_line || !is_parameters && context.config.arguments_prefer_single_line);
+  let force_use_new_lines = get_use_new_lines_for_nodes_with_preceeding_token("(", &nodes, prefer_single_line, context);
+  let range = opts.range;
+  let custom_close_paren = opts.custom_close_paren;
+  let first_member_range = nodes.iter().map(|n| n.range()).next();
+  let nodes_length = nodes.len();
   let space_around = if nodes_length > 0 && is_parameters {
     context.config.parameters_space_around
   } else if nodes_length > 0 {
@@ -7073,7 +7096,11 @@ where
             single_line_space_at_start: space_around,
             single_line_space_at_end: space_around,
             custom_single_line_separator: None,
-            multi_line_options: ir_helpers::MultiLineOptions::surround_newlines_indented(),
+            multi_line_options: if prefer_single_item_hanging {
+              MultiLineOptions::maintain_line_breaks()
+            } else {
+              MultiLineOptions::surround_newlines_indented()
+            },
             force_possible_newline_at_start: is_parameters,
             node_sorter: None,
           },
@@ -7135,6 +7162,22 @@ where
       }
     }
   }
+
+  fn only_single_item_and_no_comments(nodes: &[Node], program: &Program) -> bool {
+    if nodes.len() != 1 {
+      return false;
+    }
+    // check for leading or trailing comments on the only child node
+    let child = nodes[0];
+    if !child.leading_comments_fast(program).is_empty() || !child.trailing_comments_fast(program).is_empty() {
+      return false;
+    }
+    // search after the trailing comma if it exists
+    match child.next_token_fast(program) {
+      Some(TokenAndSpan { token: Token::Comma, span, .. }) => span.trailing_comments_fast(program).is_empty(),
+      _ => true,
+    }
+  }
 }
 
 struct GenCloseParenWithTypeOptions<'a> {
@@ -7217,7 +7260,7 @@ fn gen_close_paren_with_type<'a>(opts: GenCloseParenWithTypeOptions<'a>, context
     fn get_use_new_line_group(param_count: usize, type_node: Node, context: &mut Context) -> bool {
       if param_count == 0 {
         false
-      } else if context.config.parameters_prefer_hanging && param_count > 1 {
+      } else if context.config.parameters_prefer_hanging == PreferHanging::Always && param_count > 1 {
         // This was done to prevent the second argument becoming hanging, which doesn't
         // look good especially when the return type then becomes multi-line.
         match type_node {

tests/specs/declarations/class/method/ClassMethod_PreferHanging_True.txt

@@ -1,4 +1,4 @@
-~~ parameters.preferHanging: true, lineWidth: 50 ~~
+~~ parameters.preferHanging: always, lineWidth: 50 ~~
 == should format the return type on the same line when the rest of the header is hanging ==
 class Test {
     method(param: string, otherTestinginging: string): test | other {

tests/specs/declarations/function/Function_BracePosition_Maintain.txt

@@ -1,4 +1,4 @@
-~~ functionDeclaration.bracePosition: maintain, parameters.preferHanging: true, lineWidth: 30 ~~
+~~ functionDeclaration.bracePosition: maintain, parameters.preferHanging: always, lineWidth: 30 ~~
 == should maintain the position for the brace position when on same line ==
 function t() {
 }

tests/specs/declarations/function/Function_BracePosition_NextLine.txt

@@ -1,4 +1,4 @@
-~~ functionDeclaration.bracePosition: nextLine, parameters.preferHanging: true, lineWidth: 30 ~~
+~~ functionDeclaration.bracePosition: nextLine, parameters.preferHanging: always, lineWidth: 30 ~~
 == should use the next line for the brace position ==
 function t() {
 }

tests/specs/declarations/function/Function_BracePosition_SameLine.txt

@@ -1,4 +1,4 @@
-~~ functionDeclaration.bracePosition: sameLine, parameters.preferHanging: true, lineWidth: 30 ~~
+~~ functionDeclaration.bracePosition: sameLine, parameters.preferHanging: always, lineWidth: 30 ~~
 == should use the same line for the brace position ==
 function t()
 {

tests/specs/declarations/function/Function_CloseBraceOverMaxWidth.txt

@@ -1,4 +1,4 @@
-~~ lineWidth: 80, parameters.preferHanging: true ~~
+~~ lineWidth: 80, parameters.preferHanging: always ~~
 == Brace at 79 ==
 export function test(some, very, long, list, of, params, to, put, brace, over) {
 }