Make InferrerVisitor implement SemanticSendVisitor directly and delete 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 832 matching lines @@
     bool isIncrementOrDecrement = op == '++' || op == '--';
 
     T receiverType;
     bool isCallOnThis = false;
     if (node.receiver == null) {
       if (treatAsInstanceMember(element)) {
         receiverType = thisType;
         isCallOnThis = true;
       }
     } else {
-      receiverType = visit(node.receiver);
+      if (node.receiver != null && elements[node.receiver] is! PrefixElement) {
+        // TODO(johnniwinther): Avoid blindly recursing on the receiver.
+        receiverType = visit(node.receiver);
+      }
       isCallOnThis = isThisOrSuper(node.receiver);
     }
 
     T rhsType;
 
     if (isIncrementOrDecrement) {
       rhsType = types.uint31Type;
       if (node.isIndex) visit(node.arguments.head);
     } else if (node.isIndex) {
       visit(node.arguments.head);
@@ skipping 486 matching lines @@
                    Element element) {
     // TODO(herhut): We could do better here if we knew what we
     // are calling does not expose this.
     isThisExposed = true;
     Selector selector = elements.getSelector(node);
     TypeMask mask = elements.getTypeMask(node);
     return handleStaticSend(
         node, selector, mask, element, null);
   }
 
-  /// Handle super constructor invocation.
-  @override
-  T handleSuperConstructorInvoke(ast.Send node) {
-    Element element = elements[node];
-    ArgumentsTypes arguments = analyzeArguments(node.arguments);
-    assert(visitingInitializers);
-    seenSuperConstructorCall = true;
-    analyzeSuperConstructorCall(element, arguments);
-    Selector selector = elements.getSelector(node);
-    TypeMask mask = elements.getTypeMask(node);
-    return handleStaticSend(
-        node, selector, mask, element, arguments);
-  }
-
   @override
   T visitUnresolvedSuperIndex(
       ast.Send node,
       Element element,
       ast.Node index,
       _) {
     return handleErroneousSuperSend(node);
   }
 
   @override
@@ skipping 90 matching lines @@
       ast.Send node,
       MethodElement method,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return handleSuperMethodInvoke(
         node, method, analyzeArguments(arguments.nodes));
   }
 
   @override
+  T visitSuperSetterInvoke(
+      ast.Send node,
+      FunctionElement setter,
+      ast.NodeList arguments,
+      CallStructure callStructure,
+      _) {
+    return handleErroneousSuperSend(node);
+  }
+
+  @override
   T visitSuperIndex(
       ast.Send node,
       MethodElement method,
       ast.Node index,
       _) {
     return handleSuperMethodInvoke(
         node, method, analyzeArguments(node.arguments));
   }
 
   @override
@@ skipping 162 matching lines @@
           constructor.enclosingClass.lookupMember('[]'));
       return inferrer.concreteTypes.putIfAbsent(
         node, () => types.allocateList(
           types.nonNullExact(constructor.enclosingClass), node,
           outermostElement, elementType, length));
     } else {
       return returnType;
     }
   }
 
-  T handleNewExpression(ast.NewExpression node) {
+  @override
+  T bulkHandleNew(ast.NewExpression node, _) {
     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);
@@ skipping 161 matching lines @@
       } else {
         positional.add(argument.accept(this));
       }
       // TODO(ngeoffray): We could do better here if we knew what we
       // are calling does not expose this.
       isThisExposed = isThisExposed || argument.isThis();
     }
     return new ArgumentsTypes<T>(positional, named);
   }
 
-  T visitGetterSend(ast.Send node) {
-    if (elements[node] is! PrefixElement) {
-      // TODO(johnniwinther): Remove this when no longer called from
-      // [handleSendSet].
-      internalError(node, "Unexpected visitGetterSend");
-    }
-    return null;
-  }
-
   /// Read a local variable, function or parameter.
   T handleLocalGet(ast.Send node, LocalElement local) {
     assert(locals.use(local) != null);
     return locals.use(local);
   }
 
   /// Read a static or top level field.
   T handleStaticFieldGet(ast.Send node, FieldElement field) {
     Selector selector = elements.getSelector(node);
     TypeMask mask = elements.getTypeMask(node);
@@ skipping 446 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);
   }
 }