Roll Observatory deps (charted -> ^0.3.0)

packages/dart_style/lib/src/source_visitor.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart_style.src.source_visitor;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 
 import 'argument_list_visitor.dart';
 import 'call_chain_visitor.dart';
 import 'chunk.dart';
 import 'chunk_builder.dart';
 import 'dart_formatter.dart';
 import 'rule/argument.dart';
 import 'rule/combinator.dart';
+import 'rule/metadata.dart';
 import 'rule/rule.dart';
 import 'rule/type_argument.dart';
 import 'source_code.dart';
 import 'whitespace.dart';
 
 /// Visits every token of the AST and passes all of the relevant bits to a
 /// [ChunkBuilder].
 class SourceVisitor implements AstVisitor {
   /// The builder for the block that is currently being visited.
   ChunkBuilder builder;
@@ skipping 12 matching lines @@
 
   /// `true` if the visitor has written past the end of the selection in the
   /// original source text.
   bool _passedSelectionEnd = false;
 
   /// The character offset of the end of the selection, if there is a selection.
   ///
   /// This is calculated and cached by [_findSelectionEnd].
   int _selectionEnd;
 
-  /// The rule that should be used for the contents of a literal body that are
-  /// about to be written.
-  ///
-  /// This is set by [visitArgumentList] to ensure that all block arguments
-  /// share a rule.
-  ///
-  /// If `null`, a literal body creates its own rule.
-  Rule _nextLiteralBodyRule;
-
   /// A stack that tracks forcing nested collections to split.
   ///
   /// Each entry corresponds to a collection currently being visited and the
   /// value is whether or not it should be forced to split. Every time a
   /// collection is entered, it sets all of the existing elements to `true`
   /// then it pushes `false` for itself.
   ///
   /// When done visiting the elements, it removes its value. If it was set to
   /// `true`, we know we visited a nested collection so we force this one to
   /// split.
   final List<bool> _collectionSplits = [];
 
+  /// The stack of current rules for handling parameter metadata.
+  ///
+  /// Each time a parameter (or type parameter) list is begun, a single rule
+  /// for all of the metadata annotations on parameters in that list is pushed
+  /// onto this stack. We reuse this rule for all annotations so that they split
+  /// in unison.
+  final List<MetadataRule> _metadataRules = [];
+
+  /// The mapping for collection literals that are managed by the argument
+  /// list that contains them.
+  ///
+  /// When a collection literal appears inside an [ArgumentSublist], the
+  /// argument list provides a rule for the body to split to ensure that all
+  /// collections split in unison. It also tracks the chunk before the
+  /// argument that determines whether or not the collection body is indented
+  /// like an expression or a statement.
+  ///
+  /// Before a collection literal argument is visited, [ArgumentSublist] binds
+  /// itself to the left bracket token of each collection literal it controls.
+  /// When we later visit that literal, we use the token to find that
+  /// association.
+  final Map<Token, ArgumentSublist> _collectionArgumentLists = {};
+
   /// Initialize a newly created visitor to write source code representing
   /// the visited nodes to the given [writer].
   SourceVisitor(this._formatter, this._lineInfo, this._source) {
     builder = new ChunkBuilder(_formatter, _source);
   }
 
   /// Runs the visitor on [node], formatting its contents.
   ///
   /// Returns a [SourceCode] containing the resulting formatted source and
   /// updated selection, if any.
@@ skipping 82 matching lines @@
   }
 
   visitAwaitExpression(AwaitExpression node) {
     token(node.awaitKeyword);
     space();
     visit(node.expression);
   }
 
   visitBinaryExpression(BinaryExpression node) {
     builder.startSpan();
-    builder.nestExpression();
+
+    // If a binary operator sequence appears immediately after a `=>`, don't
+    // add an extra level of nesting. Instead, let the subsequent operands line
+    // up with the first, as in:
+    //
+    //     method() =>
+    //         argument &&
+    //         argument &&
+    //         argument;
+    var isArrowBody = node.parent is ExpressionFunctionBody;
+    if (!isArrowBody) builder.nestExpression();
 
     // Start lazily so we don't force the operator to split if a line comment
     // appears before the first operand.
     builder.startLazyRule();
 
     // Flatten out a tree/chain of the same precedence. If we split on this
     // precedence level, we will break all of them.
     var precedence = node.operator.type.precedence;
 
     traverse(Expression e) {
@@ skipping 11 matching lines @@
     }
 
     // Blocks as operands to infix operators should always nest like regular
     // operands. (Granted, this case is exceedingly rare in real code.)
     builder.startBlockArgumentNesting();
 
     traverse(node);
 
     builder.endBlockArgumentNesting();
 
-    builder.unnest();
+    if (!isArrowBody) builder.unnest();
     builder.endSpan();
     builder.endRule();
   }
 
   visitBlock(Block node) {
+    // Don't allow splitting in an empty block.
+    if (node.statements.isEmpty &&
+        node.rightBracket.precedingComments == null) {
+      token(node.leftBracket);
+      token(node.rightBracket);
+      return;
+    }
+
     // For a block that is not a function body, just bump the indentation and
     // keep it in the current block.
     if (node.parent is! BlockFunctionBody) {
       _writeBody(node.leftBracket, node.rightBracket, body: () {
         visitNodes(node.statements, between: oneOrTwoNewlines, after: newline);
       });
       return;
     }
 
     _startLiteralBody(node.leftBracket);
@@ skipping 56 matching lines @@
     builder.startBlockArgumentNesting();
 
     // If the cascade sections have consistent names they can be broken
     // normally otherwise they always get their own line.
     if (_allowInlineCascade(node.cascadeSections)) {
       builder.startRule();
       zeroSplit();
       visitNodes(node.cascadeSections, between: zeroSplit);
       builder.endRule();
     } else {
-      builder.startRule(new HardSplitRule());
+      builder.startRule(new Rule.hard());
       zeroSplit();
       visitNodes(node.cascadeSections, between: zeroSplit);
       builder.endRule();
     }
 
     builder.endBlockArgumentNesting();
     builder.unnest();
 
     if (node.target is MethodInvocation) builder.unnest();
   }
@@ skipping 210 matching lines @@
     modifier(node.factoryKeyword);
     visit(node.returnType);
     token(node.period);
     visit(node.name);
 
     // Make the rule for the ":" span both the preceding parameter list and
     // the entire initialization list. This ensures that we split before the
     // ":" if the parameters and initialization list don't all fit on one line.
     builder.startRule();
 
+    // If the redirecting constructor happens to wrap, we want to make sure
+    // the parameter list gets more deeply indented.
+    if (node.redirectedConstructor != null) builder.nestExpression();
+
     _visitBody(node.parameters, node.body, () {
       // Check for redirects or initializer lists.
       if (node.redirectedConstructor != null) {
         _visitConstructorRedirects(node);
+        builder.unnest();
       } else if (node.initializers.isNotEmpty) {
         _visitConstructorInitializers(node);
       }
     });
   }
 
   void _visitConstructorRedirects(ConstructorDeclaration node) {
-    token(node.separator /* = */, before: space, after: space);
+    token(node.separator /* = */, before: space);
+    soloSplit();
     visitCommaSeparatedNodes(node.initializers);
     visit(node.redirectedConstructor);
   }
 
   void _visitConstructorInitializers(ConstructorDeclaration node) {
     // Shift the ":" forward.
     builder.indent(Indent.constructorInitializer);
 
     split();
     token(node.separator); // ":".
@@ skipping 53 matching lines @@
   visitDefaultFormalParameter(DefaultFormalParameter node) {
     visit(node.parameter);
     if (node.separator != null) {
       builder.startSpan();
       builder.nestExpression();
 
       // The '=' separator is preceded by a space, ":" is not.
       if (node.separator.type == TokenType.EQ) space();
       token(node.separator);
 
-      soloSplit(Cost.assignment);
+      soloSplit(_assignmentCost(node.defaultValue));
       visit(node.defaultValue);
 
       builder.unnest();
       builder.endSpan();
     }
   }
 
   visitDoStatement(DoStatement node) {
-    _simpleStatement(node, () {
-      token(node.doKeyword);
-      space();
-      visit(node.body);
-      space();
-      token(node.whileKeyword);
-      space();
-      token(node.leftParenthesis);
-      soloZeroSplit();
-      visit(node.condition);
-      token(node.rightParenthesis);
-    });
+    builder.nestExpression();
+    token(node.doKeyword);
+    space();
+    builder.unnest(now: false);
+    visit(node.body);
+
+    builder.nestExpression();
+    space();
+    token(node.whileKeyword);
+    space();
+    token(node.leftParenthesis);
+    soloZeroSplit();
+    visit(node.condition);
+    token(node.rightParenthesis);
+    token(node.semicolon);
+    builder.unnest();
   }
 
   visitDoubleLiteral(DoubleLiteral node) {
     token(node.literal);
   }
 
   visitEmptyFunctionBody(EmptyFunctionBody node) {
     token(node.semicolon);
   }
 
@@ skipping 41 matching lines @@
 
     // Try to keep the "(...) => " with the start of the body for anonymous
     // functions.
     if (_isInLambda(node)) builder.startSpan();
 
     token(node.functionDefinition); // "=>".
 
     // Split after the "=>", using the rule created before the parameters
     // by _visitBody().
     split();
-    builder.endRule();
+
+    // If the body is a binary operator expression, then we want to force the
+    // split at `=>` if the operators split. See visitBinaryExpression().
+    if (node.expression is! BinaryExpression) builder.endRule();
 
     if (_isInLambda(node)) builder.endSpan();
 
     builder.startBlockArgumentNesting();
     builder.startSpan();
     visit(node.expression);
     builder.endSpan();
     builder.endBlockArgumentNesting();
 
+    if (node.expression is BinaryExpression) builder.endRule();
+
     token(node.semicolon);
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     _simpleStatement(node, () {
       visit(node.expression);
     });
   }
 
   visitExtendsClause(ExtendsClause node) {
@@ skipping 32 matching lines @@
     if (node.loopVariable != null) {
       visit(node.loopVariable);
     } else {
       visit(node.identifier);
     }
     soloSplit();
     token(node.inKeyword);
     space();
     visit(node.iterable);
     token(node.rightParenthesis);
-    space();
-    visit(node.body);
-    builder.unnest();
+    builder.unnest(now: false);
+
+    _visitLoopBody(node.body);
   }
 
   visitFormalParameterList(FormalParameterList node) {
     // Corner case: empty parameter lists.
     if (node.parameters.isEmpty) {
       token(node.leftParenthesis);
 
       // If there is a comment, do allow splitting before it.
       if (node.rightParenthesis.precedingComments != null) soloZeroSplit();
 
       token(node.rightParenthesis);
       return;
     }
 
     var requiredParams = node.parameters
         .where((param) => param is! DefaultFormalParameter)
         .toList();
     var optionalParams = node.parameters
         .where((param) => param is DefaultFormalParameter)
         .toList();
 
     builder.nestExpression();
     token(node.leftParenthesis);
 
+    _metadataRules.add(new MetadataRule());
+
     var rule;
     if (requiredParams.isNotEmpty) {
       if (requiredParams.length > 1) {
         rule = new MultiplePositionalRule(null, 0, 0);
       } else {
         rule = new SinglePositionalRule(null);
       }
 
+      _metadataRules.last.bindPositionalRule(rule);
+
       builder.startRule(rule);
       if (_isInLambda(node)) {
         // Don't allow splitting before the first argument (i.e. right after
         // the bare "(" in a lambda. Instead, just stuff a null chunk in there
         // to avoid confusing the arg rule.
         rule.beforeArgument(null);
       } else {
         // Split before the first argument.
         rule.beforeArgument(zeroSplit());
       }
 
       builder.startSpan();
 
       for (var param in requiredParams) {
         visit(param);
 
         // Write the trailing comma.
         if (param != node.parameters.last) token(param.endToken.next);
 
         if (param != requiredParams.last) rule.beforeArgument(split());
       }
 
       builder.endSpan();
       builder.endRule();
     }
 
     if (optionalParams.isNotEmpty) {
-      var namedRule = new NamedRule(null);
+      var namedRule = new NamedRule(null, 0, 0);
       if (rule != null) rule.setNamedArgsRule(namedRule);
 
+      _metadataRules.last.bindNamedRule(namedRule);
+
       builder.startRule(namedRule);
 
-      namedRule
-          .beforeArguments(builder.split(space: requiredParams.isNotEmpty));
+      // Make sure multi-line default values are indented.
+      builder.startBlockArgumentNesting();
+
+      namedRule.beforeArgument(builder.split(space: requiredParams.isNotEmpty));
 
       // "[" or "{" for optional parameters.
       token(node.leftDelimiter);
 
       for (var param in optionalParams) {
         visit(param);
 
         // Write the trailing comma.
         if (param != node.parameters.last) token(param.endToken.next);
-        if (param != optionalParams.last) split();
+        if (param != optionalParams.last) namedRule.beforeArgument(split());
       }
 
+      builder.endBlockArgumentNesting();
       builder.endRule();
 
       // "]" or "}" for optional parameters.
       token(node.rightDelimiter);
     }
 
+    _metadataRules.removeLast();
+
     token(node.rightParenthesis);
     builder.unnest();
   }
 
   visitForStatement(ForStatement node) {
     builder.nestExpression();
     token(node.forKeyword);
     space();
     token(node.leftParenthesis);
 
     builder.startRule();
 
     // The initialization clause.
     if (node.initialization != null) {
       visit(node.initialization);
     } else if (node.variables != null) {
-      // Indent split variables more so they aren't at the same level
+      // Nest split variables more so they aren't at the same level
       // as the rest of the loop clauses.
-      builder.indent(Indent.loopVariable);
+      builder.nestExpression();
 
       // Allow the variables to stay unsplit even if the clauses split.
       builder.startRule();
 
       var declaration = node.variables;
       visitDeclarationMetadata(declaration.metadata);
       modifier(declaration.keyword);
       visit(declaration.type, after: space);
 
       visitCommaSeparatedNodes(declaration.variables, between: () {
         split();
       });
 
       builder.endRule();
-      builder.unindent();
+      builder.unnest();
     }
 
     token(node.leftSeparator);
 
     // The condition clause.
     if (node.condition != null) split();
     visit(node.condition);
     token(node.rightSeparator);
 
     // The update clause.
     if (node.updaters.isNotEmpty) {
       split();
 
       // Allow the updates to stay unsplit even if the clauses split.
       builder.startRule();
 
       visitCommaSeparatedNodes(node.updaters, between: split);
 
       builder.endRule();
     }
 
     token(node.rightParenthesis);
     builder.endRule();
     builder.unnest();
 
-    // The body.
-    if (node.body is! EmptyStatement) space();
-    visit(node.body);
+    _visitLoopBody(node.body);
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
-    visitMemberMetadata(node.metadata);
-
-    builder.nestExpression();
-    modifier(node.externalKeyword);
-    visit(node.returnType, after: space);
-    modifier(node.propertyKeyword);
-    visit(node.name);
-    visit(node.functionExpression);
-    builder.unnest();
+    _visitMemberDeclaration(node, node.functionExpression);
   }
 
   visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     visit(node.functionDeclaration);
   }
 
   visitFunctionExpression(FunctionExpression node) {
     _visitBody(node.parameters, node.body);
   }
 
@@ skipping 31 matching lines @@
     _visitCombinator(node.keyword, node.hiddenNames);
   }
 
   visitIfStatement(IfStatement node) {
     builder.nestExpression();
     token(node.ifKeyword);
     space();
     token(node.leftParenthesis);
     visit(node.condition);
     token(node.rightParenthesis);
+    builder.unnest(now: false);
 
-    space();
-    visit(node.thenStatement);
-    builder.unnest();
+    visitClause(Statement clause) {
+      if (clause is Block || clause is IfStatement) {
+        space();
+        visit(clause);
+      } else {
+        // Allow splitting in an expression-bodied if even though it's against
+        // the style guide. Since we can't fix the code itself to follow the
+        // style guide, we should at least format it as well as we can.
+        builder.nestExpression(indent: 2, now: true);
+        builder.startRule();
+
+        // If there is an else clause, always split before both the then and
+        // else statements.
+        if (node.elseStatement != null) {
+          builder.writeWhitespace(Whitespace.nestedNewline);
+        } else {
+          split();
+        }
+
+        visit(clause);
+
+        builder.endRule();
+        builder.unnest();
+      }
+    }
+
+    visitClause(node.thenStatement);
 
     if (node.elseStatement != null) {
       if (node.thenStatement is Block) {
         space();
       } else {
         // Corner case where an else follows a single-statement then clause.
         // This is against the style guide, but we still need to handle it. If
         // it happens, put the else on the next line.
         newline();
       }
 
       token(node.elseKeyword);
-      space();
-      visit(node.elseStatement);
+      visitClause(node.elseStatement);
     }
   }
 
   visitImplementsClause(ImplementsClause node) {
     _visitCombinator(node.implementsKeyword, node.interfaces);
   }
 
   visitImportDirective(ImportDirective node) {
     visitDeclarationMetadata(node.metadata);
 
@@ skipping 18 matching lines @@
 
   visitIndexExpression(IndexExpression node) {
     builder.nestExpression();
 
     if (node.isCascaded) {
       token(node.period);
     } else {
       visit(node.target);
     }
 
+    finishIndexExpression(node);
+
+    builder.unnest();
+  }
+
+  /// Visit the index part of [node], excluding the target.
+  ///
+  /// Called by [CallChainVisitor] to handle index expressions in the middle of
+  /// call chains.
+  void finishIndexExpression(IndexExpression node) {
     if (node.target is IndexExpression) {
-      // Corner case: On a chain of [] accesses, allow splitting between them.
+      // Edge case: On a chain of [] accesses, allow splitting between them.
       // Produces nicer output in cases like:
       //
       //     someJson['property']['property']['property']['property']...
       soloZeroSplit();
     }
 
     builder.startSpan();
     token(node.leftBracket);
     soloZeroSplit();
     visit(node.index);
     token(node.rightBracket);
     builder.endSpan();
-    builder.unnest();
   }
 
   visitInstanceCreationExpression(InstanceCreationExpression node) {
     builder.startSpan();
     token(node.keyword);
     space();
+    builder.startSpan(Cost.constructorName);
     visit(node.constructorName);
+    builder.endSpan();
     visit(node.argumentList);
     builder.endSpan();
   }
 
   visitIntegerLiteral(IntegerLiteral node) {
     token(node.literal);
   }
 
   visitInterpolationExpression(InterpolationExpression node) {
     token(node.leftBracket);
@@ skipping 58 matching lines @@
   }
 
   visitMapLiteralEntry(MapLiteralEntry node) {
     visit(node.key);
     token(node.separator);
     soloSplit();
     visit(node.value);
   }
 
   visitMethodDeclaration(MethodDeclaration node) {
-    visitMemberMetadata(node.metadata);
-
-    modifier(node.externalKeyword);
-    modifier(node.modifierKeyword);
-    visit(node.returnType, after: space);
-    modifier(node.propertyKeyword);
-    modifier(node.operatorKeyword);
-    visit(node.name);
-
-    _visitBody(node.parameters, node.body);
+    _visitMemberDeclaration(node, node);
   }
 
   visitMethodInvocation(MethodInvocation node) {
     // If there's no target, this is a "bare" function call like "foo(1, 2)",
     // or a section in a cascade. Handle this case specially.
     if (node.target == null) {
       // Try to keep the entire method invocation one line.
       builder.startSpan();
       builder.nestExpression();
 
       // This will be non-null for cascade sections.
       token(node.operator);
       token(node.methodName.token);
       visit(node.argumentList);
 
       builder.unnest();
       builder.endSpan();
       return;
     }
 
     new CallChainVisitor(this, node).visit();
   }
 
   visitNamedExpression(NamedExpression node) {
     builder.nestExpression();
     builder.startSpan();
     visit(node.name);
-    visit(node.expression, before: soloSplit);
+
+    // Don't allow a split between a name and a collection. Instead, we want
+    // the collection itself to split, or to split before the argument.
+    if (node.expression is ListLiteral || node.expression is MapLiteral) {
+      space();
+    } else {
+      soloSplit();
+    }
+
+    visit(node.expression);
     builder.endSpan();
     builder.unnest();
   }
 
   visitNativeClause(NativeClause node) {
     token(node.nativeKeyword);
     space();
     visit(node.name);
   }
 
@@ skipping 14 matching lines @@
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     builder.nestExpression();
     token(node.leftParenthesis);
     visit(node.expression);
     builder.unnest();
     token(node.rightParenthesis);
   }
 
   visitPartDirective(PartDirective node) {
+    visitDeclarationMetadata(node.metadata);
+
     _simpleStatement(node, () {
       token(node.keyword);
       space();
       visit(node.uri);
     });
   }
 
   visitPartOfDirective(PartOfDirective node) {
+    visitDeclarationMetadata(node.metadata);
+
     _simpleStatement(node, () {
       token(node.keyword);
       space();
       token(node.ofKeyword);
       space();
       visit(node.libraryName);
     });
   }
 
   visitPostfixExpression(PostfixExpression node) {
     visit(node.operand);
     token(node.operator);
   }
 
   visitPrefixedIdentifier(PrefixedIdentifier node) {
-    visit(node.prefix);
-    token(node.period);
-    visit(node.identifier);
+    new CallChainVisitor(this, node).visit();
   }
 
   visitPrefixExpression(PrefixExpression node) {
     token(node.operator);
 
     // Corner case: put a space between successive "-" operators so we don't
     // inadvertently turn them into a "--" decrement operator.
     if (node.operand is PrefixExpression &&
         (node.operand as PrefixExpression).operator.lexeme == "-") {
       space();
@@ skipping 127 matching lines @@
   visitSwitchStatement(SwitchStatement node) {
     builder.nestExpression();
     token(node.switchKeyword);
     space();
     token(node.leftParenthesis);
     soloZeroSplit();
     visit(node.expression);
     token(node.rightParenthesis);
     space();
     token(node.leftBracket);
+    builder.unnest();
     builder.indent();
     newline();
 
     visitNodes(node.members, between: oneOrTwoNewlines, after: newline);
     token(node.rightBracket, before: () {
       builder.unindent();
       newline();
     });
-    builder.unnest();
   }
 
   visitSymbolLiteral(SymbolLiteral node) {
     token(node.poundSign);
     var components = node.components;
     for (var component in components) {
       // The '.' separator
       if (component.previous.lexeme == '.') {
         token(component.previous);
       }
@@ skipping 39 matching lines @@
 
   visitTypeParameter(TypeParameter node) {
     visitParameterMetadata(node.metadata, () {
       visit(node.name);
       token(node.extendsKeyword, before: space, after: space);
       visit(node.bound);
     });
   }
 
   visitTypeParameterList(TypeParameterList node) {
+    _metadataRules.add(new MetadataRule());
+
     _visitGenericList(node.leftBracket, node.rightBracket, node.typeParameters);
+
+    _metadataRules.removeLast();
   }
 
   visitVariableDeclaration(VariableDeclaration node) {
     visit(node.name);
     if (node.initializer == null) return;
 
     _visitAssignment(node.equals, node.initializer);
   }
 
   visitVariableDeclarationList(VariableDeclarationList node) {
     visitDeclarationMetadata(node.metadata);
+
+    // Allow but try to avoid splitting between the type and name.
+    builder.startSpan();
+
     modifier(node.keyword);
-    visit(node.type, after: space);
+    visit(node.type, after: soloSplit);
+
+    builder.endSpan();
 
     // Use a single rule for all of the variables. If there are multiple
     // declarations, we will try to keep them all on one line. If that isn't
     // possible, we split after *every* declaration so that each is on its own
     // line.
     builder.startRule();
     visitCommaSeparatedNodes(node.variables, between: split);
     builder.endRule();
   }
 
   visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     _simpleStatement(node, () {
       visit(node.variables);
     });
   }
 
   visitWhileStatement(WhileStatement node) {
     builder.nestExpression();
     token(node.whileKeyword);
     space();
     token(node.leftParenthesis);
     soloZeroSplit();
     visit(node.condition);
     token(node.rightParenthesis);
-    if (node.body is! EmptyStatement) space();
-    visit(node.body);
-    builder.unnest();
+    builder.unnest(now: false);
+
+    _visitLoopBody(node.body);
   }
 
   visitWithClause(WithClause node) {
     _visitCombinator(node.withKeyword, node.mixinTypes);
   }
 
   visitYieldStatement(YieldStatement node) {
     _simpleStatement(node, () {
       token(node.yieldKeyword);
       token(node.star);
@@ skipping 38 matching lines @@
     } else {
       visitNodes(metadata, between: space, after: spaceOrNewline);
     }
   }
 
   /// Visits metadata annotations on parameters and type parameters.
   ///
   /// These are always on the same line as the parameter.
   void visitParameterMetadata(
       NodeList<Annotation> metadata, void visitParameter()) {
+    if (metadata == null || metadata.isEmpty) {
+      visitParameter();
+      return;
+    }
+
     // Split before all of the annotations or none.
-    builder.startRule();
-    visitNodes(metadata, between: split, after: split);
+    builder.startLazyRule(_metadataRules.last);
+
+    visitNodes(metadata, between: split, after: () {
+      // Don't nest until right before the last metadata. Ensures we only
+      // indent the parameter and not any of the metadata:
+      //
+      //     function(
+      //         @LongAnnotation
+      //         @LongAnnotation
+      //             indentedParameter) {}
+      builder.nestExpression(now: true);
+      split();
+    });
     visitParameter();
 
+    builder.unnest();
+
     // Wrap the rule around the parameter too. If it splits, we want to force
     // the annotations to split as well.
     builder.endRule();
   }
 
   /// Visits the `=` and the following expression in any place where an `=`
   /// appears:
   ///
   /// * Assignment
   /// * Variable declaration
   /// * Constructor initialization
   void _visitAssignment(Token equalsOperator, Expression rightHandSide) {
     space();
     token(equalsOperator);
-    soloSplit(Cost.assignment);
+    soloSplit(_assignmentCost(rightHandSide));
     builder.startSpan();
     visit(rightHandSide);
     builder.endSpan();
   }
 
   /// Visits a type parameter or type argument list.
   void _visitGenericList(
       Token leftBracket, Token rightBracket, List<AstNode> nodes) {
     var rule = new TypeArgumentRule();
     builder.startRule(rule);
@@ skipping 13 matching lines @@
       }
     }
 
     token(rightBracket);
 
     builder.unnest();
     builder.endSpan();
     builder.endRule();
   }
 
+  /// Visits a top-level function or method declaration.
+  ///
+  /// The two AST node types are very similar but, alas, share no common
+  /// interface type in analyzer, hence the dynamic typing.
+  void _visitMemberDeclaration(
+      /* FunctionDeclaration|MethodDeclaration */ node,
+      /* FunctionExpression|MethodDeclaration */ function) {
+    visitMemberMetadata(node.metadata);
+
+    // Nest the signature in case we have to split between the return type and
+    // name.
+    builder.nestExpression();
+    builder.startSpan();
+    modifier(node.externalKeyword);
+    if (node is MethodDeclaration) modifier(node.modifierKeyword);
+    visit(node.returnType, after: soloSplit);
+    modifier(node.propertyKeyword);
+    if (node is MethodDeclaration) modifier(node.operatorKeyword);
+    visit(node.name);
+    builder.endSpan();
+
+    // If the body is a block, we need to exit any nesting first. If it's an
+    // expression, we want to wrap the nesting around that so that the body
+    // gets nested farther.
+    if (function.body is! ExpressionFunctionBody) builder.unnest();
+
+    _visitBody(function.parameters, function.body);
+
+    if (function.body is ExpressionFunctionBody) builder.unnest();
+  }
+
   /// Visit the given function [parameters] followed by its [body], printing a
   /// space before it if it's not empty.
   ///
   /// If [afterParameters] is provided, it is invoked between the parameters
   /// and body. (It's used for constructor initialization lists.)
   void _visitBody(FormalParameterList parameters, FunctionBody body,
       [afterParameters()]) {
     // If the body is "=>", add an extra level of indentation around the
     // parameters and a rule that spans the parameters and the "=>". This
     // ensures that if the parameters wrap, they wrap more deeply than the "=>"
@@ skipping 14 matching lines @@
     // level when they are actually unrelated. Splitting at "=>" forces:
     //
     //     someFunction(parameter,
     //             parameter) =>
     //         function(
     //             argument);
     if (body is ExpressionFunctionBody) {
       builder.nestExpression();
 
       // This rule is ended by visitExpressionFunctionBody().
-      builder.startLazyRule(new SimpleRule(cost: Cost.arrow));
+      builder.startLazyRule(new Rule(Cost.arrow));
     }
 
     if (parameters != null) {
       builder.nestExpression();
+      visit(parameters);
+      builder.unnest();
 
-      visit(parameters);
       if (afterParameters != null) afterParameters();
-
-      builder.unnest();
     }
 
     visit(body);
 
     if (body is ExpressionFunctionBody) builder.unnest();
   }
 
+  /// Visits the body statement of a `for` or `for in` loop.
+  void _visitLoopBody(Statement body) {
+    if (body is EmptyStatement) {
+      // No space before the ";".
+      visit(body);
+    } else if (body is Block) {
+      space();
+      visit(body);
+    } else {
+      // Allow splitting in an expression-bodied for even though it's against
+      // the style guide. Since we can't fix the code itself to follow the
+      // style guide, we should at least format it as well as we can.
+      builder.nestExpression(indent: 2, now: true);
+      builder.startRule();
+
+      split();
+      visit(body);
+
+      builder.endRule();
+      builder.unnest();
+    }
+  }
+
   /// Visit a list of [nodes] if not null, optionally separated and/or preceded
   /// and followed by the given functions.
   void visitNodes(Iterable<AstNode> nodes, {before(), between(), after()}) {
     if (nodes == null || nodes.isEmpty) return;
 
     if (before != null) before();
 
     visit(nodes.first);
     for (var node in nodes.skip(1)) {
       if (between != null) between();
@@ skipping 26 matching lines @@
   void _visitCollectionLiteral(TypedLiteral node, Token leftBracket,
       Iterable<AstNode> elements, Token rightBracket,
       [int cost]) {
     modifier(node.constKeyword);
     visit(node.typeArguments);
 
     // Don't allow splitting in an empty collection.
     if (elements.isEmpty && rightBracket.precedingComments == null) {
       token(leftBracket);
       token(rightBracket);
-
-      // Clear this out in case this empty collection is in an argument list.
-      // We don't want this rule to bleed over to some other collection.
-      _nextLiteralBodyRule = null;
       return;
     }
 
     // Force all of the surrounding collections to split.
     for (var i = 0; i < _collectionSplits.length; i++) {
       _collectionSplits[i] = true;
     }
 
     // Add this collection to the stack.
     _collectionSplits.add(false);
 
     _startLiteralBody(leftBracket);
 
     // Always use a hard rule to split the elements. The parent chunk of
     // the collection will handle the unsplit case, so this only comes
     // into play when the collection is split.
-    var rule = new HardSplitRule();
+    var rule = new Rule.hard();
     builder.startRule(rule);
 
     // If a collection contains a line comment, we assume it's a big complex
     // blob of data with some documented structure. In that case, the user
     // probably broke the elements into lines deliberately, so preserve those.
     var preserveNewlines = _containsLineComments(elements, rightBracket);
 
     for (var element in elements) {
       if (element != elements.first) {
         if (preserveNewlines) {
           if (_endLine(element.beginToken.previous) !=
               _startLine(element.beginToken)) {
             oneOrTwoNewlines();
           } else {
             soloSplit();
           }
         } else {
-          builder.blockSplit(space: true);
+          builder.split(nest: false, space: true);
         }
       }
 
       builder.nestExpression();
       visit(element);
 
       // The comma after the element.
       if (element.endToken.next.lexeme == ",") token(element.endToken.next);
 
       builder.unnest();
     }
 
     builder.endRule();
 
     // If there is a collection inside this one, it forces this one to split.
     var force = _collectionSplits.removeLast();
 
     _endLiteralBody(rightBracket, ignoredRule: rule, forceSplit: force);
   }
 
+  /// Gets the cost to split at an assignment (or `:` in the case of a named
+  /// default value) with the given [rightHandSide].
+  ///
+  /// "Block-like" expressions (collections and cascades) bind a bit tighter
+  /// because it looks better to have code like:
+  ///
+  ///     var list = [
+  ///       element,
+  ///       element,
+  ///       element
+  ///     ];
+  ///
+  ///     var builder = new SomeBuilderClass()
+  ///       ..method()
+  ///       ..method();
+  ///
+  /// over:
+  ///
+  ///     var list =
+  ///         [element, element, element];
+  ///
+  ///     var builder =
+  ///         new SomeBuilderClass()..method()..method();
+  int _assignmentCost(Expression rightHandSide) {
+    if (rightHandSide is ListLiteral) return Cost.assignBlock;
+    if (rightHandSide is MapLiteral) return Cost.assignBlock;
+    if (rightHandSide is CascadeExpression) return Cost.assignBlock;
+
+    return Cost.assign;
+  }
+
   /// Returns `true` if the collection withs [elements] delimited by
   /// [rightBracket] contains any line comments.
   ///
   /// This only looks for comments at the element boundary. Comments within an
   /// element are ignored.
   bool _containsLineComments(Iterable<AstNode> elements, Token rightBracket) {
     hasLineCommentBefore(token) {
       var comment = token.precedingComments;
       for (; comment != null; comment = comment.next) {
         if (comment.type == TokenType.SINGLE_LINE_COMMENT) return true;
@@ skipping 12 matching lines @@
   }
 
   /// Begins writing a literal body: a collection or block-bodied function
   /// expression.
   ///
   /// Writes the delimiter and then creates the [Rule] that handles splitting
   /// the body.
   void _startLiteralBody(Token leftBracket) {
     token(leftBracket);
 
-    // Split the literal. Use the explicitly given rule if we have one.
-    // Otherwise, create a new rule.
-    var rule = _nextLiteralBodyRule;
-    _nextLiteralBodyRule = null;
+    // 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 (_collectionArgumentLists.containsKey(leftBracket)) {
+      var argumentList = _collectionArgumentLists[leftBracket];
+      rule = argumentList.collectionRule;
+      argumentChunk = argumentList.previousSplit;
+    }
 
     // Create a rule for whether or not to split the block contents.
     builder.startRule(rule);
 
     // Process the collection contents as a separate set of chunks.
-    builder = builder.startBlock();
+    builder = builder.startBlock(argumentChunk);
   }
 
   /// Ends the literal body started by a call to [_startLiteralBody()].
   ///
   /// If [forceSplit] is `true`, forces the body to split. If [ignoredRule] is
   /// given, ignores that rule inside the body when determining if it should
   /// split.
   void _endLiteralBody(Token rightBracket,
       {Rule ignoredRule, bool forceSplit}) {
     if (forceSplit == null) forceSplit = false;
@@ skipping 39 matching lines @@
   void _simpleStatement(AstNode node, body()) {
     builder.nestExpression();
     body();
 
     // TODO(rnystrom): Can the analyzer move "semicolon" to some shared base
     // type?
     token((node as dynamic).semicolon);
     builder.unnest();
   }
 
-  /// Makes [rule] the rule that will be used for the contents of a collection
-  /// or function literal body that are about to be visited.
-  void setNextLiteralBodyRule(Rule rule) {
-    _nextLiteralBodyRule = rule;
+  /// Marks the collection literal that starts with [leftBracket] as being
+  /// controlled by [argumentList].
+  ///
+  /// When the collection is visited, [argumentList] will determine the
+  /// indentation and splitting rule for the collection.
+  void beforeCollection(Token leftBracket, ArgumentSublist argumentList) {
+    _collectionArgumentLists[leftBracket] = argumentList;
   }
 
   /// Writes an bracket-delimited body and handles indenting and starting the
   /// rule used to split the contents.
   ///
   /// If [space] is `true`, then the contents and delimiters will have a space
   /// between then when unsplit.
   void _writeBody(Token leftBracket, Token rightBracket,
       {bool space: false, body()}) {
     token(leftBracket);
 
     // Indent the body.
     builder.indent();
 
     // Split after the bracket.
     builder.startRule();
-    builder.blockSplit(space: space, isDouble: false);
+    builder.split(isDouble: false, nest: false, space: space);
 
     body();
 
     token(rightBracket, before: () {
       // Split before the closing bracket character.
       builder.unindent();
-      builder.blockSplit(space: space);
+      builder.split(nest: false, space: space);
     });
 
     builder.endRule();
   }
 
   /// Returns `true` if [node] is immediately contained within an anonymous
   /// [FunctionExpression].
-  bool _isInLambda(AstNode node) => node.parent is FunctionExpression &&
+  bool _isInLambda(AstNode node) =>
+      node.parent is FunctionExpression &&
       node.parent.parent is! FunctionDeclaration;
 
   /// Writes the string literal [string] to the output.
   ///
   /// Splits multiline strings into separate chunks so that the line splitter
   /// can handle them correctly.
   void _writeStringLiteral(String string, int offset) {
     // Split each line of a multiline string into separate chunks.
     var lines = string.split(_formatter.lineEnding);
 
@@ skipping 55 matching lines @@
   /// Returns the chunk the split was applied to.
   Chunk split() => builder.split(space: true);
 
   /// Writes a zero-space split owned by the current rule.
   ///
   /// Returns the chunk the split was applied to.
   Chunk zeroSplit() => builder.split();
 
   /// Writes a single space split with its own rule.
   void soloSplit([int cost]) {
-    builder.startRule(new SimpleRule(cost: cost));
+    builder.startRule(new Rule(cost));
     split();
     builder.endRule();
   }
 
   /// Writes a zero-space split with its own rule.
   void soloZeroSplit() {
     builder.startRule();
     builder.split();
     builder.endRule();
   }
@@ skipping 200 matching lines @@
   /// Gets the 1-based line number that the beginning of [token] lies on.
   int _startLine(Token token) => _lineInfo.getLocation(token.offset).lineNumber;
 
   /// Gets the 1-based line number that the end of [token] lies on.
   int _endLine(Token token) => _lineInfo.getLocation(token.end).lineNumber;
 
   /// Gets the 1-based column number that the beginning of [token] lies on.
   int _startColumn(Token token) =>
       _lineInfo.getLocation(token.offset).columnNumber;
 }