Deprecate visitStaticSend in ResolvedVisitor.

pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart

 // Copyright (c) 2013, 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 simple_types_inferrer;
 
 import '../closure.dart' show
     ClosureClassMap,
     ClosureScope;
 import '../common/names.dart' show
@@ skipping 574 matching lines @@
         locals.update(element, parameterType, node);
       });
       ClassElement cls = analyzedElement.enclosingClass;
       Spannable spannable = node;
       if (analyzedElement.isSynthesized) {
         spannable = analyzedElement;
         ConstructorElement constructor = analyzedElement;
         synthesizeForwardingCall(spannable, constructor.definingConstructor);
       } else {
         visitingInitializers = true;
-        visit(node.initializers);
+        if (node.initializers != null) {
+          for (ast.Node initializer in node.initializers) {
+            ast.SendSet fieldInitializer = initializer.asSendSet();
+            if (fieldInitializer != null) {
+              handleSendSet(fieldInitializer);
+            } else {
+              Element element = elements[initializer];
+              handleConstructorSend(initializer, element);
+            }
+          }
+        }
         visitingInitializers = false;
         // For a generative constructor like: `Foo();`, we synthesize
         // a call to the default super constructor (the one that takes
         // no argument). Resolution ensures that such a constructor
         // exists.
         if (!isConstructorRedirect
             && !seenSuperConstructorCall
             && !cls.isObject) {
           FunctionElement target = cls.superclass.lookupDefaultConstructor();
           ArgumentsTypes arguments = new ArgumentsTypes([], {});
@@ skipping 970 matching lines @@
   @override
   T handleTypeLiteralInvoke(ast.NodeList arguments) {
     // This is reached when users forget to put a `new` in front of a type
     // literal. The emitter will generate an actual call (even though it is
     // likely invalid), and for that it needs to have the arguments processed
     // as well.
     analyzeArguments(arguments.nodes);
     return super.handleTypeLiteralInvoke(arguments);
   }
 
-  T visitStaticSend(ast.Send node) {
-    assert(!elements.isAssert(node));
-    Element element = elements[node];
-    return handleConstructorSend(node, element);
-  }
-
   /// Handle constructor invocation of [element].
   T handleConstructorSend(ast.Send node, ConstructorElement element) {
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     if (visitingInitializers) {
       if (ast.Initializers.isConstructorRedirect(node)) {
         isConstructorRedirect = true;
       } else if (ast.Initializers.isSuperConstructorCall(node)) {
         seenSuperConstructorCall = true;
         analyzeSuperConstructorCall(element, arguments);
       }
@@ skipping 51 matching lines @@
       return inferrer.concreteTypes.putIfAbsent(
         node, () => types.allocateList(
           types.nonNullExact(constructor.enclosingClass), node,
           outermostElement, elementType, length));
     } else {
       return returnType;
     }
   }
 
   T handleNewExpression(ast.NewExpression node) {
-    return visitStaticSend(node.send);
+    Element element = elements[node.send];
+    return handleConstructorSend(node.send, element);
   }
 
   /// Handle invocation of a top level or static field or getter [element].
   T handleStaticFieldOrGetterInvoke(ast.Send node, Element element) {
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
     TypeMask mask = elements.getTypeMask(node);
     handleStaticSend(node, selector, mask, element, arguments);
     return inferrer.registerCalledClosure(
               node, selector, mask, inferrer.typeOfElement(element),
@@ skipping 634 matching lines @@
     TypeMask moveNextMask = elements.getMoveNextTypeMask(node);
 
     T iteratorType = handleDynamicSend(
         node, iteratorSelector, iteratorMask, expressionType,
         new ArgumentsTypes<T>.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
                            moveNextSelector, moveNextMask);
   }
 }