Removed fixed dependencies

packages/dart_style/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 76 matching lines @@
 
   /// Creates a new call chain visitor for [visitor] starting with [node].
   ///
   /// The [node] is the outermost expression containing the chained "."
   /// 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 = [];
+    var calls = <Expression>[];
     flatten(expression) {
       target = expression;
 
       // 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
@@ skipping 15 matching lines @@
 
     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:
     //
     //     address.street.number
     //       .toString()
     //       .length;
-    var properties = [];
+    var properties = <Expression>[];
     if (target is SimpleIdentifier) {
       properties = calls.takeWhile((call) {
         // Step into index expressions to see what the index is on.
-        while (call is IndexExpression) call = call.target;
+        while (call is IndexExpression) {
+          call = (call as IndexExpression).target;
+        }
         return call is! MethodInvocation;
       }).toList();
     }
 
     calls.removeRange(0, properties.length);
 
     // Separate out the block calls, if there are any.
-    var blockCalls;
+    List<Expression> blockCalls;
     var hangingCall;
 
     var inBlockCalls = false;
     for (var call in calls) {
       // See if this call is a method call whose arguments are block formatted.
       var isBlockCall = false;
       if (call is MethodInvocation) {
         var args = new ArgumentListVisitor(visitor, call.argumentList);
         isBlockCall = args.hasBlockArguments;
       }
@@ skipping 44 matching lines @@
 
     // Try to keep the entire method invocation one line.
     _visitor.builder.startSpan();
 
     // If a split in the target expression forces the first `.` to split, then
     // start the rule now so that it surrounds the target.
     var splitOnTarget = _forcesSplit(_target);
 
     if (splitOnTarget) {
       if (_properties.length > 1) {
-        _propertyRule = new MultiplePositionalRule(null, 0, 0);
+        _propertyRule = new PositionalRule(null, 0, 0);
         _visitor.builder.startLazyRule(_propertyRule);
       } else if (_calls.isNotEmpty) {
         _enableRule(lazy: true);
       }
     }
 
     _visitor.visit(_target);
 
     // Leading properties split like positional arguments: either not at all,
     // before one ".", or before all of them.
     if (_properties.length == 1) {
       _visitor.soloZeroSplit();
       _writeCall(_properties.single);
     } else if (_properties.length > 1) {
       if (!splitOnTarget) {
-        _propertyRule = new MultiplePositionalRule(null, 0, 0);
+        _propertyRule = new PositionalRule(null, 0, 0);
         _visitor.builder.startRule(_propertyRule);
       }
 
       for (var property in _properties) {
         _propertyRule.beforeArgument(_visitor.zeroSplit());
         _writeCall(property);
       }
 
       _visitor.builder.endRule();
     }
@@ skipping 71 matching lines @@
 
     // Don't split right after a non-empty curly-bodied function.
     if (expression is FunctionExpression) {
       if (expression.body is! BlockFunctionBody) return false;
 
       return (expression.body as BlockFunctionBody).block.statements.isEmpty;
     }
 
     // If the expression ends in an argument list, base the splitting on the
     // last argument.
-    var argumentList;
+    ArgumentList argumentList;
     if (expression is MethodInvocation) {
       argumentList = expression.argumentList;
     } else if (expression is InstanceCreationExpression) {
       argumentList = expression.argumentList;
     } else if (expression is FunctionExpressionInvocation) {
       argumentList = expression.argumentList;
     }
 
     // Any other kind of expression always splits.
     if (argumentList == null) return true;
     if (argumentList.arguments.isEmpty) return true;
 
     var argument = argumentList.arguments.last;
-    if (argument is NamedExpression) argument = argument.expression;
+    if (argument is NamedExpression) {
+      argument = (argument as NamedExpression).expression;
+    }
 
     // TODO(rnystrom): This logic is similar (but not identical) to
     // ArgumentListVisitor.hasBlockArguments. They overlap conceptually and
     // both have their own peculiar heuristics. It would be good to unify and
     // rationalize them.
 
     return _forcesSplit(argument);
   }
 
   /// Writes [call], which must be one of the supported expression types.
@@ skipping 47 matching lines @@
     // "." when calling a single method on a single name. This is especially
     // important because the identifier is often a library prefix, and splitting
     // there looks really odd.
     if (_properties.isEmpty &&
         _calls.length == 1 &&
         _blockCalls == null &&
         _target is SimpleIdentifier) {
       _endSpan();
     }
 
-    _visitor.visit(invocation.argumentList);
+    _visitor.builder.nestExpression();
+    _visitor.visit(invocation.typeArguments);
+    _visitor.visitArgumentList(invocation.argumentList, nestExpression: false);
+    _visitor.builder.unnest();
   }
 
   void _writeBlockCall(MethodInvocation invocation) {
     _visitor.token(invocation.operator);
     _visitor.token(invocation.methodName.token);
+    _visitor.visit(invocation.typeArguments);
     _visitor.visit(invocation.argumentList);
   }
 
   /// If a [Rule] for the method chain is currently active, ends it.
   void _disableRule() {
     if (_ruleEnabled == false) return;
 
     _visitor.builder.endRule();
     _ruleEnabled = false;
   }
@@ skipping 16 matching lines @@
   }
 
   /// Ends the span wrapping the call chain if it hasn't ended already.
   void _endSpan() {
     if (_spanEnded) return;
 
     _visitor.builder.endSpan();
     _spanEnded = true;
   }
 }