Refactor SsaBuilder.visitStaticSend and visitGetterSend.

pkg/compiler/lib/src/resolution/send_structure.dart

 // Copyright (c) 2015, 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 dart2js.send_structure;
 
 import 'access_semantics.dart';
 import 'operators.dart';
 import 'semantic_visitor.dart';
 import '../dart_types.dart';
@@ skipping 315 matching lines @@
             callStructure,
             arg);
       case AccessKind.CONSTANT:
         return visitor.visitConstantInvoke(
             node,
             semantics.constant,
             node.argumentsNode,
             callStructure,
             arg);
       case AccessKind.UNRESOLVED:
-        return visitor.errorUnresolvedInvoke(
+        return visitor.visitUnresolvedInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             selector,
             arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperInvoke(
             node,
             semantics.element,
             node.argumentsNode,
@@ skipping 20 matching lines @@
   final Selector selector;
 
   /// The [CallStructure] of the invocation.
   // TODO(johnniwinther): Store this directly for static invocations.
   CallStructure get callStructure => selector.callStructure;
 
   IncompatibleInvokeStructure(this.semantics, this.selector);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
+      case AccessKind.STATIC_METHOD:
+        return visitor.visitStaticFunctionIncompatibleInvoke(
+            node,
+            semantics.element,
+            node.argumentsNode,
+            callStructure,
+            arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperMethodIncompatibleInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             callStructure,
             arg);
-      default:
+      case AccessKind.TOPLEVEL_METHOD:
+        return visitor.visitTopLevelFunctionIncompatibleInvoke(
+            node,
+            semantics.element,
+            node.argumentsNode,
+            callStructure,
+            arg);
+     default:
         // TODO(johnniwinther): Support more variants of this invoke structure.
         break;
     }
     throw new SpannableAssertionFailure(
         node, "Invalid incompatible invoke: ${semantics}");
   }
 
   String toString() => 'incompatible-invoke($selector, $semantics)';
 }
 
@@ skipping 120 matching lines @@
         return visitor.errorSuperSetterGet(
             node,
             semantics.element,
             arg);
       case AccessKind.CONSTANT:
         return visitor.visitConstantGet(
             node,
             semantics.constant,
             arg);
       case AccessKind.UNRESOLVED:
-        return visitor.errorUnresolvedGet(
+        return visitor.visitUnresolvedGet(
             node,
             semantics.element,
             arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperGet(
             node,
             semantics.element,
             arg);
       case AccessKind.COMPOUND:
         // This is not a valid case.
@@ skipping 1613 matching lines @@
   final ConstructorElement constructor;
   final Selector selector;
 
   ThisConstructorInvokeStructure(this.constructor, this.selector);
 
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitThisConstructorInvoke(
         node, constructor, node.argumentsNode, selector, arg);
   }
 }