Handle unresolved elements in the new IR

sdk/lib/_internal/compiler/implementation/ir/ir_builder.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;
 
 import 'ir_nodes.dart' as ir;
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
@@ skipping 1016 matching lines @@
     add(new ir.LetCont(k, invoke));
     return v;
   }
 
   _GetterElements translateGetter(ast.Send node, Selector selector) {
     Element element = elements[node];
     ir.Primitive result;
     ir.Primitive receiver;
     ir.Primitive index;
 
-    if (Elements.isErroneousElement(element)) {
-      giveup(node, 'Erroneous element on GetterSend');
-      return null;
-    }
-
     if (element != null && element.isConst) {
       // Reference to constant local, top-level or static field
 
       result = translateConstant(node);
     } else if (Elements.isLocal(element)) {
       // Reference to local variable
 
       result = lookupLocal(element);
     } else if (element == null ||
                Elements.isInstanceField(element) ||
@@ skipping 13 matching lines @@
       }
 
       ir.Parameter v = new ir.Parameter(null);
       ir.Continuation k = new ir.Continuation([v]);
       assert(selector.kind == SelectorKind.GETTER ||
              selector.kind == SelectorKind.INDEX);
       ir.Expression invoke =
           createDynamicInvoke(node, selector, receiver, k, arguments);
       add(new ir.LetCont(k, invoke));
       result = v;
-    } else if (element.isField || element.isGetter ||
+    } else if (element.isField || element.isGetter || element.isErroneous ||
         // Access to a static field or getter (non-static case handled above).
         // Even if there is only a setter, we compile as if it was a getter,
         // so the vm can fail at runtime.
-
         element.isSetter) {
       ir.Parameter v = new ir.Parameter(null);
       ir.Continuation k = new ir.Continuation([v]);
       assert(selector.kind == SelectorKind.GETTER ||
              selector.kind == SelectorKind.SETTER);
       ir.Expression invoke =
           new ir.InvokeStatic(element, selector, k, []);
       add(new ir.LetCont(k, invoke));
       result = v;
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
@@ skipping 147 matching lines @@
       return buildNegation(visit(node.receiver));
     }
     if (op.source == "!=") {
       assert(node.receiver != null);
       assert(!node.arguments.isEmpty);
       assert(node.arguments.tail.isEmpty);
       return buildNegation(visitDynamicSend(node));
     }
     if (op.source == "is") {
       DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
-      if (type.isMalformed) return giveup(node, "Malformed type for is");
       ir.Primitive receiver = visit(node.receiver);
       ir.IsCheck isCheck = new ir.IsCheck(receiver, type);
       add(new ir.LetPrim(isCheck));
       return node.isIsNotCheck ? buildNegation(isCheck) : isCheck;
     }
     if (op.source == "as") {
       DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
-      if (type.isMalformed) return giveup(node, "Malformed type for as");
       ir.Primitive receiver = visit(node.receiver);
       ir.Parameter v = new ir.Parameter(null);
       ir.Continuation k = new ir.Continuation([v]);
       ir.AsCast asCast = new ir.AsCast(receiver, type, k);
       add(new ir.LetCont(k, asCast));
       return v;
     }
-    return giveup(node);
+    compiler.internalError(node, "Unknown operator '${op.source}'");
   }
 
   // Build(StaticSend(f, arguments), C) = C[C'[InvokeStatic(f, xs)]]
   //   where (C', xs) = arguments.fold(Build, C)
   ir.Primitive visitStaticSend(ast.Send node) {
     assert(isOpen);
     Element element = elements[node];
-    // TODO(lry): support constructors / factory calls.
-    if (element.isConstructor) return giveup(node, 'StaticSend: constructor');
+    assert(!element.isConstructor);
     // TODO(lry): support foreign functions.
     if (element.isForeign(compiler)) return giveup(node, 'StaticSend: foreign');
-    // TODO(lry): for elements that could not be resolved emit code to throw a
-    // [NoSuchMethodError].
-    if (element.isErroneous) return giveup(node, 'StaticSend: erroneous');
-    // TODO(lry): generate IR for object identicality.
-    if (element == compiler.identicalFunction) {
-      return giveup(node, 'StaticSend: identical');
-    }
 
     Selector selector = elements.getSelector(node);
 
     // TODO(lry): support default arguments, need support for locals.
     List<ir.Definition> arguments = node.arguments.mapToList(visit,
                                                              growable:false);
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
     ir.Expression invoke =
         new ir.InvokeStatic(element, selector, k, arguments);
@@ skipping 90 matching lines @@
       ir.Continuation k = new ir.Continuation([valueToStore]);
       ir.Expression invoke =
           new ir.InvokeMethod(originalValue, operatorSelector, k, [arg]);
       add(new ir.LetCont(k, invoke));
     }
 
     // Set the value
     if (Elements.isLocal(element)) {
       valueToStore.useElementAsHint(element);
       assignedVars[variableIndex[element]] = valueToStore;
-    } else if (Elements.isStaticOrTopLevel(element)) {
+    } else if ((!node.isSuperCall && Elements.isErroneousElement(element)) ||
+                Elements.isStaticOrTopLevel(element)) {
       assert(element.isField || element.isSetter);
       ir.Parameter v = new ir.Parameter(null);
       ir.Continuation k = new ir.Continuation([v]);
       Selector selector = elements.getSelector(node);
       ir.InvokeStatic invoke =
           new ir.InvokeStatic(element, selector, k, [valueToStore]);
       add(new ir.LetCont(k, invoke));
     } else {
-      if (element != null && Elements.isUnresolved(element)) {
-        return giveup(node, 'SendSet: non-local, non-static, unresolved');
-      }
       // Setter or index-setter invocation
       ir.Parameter v = new ir.Parameter(null);
       ir.Continuation k = new ir.Continuation([v]);
       Selector selector = elements.getSelector(node);
       assert(selector.kind == SelectorKind.SETTER ||
           selector.kind == SelectorKind.INDEX);
       List<ir.Definition> arguments = selector.isIndexSet
           ? [index, valueToStore]
           : [valueToStore];
       ir.Expression invoke =
           createDynamicInvoke(node, selector, receiver, k, arguments);
       add(new ir.LetCont(k, invoke));
     }
 
     if (node.isPostfix) {
       assert(originalValue != null);
       return originalValue;
     } else {
       return valueToStore;
     }
   }
 
   ir.Primitive visitNewExpression(ast.NewExpression node) {
     assert(isOpen);
     if (node.isConst) {
       return translateConstant(node);
     }
     FunctionElement element = elements[node.send];
-    if (Elements.isUnresolved(element)) {
-      return giveup(node, 'NewExpression: unresolved constructor');
-    }
     Selector selector = elements.getSelector(node.send);
     ast.Node selectorNode = node.send.selector;
-    GenericType type = elements.getType(node);
+    DartType type = elements.getType(node);
     List<ir.Primitive> args =
         node.send.arguments.mapToList(visit, growable:false);
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
     ir.InvokeConstructor invoke =
         new ir.InvokeConstructor(type, element,selector, k, args);
     add(new ir.LetCont(k, invoke));
     return v;
   }
 
@@ skipping 207 matching lines @@
   ConstExp visitConditional(ast.Conditional node) {
     BoolConstant condition = computeConstant(node.condition);
     return visit(condition.isTrue ? node.thenExpression : node.elseExpression);
   }
 
   ConstExp visitNode(ast.Node node) {
     throw "Unexpected constant: $node";
   }
 
 }