Don't split cascades on record literals. (#1207)

This is consistent with how other collection literals preceding
single-section cascades are formatted.

Author: munificent

CHANGELOG.md

@@ -6,6 +6,7 @@
 * Don't indent `||` pattern operands in switch expression cases.  
 * Don't format `sealed`, `interface`, and `final` keywords on mixin
   declarations. The proposal was updated to no longer support them.
+* Don't split before a single-section cascade following a record literal.
 
 # 2.3.0
 

lib/src/ast_extensions.dart

@@ -88,40 +88,6 @@ extension AstIterableExtensions on Iterable<AstNode> {
 }
 
 extension ExpressionExtensions on Expression {
-  /// Whether [expression] is a collection literal, or a call with a trailing
-  /// comma in an argument list.
-  ///
-  /// In that case, when the expression is a target of a cascade, we don't
-  /// force a split before the ".." as eagerly to avoid ugly results like:
-  ///
-  ///     [
-  ///       1,
-  ///       2,
-  ///     ]..addAll(numbers);
-  bool get isCollectionLike {
-    var expression = this;
-    if (expression is ListLiteral) return true;
-    if (expression is SetOrMapLiteral) return true;
-
-    // If the target is a call with a trailing comma in the argument list,
-    // treat it like a collection literal.
-    ArgumentList? arguments;
-    if (expression is InvocationExpression) {
-      arguments = expression.argumentList;
-    } else if (expression is InstanceCreationExpression) {
-      arguments = expression.argumentList;
-    }
-
-    // TODO(rnystrom): Do we want to allow an invocation where the last
-    // argument is a collection literal? Like:
-    //
-    //     foo(argument, [
-    //       element
-    //     ])..cascade();
-
-    return arguments != null && arguments.arguments.hasCommaAfter;
-  }
-
   /// Whether this is an argument in an argument list with a trailing comma.
   bool get isTrailingCommaArgument {
     var parent = this.parent;

lib/src/source_visitor.dart

@@ -424,9 +424,25 @@ class SourceVisitor extends ThrowingAstVisitor {
     //       stuff
     //     ]
     //       ..add(more);
-    var splitIfOperandsSplit =
-        node.cascadeSections.length > 1 || !node.target.isCollectionLike;
-    if (splitIfOperandsSplit) {
+    var target = node.target;
+    var splitIfTargetSplits = true;
+    if (node.cascadeSections.length > 1) {
+      // Always split if there are multiple cascade sections.
+    } else if (target is ListLiteral ||
+        target is RecordLiteral ||
+        target is SetOrMapLiteral) {
+      splitIfTargetSplits = false;
+    } else if (target is InvocationExpression) {
+      // If the target is a call with a trailing comma in the argument list,
+      // treat it like a collection literal.
+      splitIfTargetSplits = !target.argumentList.arguments.hasCommaAfter;
+    } else if (target is InstanceCreationExpression) {
+      // If the target is a call with a trailing comma in the argument list,
+      // treat it like a collection literal.
+      splitIfTargetSplits = !target.argumentList.arguments.hasCommaAfter;
+    }
+
+    if (splitIfTargetSplits) {
       builder.startLazyRule(node.allowInline ? Rule() : Rule.hard());
     }
 
@@ -437,21 +453,17 @@ class SourceVisitor extends ThrowingAstVisitor {
 
     // If the cascade section shouldn't cause the cascade to split, end the
     // rule early so it isn't affected by it.
-    if (!splitIfOperandsSplit) {
+    if (!splitIfTargetSplits) {
       builder.startRule(node.allowInline ? Rule() : Rule.hard());
     }
 
     zeroSplit();
 
-    if (!splitIfOperandsSplit) {
-      builder.endRule();
-    }
+    if (!splitIfTargetSplits) builder.endRule();
 
     visitNodes(node.cascadeSections, between: zeroSplit);
 
-    if (splitIfOperandsSplit) {
-      builder.endRule();
-    }
+    if (splitIfTargetSplits) builder.endRule();
 
     builder.endBlockArgumentNesting();
     builder.unnest();

test/whitespace/cascades.stmt

@@ -108,6 +108,13 @@ var map = {1:2,}..addAll(more);
 var map = {
   1: 2,
 }..addAll(more);
+>>> omit split if single section on record literal
+(1,2,)..addAll(more);
+<<<
+(
+  1,
+  2,
+)..addAll(more);
 >>> omit split if single section on trailing comma call
 foo(1,)..addAll(more);
 <<<