Add AccessSemantics.INVALID for invalid expressions.

tests/compiler/dart2js/semantic_visitor_test.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.semantics_visitor_test;
 
 import 'dart:async';
 import 'dart:mirrors';
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
@@ skipping 28 matching lines @@
   final index;
   final getter;
   final setter;
   final constant;
   final selector;
   final parameters;
   final body;
   final target;
   final targetType;
   final initializers;
+  final error;
 
   const Visit(this.method,
               {this.element,
                this.rhs,
                this.arguments,
                this.receiver,
                this.name,
                this.expression,
                this.left,
                this.right,
                this.type,
                this.operator,
                this.index,
                this.getter,
                this.setter,
                this.constant,
                this.selector,
                this.parameters,
                this.body,
                this.target,
                this.targetType,
-               this.initializers});
+               this.initializers,
+               this.error});
 
   int get hashCode => toString().hashCode;
 
   bool operator ==(other) => '$this' == '$other';
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('method=$method');
     if (element != null) {
       sb.write(',element=$element');
@@ skipping 48 matching lines @@
     }
     if (target != null) {
       sb.write(',target=$target');
     }
     if (targetType != null) {
       sb.write(',targetType=$targetType');
     }
     if (initializers != null) {
       sb.write(',initializers=$initializers');
     }
+    if (error != null) {
+      sb.write(',error=$error');
+    }
     return sb.toString();
   }
 }
 
 class Test {
   final String codeByPrefix;
   final bool isDeferred;
   final String code;
   final /*Visit | List<Visit>*/ expectedVisits;
   final String cls;
@@ skipping 55 matching lines @@
   VisitKind.VISIT_TOP_LEVEL_FUNCTION_SET,
   VisitKind.VISIT_FINAL_SUPER_FIELD_SET,
   VisitKind.VISIT_SUPER_GETTER_SET,
   VisitKind.VISIT_SUPER_METHOD_SET,
   // The only undefined unary, `+`, is currently handled and skipped in the
   // parser.
   VisitKind.ERROR_UNDEFINED_UNARY_EXPRESSION,
   // Constant expression are currently not computed during resolution.
   VisitKind.VISIT_CONSTANT_GET,
   VisitKind.VISIT_CONSTANT_INVOKE,
+  // TODO(johnniwinther): Test these when ResolverVisitor.visitSendSet has been
+  // rewritten.
+  VisitKind.ERROR_INVALID_SET,
+  VisitKind.ERROR_INVALID_PREFIX,
+  VisitKind.ERROR_INVALID_POSTFIX,
+  VisitKind.ERROR_INVALID_COMPOUND,
 ];
 
 main(List<String> arguments) {
   Set<VisitKind> kinds = new Set<VisitKind>.from(VisitKind.values);
   asyncTest(() => Future.forEach([
     () {
       return test(
           kinds,
           arguments,
           SEND_TESTS,
@@ skipping 475 matching lines @@
   VISIT_IF_NOT_NULL_DYNAMIC_PROPERTY_GET,
   VISIT_IF_NOT_NULL_DYNAMIC_PROPERTY_SET,
   VISIT_IF_NOT_NULL_DYNAMIC_PROPERTY_INVOKE,
   VISIT_IF_NOT_NULL_DYNAMIC_PROPERTY_COMPOUND,
   VISIT_IF_NOT_NULL_DYNAMIC_PROPERTY_PREFIX,
   VISIT_IF_NOT_NULL_DYNAMIC_PROPERTY_POSTFIX,
 
   ERROR_INVALID_ASSERT,
   ERROR_UNDEFINED_UNARY_EXPRESSION,
   ERROR_UNDEFINED_BINARY_EXPRESSION,
+  ERROR_INVALID_GET,
+  ERROR_INVALID_INVOKE,
+  ERROR_INVALID_SET,
+  ERROR_INVALID_PREFIX,
+  ERROR_INVALID_POSTFIX,
+  ERROR_INVALID_COMPOUND,
 
   VISIT_CONSTANT_GET,
   VISIT_CONSTANT_INVOKE,
 
   PREVISIT_DEFERRED_ACCESS,
 }