diff --git a/lib/src/argument_list_visitor.dart b/lib/src/argument_list_visitor.dart
index c71b9f0..c17264c 100644
--- a/lib/src/argument_list_visitor.dart
+++ b/lib/src/argument_list_visitor.dart
@@ -453,7 +453,7 @@
       rule.disableSplitOnInnerRules();
 
       // Tell it to use the rule we've already created.
-      visitor.beforeBlock(_blocks[argument], this);
+      visitor.beforeBlock(_blocks[argument], blockRule, previousSplit);
     } else if (_allArguments.length > 1) {
       // Edge case: Only bump the nesting if there are multiple arguments. This
       // lets us avoid spurious indentation in cases like:
diff --git a/lib/src/dart_formatter.dart b/lib/src/dart_formatter.dart
index afd0626..4a3950c 100644
--- a/lib/src/dart_formatter.dart
+++ b/lib/src/dart_formatter.dart
@@ -114,6 +114,9 @@
     // Parse it.
     var parser = new Parser(stringSource, errorListener);
     parser.enableOptionalNewAndConst = true;
+    parser.enableSetLiterals = true;
+    parser.enableSpreadCollections = true;
+    parser.enableControlFlowCollections = true;
 
     AstNode node;
     if (source.isCompilationUnit) {
diff --git a/lib/src/nesting_builder.dart b/lib/src/nesting_builder.dart
index 2efebb3..544ab57 100644
--- a/lib/src/nesting_builder.dart
+++ b/lib/src/nesting_builder.dart
@@ -64,22 +64,11 @@
   NestingLevel get currentNesting =>
       _pendingNesting != null ? _pendingNesting : _nesting;
 
-  /// The top "nesting level" that represents no expression nesting for the
-  /// current block.
-  NestingLevel get blockNesting {
-    // Walk the nesting levels until we bottom out.
-    var result = _nesting;
-    while (result.parent != null) {
-      result = result.parent;
-    }
-    return result;
-  }
-
   /// Creates a new indentation level [spaces] deeper than the current one.
   ///
   /// If omitted, [spaces] defaults to [Indent.block].
   void indent([int spaces]) {
-    if (spaces == null) spaces = Indent.block;
+    spaces ??= Indent.block;
 
     // Indentation should only change outside of nesting.
     assert(_pendingNesting == null);
diff --git a/lib/src/source_visitor.dart b/lib/src/source_visitor.dart
index 6aa452a..85c02e1 100644
--- a/lib/src/source_visitor.dart
+++ b/lib/src/source_visitor.dart
@@ -153,7 +153,12 @@
   /// Before a block argument is visited, [ArgumentSublist] binds itself to the
   /// beginning token of each block it controls. When we later visit that
   /// literal, we use the token to find that association.
-  final Map<Token, ArgumentSublist> _blockArgumentLists = {};
+  ///
+  /// This mapping is also used for spread collection literals that appear
+  /// inside control flow elements to ensure that when a "then" collection
+  /// splits, the corresponding "else" one does too.
+  final Map<Token, Rule> _blockRules = {};
+  final Map<Token, Chunk> _blockPreviousChunks = {};
 
   /// Initialize a newly created visitor to write source code representing
   /// the visited nodes to the given [writer].
@@ -1387,6 +1392,121 @@
     _visitCombinator(node.keyword, node.hiddenNames);
   }
 
+  void visitIfElement(IfElement node) {
+    // Wrap the whole thing in a single rule. If a split happens inside the
+    // condition or the then clause, we want the then and else clauses to split.
+    builder.startRule();
+
+    token(node.ifKeyword);
+    space();
+    token(node.leftParenthesis);
+    visit(node.condition);
+    token(node.rightParenthesis);
+
+    // If the body of the then or else branch is a spread of a collection
+    // literal, then we want to format those collections more like blocks than
+    // like standalone objects. In particular, if both the then and else branch
+    // are spread collection literals, we want to ensure that they both split
+    // if either splits. So this:
+    //
+    //     [
+    //       if (condition) ...[
+    //         thenClause
+    //       ] else ...[
+    //         elseClause
+    //       ]
+    //     ]
+    //
+    // And not something like this:
+    //
+    //     [
+    //       if (condition) ...[
+    //         thenClause
+    //       ] else ...[elseClause]
+    //     ]
+    //
+    // To do that, if we see that either clause is a spread collection, we
+    // create a single rule and force both collections to use it.
+    var thenSpreadBracket = _findSpreadCollectionBracket(node.thenElement);
+    var elseSpreadBracket = _findSpreadCollectionBracket(node.elseElement);
+
+    if (thenSpreadBracket != null || elseSpreadBracket != null) {
+      var spreadRule = Rule();
+      if (thenSpreadBracket != null) {
+        beforeBlock(thenSpreadBracket, spreadRule, null);
+      }
+
+      if (elseSpreadBracket != null) {
+        beforeBlock(elseSpreadBracket, spreadRule, null);
+      }
+    }
+
+    builder.nestExpression(indent: 2, now: true);
+
+    // Treat a spread of a collection literal like a block in an if statement
+    // and don't split after the "else".
+    if (thenSpreadBracket != null) {
+      space();
+    } else {
+      split();
+
+      // If the then clause is a non-spread collection or lambda, make sure the
+      // body is indented.
+      builder.startBlockArgumentNesting();
+    }
+
+    visit(node.thenElement);
+
+    if (thenSpreadBracket == null) builder.endBlockArgumentNesting();
+    builder.unnest();
+
+    if (node.elseElement != null) {
+      if (thenSpreadBracket != null) {
+        space();
+      } else {
+        split();
+      }
+
+      token(node.elseKeyword);
+
+      builder.nestExpression(indent: 2, now: true);
+
+      if (elseSpreadBracket != null) {
+        space();
+      } else {
+        split();
+
+        // If the else clause is a non-spread collection or lambda, make sure
+        // the body is indented.
+        builder.startBlockArgumentNesting();
+      }
+
+      visit(node.elseElement);
+
+      if (elseSpreadBracket == null) builder.endBlockArgumentNesting();
+      builder.unnest();
+    }
+
+    builder.endRule();
+  }
+
+  /// If [node] is a spread of a collection literal, then this returns the
+  /// token for the opening bracket of the collection, as in:
+  ///
+  ///     [ ...[a, list] ]
+  ///     //   ^
+  ///
+  /// Otherwise, returns `null`.
+  Token _findSpreadCollectionBracket(AstNode node) {
+    if (node is SpreadElement) {
+      var expression = node.expression;
+      if (expression is ListLiteral) return expression.leftBracket;
+      if (expression is SetOrMapLiteral) return expression.leftBracket;
+    }
+
+    return null;
+  }
+
   visitIfStatement(IfStatement node) {
     builder.nestExpression();
     token(node.ifKeyword);
@@ -1611,10 +1731,12 @@
   }
 
   visitMapLiteralEntry(MapLiteralEntry node) {
+    builder.nestExpression();
     visit(node.key);
     token(node.separator);
     soloSplit();
     visit(node.value);
+    builder.unnest();
   }
 
   visitMethodDeclaration(MethodDeclaration node) {
@@ -1882,6 +2004,11 @@
     _writeStringLiteral(node.literal);
   }
 
+  visitSpreadElement(SpreadElement node) {
+    token(node.spreadOperator);
+    visit(node.expression);
+  }
+
   visitStringInterpolation(StringInterpolation node) {
     for (var element in node.elements) {
       visit(element);
@@ -2511,15 +2638,12 @@
         }
       }
 
-      builder.nestExpression();
       visit(element);
 
       // The comma after the element.
       if (element.endToken.next.type == TokenType.COMMA) {
         token(element.endToken.next);
       }
-
-      builder.unnest();
     }
 
     builder.endRule();
@@ -2741,14 +2865,17 @@
   void _startLiteralBody(Token leftBracket) {
     token(leftBracket);
 
-    // See if this literal is associated with an argument list that wants to
-    // handle splitting and indenting it. If not, we'll use a default rule.
-    var rule;
-    var argumentChunk;
-    if (_blockArgumentLists.containsKey(leftBracket)) {
-      var argumentList = _blockArgumentLists[leftBracket];
-      rule = argumentList.blockRule;
-      argumentChunk = argumentList.previousSplit;
+    // See if this literal is associated with an argument list or if element
+    // that wants to handle splitting and indenting it. If not, we'll use a
+    // default rule.
+    Rule rule;
+    if (_blockRules.containsKey(leftBracket)) {
+      rule = _blockRules[leftBracket];
+    }
+
+    Chunk argumentChunk;
+    if (_blockPreviousChunks.containsKey(leftBracket)) {
+      argumentChunk = _blockPreviousChunks[leftBracket];
     }
 
     // Create a rule for whether or not to split the block contents.
@@ -2844,12 +2971,15 @@
   }
 
   /// Marks the block that starts with [token] as being controlled by
-  /// [argumentList].
+  /// [rule] and following [previousChunk].
   ///
-  /// When the block is visited, [argumentList] will determine the
-  /// indentation and splitting rule for the block.
-  void beforeBlock(Token token, ArgumentSublist argumentList) {
-    _blockArgumentLists[token] = argumentList;
+  /// When the block is visited, these will determine the indentation and
+  /// splitting rule for the block. These are used for handling block-like
+  /// expressions inside argument lists and spread collections inside if
+  /// elements.
+  void beforeBlock(Token token, Rule rule, [Chunk previousChunk]) {
+    _blockRules[token] = rule;
+    if (previousChunk != null) _blockPreviousChunks[token] = previousChunk;
   }
 
   /// Writes the beginning of a brace-delimited body and handles indenting and
diff --git a/test/splitting/list_collection_if.stmt b/test/splitting/list_collection_if.stmt
new file mode 100644
index 0000000..7f272a7
--- /dev/null
+++ b/test/splitting/list_collection_if.stmt
@@ -0,0 +1,217 @@
+40 columns                              |
+>>> split in condition
+var list = [1, if (veryLongConditionExpression || anotherPart) 2];
+<<<
+var list = [
+  1,
+  if (veryLongConditionExpression ||
+      anotherPart)
+    2
+];
+>>> without else on one line
+var list = [1, if (c) 2, 3];
+<<<
+var list = [1, if (c) 2, 3];
+>>> with else on one line
+var list = [1, if (c) 2 else 2, 3];
+<<<
+var list = [1, if (c) 2 else 2, 3];
+>>> split collection before if
+var list = [if (c) somewhatLongThingHere];
+<<<
+var list = [
+  if (c) somewhatLongThingHere
+];
+>>> one line in multi-line
+var list = [veryLongThingThatForcesASplit, if (c) 2, 3];
+<<<
+var list = [
+  veryLongThingThatForcesASplit,
+  if (c) 2,
+  3
+];
+>>> one line in multi-line with else
+var list = [veryLongThingThatForcesASplit, if (c) 2 else 2, 3];
+<<<
+var list = [
+  veryLongThingThatForcesASplit,
+  if (c) 2 else 2,
+  3
+];
+>>> long then branch forces split
+var list = [1, if (condition) veryLongThingThatForcesASplit, 3];
+<<<
+var list = [
+  1,
+  if (condition)
+    veryLongThingThatForcesASplit,
+  3
+];
+>>> long then branch forces both to split
+var list = [1, if (condition) veryLongThingThatForcesASplit else 2, 3];
+<<<
+var list = [
+  1,
+  if (condition)
+    veryLongThingThatForcesASplit
+  else
+    2,
+  3
+];
+>>> long else branch forces both to split
+var list = [1, if (condition) 2 else veryLongThingThatForcesASplit, 3];
+<<<
+var list = [
+  1,
+  if (condition)
+    2
+  else
+    veryLongThingThatForcesASplit,
+  3
+];
+>>> split inside then
+var list = [1, if (condition) veryLongThingThatForcesASplit + anotherLongThing, 3];
+<<<
+var list = [
+  1,
+  if (condition)
+    veryLongThingThatForcesASplit +
+        anotherLongThing,
+  3
+];
+>>> split inside else
+var list = [1, if (condition) ok else veryLongThingThatForcesASplit + anotherLongThing, 3];
+<<<
+var list = [
+  1,
+  if (condition)
+    ok
+  else
+    veryLongThingThatForcesASplit +
+        anotherLongThing,
+  3
+];
+>>> trailing comma
+var list = [if (c) 2,];
+<<<
+var list = [
+  if (c) 2,
+];
+>>> spread list inside if stays on one line if it fits
+var list = [if (c) ...[1, 2]];
+<<<
+var list = [
+  if (c) ...[1, 2]
+];
+>>> spread list inside if formats like block if it splits
+var list = [if (c) ...[1, 2,]];
+<<<
+var list = [
+  if (c) ...[
+    1,
+    2,
+  ]
+];
+>>> both spreads split if then must
+var list = [if (c) ...[1, 2,] else ...[1, 2]];
+<<<
+var list = [
+  if (c) ...[
+    1,
+    2,
+  ] else ...[
+    1,
+    2
+  ]
+];
+>>> both spreads split if else must
+var list = [if (c) ...[1, 2] else ...[1, 2,]];
+<<<
+var list = [
+  if (c) ...[
+    1,
+    2
+  ] else ...[
+    1,
+    2,
+  ]
+];
+>>> a split collection that isn't spread wraps and indents
+var list = [if (c) [1,2,]];
+<<<
+var list = [
+  if (c)
+    [
+      1,
+      2,
+    ]
+];
+>>> a split collection that isn't spread wraps and indents
+var list = [if (c) [1,2,] else thing];
+<<<
+var list = [
+  if (c)
+    [
+      1,
+      2,
+    ]
+  else
+    thing
+];
+>>> a split collection that isn't spread wraps and indents
+var list = [if (c) thing else [1,2,]];
+<<<
+var list = [
+  if (c)
+    thing
+  else
+    [
+      1,
+      2,
+    ]
+];
+>>> lambda inside then
+var list = [if (c) () { body; }];
+<<<
+var list = [
+  if (c)
+    () {
+      body;
+    }
+];
+>>> lambda inside else
+var list = [if (c) thing else () { body; }];
+<<<
+var list = [
+  if (c)
+    thing
+  else
+    () {
+      body;
+    }
+];
+>>> nested if doesn't split if it fits
+var list = [if (c) if (d) thing];
+<<<
+var list = [if (c) if (d) thing];
+>>> split collection before nested if
+var list = [if (c) if (d) fairlyLongThingHere];
+<<<
+var list = [
+  if (c) if (d) fairlyLongThingHere
+];
+>>> just split outer if
+var list = [if (condition) if (another) longThingHereThatIsLong];
+<<<
+var list = [
+  if (condition)
+    if (another) longThingHereThatIsLong
+];
+>>> split inside condition
+var list = [if (veryLongCondition + thatNeedsToSplit) thing];
+<<<
+var list = [
+  if (veryLongCondition +
+      thatNeedsToSplit)
+    thing
+];
\ No newline at end of file
diff --git a/test/splitting/lists.stmt b/test/splitting/lists.stmt
index 86698f6..4b45a1e 100644
--- a/test/splitting/lists.stmt
+++ b/test/splitting/lists.stmt
@@ -167,4 +167,28 @@
   element,
 
   element
+];
+>>> a spread list literal splits an outer list even if it fits
+var list = [1, ...[2, 3], 4];
+<<<
+var list = [
+  1,
+  ...[2, 3],
+  4
+];
+>>> spread empty list does not force outer split
+var list = [1, ...[], 4];
+<<<
+var list = [1, ...[], 4];
+>>> split inside spread expression
+var list = [1, ...some + very + long + spread + expression, 3];
+<<<
+var list = [
+  1,
+  ...some +
+      very +
+      long +
+      spread +
+      expression,
+  3
 ];
\ No newline at end of file
diff --git a/test/splitting/map_collection_if.stmt b/test/splitting/map_collection_if.stmt
new file mode 100644
index 0000000..ef4758a
--- /dev/null
+++ b/test/splitting/map_collection_if.stmt
@@ -0,0 +1,203 @@
+40 columns                              |
+>>> split in condition
+var map = {1: 1, if (veryLongConditionExpression || anotherPart) 2: 2};
+<<<
+var map = {
+  1: 1,
+  if (veryLongConditionExpression ||
+      anotherPart)
+    2: 2
+};
+>>> without else on one line
+var map = {1: 1, if (c) 2: 2, 3: 3};
+<<<
+var map = {1: 1, if (c) 2: 2, 3: 3};
+>>> with else on one line
+var map = {1: 1, if (c) 2: 2 else 2: 2};
+<<<
+var map = {1: 1, if (c) 2: 2 else 2: 2};
+>>> split collection before if
+var map = {if (c) somewhatLongThingHere: 1};
+<<<
+var map = {
+  if (c) somewhatLongThingHere: 1
+};
+>>> one line in multi-line
+var map = {veryLongThingThatForcesASplit, if (c) 2: 2, 3: 3};
+<<<
+var map = {
+  veryLongThingThatForcesASplit,
+  if (c) 2: 2,
+  3: 3
+};
+>>> one line in multi-line with else
+var map = {veryLongThingThatForcesASplit: 1, if (c) 2: 2 else 2: 2, 3: 3};
+<<<
+var map = {
+  veryLongThingThatForcesASplit: 1,
+  if (c) 2: 2 else 2: 2,
+  3: 3
+};
+>>> long then branch forces split
+var map = {1: 1, if (condition) veryLongThingThatForcesASplit: 2, 3: 3};
+<<<
+var map = {
+  1: 1,
+  if (condition)
+    veryLongThingThatForcesASplit: 2,
+  3: 3
+};
+>>> long then branch forces both to split
+var map = {1: 1, if (condition) veryLongThingThatForcesASplit: 2 else 2: 2, 3: 3};
+<<<
+var map = {
+  1: 1,
+  if (condition)
+    veryLongThingThatForcesASplit: 2
+  else
+    2: 2,
+  3: 3
+};
+>>> long else branch forces both to split
+var map = {1: 1, if (condition) 2: 2 else veryLongThingThatForcesASplit: 2, 3: 3};
+<<<
+var map = {
+  1: 1,
+  if (condition)
+    2: 2
+  else
+    veryLongThingThatForcesASplit: 2,
+  3: 3
+};
+>>> trailing comma
+var map = {if (c) 2: 2,};
+<<<
+var map = {
+  if (c) 2: 2,
+};
+>>> spread list inside if stays on one line if it fits
+var map = {if (c) ...{1: 1, 2: 2}};
+<<<
+var map = {
+  if (c) ...{1: 1, 2: 2}
+};
+>>> spread list inside if formats like block if it splits
+var map = {if (c) ...{1: 1, 2: 2,}};
+<<<
+var map = {
+  if (c) ...{
+    1: 1,
+    2: 2,
+  }
+};
+>>> both spreads split if then must
+var map = {if (c) ...{1: 1, 2: 2,} else ...{1: 1, 2: 2}};
+<<<
+var map = {
+  if (c) ...{
+    1: 1,
+    2: 2,
+  } else ...{
+    1: 1,
+    2: 2
+  }
+};
+>>> both spreads split if else must
+var map = {if (c) ...{1: 1, 2: 2} else ...{1: 1, 2: 2,}};
+<<<
+var map = {
+  if (c) ...{
+    1: 1,
+    2: 2
+  } else ...{
+    1: 1,
+    2: 2,
+  }
+};
+>>> a split collection that isn't spread wraps and indents
+var map = {if (c) {1: 1,2: 2,}};
+<<<
+var map = {
+  if (c)
+    {
+      1: 1,
+      2: 2,
+    }
+};
+>>> a split collection that isn't spread wraps and indents
+var map = {if (c) {1: 1,2: 2,} else thing: 3};
+<<<
+var map = {
+  if (c)
+    {
+      1: 1,
+      2: 2,
+    }
+  else
+    thing: 3
+};
+>>> a split collection that isn't spread wraps and indents
+var map = {if (c) thing: 0 else {1: 1,2: 2,}};
+<<<
+var map = {
+  if (c)
+    thing: 0
+  else
+    {
+      1: 1,
+      2: 2,
+    }
+};
+>>> lambda inside then
+var map = {if (c) k: () { body; }};
+<<<
+var map = {
+  if (c)
+    k: () {
+      body;
+    }
+};
+>>> lambda inside else
+var map = {if (c) thing: 1 else k: () { body; }};
+<<<
+var map = {
+  if (c)
+    thing: 1
+  else
+    k: () {
+      body;
+    }
+};
+>>> nested if doesn't split if it fits
+var map = {if (c) if (d) thing: 1};
+<<<
+var map = {if (c) if (d) thing: 1};
+>>> split collection before nested if
+var map = {if (c) if (d) fairlyLongThingHere: 1};
+<<<
+var map = {
+  if (c) if (d) fairlyLongThingHere: 1
+};
+>>> just split outer if
+var map = {if (condition) if (another) longThingThatIsLong: 1};
+<<<
+var map = {
+  if (condition)
+    if (another) longThingThatIsLong: 1
+};
+>>> split inside condition
+var map = {if (veryLongCondition + thatNeedsToSplit) thing: 1};
+<<<
+var map = {
+  if (veryLongCondition +
+      thatNeedsToSplit)
+    thing: 1
+};
+>>> split entry inside if
+var map = { if (condition) veryLongKeyExpression: andAVeryLongValueExpression};
+<<<
+var map = {
+  if (condition)
+    veryLongKeyExpression:
+        andAVeryLongValueExpression
+};
\ No newline at end of file
diff --git a/test/splitting/set_collection_if.stmt b/test/splitting/set_collection_if.stmt
new file mode 100644
index 0000000..86375ad
--- /dev/null
+++ b/test/splitting/set_collection_if.stmt
@@ -0,0 +1,195 @@
+40 columns                              |
+>>> split in condition
+var set = {1, if (veryLongConditionExpression || anotherPart) 2};
+<<<
+var set = {
+  1,
+  if (veryLongConditionExpression ||
+      anotherPart)
+    2
+};
+>>> without else on one line
+var set = {1, if (c) 2, 3};
+<<<
+var set = {1, if (c) 2, 3};
+>>> with else on one line
+var set = {1, if (c) 2 else 2, 3};
+<<<
+var set = {1, if (c) 2 else 2, 3};
+>>> split collection before if
+var set = {if (c) somewhatLongThingHere};
+<<<
+var set = {
+  if (c) somewhatLongThingHere
+};
+>>> one line in multi-line
+var set = {veryLongThingThatForcesASplit, if (c) 2, 3};
+<<<
+var set = {
+  veryLongThingThatForcesASplit,
+  if (c) 2,
+  3
+};
+>>> one line in multi-line with else
+var set = {veryLongThingThatForcesASplit, if (c) 2 else 2, 3};
+<<<
+var set = {
+  veryLongThingThatForcesASplit,
+  if (c) 2 else 2,
+  3
+};
+>>> long then branch forces split
+var set = {1, if (condition) veryLongThingThatForcesASplit, 3};
+<<<
+var set = {
+  1,
+  if (condition)
+    veryLongThingThatForcesASplit,
+  3
+};
+>>> long then branch forces both to split
+var set = {1, if (condition) veryLongThingThatForcesASplit else 2, 3};
+<<<
+var set = {
+  1,
+  if (condition)
+    veryLongThingThatForcesASplit
+  else
+    2,
+  3
+};
+>>> long else branch forces both to split
+var set = {1, if (condition) 2 else veryLongThingThatForcesASplit, 3};
+<<<
+var set = {
+  1,
+  if (condition)
+    2
+  else
+    veryLongThingThatForcesASplit,
+  3
+};
+>>> trailing comma
+var set = {if (c) 2,};
+<<<
+var set = {
+  if (c) 2,
+};
+>>> spread list inside if stays on one line if it fits
+var set = {if (c) ...{1, 2}};
+<<<
+var set = {
+  if (c) ...{1, 2}
+};
+>>> spread list inside if formats like block if it splits
+var set = {if (c) ...{1, 2,}};
+<<<
+var set = {
+  if (c) ...{
+    1,
+    2,
+  }
+};
+>>> both spreads split if then must
+var set = {if (c) ...{1, 2,} else ...{1, 2}};
+<<<
+var set = {
+  if (c) ...{
+    1,
+    2,
+  } else ...{
+    1,
+    2
+  }
+};
+>>> both spreads split if else must
+var set = {if (c) ...{1, 2} else ...{1, 2,}};
+<<<
+var set = {
+  if (c) ...{
+    1,
+    2
+  } else ...{
+    1,
+    2,
+  }
+};
+>>> a split collection that isn't spread wraps and indents
+var set = {if (c) {1,2,}};
+<<<
+var set = {
+  if (c)
+    {
+      1,
+      2,
+    }
+};
+>>> a split collection that isn't spread wraps and indents
+var set = {if (c) {1,2,} else thing};
+<<<
+var set = {
+  if (c)
+    {
+      1,
+      2,
+    }
+  else
+    thing
+};
+>>> a split collection that isn't spread wraps and indents
+var set = {if (c) thing else {1,2,}};
+<<<
+var set = {
+  if (c)
+    thing
+  else
+    {
+      1,
+      2,
+    }
+};
+>>> lambda inside then
+var set = {if (c) () { body; }};
+<<<
+var set = {
+  if (c)
+    () {
+      body;
+    }
+};
+>>> lambda inside else
+var set = {if (c) thing else () { body; }};
+<<<
+var set = {
+  if (c)
+    thing
+  else
+    () {
+      body;
+    }
+};
+>>> nested if doesn't split if it fits
+var set = {if (c) if (d) thing};
+<<<
+var set = {if (c) if (d) thing};
+>>> split collection before nested if
+var set = {if (c) if (d) fairlyLongThingHere};
+<<<
+var set = {
+  if (c) if (d) fairlyLongThingHere
+};
+>>> just split outer if
+var set = {if (condition) if (another) longThingHereThatIsLong};
+<<<
+var set = {
+  if (condition)
+    if (another) longThingHereThatIsLong
+};
+>>> split inside condition
+var set = {if (veryLongCondition + thatNeedsToSplit) thing};
+<<<
+var set = {
+  if (veryLongCondition +
+      thatNeedsToSplit)
+    thing
+};
\ No newline at end of file
diff --git a/test/whitespace/collections.stmt b/test/whitespace/collections.stmt
new file mode 100644
index 0000000..bcf7119
--- /dev/null
+++ b/test/whitespace/collections.stmt
@@ -0,0 +1,59 @@
+40 columns                              |
+>>> empty map literal (dartbug.com/16382)
+var m = { };
+<<<
+var m = {};
+>>>
+var m = {};
+<<<
+var m = {};
+>>> generic map literal
+<   int,int  >{   };
+<<<
+<int, int>{};
+>>> generic set literal
+<   int  >{   };
+<<<
+<int>{};
+>>> list spread
+var list = [  ...  a,...b,  ...
+c];
+<<<
+var list = [...a, ...b, ...c];
+>>> map spread
+var map = {  ...  a,...b,1:2,  ...
+c};
+<<<
+var map = {...a, ...b, 1: 2, ...c};
+>>> set spread
+var set = {  ...  a,...b, 1,   ...
+c};
+<<<
+var set = {...a, ...b, 1, ...c};
+>>> list null aware spread
+var list = [  ...?  a,...?b,  ...?
+c];
+<<<
+var list = [...?a, ...?b, ...?c];
+>>> map null aware spread
+var map = {  ...?  a,...?b,1:2,  ...?
+c};
+<<<
+var map = {...?a, ...?b, 1: 2, ...?c};
+>>> set null aware spread
+var set = {  ...?  a,...?b, 1,   ...?
+c};
+<<<
+var set = {...?a, ...?b, 1, ...?c};
+>>> if
+var list = [   if   ( c    )   1    ,];
+<<<
+var list = [
+  if (c) 1,
+];
+>>> if else
+var list = [   if   ( c    )   1    else    2   ,];
+<<<
+var list = [
+  if (c) 1 else 2,
+];
\ No newline at end of file
diff --git a/test/whitespace/expressions.stmt b/test/whitespace/expressions.stmt
index c1ed6b2..10980d5 100644
--- a/test/whitespace/expressions.stmt
+++ b/test/whitespace/expressions.stmt
@@ -32,22 +32,6 @@
     y;
 <<<
 x && y;
->>> empty map literal (dartbug.com/16382)
-var m = { };
-<<<
-var m = {};
->>>
-var m = {};
-<<<
-var m = {};
->>> generic map literal
-<   int,int  >{   };
-<<<
-<int, int>{};
->>> generic set literal
-<   int  >{   };
-<<<
-<int>{};
 >>> unqualified symbol
 var x = #foo;
 <<<