Refactor SsaBuilder.visitSuperSend.

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 321 matching lines @@
             node.argumentsNode,
             callStructure,
             arg);
       case AccessKind.UNRESOLVED:
         return visitor.errorUnresolvedInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             selector,
             arg);
+      case AccessKind.UNRESOLVED_SUPER:
+        return visitor.visitUnresolvedSuperInvoke(
+            node,
+            semantics.element,
+            node.argumentsNode,
+            selector,
+            arg);
       case AccessKind.COMPOUND:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid invoke: ${semantics}");
   }
 
   String toString() => 'invoke($selector,$semantics)';
 }
 
+/// The structure for a [Send] that is an incompatible invocation, i.e. an
+/// invocation of a known target where the call structure does not match.
+class IncompatibleInvokeStructure<R, A> implements SendStructure<R, A> {
+  /// The target of the invocation.
+  final AccessSemantics semantics;
+
+  /// The [Selector] for the invocation.
+  // TODO(johnniwinther): Store this only for dynamic invocations.
+  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.SUPER_METHOD:
+        return visitor.visitSuperMethodIncompatibleInvoke(
+            node,
+            semantics.element,
+            node.argumentsNode,
+            callStructure,
+            arg);
+      default:
+        // TODO(johnniwinther): Support more variant of this invoke structure.

[karlklose, 2015/04/27 14:01:55]

'variant' -> 'variants'.

[Johnni Winther, 2015/04/28 08:18:28]

Done.

+        break;
+    }
+    throw new SpannableAssertionFailure(
+        node, "Invalid incompatible invoke: ${semantics}");
+  }
+
+  String toString() => 'invoke($selector,$semantics)';

[karlklose, 2015/04/27 14:01:55]

Space after ',
?

[Johnni Winther, 2015/04/28 08:18:28]

Done.

+}
+
 /// The structure for a [Send] that is a read access.
 class GetStructure<R, A> implements SendStructure<R, A> {
   /// The target of the read access.
   final AccessSemantics semantics;
 
   /// The [Selector] for the getter invocation.
   final Selector selector;
 
   GetStructure(this.semantics, this.selector);
 
@@ skipping 114 matching lines @@
       case AccessKind.CONSTANT:
         return visitor.visitConstantGet(
             node,
             semantics.constant,
             arg);
       case AccessKind.UNRESOLVED:
         return visitor.errorUnresolvedGet(
             node,
             semantics.element,
             arg);
+      case AccessKind.UNRESOLVED_SUPER:
+        return visitor.visitUnresolvedSuperGet(
+            node,
+            semantics.element,
+            arg);
       case AccessKind.COMPOUND:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid getter: ${semantics}");
   }
 
   String toString() => 'get($selector,$semantics)';
 }
 
@@ skipping 138 matching lines @@
             arg);
       case AccessKind.SUPER_SETTER:
         return visitor.visitSuperSetterSet(
             node,
             semantics.element,
             node.arguments.single,
             arg);
       case AccessKind.CONSTANT:
         // TODO(johnniwinther): Should this be a valid case?
         break;
+      case AccessKind.UNRESOLVED_SUPER:
+        // TODO(johnniwinther): Handle this separately.
       case AccessKind.UNRESOLVED:
         return visitor.errorUnresolvedSet(
             node,
             semantics.element,
             node.arguments.single,
             arg);
+        break;
       case AccessKind.COMPOUND:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid setter: ${semantics}");
   }
 
   String toString() => 'set($selector,$semantics)';
 }
 
@@ skipping 46 matching lines @@
             node,
             operator,
             node.receiver,
             arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperUnary(
             node,
             operator,
             semantics.element,
             arg);
-      case AccessKind.UNRESOLVED:
-        return visitor.errorUnresolvedSuperUnary(
+      case AccessKind.UNRESOLVED_SUPER:
+        return visitor.visitUnresolvedSuperUnary(
             node,
             operator,
             semantics.element,
             arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid setter: ${semantics}");
   }
@@ skipping 37 matching lines @@
             node,
             node.receiver,
             node.arguments.single,
             arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperIndex(
             node,
             semantics.element,
             node.arguments.single,
             arg);
-      case AccessKind.UNRESOLVED:
-        return visitor.errorUnresolvedSuperIndex(
+      case AccessKind.UNRESOLVED_SUPER:
+        return visitor.visitUnresolvedSuperIndex(
             node,
             semantics.element,
             node.arguments.single,
             arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid index: ${semantics}");
   }
@@ skipping 96 matching lines @@
             operator,
             node.arguments.single,
             arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperBinary(
             node,
             semantics.element,
             operator,
             node.arguments.single,
             arg);
-      case AccessKind.UNRESOLVED:
-        return visitor.errorUnresolvedSuperBinary(
+      case AccessKind.UNRESOLVED_SUPER:
+        return visitor.visitUnresolvedSuperBinary(
             node,
             semantics.element,
             operator,
             node.arguments.single,
             arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(
@@ skipping 41 matching lines @@
             node.arguments.first,
             node.arguments.tail.head,
             arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperIndexSet(
             node,
             semantics.element,
             node.arguments.first,
             node.arguments.tail.head,
             arg);
+      case AccessKind.UNRESOLVED_SUPER:
       case AccessKind.UNRESOLVED:
+        // TODO(johnniwinther): Support these through [AccessKind.COMPOUND].
         return visitor.errorUnresolvedSuperIndexSet(
             node,
             semantics.element,
             node.arguments.first,
             node.arguments.tail.head,
             arg);
       default:
         // This is not a valid case.
         break;
     }
@@ skipping 28 matching lines @@
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitIndexPrefix(
             node,
             node.receiver,
             node.arguments.single,
             operator,
             arg);
+      case AccessKind.UNRESOLVED_SUPER:
       case AccessKind.UNRESOLVED:
+        // TODO(johnniwinther): Support these through [AccessKind.COMPOUND].
         return visitor.errorUnresolvedSuperIndexPrefix(
             node,
             semantics.element,
             node.arguments.single,
             operator,
             arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
           case CompoundAccessKind.SUPER_GETTER_SETTER:
@@ skipping 42 matching lines @@
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitIndexPostfix(
             node,
             node.receiver,
             node.arguments.single,
             operator,
             arg);
+      case AccessKind.UNRESOLVED_SUPER:
       case AccessKind.UNRESOLVED:
+        // TODO(johnniwinther): Support these through [AccessKind.COMPOUND].
         return visitor.errorUnresolvedSuperIndexPostfix(
             node,
             semantics.element,
             node.arguments.single,
             operator,
             arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
           case CompoundAccessKind.SUPER_GETTER_SETTER:
@@ skipping 156 matching lines @@
         break;
       case AccessKind.SUPER_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.SUPER_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.CONSTANT:
         // TODO(johnniwinther): Should this be a valid case?
         break;
+      case AccessKind.UNRESOLVED_SUPER:
       case AccessKind.UNRESOLVED:
+        // TODO(johnniwinther): Support these through [AccessKind.COMPOUND].
         return visitor.errorUnresolvedCompound(
             node,
             semantics.element,
             operator,
             node.arguments.single,
             arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
           case CompoundAccessKind.STATIC_GETTER_SETTER:
@@ skipping 95 matching lines @@
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitCompoundIndexSet(
             node,
             node.receiver,
             node.arguments.first,
             operator,
             node.arguments.tail.head,
             arg);
+      case AccessKind.UNRESOLVED_SUPER:
       case AccessKind.UNRESOLVED:
+        // TODO(johnniwinther): Support these through [AccessKind.COMPOUND].
         return visitor.errorUnresolvedSuperCompoundIndexSet(
             node,
             semantics.element,
             node.arguments.first,
             operator,
             node.arguments.tail.head,
             arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
@@ skipping 148 matching lines @@
         break;
       case AccessKind.SUPER_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.SUPER_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.CONSTANT:
         // TODO(johnniwinther): Should this be a valid case?
         break;
+      case AccessKind.UNRESOLVED_SUPER:
       case AccessKind.UNRESOLVED:
+        // TODO(johnniwinther): Support these through [AccessKind.COMPOUND].
         return visitor.errorUnresolvedPrefix(
             node,
             semantics.element,
             operator,
             arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
           case CompoundAccessKind.STATIC_GETTER_SETTER:
             return visitor.visitStaticGetterSetterPrefix(
@@ skipping 193 matching lines @@
         break;
       case AccessKind.SUPER_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.SUPER_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.CONSTANT:
         // TODO(johnniwinther): Should this be a valid case?
         break;
+      case AccessKind.UNRESOLVED_SUPER:
       case AccessKind.UNRESOLVED:
+        // TODO(johnniwinther): Support these through [AccessKind.COMPOUND].
         return visitor.errorUnresolvedPostfix(
             node,
             semantics.element,
             operator,
             arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
           case CompoundAccessKind.STATIC_GETTER_SETTER:
             return visitor.visitStaticGetterSetterPostfix(
@@ skipping 329 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);
   }
 }