Handle index expressions in the middle of call chains.

lib/src/call_chain_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.call_chain_visitor;
 
 import 'package:analyzer/analyzer.dart';
 
 import 'argument_list_visitor.dart';
 import 'rule/argument.dart';
@@ skipping 33 matching lines @@
   /// operators and must be a [MethodInvocation], [PropertyAccess] or
   /// [PrefixedIdentifier].
   factory CallChainVisitor(SourceVisitor visitor, Expression node) {
     var target;
 
     // Recursively walk the chain of calls and turn the tree into a list.
     var calls = [];
     flatten(expression) {
       target = expression;
 
-      if (expression is MethodInvocation && expression.target != null) {
-        flatten(expression.target);
+      // Treat index expressions where the target is a valid call in a method
+      // chain as being part of the call. Handles cases like:
+      //
+      //     receiver
+      //         .property
+      //         .property[0]
+      //         .property
+      //         .property;
+      var call = expression;
+      while (call is IndexExpression) call = call.target;
+
+      if (call is MethodInvocation && call.target != null) {
+        flatten(call.target);
         calls.add(expression);
-      } else if (expression is PropertyAccess && expression.target != null) {
-        flatten(expression.target);
+      } else if (call is PropertyAccess && call.target != null) {
+        flatten(call.target);
         calls.add(expression);
-      } else if (expression is PrefixedIdentifier) {
-        flatten(expression.prefix);
+      } else if (call is PrefixedIdentifier) {
+        flatten(call.prefix);
         calls.add(expression);
       }
     }
 
     flatten(node);
 
     // An expression that starts with a series of dotted names gets treated a
     // little specially. We don't force leading properties to split with the
     // rest of the chain. Allows code like:
     //
@@ skipping 56 matching lines @@
     }
 
     _disableRule();
     _endSpan();
 
     if (unnest) _visitor.builder.unnest();
   }
 
   /// Writes [call], which must be one of the supported expression types.
   void _writeCall(Expression call) {
-    if (call is MethodInvocation) {
+    if (call is IndexExpression) {
+      _visitor.builder.nestExpression();
+      _writeCall(call.target);
+      _visitor.finishIndexExpression(call);
+      _visitor.builder.unnest();
+    } else if (call is MethodInvocation) {
       _writeInvocation(call);
     } else if (call is PropertyAccess) {
-      _writePropertyAccess(call);
+      _visitor.token(call.operator);
+      _visitor.visit(call.propertyName);
     } else if (call is PrefixedIdentifier) {
-      _writePrefixedIdentifier(call);
+      _visitor.token(call.period);
+      _visitor.visit(call.identifier);
     } else {
       // Unexpected type.
       assert(false);
     }
   }
 
   void _writeInvocation(MethodInvocation invocation) {
     _visitor.token(invocation.operator);
     _visitor.token(invocation.methodName.token);
 
@@ skipping 50 matching lines @@
         _calls.length == 1 &&
         _target is SimpleIdentifier) {
       _endSpan();
     }
 
     _visitor.visit(invocation.argumentList);
 
     if (args.nestMethodArguments) _visitor.builder.endBlockArgumentNesting();
   }
 
-  void _writePropertyAccess(PropertyAccess property) {
-    _visitor.token(property.operator);
-    _visitor.visit(property.propertyName);
-  }
-
-  void _writePrefixedIdentifier(PrefixedIdentifier prefix) {
-    _visitor.token(prefix.period);
-    _visitor.visit(prefix.identifier);
-  }
-
   /// If a [Rule] for the method chain is currently active, ends it.
   void _disableRule() {
     if (_ruleEnabled == false) return;
 
     _visitor.builder.endRule();
     _ruleEnabled = false;
   }
 
   /// Creates a new method chain [Rule] if one is not already active.
   void _enableRule() {
     if (_ruleEnabled) return;
 
     _visitor.builder.startRule();
     _ruleEnabled = true;
   }
 
   /// Ends the span wrapping the call chain if it hasn't ended already.
   void _endSpan() {
     if (_spanEnded) return;
 
     _visitor.builder.endSpan();
     _spanEnded = true;
   }
 }