dart2js cps: Handle error cases.

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 122 matching lines @@
 // TODO(johnniwinther): Implement [SemanticDeclVisitor].
 abstract class IrBuilderVisitor extends ast.Visitor<ir.Primitive>
     with IrBuilderMixin<ast.Node>,
          SemanticSendResolvedMixin<ir.Primitive, dynamic>,
          SendResolverMixin,
          BaseImplementationOfStaticsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfLocalsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfDynamicsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfConstantsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfSuperIncDecsMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfNewMixin<ir.Primitive, dynamic>,
-         ErrorBulkMixin<ir.Primitive, dynamic>
+         BaseImplementationOfNewMixin<ir.Primitive, dynamic>
     implements SemanticSendVisitor<ir.Primitive, dynamic> {
   final TreeElements elements;
   final Compiler compiler;
   final SourceInformationBuilder sourceInformationBuilder;
 
   /// A map from try statements in the source to analysis information about
   /// them.
   ///
   /// The analysis information includes the set of variables that must be
   /// copied into [ir.MutableVariable]s on entry to the try and copied out on
@@ skipping 16 matching lines @@
   // assigned in the delimited subexpression to their reaching definition ---
   // that is, the definition in effect at the hole in 'current'.  These are
   // used to determine if a join-point continuation needs to be passed
   // arguments, and what the arguments are.
 
   /// Construct a top-level visitor.
   IrBuilderVisitor(this.elements,
                    this.compiler,
                    this.sourceInformationBuilder);
 
-  @override
-  bulkHandleNode(ast.Node node, String message, _) {
-    giveup(node, message.replaceFirst('#', '$node'));
-  }
-
   String bailoutMessage = null;
 
   @override
   ir.Primitive apply(ast.Node node, _) => node.accept(this);
 
   @override
   SemanticSendVisitor get sendVisitor => this;
 
   /**
    * Builds the [ir.RootNode] for an executable element. In case the
@@ skipping 20 matching lines @@
   /// Normalizes the argument list of a dynamic invocation (i.e. where the
   /// target element is unknown).
   ///
   /// For the JS backend, normalizes order of named arguments.
   ///
   /// For the Dart backend, returns [arguments].
   List<ir.Primitive> normalizeDynamicArguments(
       CallStructure callStructure,
       List<ir.Primitive> arguments);
 
+  /// Creates a [TypedSelector] variant of [newSelector] using the type of
+  /// [oldSelector], if available.
+  ///
+  /// This is needed to preserve inferred receiver types when creating new
+  /// selectors.
+  Selector useSelectorType(Selector newSelector, Selector oldSelector) {
+    // TODO(asgerf,johnniwinther): This works but it is brittle.
+    //     We should decouple selectors from inferred receiver type masks.
+    // TODO(asgerf): Use this whenever we create a selector for a dynamic call.
+    if (oldSelector is TypedSelector) {
+      return new TypedSelector(oldSelector.mask, newSelector, compiler.world);
+    } else {
+      return newSelector;
+    }
+  }
+
+  /// Like [useSelectorType], except the original typed selector is obtained
+  /// from the [node].
+  Selector useSelectorTypeOfNode(Selector newSelector, ast.Send node) {
+    return useSelectorType(newSelector, elements.getSelector(node));
+  }
+
   ir.RootNode _makeFunctionBody(FunctionElement element,
                                 ast.FunctionExpression node) {
     FunctionSignature signature = element.functionSignature;
     List<ParameterElement> parameters = [];
     signature.orderedForEachParameter(parameters.add);
 
     irBuilder.buildFunctionHeader(parameters,
                                   closureScope: getClosureScopeForNode(node),
                                   env: getClosureEnvironment());
 
@@ skipping 371 matching lines @@
         node.entries.nodes.map((e) => e.key),
         node.entries.nodes.map((e) => e.value),
         build);
   }
 
   ir.Primitive visitLiteralSymbol(ast.LiteralSymbol node) {
     assert(irBuilder.isOpen);
     return translateConstant(node);
   }
 
-  ir.Primitive visitIdentifier(ast.Identifier node) {
-    // "this" is the only identifier that should be met by the visitor.
-    assert(node.isThis());
-    return irBuilder.buildThis();
-  }
-
   ir.Primitive visitParenthesizedExpression(
       ast.ParenthesizedExpression node) {
     assert(irBuilder.isOpen);
     return visit(node.expression);
   }
 
   // Stores the result of visiting a CascadeReceiver, so we can return it from
   // its enclosing Cascade.
   ir.Primitive _currentCascadeReceiver;
 
@@ skipping 155 matching lines @@
 
   @override
   ir.Primitive visitSuperMethodGet(
       ast.Send node,
       MethodElement method,
       _) {
     return irBuilder.buildSuperMethodGet(method);
   }
 
   @override
-  ir.Primitive visitUnresolvedGet(
-      ast.Send node,
-      Element element,
-      _) {
-    return giveup(node, 'visitUnresolvedGet');
-  }
-
-  @override
   ir.Primitive visitUnresolvedSuperGet(
       ast.Send node,
-      Element element,
-      _) {
-    return giveup(node, 'visitUnresolvedSuperGet');
+      Element element, _) {
+    return buildInstanceNoSuchMethod(elements.getSelector(node), []);
   }
 
   @override
   ir.Primitive visitThisGet(ast.Identifier node, _) {
+    if (irBuilder.state.thisParameter == null) {
+      // TODO(asgerf,johnniwinther): Should be in a visitInvalidThis method.
+      // 'this' in static context. Just translate to null.
+      assert(compiler.compilationFailed);
+      return irBuilder.buildNullConstant();
+    }
     return irBuilder.buildThis();
   }
 
   ir.Primitive translateTypeVariableTypeLiteral(TypeVariableElement element) {
-    return buildReifyTypeVariable(irBuilder.buildThis(), element.type);
+    return irBuilder.buildReifyTypeVariable(element.type);
   }
 
   @override
   ir.Primitive visitTypeVariableTypeLiteralGet(ast.Send node,
                                                TypeVariableElement element, _) {
     return translateTypeVariableTypeLiteral(element);
   }
 
   ir.Primitive translateLogicalOperator(ast.Expression left,
                                         ast.Expression right,
@@ skipping 96 matching lines @@
   ir.Primitive visitSuperBinary(
       ast.Send node,
       FunctionElement function,
       op.BinaryOperator operator,
       ast.Node argument,
       _) {
     return translateSuperBinary(function, operator, argument);
   }
 
   @override
-  ir.Primitive visitUnresolvedSuperBinary(
-      ast.Send node,
-      Element element,
-      op.BinaryOperator operator,
-      ast.Node argument,
-      _) {
-    return giveup(node, 'visitUnresolvedSuperBinary');
-  }
-
-  @override
   ir.Primitive visitSuperIndex(
       ast.Send node,
       FunctionElement function,
       ast.Node index,
       _) {
     return irBuilder.buildSuperIndex(function, visit(index));
   }
 
   @override
-  ir.Primitive visitUnresolvedSuperIndex(
-      ast.Send node,
-      Element element,
-      ast.Node index,
-      _) {
-    return giveup(node, 'visitUnresolvedSuperIndex');
-  }
-
-  @override
   ir.Primitive visitEquals(
       ast.Send node,
       ast.Node left,
       ast.Node right,
       _) {
     return translateBinary(left, op.BinaryOperator.EQ, right);
   }
 
   @override
   ir.Primitive visitSuperEquals(
@@ skipping 47 matching lines @@
   @override
   ir.Primitive visitSuperUnary(
       ast.Send node,
       op.UnaryOperator operator,
       FunctionElement function,
       _) {
     return irBuilder.buildSuperMethodInvocation(
         function, CallStructure.NO_ARGS, const []);
   }
 
-  @override
-  ir.Primitive visitUnresolvedSuperUnary(
-      ast.Send node,
-      op.UnaryOperator operator,
-      Element element,
-      _) {
-    return giveup(node, 'visitUnresolvedSuperUnary');
-  }
-
   // TODO(johnniwinther): Handle this in the [IrBuilder] to ensure the correct
   // semantic correlation between arguments and invocation.
   List<ir.Primitive> translateDynamicArguments(ast.NodeList nodeList,
                                                CallStructure callStructure) {
     List<ir.Primitive> arguments = nodeList.nodes.mapToList(visit);
     return normalizeDynamicArguments(callStructure, arguments);
   }
 
   // TODO(johnniwinther): Handle this in the [IrBuilder] to ensure the correct
   // semantic correlation between arguments and invocation.
@@ skipping 83 matching lines @@
     return irBuilder.buildStaticFunctionInvocation(function, callStructure,
         translateStaticArguments(arguments, function, callStructure),
         sourceInformation: sourceInformationBuilder.buildCall(node));
   }
 
   @override
   ir.Primitive handleStaticFunctionIncompatibleInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
-    return giveup(node, 'handleStaticFunctionIncompatibleInvoke');
+      CallStructure callStructure, _) {
+    return buildStaticNoSuchMethod(
+        elements.getSelector(node),
+        arguments.nodes.mapToList(visit));
   }
 
   @override
   ir.Primitive handleStaticGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     if (getter.isForeign(compiler.backend)) {
@@ skipping 40 matching lines @@
       _) {
     return irBuilder.buildSuperMethodInvocation(method, callStructure,
         translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive visitSuperMethodIncompatibleInvoke(
       ast.Send node,
       MethodElement method,
       ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
-    return giveup(node, 'visitSuperMethodIncompatibleInvoke');
+      CallStructure callStructure, _) {
+    return buildInstanceNoSuchMethod(
+        elements.getSelector(node),
+        translateDynamicArguments(arguments, callStructure));
   }
 
   @override
-  ir.Primitive visitUnresolvedInvoke(
-      ast.Send node,
-      Element element,
-      ast.NodeList arguments,
-      Selector selector,
-      _) {
-    return giveup(node, 'visitUnresolvedInvoke');
-  }
-
-  @override
   ir.Primitive visitUnresolvedSuperInvoke(
       ast.Send node,
       Element element,
       ast.NodeList arguments,
-      Selector selector,
-      _) {
-    return giveup(node, 'visitUnresolvedSuperInvoke');
+      Selector selector, _) {
+    return buildInstanceNoSuchMethod(
+        elements.getSelector(node),
+        translateDynamicArguments(arguments, selector.callStructure));
   }
 
   @override
   ir.Primitive visitThisInvoke(
       ast.Send node,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return translateCallInvoke(irBuilder.buildThis(), arguments, callStructure);
   }
 
   @override
   ir.Primitive visitTypeVariableTypeLiteralInvoke(
       ast.Send node,
       TypeVariableElement element,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return translateCallInvoke(
         translateTypeVariableTypeLiteral(element),
         arguments,
         callStructure);
   }
 
-  // TODO(johnniwinther): This should be a method on [IrBuilder].
-  ir.Primitive buildReifyTypeVariable(ir.Primitive target,
-                                      TypeVariableType variable);
-
   @override
   ir.Primitive visitIndexSet(
        ast.SendSet node,
        ast.Node receiver,
        ast.Node index,
        ast.Node rhs,
        _) {
     return irBuilder.buildDynamicIndexSet(
         visit(receiver), visit(index), visit(rhs));
   }
@@ skipping 593 matching lines @@
     return irBuilder.buildConstant(getConstantForNode(node));
   }
 
   ir.Primitive visitThrow(ast.Throw node) {
     assert(irBuilder.isOpen);
     // This function is not called for throw expressions occurring as
     // statements.
     return irBuilder.buildNonTailThrow(visit(node.expression));
   }
 
+  ir.Primitive buildStaticNoSuchMethod(
+      Selector selector,
+      List<ir.Primitive> arguments);
+
+  ir.Primitive buildInstanceNoSuchMethod(
+      Selector selector,
+      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 errorUnresolvedCompound(
+      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), []);
+  }
+
+  @override
+  ir.Primitive visitUnresolvedClassConstructorInvoke(
+      ast.NewExpression node,
+      Element element,
+      DartType type,
+      ast.NodeList arguments,
+      Selector selector, _) {
+    // If the class is missing it's a runtime error.
+    return buildRuntimeError("Unresolved class: '${element.name}'");
+  }
+
+  @override
+  ir.Primitive visitUnresolvedConstructorInvoke(
+      ast.NewExpression node,
+      Element constructor,
+      DartType type,
+      ast.NodeList arguments,
+      Selector selector, _) {
+    // If the class is there but the constructor is missing, it's an NSM error.
+    return buildStaticNoSuchMethod(selector,
+        translateDynamicArguments(arguments, selector.callStructure));
+  }
+
+  @override
+  ir.Primitive errorNonConstantConstructorInvoke(
+      ast.NewExpression node,
+      Element element,
+      InterfaceType 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,
+      ast.NodeList arguments,
+      Selector selector, _) {
+    return buildStaticNoSuchMethod(elements.getSelector(node),
+        arguments.nodes.mapToList(visit));
+  }
+
+  @override
+  ir.Primitive errorUnresolvedPostfix(
+      ast.Send node,
+      Element element,
+      op.IncDecOperator operator, _) {
+    // TODO(asgerf): Which ones are missing? The getter and/or the setter?
+    return buildStaticNoSuchMethod(elements.getSelector(node), []);
+  }
+
+  @override
+  ir.Primitive errorUnresolvedPrefix(
+      ast.Send node,
+      Element element,
+      op.IncDecOperator operator, _) {
+    // TODO(asgerf): Which ones are missing? The getter and/or the setter?
+    return buildStaticNoSuchMethod(elements.getSelector(node), []);
+  }
+
+  @override
+  ir.Primitive visitUnresolvedRedirectingFactoryConstructorInvoke(
+       ast.NewExpression node,
+       ConstructorElement constructor,
+       InterfaceType type,
+       ast.NodeList arguments,
+       CallStructure callStructure, _) {
+    String nameString = Elements.reconstructConstructorName(constructor);
+    Name name = new Name(nameString, constructor.library);
+    return buildStaticNoSuchMethod(
+        new Selector(SelectorKind.CALL, name, callStructure),
+        translateDynamicArguments(arguments, callStructure));
+  }
+
+  @override
+  ir.Primitive errorUnresolvedSet(
+      ast.Send node,
+      Element element,
+      ast.Node rhs, _) {
+    return buildStaticNoSuchMethod(elements.getSelector(node), [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorUnresolvedSuperCompoundIndexSet(
+      ast.SendSet node,
+      Element element,
+      ast.Node index,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    // Assume the index getter is missing.
+    Selector selector = useSelectorTypeOfNode(new Selector.index(), node);
+    return buildInstanceNoSuchMethod(selector, [visit(index)]);
+  }
+
+  @override
+  ir.Primitive visitUnresolvedSuperIndex(
+      ast.Send node,
+      Element function,
+      ast.Node index, _) {
+    // Assume the index getter is missing.
+    Selector selector = useSelectorTypeOfNode(new Selector.index(), node);
+    return buildInstanceNoSuchMethod(selector, [visit(index)]);
+  }
+
+  @override
+  ir.Primitive errorUnresolvedSuperIndexPostfix(
+      ast.Send node,
+      Element function,
+      ast.Node index,
+      op.IncDecOperator operator, _) {
+    // Assume the index getter is missing.
+    Selector selector = useSelectorTypeOfNode(new Selector.index(), node);
+    return buildInstanceNoSuchMethod(selector, [visit(index)]);
+  }
+
+  @override
+  ir.Primitive errorUnresolvedSuperIndexPrefix(
+      ast.Send node,
+      Element function,
+      ast.Node index,
+      op.IncDecOperator operator, _) {
+    // Assume the index getter is missing.
+    Selector selector = useSelectorTypeOfNode(new Selector.index(), node);
+    return buildInstanceNoSuchMethod(selector, [visit(index)]);
+  }
+
+  @override
+  ir.Primitive errorUnresolvedSuperIndexSet(
+      ast.SendSet node,
+      Element element,
+      ast.Node index,
+      ast.Node rhs, _) {
+    Selector selector = useSelectorTypeOfNode(new Selector.index(), node);
+    return buildInstanceNoSuchMethod(
+        selector,
+        [visit(index), visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive visitUnresolvedSuperBinary(
+      ast.Send node,
+      Element element,
+      op.BinaryOperator operator,
+      ast.Node argument, _) {
+    return buildInstanceNoSuchMethod(
+        elements.getSelector(node),
+        [visit(argument)]);
+  }
+
+  @override
+  ir.Primitive visitUnresolvedSuperUnary(
+      ast.Send node,
+      op.UnaryOperator operator,
+      Element element, _) {
+    return buildInstanceNoSuchMethod(elements.getSelector(node), []);
+  }
+
+  @override
+  ir.Primitive errorUndefinedBinaryExpression(
+      ast.Send node,
+      ast.Node left,
+      ast.Operator operator,
+      ast.Node right, _) {
+    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 errorTopLevelFunctionSet(
+      ast.Send node,
+      MethodElement function,
+      ast.Node rhs, _) {
+    return buildStaticNoSuchMethod(
+        new Selector.setter(function.name, function.library),
+        [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorTopLevelSetterGet(
+      ast.Send node,
+      FunctionElement setter, _) {
+    return buildStaticNoSuchMethod(
+        new Selector.getter(setter.name, setter.library), []);
+  }
+
+  @override
+  ir.Primitive errorTopLevelGetterSet(
+      ast.SendSet node,
+      FunctionElement getter,
+      ast.Node rhs, _) {
+    return buildStaticNoSuchMethod(
+        new Selector.setter(getter.name, getter.library),
+        [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorTopLevelSetterInvoke(
+      ast.Send node,
+      FunctionElement setter,
+      ast.NodeList arguments,
+      CallStructure callStructure, _) {
+    return buildStaticNoSuchMethod(
+        new Selector.getter(setter.name, setter.library), []);
+  }
+
+  @override
+  ir.Primitive errorClassTypeLiteralSet(
+      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)]);
+  }
+
+  @override
+  ir.Primitive errorTypedefTypeLiteralSet(
+      ast.SendSet node,
+      TypeConstantExpression constant,
+      ast.Node rhs, _) {
+    TypedefType type = constant.type;
+    TypedefElement element = type.element;
+    return buildStaticNoSuchMethod(
+        new Selector.setter(element.name, element.library), [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorTypeVariableTypeLiteralSet(
+      ast.SendSet node,
+      TypeVariableElement element,
+      ast.Node rhs, _) {
+    return buildStaticNoSuchMethod(
+        new Selector.setter(element.name, element.library), [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorDynamicTypeLiteralSet(
+      ast.SendSet node,
+      ConstantExpression constant,
+      ast.Node rhs, _) {
+    return buildStaticNoSuchMethod(
+        new Selector.setter('dynamic', null), [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive visitAbstractClassConstructorInvoke(
+      ast.NewExpression node,
+      ConstructorElement element,
+      InterfaceType type,
+      ast.NodeList arguments,
+      CallStructure callStructure, _) {
+    return buildAbstractClassInstantiationError(element.enclosingClass);
+  }
+
+  @override
+  ir.Primitive errorClassTypeLiteralCompound(
+      ast.Send node,
+      ConstantExpression constant,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildConstant(constant),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) {}); // The binary operator will throw before this.
+  }
+
+  @override
+  ir.Primitive errorClassTypeLiteralPostfix(
+      ast.Send node,
+      ConstantExpression constant,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+      getValue: () => irBuilder.buildConstant(constant),
+      operator: operator,
+      setValue: (value) {}, // The binary operator will throw before this.
+      isPrefix: false);
+  }
+
+  @override
+  ir.Primitive errorClassTypeLiteralPrefix(
+      ast.Send node,
+      ConstantExpression constant,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+      getValue: () => irBuilder.buildConstant(constant),
+      operator: operator,
+      setValue: (value) {}, // The binary operator will throw before this.
+      isPrefix: true);
+  }
+
+  @override
+  ir.Primitive errorDynamicTypeLiteralCompound(
+      ast.Send node,
+      ConstantExpression constant,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildConstant(constant),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) {}); // The binary operator will throw before this.
+  }
+
+  @override
+  ir.Primitive errorDynamicTypeLiteralPostfix(
+      ast.Send node,
+      ConstantExpression constant,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildConstant(constant),
+        operator: operator,
+        setValue: (value) {}, // The binary operator will throw before this.
+        isPrefix: false);
+  }
+
+  @override
+  ir.Primitive errorDynamicTypeLiteralPrefix(
+      ast.Send node,
+      ConstantExpression constant,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildConstant(constant),
+        operator: operator,
+        setValue: (value) {}, // The binary operator will throw before this.
+        isPrefix: true);
+  }
+
+  @override
+  ir.Primitive errorFinalLocalVariableCompound(
+      ast.Send node,
+      LocalVariableElement variable,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    Selector selector = new Selector.setter(variable.name, null);
+    return translateCompound(
+        getValue: () => irBuilder.buildLocalVariableGet(variable),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) => buildStaticNoSuchMethod(selector, [value]));
+  }
+
+  @override
+  ir.Primitive errorFinalLocalVariableSet(
+      ast.SendSet node,
+      LocalVariableElement variable,
+      ast.Node rhs, _) {
+    Selector selector = new Selector.setter(variable.name, null);
+    return buildStaticNoSuchMethod(selector, [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorFinalParameterCompound(
+      ast.Send node,
+      ParameterElement parameter,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    Selector selector = new Selector.setter(parameter.name, null);
+    return translateCompound(
+        getValue: () => irBuilder.buildLocalVariableGet(parameter),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) => buildStaticNoSuchMethod(selector, [value]));
+  }
+
+  @override
+  ir.Primitive errorFinalParameterSet(
+      ast.SendSet node,
+      ParameterElement parameter,
+      ast.Node rhs, _) {
+    Selector selector = new Selector.setter(parameter.name, null);
+    return buildStaticNoSuchMethod(selector, [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorFinalStaticFieldCompound(
+      ast.Send node,
+      FieldElement field,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildStaticFieldGet(field),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) => buildStaticNoSuchMethod(
+            new Selector.setter(field.name, field.library), [value]));
+  }
+
+  @override
+  ir.Primitive errorFinalStaticFieldSet(
+      ast.SendSet node,
+      FieldElement field,
+      ast.Node rhs, _) {
+    // TODO(asgerf): Include class name somehow?
+    return buildStaticNoSuchMethod(
+        new Selector.setter(field.name, field.library),
+        [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorFinalSuperFieldCompound(
+      ast.Send node,
+      FieldElement field,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    Selector selector = useSelectorTypeOfNode(
+        new Selector.setter(field.name, field.library),
+        node);
+    return translateCompound(
+        getValue: () => irBuilder.buildSuperFieldGet(field),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) => buildInstanceNoSuchMethod(selector, [value]));
+  }
+
+  @override
+  ir.Primitive errorFinalSuperFieldSet(
+      ast.SendSet node,
+      FieldElement field,
+      ast.Node rhs, _) {
+    Selector selector = useSelectorTypeOfNode(
+        new Selector.setter(field.name, field.library),
+        node);
+    return buildInstanceNoSuchMethod(selector, [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorFinalTopLevelFieldCompound(
+      ast.Send node,
+      FieldElement field,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildStaticFieldGet(field),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) => buildStaticNoSuchMethod(
+            new Selector.setter(field.name, field.library), [value]));
+  }
+
+  @override
+  ir.Primitive errorFinalTopLevelFieldSet(
+      ast.SendSet node,
+      FieldElement field,
+      ast.Node rhs, _) {
+    return buildStaticNoSuchMethod(
+        new Selector.setter(field.name, field.library),
+        [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorLocalFunctionCompound(
+      ast.Send node,
+      LocalFunctionElement function,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildLocalFunctionGet(function),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) {}); // Binary operator will throw before this.
+  }
+
+  @override
+  ir.Primitive errorLocalFunctionPostfix(
+      ast.Send node,
+      LocalFunctionElement function,
+      op.IncDecOperator operator,
+      _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildLocalFunctionGet(function),
+        operator: operator,
+        setValue: (value) {}, // Binary operator will throw before this.
+        isPrefix: false);
+  }
+
+  @override
+  ir.Primitive errorLocalFunctionPrefix(
+      ast.Send node,
+      LocalFunctionElement function,
+      op.IncDecOperator operator,
+      _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildLocalFunctionGet(function),
+        operator: operator,
+        setValue: (value) {}, // Binary operator will throw before this.
+        isPrefix: true);
+  }
+
+  @override
+  ir.Primitive errorLocalFunctionSet(
+      ast.SendSet node,
+      LocalFunctionElement function,
+      ast.Node rhs, _) {
+    return buildStaticNoSuchMethod(
+        new Selector.setter(function.name, null),
+        [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorStaticFunctionSet(
+      ast.Send node,
+      MethodElement function,
+      ast.Node rhs,
+      _) {
+    return buildStaticNoSuchMethod(
+        new Selector.setter(function.name, function.library),
+        [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorStaticGetterSet(
+      ast.SendSet node,
+      FunctionElement getter,
+      ast.Node rhs,
+      _) {
+    return buildStaticNoSuchMethod(
+        new Selector.setter(getter.name, getter.library),
+        [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorStaticSetterGet(
+      ast.Send node,
+      FunctionElement setter,
+      _) {
+    return buildStaticNoSuchMethod(
+        new Selector.getter(setter.name, setter.library),
+        []);
+  }
+
+  @override
+  ir.Primitive errorStaticSetterInvoke(
+      ast.Send node,
+      FunctionElement setter,
+      ast.NodeList arguments,
+      CallStructure callStructure, _) {
+    // Translate as a method call.
+    List<ir.Primitive> args = arguments.nodes.mapToList(visit);
+    Name name = new Name(setter.name, setter.library);
+    return buildStaticNoSuchMethod(
+        new Selector(SelectorKind.CALL, name, callStructure),
+        args);
+  }
+
+  @override
+  ir.Primitive errorSuperGetterSet(
+      ast.SendSet node,
+      FunctionElement getter,
+      ast.Node rhs,
+      _) {
+    Selector selector = useSelectorTypeOfNode(
+        new Selector.setter(getter.name, getter.library),
+        node);
+    return buildInstanceNoSuchMethod(selector, [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorSuperMethodSet(
+      ast.Send node,
+      MethodElement method,
+      ast.Node rhs,
+      _) {
+    Selector selector = useSelectorTypeOfNode(
+        new Selector.setter(method.name, method.library),
+        node);
+    return buildInstanceNoSuchMethod(selector, [visit(rhs)]);
+  }
+
+  @override
+  ir.Primitive errorSuperSetterGet(
+      ast.Send node,
+      FunctionElement setter, _) {
+    Selector selector = useSelectorTypeOfNode(
+        new Selector.setter(setter.name, setter.library),
+        node);
+    return buildInstanceNoSuchMethod(selector, []);
+  }
+
+  @override
+  ir.Primitive errorSuperSetterInvoke(
+      ast.Send node,
+      FunctionElement setter,
+      ast.NodeList arguments,
+      CallStructure callStructure, _) {
+    List<ir.Primitive> args =
+        translateDynamicArguments(arguments, callStructure);
+    Name name = new Name(setter.name, setter.library);
+    Selector selector = useSelectorTypeOfNode(
+        new Selector(SelectorKind.CALL, name, callStructure),
+        node);
+    return buildInstanceNoSuchMethod(selector, args);
+  }
+
+  @override
+  ir.Primitive errorTypeVariableTypeLiteralCompound(
+      ast.Send node,
+      TypeVariableElement element,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildReifyTypeVariable(element.type),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) {}); // The binary operator will throw before this.
+  }
+
+  @override
+  ir.Primitive errorTypeVariableTypeLiteralPostfix(
+      ast.Send node,
+      TypeVariableElement element,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildReifyTypeVariable(element.type),
+        operator: operator,
+        setValue: (value) {}, // The binary operator will throw before this.
+        isPrefix: false);
+  }
+
+  @override
+  ir.Primitive errorTypeVariableTypeLiteralPrefix(
+      ast.Send node,
+      TypeVariableElement element,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildReifyTypeVariable(element.type),
+        operator: operator,
+        setValue: (value) {}, // The binary operator will throw before this.
+        isPrefix: true);
+  }
+
+  @override
+  ir.Primitive errorTypedefTypeLiteralCompound(
+      ast.Send node,
+      ConstantExpression constant,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildConstant(constant),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) {}); // The binary operator will throw before this.
+  }
+
+  @override
+  ir.Primitive errorTypedefTypeLiteralPostfix(
+      ast.Send node,
+      ConstantExpression constant,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildConstant(constant),
+        operator: operator,
+        setValue: (value) {}, // The binary operator will throw before this.
+        isPrefix: false);
+  }
+
+  @override
+  ir.Primitive errorTypedefTypeLiteralPrefix(
+      ast.Send node,
+      TypeConstantExpression constant,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildConstant(constant),
+        operator: operator,
+        setValue: (value) {}, // The binary operator will throw before this.
+        isPrefix: true);
+  }
+
   ir.RootNode nullIfGiveup(ir.RootNode action()) {
     try {
       return action();
     } catch(e) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
     }
   }
@@ skipping 303 matching lines @@
     return arguments;
   }
 
   List<ir.Primitive> normalizeDynamicArguments(
       CallStructure callStructure,
       List<ir.Primitive> arguments) {
     return arguments;
   }
 
   @override
-  ir.Primitive buildReifyTypeVariable(ir.Primitive target,
-                                      TypeVariableType variable) {
-    assert(target == irBuilder.state.enclosingMethodThisParameter);
-    ir.Primitive prim = new ir.ReifyTypeVar(variable.element);
-    irBuilder.add(new ir.LetPrim(prim));
-    return prim;
-  }
-
-  @override
   ir.Primitive handleConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement constructor,
       DartType type,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
     List<ir.Primitive> arguments =
         node.send.arguments.mapToList(visit, growable:false);
     return irBuilder.buildConstructorInvocation(
         constructor,
         callStructure,
         type,
         arguments);
   }
+
+  @override
+  ir.Primitive buildStaticNoSuchMethod(Selector selector,
+                                       List<ir.Primitive> arguments) {
+    return giveup(null, 'Static noSuchMethod');
+  }
+
+  @override
+  ir.Primitive buildInstanceNoSuchMethod(Selector selector,
+                                         List<ir.Primitive> arguments) {
+    return giveup(null, 'Instance noSuchMethod');
+  }
+
+  @override
+  ir.Primitive buildRuntimeError(String message) {
+    return giveup(null, 'Build runtime error: $message');
+  }
+
+  @override
+  ir.Primitive buildAbstractClassInstantiationError(ClassElement element) {
+    return giveup(null, 'Abstract class instantiation: ${element.name}');
+  }
 }
 
 /// The [IrBuilder]s view on the information about the program that has been
 /// computed in resolution and and type interence.
 class GlobalProgramInformation {
   final Compiler _compiler;
   JavaScriptBackend get _backend => _compiler.backend;
 
   GlobalProgramInformation(this._compiler);
 
   /// Returns [true], if the analysis could not determine that the type
   /// arguments for the class [cls] are never used in the program.
   bool requiresRuntimeTypesFor(ClassElement cls) {
     return cls.typeVariables.isNotEmpty && _backend.classNeedsRti(cls);
   }
 }
 
 /// IR builder specific to the JavaScript backend, coupled to the [JsIrBuilder].
 class JsIrBuilderVisitor extends IrBuilderVisitor {
   /// Promote the type of [irBuilder] to [JsIrBuilder].
   JsIrBuilder get irBuilder => super.irBuilder;
 
+  JavaScriptBackend get backend => compiler.backend;
+
   /// Result of closure conversion for the current body of code.
   ///
   /// Will be initialized upon entering the body of a function.
   /// It is computed by the [ClosureTranslator].
   ClosureClassMap closureMap;
 
   /// During construction of a constructor factory, [fieldValues] maps fields
   /// to the primitive containing their initial value.
   Map<FieldElement, ir.Primitive> fieldValues = <FieldElement, ir.Primitive>{};
 
@@ skipping 560 matching lines @@
     for (int i=0; i < callStructure.positionalArgumentCount; i++) {
       result.add(arguments[i]);
     }
     for (String argName in callStructure.getOrderedNamedArguments()) {
       int nameIndex = callStructure.namedArguments.indexOf(argName);
       int translatedIndex = callStructure.positionalArgumentCount + nameIndex;
       result.add(arguments[translatedIndex]);
     }
     return result;
   }
-
-  @override
-  ir.Primitive buildReifyTypeVariable(ir.Primitive target,
-                                      TypeVariableType variable) {
-    ir.Primitive typeArgument =
-        irBuilder.buildTypeVariableAccess(target, variable);
-
-    ir.Primitive type = new ir.ReifyRuntimeType(typeArgument);
-    irBuilder.add(new ir.LetPrim(type));
-    return type;
-  }
-
   @override
   ir.Primitive handleConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement constructor,
       DartType type,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     List<ir.Primitive> arguments =
         node.send.arguments.mapToList(visit, growable:false);
     arguments = normalizeStaticArguments(
         callStructure, constructor, arguments);
     return irBuilder.buildConstructorInvocation(
         constructor.effectiveTarget,
         callStructure,
         constructor.computeEffectiveTargetType(type),
         arguments);
   }
+
+  @override
+  ir.Primitive buildStaticNoSuchMethod(Selector selector,
+                                       List<ir.Primitive> arguments) {
+    Element thrower = backend.getThrowNoSuchMethod();
+    ir.Primitive receiver = irBuilder.buildStringConstant('');
+    ir.Primitive name = irBuilder.buildStringConstant(selector.name);
+    ir.Primitive argumentList = irBuilder.buildListLiteral(null, arguments);
+    ir.Primitive expectedArgumentNames = irBuilder.buildNullConstant();
+    return irBuilder.buildStaticFunctionInvocation(
+        thrower,
+        new CallStructure.unnamed(4),
+        [receiver, name, argumentList, expectedArgumentNames]);
+  }
+
+  @override
+  ir.Primitive buildInstanceNoSuchMethod(Selector selector,
+                                         List<ir.Primitive> arguments) {
+    return irBuilder.buildDynamicInvocation(
+        irBuilder.buildThis(),
+        useSelectorType(compiler.noSuchMethodSelector, selector),
+        [irBuilder.buildInvocationMirror(selector, arguments)]);
+  }
+
+  @override
+  ir.Primitive buildRuntimeError(String message) {
+    return irBuilder.buildStaticFunctionInvocation(
+        backend.getThrowRuntimeError(),
+        new CallStructure.unnamed(1),
+        [irBuilder.buildStringConstant(message)]);
+  }
+
+  @override
+  ir.Primitive buildAbstractClassInstantiationError(ClassElement element) {
+    return irBuilder.buildStaticFunctionInvocation(
+        backend.getThrowAbstractClassInstantiationError(),
+        new CallStructure.unnamed(1),
+        [irBuilder.buildStringConstant(element.name)]);
+  }
 }
 
 /// Perform simple post-processing on the initial CPS-translated root term.
 ///
 /// This pass performs backend-independent post-processing on the translated
 /// term.  It is implemented separately from the optimization passes because
 /// it is required for correctness of the implementation.
 ///
 /// It performs the following translations:
 ///   - Replace [ir.LetPrim] binding a [ir.NonTailThrow] with a [ir.Throw]
@@ skipping 48 matching lines @@
     node.body = replacementFor(node.body);
   }
 }
 
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends ir.RecursiveVisitor {
   processReference(ir.Reference reference) {
     reference.unlink();
   }
 }