Refactor common logic of SsaBuilder.visitSend.

lib/compiler/implementation/tree/nodes.dart

Index: lib/compiler/implementation/tree/nodes.dart
diff --git a/lib/compiler/implementation/tree/nodes.dart b/lib/compiler/implementation/tree/nodes.dart
index f5aa5adcded14326fc9d60e49603f1ca1b960fd2..332054facb8065b8fb4e90e3e6d1745abee6fe2b 100644
--- a/lib/compiler/implementation/tree/nodes.dart
+++ b/lib/compiler/implementation/tree/nodes.dart
@@ -293,6 +293,54 @@ class Send extends Expression {
     assert(receiver === null);
     return new Send(newReceiver, selector, argumentsNode);
   }
+
+  analyse([

[ahe, 2012/06/01 13:50:34]

To be perfectly clear: I don't like this method.

What I don't like is the following:

* the name of the method.

* optional arguments

* the argument methodInterceptionEnabled (it doesn't belong here).

[Anton Muhin, 2012/06/01 14:07:06]

What will you like more?  analyseSubtype?  subtypeAccess?
Sorry, those a remnants of passing many closures, with new interface they may go
away.
That irritates me too, but do you have any better idea? One option would be to
move methodIntercepted into SSA builder as if methodInterception is false:
visitDynamicSend/visitForeignSend abd staticSend would check if node.isOperator
and methodInterceptionEnable and delegate to visitOperatorSend, wdyt?

+      bool methodInterceptionEnabled,
+      TreeElements elements,
+      SendVisitor sendVisitor]) {
+    if (isSuperCall) {
+      return sendVisitor.visitSuperSend(this);
+    } else if (isOperator && methodInterceptionEnabled) {
+      return sendVisitor.visitOperatorSend(this);
+    } else if (isPropertyAccess) {
+      return sendVisitor.visitGetterSend(this);
+    } else if (Elements.isClosureSend(this, elements)) {
+      return sendVisitor.visitClosureSend(this);
+    } else {
+      Element element = elements[this];
+      if (element === null) {
+        // Example: f() with 'f' unbound.
+        // This can only happen inside an instance method.
+        return sendVisitor.visitDynamicSend(this);
+      } else if (element.kind == ElementKind.CLASS) {
+        sendVisitor.internalError("Cannot generate code for send", node: node);
+      } else if (element.isInstanceMember()) {
+        // Example: f() with 'f' bound to instance method.
+        return sendVisitor.visitDynamicSend(this);
+      } else if (element.kind === ElementKind.FOREIGN) {
+        return sendVisitor.visitForeignSend(this);
+      } else if (!element.isInstanceMember()) {
+        // Example: A.f() or f() with 'f' bound to a static function.
+        // Also includes new A() or new A.named() which is treated like a
+        // static call to a factory.
+        return sendVisitor.visitStaticSend(this);
+      } else {
+        sendVisitor.internalError("Cannot generate code for send", node: node);
+      }
+    }
+  }
+}
+
+interface SendVisitor {
+  visitSuperSend(Send node);
+  visitOperatorSend(Send node);
+  visitGetterSend(Send node);
+  visitClosureSend(Send node);
+  visitDynamicSend(Send node);
+  visitForeignSend(Send node);
+  visitStaticSend(Send node);
+
+  internalError(String reason, [Node node]);
 }
 
 class Postfix extends NodeList {