Add AccessSemantics.INVALID for invalid expressions.

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 355 matching lines @@
             node.argumentsNode,
             selector,
             arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             selector,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidInvoke(
+            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)';
 }
 
@@ skipping 197 matching lines @@
       case AccessKind.UNRESOLVED:
         return visitor.visitUnresolvedGet(
             node,
             semantics.element,
             arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperGet(
             node,
             semantics.element,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidGet(
+            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 183 matching lines @@
         // TODO(johnniwinther): Should this be a valid case?
         break;
       case AccessKind.UNRESOLVED_SUPER:
         // TODO(johnniwinther): Handle this separately.
       case AccessKind.UNRESOLVED:
         return visitor.visitUnresolvedSet(
             node,
             semantics.element,
             node.arguments.single,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidSet(
+            node,
+            semantics.element,
+            node.arguments.single,
+            arg);
       case AccessKind.COMPOUND:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid setter: ${semantics}");
   }
 
   String toString() => 'set($selector,$semantics)';
 }
 
@@ skipping 655 matching lines @@
             operator,
             node.arguments.single,
             arg);
       case AccessKind.UNRESOLVED:
         return visitor.visitUnresolvedCompound(
             node,
             semantics.element,
             operator,
             node.arguments.single,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidCompound(
+            node,
+            semantics.element,
+            operator,
+            node.arguments.single,
+            arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
           case CompoundAccessKind.STATIC_GETTER_SETTER:
             return visitor.visitStaticGetterSetterCompound(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 node.arguments.single,
@@ skipping 383 matching lines @@
             node,
             semantics.element,
             operator,
             arg);
       case AccessKind.UNRESOLVED:
         return visitor.visitUnresolvedPrefix(
             node,
             semantics.element,
             operator,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidPrefix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
           case CompoundAccessKind.STATIC_GETTER_SETTER:
             return visitor.visitStaticGetterSetterPrefix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
@@ skipping 296 matching lines @@
             node,
             semantics.element,
             operator,
             arg);
       case AccessKind.UNRESOLVED:
         return visitor.visitUnresolvedPostfix(
             node,
             semantics.element,
             operator,
             arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidPostfix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
           case CompoundAccessKind.STATIC_GETTER_SETTER:
             return visitor.visitStaticGetterSetterPostfix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
@@ skipping 454 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;
 }