Support using a comma as separator in type literals

src/configuration/builder.rs

@@ -386,6 +386,21 @@ impl ConfigurationBuilder {
         self.insert("memberExpression.linePerExpression", value.into())
     }
 
+    /// The kind of separator to use in type literals.
+    pub fn type_literal_separator_kind(&mut self, value: SemiColonsOrCommas) -> &mut Self {
+        self.insert("typeLiteral.separatorKind", value.to_string().into())
+    }
+
+    /// The kind of separator to use in type literals when single line.
+    pub fn type_literal_separator_kind_single_line(&mut self, value: SemiColonsOrCommas) -> &mut Self {
+        self.insert("typeLiteral.separatorKind.singleLine", value.to_string().into())
+    }
+
+    /// The kind of separator to use in type literals when multi-line.
+    pub fn type_literal_separator_kind_multi_line(&mut self, value: SemiColonsOrCommas) -> &mut Self {
+        self.insert("typeLiteral.separatorKind.multiLine", value.to_string().into())
+    }
+
     /* ignore comments */
 
     /// The text to use for an ignore comment (ex. `// dprint-ignore`).
@@ -676,6 +691,11 @@ impl ConfigurationBuilder {
         self.insert("tupleType.trailingCommas", value.to_string().into())
     }
 
+    /// Only applies when using commas on type literals.
+    pub fn type_literal_trailing_commas(&mut self, value: TrailingCommas) -> &mut Self {
+        self.insert("typeLiteral.trailingCommas", value.to_string().into())
+    }
+
     pub fn type_parameters_trailing_commas(&mut self, value: TrailingCommas) -> &mut Self {
         self.insert("typeParameters.trailingCommas", value.to_string().into())
     }
@@ -836,6 +856,9 @@ mod tests {
             .arrow_function_use_parentheses(UseParentheses::Maintain)
             .binary_expression_line_per_expression(false)
             .member_expression_line_per_expression(false)
+            .type_literal_separator_kind(SemiColonsOrCommas::Commas)
+            .type_literal_separator_kind_single_line(SemiColonsOrCommas::Commas)
+            .type_literal_separator_kind_multi_line(SemiColonsOrCommas::Commas)
             /* ignore comments */
             .ignore_node_comment_text("ignore")
             .ignore_file_comment_text("ignore-file")
@@ -912,6 +935,7 @@ mod tests {
             .object_pattern_trailing_commas(TrailingCommas::Never)
             .type_parameters_trailing_commas(TrailingCommas::Never)
             .tuple_type_trailing_commas(TrailingCommas::Never)
+            .type_literal_trailing_commas(TrailingCommas::Never)
             /* use braces */
             .if_statement_use_braces(UseBraces::Always)
             .for_statement_use_braces(UseBraces::Always)
@@ -970,7 +994,7 @@ mod tests {
             .while_statement_space_after_while_keyword(true);
 
         let inner_config = config.get_inner_config();
-        assert_eq!(inner_config.len(), 137);
+        assert_eq!(inner_config.len(), 141);
         let diagnostics = resolve_config(inner_config, &resolve_global_config(HashMap::new()).config).diagnostics;
         assert_eq!(diagnostics.len(), 0);
     }

src/configuration/resolve_config.rs

@@ -41,6 +41,7 @@ pub fn resolve_config(config: ConfigKeyMap, global_config: &GlobalConfiguration)
     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_single_line = get_value(&mut config, "preferSingleLine", false, &mut diagnostics);
+    let type_literal_separator_kind = get_value(&mut config, "typeLiteral.separatorKind", SemiColonsOrCommas::SemiColons, &mut diagnostics);
 
     let resolved_config = Configuration {
         line_width: get_value(&mut config, "lineWidth", global_config.line_width.unwrap_or(DEFAULT_GLOBAL_CONFIGURATION.line_width), &mut diagnostics),
@@ -53,6 +54,8 @@ pub fn resolve_config(config: ConfigKeyMap, global_config: &GlobalConfiguration)
         arrow_function_use_parentheses: get_value(&mut config, "arrowFunction.useParentheses", UseParentheses::Maintain, &mut diagnostics),
         binary_expression_line_per_expression: get_value(&mut config, "binaryExpression.linePerExpression", false, &mut diagnostics),
         member_expression_line_per_expression: get_value(&mut config, "memberExpression.linePerExpression", false, &mut diagnostics),
+        type_literal_separator_kind_single_line: get_value(&mut config, "typeLiteral.separatorKind.singleLine", type_literal_separator_kind, &mut diagnostics),
+        type_literal_separator_kind_multi_line: get_value(&mut config, "typeLiteral.separatorKind.multiLine", type_literal_separator_kind, &mut diagnostics),
         /* ignore comments */
         ignore_node_comment_text: get_value(&mut config, "ignoreNodeCommentText", String::from("dprint-ignore"), &mut diagnostics),
         ignore_file_comment_text: get_value(&mut config, "ignoreFileCommentText", String::from("dprint-ignore-file"), &mut diagnostics),
@@ -128,6 +131,7 @@ pub fn resolve_config(config: ConfigKeyMap, global_config: &GlobalConfiguration)
         object_expression_trailing_commas: get_value(&mut config, "objectExpression.trailingCommas", trailing_commas, &mut diagnostics),
         object_pattern_trailing_commas: get_value(&mut config, "objectPattern.trailingCommas", trailing_commas, &mut diagnostics),
         tuple_type_trailing_commas: get_value(&mut config, "tupleType.trailingCommas", trailing_commas, &mut diagnostics),
+        type_literal_trailing_commas: get_value(&mut config, "typeLiteral.trailingCommas", trailing_commas, &mut diagnostics),
         type_parameters_trailing_commas: get_value(&mut config, "typeParameters.trailingCommas", trailing_commas, &mut diagnostics),
         /* use braces */
         if_statement_use_braces: get_value(&mut config, "ifStatement.useBraces", use_braces, &mut diagnostics),

src/configuration/types.rs

@@ -217,6 +217,22 @@ generate_str_to_from![
     [PreferSingle, "preferSingle"]
 ];
 
+/// Whether to use semi-colons or commas.
+#[derive(Clone, PartialEq, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum SemiColonsOrCommas {
+    /// Use semi colons (default).
+    SemiColons,
+    /// Use commas.
+    Commas,
+}
+
+generate_str_to_from![
+    SemiColonsOrCommas,
+    [SemiColons, "semiColons"],
+    [Commas, "commas"]
+];
+
 #[derive(Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Configuration {
@@ -233,6 +249,10 @@ pub struct Configuration {
     pub binary_expression_line_per_expression: bool,
     #[serde(rename = "memberExpression.linePerExpression")]
     pub member_expression_line_per_expression: bool,
+    #[serde(rename = "typeLiteral.separatorKind.singleLine")]
+    pub type_literal_separator_kind_single_line: SemiColonsOrCommas,
+    #[serde(rename = "typeLiteral.separatorKind.multiLine")]
+    pub type_literal_separator_kind_multi_line: SemiColonsOrCommas,
     /* ignore comments */
     pub ignore_node_comment_text: String,
     pub ignore_file_comment_text: String,
@@ -373,6 +393,8 @@ pub struct Configuration {
     pub object_expression_trailing_commas: TrailingCommas,
     #[serde(rename = "tupleType.trailingCommas")]
     pub tuple_type_trailing_commas: TrailingCommas,
+    #[serde(rename = "typeLiteral.trailingCommas")]
+    pub type_literal_trailing_commas: TrailingCommas,
     #[serde(rename = "typeParameters.trailingCommas")]
     pub type_parameters_trailing_commas: TrailingCommas,
     /* use braces */