Handle super index SendSet operations.

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 817 matching lines @@
 
   NotStructure(this.semantics);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitNot(
             node,
             node.receiver,
             arg);
-      default:
+     default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid setter: ${semantics}");
   }
 
   String toString() => 'not($semantics)';
 }
 
 /// The structure for a [Send] that is an invocation of a user definable unary
@@ skipping 20 matching lines @@
             node,
             operator,
             semantics.element,
             arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperUnary(
             node,
             operator,
             semantics.element,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidUnary(
+            node,
+            operator,
+            semantics.element,
+            arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid setter: ${semantics}");
   }
 
   String toString() => 'unary($operator,$semantics)';
 }
 
@@ skipping 35 matching lines @@
             node,
             semantics.element,
             node.arguments.single,
             arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperIndex(
             node,
             semantics.element,
             node.arguments.single,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidIndex(
+            node,
+            semantics.element,
+            node.arguments.single,
+            arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid index: ${semantics}");
   }
 }
 
 /// The structure for a [Send] that is an equals test, i.e. of the form
 /// `a == b`.
@@ skipping 10 matching lines @@
             node,
             node.receiver,
             node.arguments.single,
             arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperEquals(
             node,
             semantics.element,
             node.arguments.single,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidEquals(
+            node,
+            semantics.element,
+            node.arguments.single,
+            arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid equals: ${semantics}");
   }
 
   String toString() => '==($semantics)';
 }
 
@@ skipping 12 matching lines @@
             node,
             node.receiver,
             node.arguments.single,
             arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperNotEquals(
             node,
             semantics.element,
             node.arguments.single,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidNotEquals(
+            node,
+            semantics.element,
+            node.arguments.single,
+            arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(
         node, "Invalid not equals: ${semantics}");
   }
 
   String toString() => '!=($semantics)';
 }
@@ skipping 25 matching lines @@
             operator,
             node.arguments.single,
             arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperBinary(
             node,
             semantics.element,
             operator,
             node.arguments.single,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidBinary(
+            node,
+            semantics.element,
+            operator,
+            node.arguments.single,
+            arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(
         node, "Invalid binary: ${semantics}");
   }
 
   String toString() => 'binary($operator,$semantics)';
 }
@@ skipping 44 matching lines @@
             node.arguments.tail.head,
             arg);
       case AccessKind.UNRESOLVED_SUPER:
       case AccessKind.UNRESOLVED:
         return visitor.visitUnresolvedSuperIndexSet(
             node,
             semantics.element,
             node.arguments.first,
             node.arguments.tail.head,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidIndexSet(
+            node,
+            semantics.element,
+            node.arguments.first,
+            node.arguments.tail.head,
+            arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(
         node, "Invalid index set: ${semantics}");
   }
 
   String toString() => '[]=($semantics)';
 }
@@ skipping 29 matching lines @@
             node.arguments.single,
             operator,
             arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperIndexPrefix(
             node,
             semantics.element,
             node.arguments.single,
             operator,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidIndexPrefix(
+            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,
@@ skipping 59 matching lines @@
             node.arguments.single,
             operator,
             arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperIndexPostfix(
             node,
             semantics.element,
             node.arguments.single,
             operator,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidIndexPostfix(
+            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,
@@ skipping 408 matching lines @@
             node.arguments.tail.head,
             arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperCompoundIndexSet(
             node,
             semantics.element,
             node.arguments.first,
             operator,
             node.arguments.tail.head,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidCompoundIndexSet(
+            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,
@@ skipping 1020 matching lines @@
   ThisConstructorInvokeStructure(
       this.node, this.constructor, this.callStructure);
 
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, A arg) {
     return visitor.visitThisConstructorInvoke(
         node, constructor, node.argumentsNode, callStructure, arg);
   }
 
   bool get isConstructorInvoke => true;
 }