Refactor index operator in SimpleTypeInferrer.

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 1001 matching lines @@
             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(
+        return visitor.visitUnresolvedSuperIndexSet(
             node,
             semantics.element,
             node.arguments.first,
             node.arguments.tail.head,
             arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(
@@ skipping 27 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:
             return visitor.visitSuperIndexPrefix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 node.arguments.single,
                 operator,
                 arg);
+          case CompoundAccessKind.UNRESOLVED_SUPER_GETTER:
+            return visitor.visitUnresolvedSuperGetterIndexPrefix(
+                node,
+                compoundSemantics.getter,
+                node.arguments.single,
+                operator,
+                arg);
+          case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
+            return visitor.visitUnresolvedSuperSetterIndexPrefix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                node.arguments.single,
+                operator,
+                arg);
           default:
             // This is not a valid case.
             break;
         }
         break;
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(
@@ skipping 25 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:
             return visitor.visitSuperIndexPostfix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 node.arguments.single,
                 operator,
                 arg);
+          case CompoundAccessKind.UNRESOLVED_SUPER_GETTER:
+            return visitor.visitUnresolvedSuperGetterIndexPostfix(
+                node,
+                compoundSemantics.getter,
+                node.arguments.single,
+                operator,
+                arg);
+          case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
+            return visitor.visitUnresolvedSuperSetterIndexPostfix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                node.arguments.single,
+                operator,
+                arg);
           default:
             // This is not a valid case.
             break;
         }
         break;
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(
@@ skipping 218 matching lines @@
                 node.arguments.single,
                 arg);
           case CompoundAccessKind.SUPER_FIELD_SETTER:
             return visitor.visitSuperFieldSetterCompound(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 node.arguments.single,
                 arg);
+          case CompoundAccessKind.UNRESOLVED_SUPER_GETTER:
+          case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
+            // TODO(johnniwinther): Handle these separately.
+            return visitor.errorUnresolvedCompound(
+                node,
+                semantics.element,
+                operator,
+                node.arguments.single,
+                arg);
+            break;
         }
         break;
     }
     throw new SpannableAssertionFailure(node,
         "Invalid compound assigment: ${semantics}");
   }
 
   String toString() => 'compound($operator,$semantics)';
 }
 
@@ skipping 19 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) {
           case CompoundAccessKind.SUPER_GETTER_SETTER:
             return visitor.visitSuperCompoundIndexSet(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 node.arguments.first,
                 operator,
                 node.arguments.tail.head,
                 arg);
+          case CompoundAccessKind.UNRESOLVED_SUPER_GETTER:
+            return visitor.visitUnresolvedSuperGetterCompoundIndexSet(
+                node,
+                compoundSemantics.getter,
+                node.arguments.first,
+                operator,
+                node.arguments.tail.head,
+                arg);
+          case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
+            return visitor.visitUnresolvedSuperSetterCompoundIndexSet(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                node.arguments.first,
+                operator,
+                node.arguments.tail.head,
+                arg);
           default:
             // This is not a valid case.
             break;
         }
         break;
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(
@@ skipping 203 matching lines @@
                 compoundSemantics.setter,
                 operator,
                 arg);
           case CompoundAccessKind.SUPER_FIELD_SETTER:
             return visitor.visitSuperFieldSetterPrefix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
+          case CompoundAccessKind.UNRESOLVED_SUPER_GETTER:
+          case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
+            // TODO(johnniwinther): Handle these directly.
+            return visitor.errorUnresolvedPrefix(
+                node,
+                semantics.element,
+                operator,
+                arg);
         }
     }
     throw new SpannableAssertionFailure(node,
         "Invalid compound assigment: ${semantics}");
   }
 
   String toString() => 'prefix($operator,$semantics)';
 }
 
 /// The structure for a [Send] that is a postfix operations. For instance
@@ skipping 196 matching lines @@
                 compoundSemantics.setter,
                 operator,
                 arg);
           case CompoundAccessKind.SUPER_FIELD_SETTER:
             return visitor.visitSuperFieldSetterPostfix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
+          case CompoundAccessKind.UNRESOLVED_SUPER_GETTER:
+          case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
+            // TODO(johnniwinther): Handle these directly.
+            return visitor.errorUnresolvedPostfix(
+                node,
+                semantics.element,
+                operator,
+                arg);
         }
     }
     throw new SpannableAssertionFailure(node,
         "Invalid compound assigment: ${semantics}");
   }
 
   String toString() => 'postfix($operator,$semantics)';
 }
 
 /// The structure for a [NewExpression] of a new invocation.
@@ skipping 258 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);
   }
 }