Implement ResolvedVisitor using SemanticSendVisitor.

pkg/compiler/lib/src/resolved_visitor.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.
 
 part of dart2js;
 
-abstract class ResolvedVisitor<R> extends Visitor<R> {
-  TreeElements elements;
-
-  ResolvedVisitor(this.elements);
-
-  R visitSend(Send node) {
-    Element element = elements[node];
-    if (elements.isAssert(node)) {
-      return visitAssert(node);
-    } else if (elements.isTypeLiteral(node)) {
-      return visitTypeLiteralSend(node);
-    } else if (node.isSuperCall) {
-      return visitSuperSend(node);
-    } else if (node.isOperator) {
-      return visitOperatorSend(node);
-    } else if (node.isPropertyAccess) {
-      if (!Elements.isUnresolved(element) && element.impliesType) {
-        return visitTypePrefixSend(node);
-      } else {
-        return visitGetterSend(node);
-      }
-    } else if (element != null && Initializers.isConstructorRedirect(node)) {
-      return visitStaticSend(node);
-    } else if (Elements.isClosureSend(node, element)) {
-      return visitClosureSend(node);
-    } else {
-      if (Elements.isUnresolved(element)) {
-        if (element == null) {
-          // Example: f() with 'f' unbound.
-          // This can only happen inside an instance method.
-          return visitDynamicSend(node);
-        } else {
-          return visitStaticSend(node);
-        }
-      } else if (element.isInstanceMember) {
-        // Example: f() with 'f' bound to instance method.
-        return visitDynamicSend(node);
-      } 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 visitStaticSend(node);
-      } else {
-        internalError("Cannot generate code for send", node: node);
-        return null;
-      }
-    }
-  }
-
+/// Enum for the visit methods added in [ResolvedVisitor].
+// TODO(johnniwinther): Remove this.
+enum ResolvedKind {
+  ASSERT,
+  TYPE_LITERAL,
+  SUPER,
+  OPERATOR,
+  TYPE_PREFIX,
+  GETTER,
+  STATIC,
+  CLOSURE,
+  DYNAMIC,
+  ERROR,
+}
+
+/// Abstract interface for a [ResolvedVisitor].
+// TODO(johnniwinther): Remove this.
+abstract class ResolvedKindVisitor<R> {
   R visitSuperSend(Send node);
   R visitOperatorSend(Send node);
   R visitGetterSend(Send node);
   R visitClosureSend(Send node);
   R visitDynamicSend(Send node);
   R visitStaticSend(Send node);
 
   /// Visitor callback for a type literal.
   R visitTypeLiteralSend(Send node);
 
   /// Visitor callback for the class prefix of a static access, like `Foo` in
   /// `Foo.staticField`.
   // TODO(johnniwinther): Remove this when not needed by the dart backend.
   R visitTypePrefixSend(Send node);
 
-  R visitAssert(Send node);
-
-  void internalError(String reason, {Node node});
+  R visitAssertSend(Send node);
+
+  internalError(Spannable node, String reason);
+}
+
+/// Visitor that returns the [ResolvedKind] corresponding to the called visitor
+/// method.
+class ResolvedKindComputer implements ResolvedKindVisitor {
+  const ResolvedKindComputer();
+
+  ResolvedKind visitSuperSend(Send node) => ResolvedKind.SUPER;
+  ResolvedKind visitOperatorSend(Send node) => ResolvedKind.OPERATOR;
+  ResolvedKind visitGetterSend(Send node) => ResolvedKind.GETTER;
+  ResolvedKind visitClosureSend(Send node) => ResolvedKind.CLOSURE;
+  ResolvedKind visitDynamicSend(Send node) => ResolvedKind.DYNAMIC;
+  ResolvedKind visitStaticSend(Send node) => ResolvedKind.STATIC;
+  ResolvedKind visitTypeLiteralSend(Send node) => ResolvedKind.TYPE_LITERAL;
+  ResolvedKind visitTypePrefixSend(Send node) => ResolvedKind.TYPE_PREFIX;
+  ResolvedKind visitAssertSend(Send node) => ResolvedKind.ASSERT;
+  internalError(Spannable node, String reason) => ResolvedKind.ERROR;
+}
+
+abstract class ResolvedVisitor<R>
+    implements Visitor<R>, ResolvedKindVisitor<R> {}
+
+abstract class BaseResolvedVisitor<R> extends Visitor<R>
+    implements ResolvedVisitor<R> {
+
+  TreeElements elements;
+
+  BaseResolvedVisitor(this.elements);
+
+  /// Dispatch using the old [ResolvedVisitor] logic.
+  // TODO(johnniwinther): Remove this.
+  _oldDispatch(Send node, ResolvedKindVisitor visitor) {
+    Element element = elements[node];
+    if (elements.isAssert(node)) {
+      return visitor.visitAssertSend(node);
+    } else if (elements.isTypeLiteral(node)) {
+      return visitor.visitTypeLiteralSend(node);
+    } else if (node.isSuperCall) {
+      return visitor.visitSuperSend(node);
+    } else if (node.isOperator) {
+      return visitor.visitOperatorSend(node);
+    } else if (node.isPropertyAccess) {
+      if (!Elements.isUnresolved(element) && element.impliesType) {
+        return visitor.visitTypePrefixSend(node);
+      } else {
+        return visitor.visitGetterSend(node);
+      }
+    } else if (element != null && Initializers.isConstructorRedirect(node)) {
+      return visitor.visitStaticSend(node);
+    } else if (Elements.isClosureSend(node, element)) {
+      return visitor.visitClosureSend(node);
+    } else {
+      if (Elements.isUnresolved(element)) {
+        if (element == null) {
+          // Example: f() with 'f' unbound.
+          // This can only happen inside an instance method.
+          return visitor.visitDynamicSend(node);
+        } else {
+          return visitor.visitStaticSend(node);
+        }
+      } else if (element.isInstanceMember) {
+        // Example: f() with 'f' bound to instance method.
+        return visitor.visitDynamicSend(node);
+      } 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 visitor.visitStaticSend(node);
+      } else {
+        return visitor.internalError(node, "Cannot generate code for send");
+      }
+    }
+  }
+
+  internalError(Spannable node, String reason);
 
   R visitNode(Node node) {
-    internalError("Unhandled node", node: node);
+    internalError(node, "Unhandled node");
     return null;
   }
 }
+
+// TODO(johnniwinther): Remove this. Currently need by the old dart2dart
+// backend.
+abstract class OldResolvedVisitor<R> extends BaseResolvedVisitor<R> {
+  OldResolvedVisitor(TreeElements elements) : super(elements);
+
+  R visitSend(Send node) {
+    return _oldDispatch(node, this);
+  }
+}
+
+abstract class NewResolvedVisitor<R> extends BaseResolvedVisitor<R>
+    with SendResolverMixin,
+         GetBulkMixin<R, dynamic>,
+         SetBulkMixin<R, dynamic>,
+         ErrorBulkMixin<R, dynamic>,
+         InvokeBulkMixin<R, dynamic>,
+         IndexSetBulkMixin<R, dynamic>,
+         CompoundBulkMixin<R, dynamic>,
+         UnaryBulkMixin<R, dynamic>,
+         BaseBulkMixin<R, dynamic>,
+         BinaryBulkMixin<R, dynamic>,
+         PrefixBulkMixin<R, dynamic>,
+         PostfixBulkMixin<R, dynamic> {
+
+  final ResolvedSemanticDispatcher<R> _semanticDispatcher =
+      new ResolvedSemanticDispatcher<R>();
+
+  final ResolvedSemanticDispatcher<ResolvedKind> _resolvedKindDispatcher =
+      new ResolvedSemanticDispatcher<ResolvedKind>();
+
+  NewResolvedVisitor(TreeElements elements) : super(elements);
+
+  /// Dispatch using the new [SemanticSendVisitor] logic.
+  _newDispatch(Send node,
+               ResolvedKindVisitor kindVisitor,
+               SemanticSendVisitor sendVisitor) {
+    Element element = elements[node];
+    if (element != null && element.isConstructor) {
+      if (node.isSuperCall) {
+        return kindVisitor.visitSuperSend(node);
+      } else {
+        return kindVisitor.visitStaticSend(node);
+      }
+    } else if (element != null && element.isPrefix) {
+      return kindVisitor.visitGetterSend(node);
+    } else if (!elements.isTypeLiteral(node) &&
+               node.isPropertyAccess &&
+               !Elements.isUnresolved(element) &&
+               element.impliesType) {
+      return kindVisitor.visitTypePrefixSend(node);
+    } else {
+      SendStructure sendStructure = computeSendStructure(node);
+      if (sendStructure != null) {
+        var arg = sendVisitor == _resolvedKindDispatcher
+            ? kindVisitor : sendStructure;
+        return sendStructure.dispatch(sendVisitor, node, arg);
+      } else {
+        return kindVisitor.visitStaticSend(node);
+      }
+    }
+  }
+
+  R visitSend(Send node) {
+    ResolvedKind oldKind;
+    ResolvedKind newKind;
+    assert(invariant(node, () {
+      oldKind = _oldDispatch(node, const ResolvedKindComputer());
+      newKind = _newDispatch(
+          node, const ResolvedKindComputer(), _resolvedKindDispatcher);
+      return oldKind == newKind;
+    }, message: () => '$oldKind != $newKind'));
+    return _newDispatch(node, this, this);
+  }
+
+  @override
+  R apply(Node node, arg) {
+    return visitNode(node);
+  }
+
+  @override
+  R bulkHandleNode(
+      Node node,
+      String message,
+      SendStructure sendStructure) {
+    return sendStructure.dispatch(_semanticDispatcher, node, this);
+  }
+}
+
+/// Visitor that dispatches [SemanticSendVisitor] calls to the corresponding
+/// visit methods in [ResolvedVisitor].
+class ResolvedSemanticDispatcher<R> extends Object
+    with GetBulkMixin<R, ResolvedKindVisitor<R>>,
+         SetBulkMixin<R, ResolvedKindVisitor<R>>,
+         InvokeBulkMixin<R, ResolvedKindVisitor<R>>,
+         PrefixBulkMixin<R, ResolvedKindVisitor<R>>,
+         PostfixBulkMixin<R, ResolvedKindVisitor<R>>,
+         SuperBulkMixin<R, ResolvedKindVisitor<R>>,
+         CompoundBulkMixin<R, ResolvedKindVisitor<R>>,
+         IndexSetBulkMixin<R, ResolvedKindVisitor<R>>,
+         ErrorBulkMixin<R, ResolvedKindVisitor<R>>
+    implements SemanticSendVisitor<R, ResolvedKindVisitor<R>> {
+
+  ResolvedSemanticDispatcher();
+
+  @override
+  R apply(Node node, ResolvedKindVisitor<R> visitor) {
+    return visitor.internalError(
+        node, "ResolvedSemanticDispatcher.apply unsupported.");
+  }
+
+  @override
+  R bulkHandleNode(
+      Node node,
+      String message,
+      ResolvedKindVisitor<R> visitor) {
+    // Set, Compound and IndexSet are not handled by [ResolvedVisitor].
+    return bulkHandleError(node, visitor);
+  }
+
+  R bulkHandleError(Node node, ResolvedKindVisitor<R> visitor) {
+    return visitor.internalError(node, "No resolved kind for node.");
+  }
+
+  @override
+  R bulkHandleGet(Node node, ResolvedKindVisitor<R> visitor) {
+    return visitor.visitGetterSend(node);
+  }
+
+  @override
+  R bulkHandleInvoke(Node node, ResolvedKindVisitor<R> visitor) {
+    // Most invokes are static.
+    return visitor.visitStaticSend(node);
+  }
+
+  @override
+  R bulkHandlePrefix(Node node, ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R bulkHandlePostfix(Node node, ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R bulkHandleSuper(Node node, ResolvedKindVisitor<R> visitor) {
+    return visitor.visitSuperSend(node);
+  }
+
+  @override
+  R errorInvalidAssert(
+      Send node,
+      NodeList arguments,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitAssertSend(node);
+  }
+
+  @override
+  R errorLocalFunctionPostfix(
+      Send node,
+      LocalFunctionElement function,
+      op.IncDecOperator operator,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R errorLocalFunctionPrefix(
+      Send node,
+      LocalFunctionElement function,
+      op.IncDecOperator operator,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R errorStaticSetterGet(
+      Send node,
+      FunctionElement setter,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitGetterSend(node);
+  }
+
+  @override
+  R errorStaticSetterInvoke(
+      Send node,
+      FunctionElement setter,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitStaticSend(node);
+  }
+
+  @override
+  R errorSuperSetterGet(
+      Send node,
+      FunctionElement setter,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitGetterSend(node);
+  }
+
+  @override
+  R errorSuperSetterInvoke(
+      Send node,
+      FunctionElement setter,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitSuperSend(node);
+  }
+
+  @override
+  R errorTopLevelSetterGet(
+      Send node,
+      FunctionElement setter,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitGetterSend(node);
+  }
+
+  @override
+  R errorTopLevelSetterInvoke(
+      Send node,
+      FunctionElement setter,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitStaticSend(node);
+  }
+
+  @override
+  R errorUndefinedBinaryExpression(
+      Send node,
+      Node left,
+      Operator operator,
+      Node right,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R errorUndefinedUnaryExpression(
+      Send node,
+      Operator operator,
+      Node expression,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R errorUnresolvedGet(
+      Send node,
+      Element element,
+      ResolvedKindVisitor<R> visitor) {
+    if (node.isSuperCall) {
+      return visitor.visitSuperSend(node);
+    }
+    return visitor.visitGetterSend(node);
+  }
+
+  @override
+  R errorUnresolvedInvoke(
+      Send node,
+      Element element,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    if (node.isSuperCall) {
+      return visitor.visitSuperSend(node);
+    }
+    return visitor.visitStaticSend(node);
+  }
+
+  @override
+  R errorUnresolvedPostfix(
+      Send node,
+      Element element,
+      op.IncDecOperator operator,
+      ResolvedKindVisitor<R> visitor) {
+    if (node.isSuperCall) {
+      return visitor.visitSuperSend(node);
+    }
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R errorUnresolvedPrefix(
+      Send node,
+      Element element,
+      op.IncDecOperator operator,
+      ResolvedKindVisitor<R> visitor) {
+    if (node.isSuperCall) {
+      return visitor.visitSuperSend(node);
+    }
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R errorUnresolvedSuperBinary(
+      Send node,
+      Element element,
+      op.BinaryOperator operator,
+      Node argument,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitSuperSend(node);
+  }
+
+  @override
+  R errorUnresolvedSuperUnary(
+      Send node,
+      op.UnaryOperator operator,
+      Element element,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitSuperSend(node);
+  }
+
+  @override
+  R visitAs(
+      Send node,
+      Node expression,
+      DartType type,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R visitAssert(
+      Send node,
+      Node expression,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitAssertSend(node);
+  }
+
+  @override
+  R visitBinary(
+      Send node,
+      Node left,
+      op.BinaryOperator operator,
+      Node right,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R visitEquals(
+      Send node,
+      Node left,
+      Node right,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R visitIs(
+      Send node,
+      Node expression,
+      DartType type,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R visitIsNot(
+      Send node,
+      Node expression,
+      DartType type,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R visitLogicalAnd(
+      Send node,
+      Node left,
+      Node right,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R visitLogicalOr(
+      Send node,
+      Node left,
+      Node right,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R visitNot(
+      Send node,
+      Node expression,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R visitNotEquals(
+      Send node,
+      Node left,
+      Node right,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R visitUnary(
+      Send node,
+      op.UnaryOperator operator,
+      Node expression,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R visitDynamicPropertyInvoke(
+      Send node,
+      Node receiver,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitDynamicSend(node);
+  }
+
+  @override
+  R visitThisPropertyInvoke(
+      Send node,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitDynamicSend(node);
+  }
+
+  @override
+  R visitExpressionInvoke(
+      Send node,
+      Node receiver,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitClosureSend(node);
+  }
+
+  @override
+  R visitParameterInvoke(
+      Send node,
+      ParameterElement parameter,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitClosureSend(node);
+  }
+
+  @override
+  R visitLocalVariableInvoke(
+      Send node,
+      LocalVariableElement variable,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitClosureSend(node);
+  }
+
+  @override
+  R visitLocalFunctionInvoke(
+      Send node,
+      LocalFunctionElement function,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitClosureSend(node);
+  }
+
+  @override
+  R visitThisInvoke(
+      Send node,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitClosureSend(node);
+  }
+
+  @override
+  R visitClassTypeLiteralGet(
+      Send node,
+      TypeConstantExpression constant,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitTypeLiteralSend(node);
+  }
+
+  @override
+  R visitTypedefTypeLiteralGet(
+      Send node,
+      TypeConstantExpression constant,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitTypeLiteralSend(node);
+  }
+
+  @override
+  R visitDynamicTypeLiteralGet(
+      Send node,
+      TypeConstantExpression constant,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitTypeLiteralSend(node);
+  }
+
+  @override
+  R visitTypeVariableTypeLiteralGet(
+      Send node,
+      TypeVariableElement element,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitTypeLiteralSend(node);
+  }
+
+  @override
+  R visitClassTypeLiteralInvoke(
+      Send node,
+      TypeConstantExpression constant,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitTypeLiteralSend(node);
+  }
+
+  @override
+  R visitTypedefTypeLiteralInvoke(
+      Send node,
+      TypeConstantExpression constant,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitTypeLiteralSend(node);
+  }
+
+  @override
+  R visitDynamicTypeLiteralInvoke(
+      Send node,
+      TypeConstantExpression constant,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitTypeLiteralSend(node);
+  }
+
+  @override
+  R visitTypeVariableTypeLiteralInvoke(
+      Send node,
+      TypeVariableElement element,
+      NodeList arguments,
+      Selector selector,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitTypeLiteralSend(node);
+  }
+
+  @override
+  R visitIndex(
+      Send node,
+      Node receiver,
+      Node index,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitOperatorSend(node);
+  }
+
+  @override
+  R visitSuperIndex(
+      Send node,
+      FunctionElement function,
+      Node index,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitSuperSend(node);
+  }
+
+  @override
+  R errorUnresolvedSuperIndex(
+      Send node,
+      Element function,
+      Node index,
+      ResolvedKindVisitor<R> visitor) {
+    return visitor.visitSuperSend(node);
+  }
+}