Refactor common logic of SsaBuilder.visitSend.

lib/compiler/implementation/tree/nodes.dart

 // Copyright (c) 2012, 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.
 
 interface Visitor<R> {
   R visitBlock(Block node);
   R visitBreakStatement(BreakStatement node);
   R visitCascade(Cascade node);
   R visitCascadeReceiver(CascadeReceiver node);
   R visitCaseMatch(CaseMatch node);
@@ skipping 275 matching lines @@
       return argumentsNode.getEndToken();
     }
     if (selector !== null) return selector.getEndToken();
     return receiver.getBeginToken();
   }
 
   Send copyWithReceiver(Node newReceiver) {
     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 {
   Postfix() : super(nodes: const EmptyLink<Node>());
   Postfix.singleton(Node argument) : super.singleton(argument);
 }
 
 class Prefix extends NodeList {
   Prefix() : super(nodes: const EmptyLink<Node>());
   Prefix.singleton(Node argument) : super.singleton(argument);
@@ skipping 1394 matching lines @@
  * argument).
  *
  * TODO(ahe): This method is controversial, the team needs to discuss
  * if top-level methods are acceptable and what naming conventions to
  * use.
  */
 initializerDo(Node node, f(Node node)) {
   SendSet send = node.asSendSet();
   if (send !== null) return f(send.arguments.head);
 }