Add AccessSemantics.INVALID for invalid expressions.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 77 matching lines @@
 /// and the current reaching definition of local variables.
 ///
 /// Visiting a statement or expression extends the IR builder's fragment.
 /// For expressions, the primitive holding the resulting value is returned.
 /// For statements, `null` is returned.
 // TODO(johnniwinther): Implement [SemanticDeclVisitor].
 abstract class IrBuilderVisitor extends ast.Visitor<ir.Primitive>
     with IrBuilderMixin<ast.Node>,
          SemanticSendResolvedMixin<ir.Primitive, dynamic>,
          SendResolverMixin,
+         ErrorBulkMixin<ir.Primitive, dynamic>,
          BaseImplementationOfStaticsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfLocalsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfDynamicsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfConstantsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfNewMixin<ir.Primitive, dynamic>,
          BaseImplementationOfCompoundsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfIndexCompoundsMixin<ir.Primitive, dynamic>
     implements SemanticSendVisitor<ir.Primitive, dynamic> {
   final TreeElements elements;
   final Compiler compiler;
@@ skipping 493 matching lines @@
 
   // ## Sends ##
   @override
   ir.Primitive visitAssert(ast.Send node, ast.Node condition, _) {
     assert(irBuilder.isOpen);
     if (compiler.enableUserAssertions) {
       return giveup(node, 'assert in checked mode not implemented');
     } else {
       // The call to assert and its argument expression must be ignored
       // in production mode.
-      // Assertions can onl)y occur in expression statements, so no value needs
+      // Assertions can only occur in expression statements, so no value needs
       // to be returned.
       return null;
     }
   }
 
   @override
   void previsitDeferredAccess(ast.Send node, PrefixElement prefix, _) {
     giveup(node, 'deferred access is not implemented');
   }
 
@@ skipping 1093 matching lines @@
   ir.Primitive buildInstanceNoSuchMethod(
       Selector selector,
       TypeMask mask,
       List<ir.Primitive> arguments);
 
   ir.Primitive buildRuntimeError(String message);
 
   ir.Primitive buildAbstractClassInstantiationError(ClassElement element);
 
   @override
-  ir.Primitive errorInvalidAssert(
-      ast.Send node,
-      ast.NodeList arguments, _) {
-    if (compiler.enableUserAssertions) {
-      return giveup(node, 'Assert');
-    } else {
-      return irBuilder.buildNullConstant();
-    }
-  }
-
-  @override
   ir.Primitive visitUnresolvedCompound(
       ast.Send node,
       Element element,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     // TODO(asgerf): What is unresolved? The getter and/or the setter?
     //               If it was the setter, we must evaluate the right-hand side.
     return buildStaticNoSuchMethod(elements.getSelector(node), []);
   }
 
@@ skipping 25 matching lines @@
       ast.NewExpression node,
       Element constructor,
       DartType type,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
     return buildStaticNoSuchMethod(elements.getSelector(node.send),
         translateDynamicArguments(arguments, callStructure));
   }
 
   @override
-  ir.Primitive errorNonConstantConstructorInvoke(
-      ast.NewExpression node,
-      Element element,
-      DartType type,
-      ast.NodeList arguments,
-      CallStructure callStructure, _) {
-    assert(compiler.compilationFailed);
-    return irBuilder.buildNullConstant();
-  }
-
-  @override
   ir.Primitive visitUnresolvedGet(
       ast.Send node,
       Element element, _) {
     return buildStaticNoSuchMethod(elements.getSelector(node), []);
   }
 
   @override
   ir.Primitive visitUnresolvedInvoke(
       ast.Send node,
       Element element,
@@ skipping 50 matching lines @@
   @override
   ir.Primitive visitUnresolvedSuperUnary(
       ast.Send node,
       op.UnaryOperator operator,
       Element element, _) {
     return buildInstanceNoSuchMethod(
         elements.getSelector(node), elements.getTypeMask(node), []);
   }
 
   @override
-  ir.Primitive errorUndefinedBinaryExpression(
-      ast.Send node,
-      ast.Node left,
-      ast.Operator operator,
-      ast.Node right, _) {
+  ir.Primitive bulkHandleNode(ast.Node node, String message, _) {
+    return giveup(node, "Unhandled node: ${message.replaceAll('#', '$node')}");
+  }
+
+  @override
+  ir.Primitive bulkHandleError(ast.Send node, ErroneousElement error, _) {
     assert(compiler.compilationFailed);
     return irBuilder.buildNullConstant();
   }
-
-  @override
-  ir.Primitive errorUndefinedUnaryExpression(
-      ast.Send node,
-      ast.Operator operator,
-      ast.Node expression, _) {
-    assert(compiler.compilationFailed);
-    return irBuilder.buildNullConstant();
-  }
 
   @override
   ir.Primitive visitClassTypeLiteralSet(
       ast.SendSet node,
       TypeConstantExpression constant,
       ast.Node rhs, _) {
     InterfaceType type = constant.type;
     ClassElement element = type.element;
     return buildStaticNoSuchMethod(
         new Selector.setter(element.name, element.library), [visit(rhs)]);
@@ skipping 1475 matching lines @@
     if (compiler.backend.isForeign(function)) {
       return handleForeignCode(node, function, argumentList, callStructure);
     } else {
       return irBuilder.buildStaticFunctionInvocation(function, callStructure,
           translateStaticArguments(argumentList, function, callStructure),
           sourceInformation:
               sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 }