Record dependency information to implement first version of dependency

dart/sdk/lib/_internal/compiler/implementation/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
+  Element get currentElement;
+  Set<Node> get superUses;
+  Set<Element> get backendDependencies;
+
   Element operator[](Node node);
   Selector getSelector(Send send);
   Selector getGetterSelectorInComplexSendSet(SendSet node);
   Selector getOperatorSelectorInComplexSendSet(SendSet node);
   Selector getIteratorSelector(ForIn node);
   Selector getMoveNextSelector(ForIn node);
   Selector getCurrentSelector(ForIn node);
   DartType getType(Node node);
   bool isParameterChecked(Element element);
-  Set<Node> get superUses;
+  void registerBackendDependency(Element element);
 }
 
 class TreeElementMapping implements TreeElements {
   final Element currentElement;
   final Map<Spannable, Selector> selectors =
       new LinkedHashMap<Spannable, Selector>();
   final Map<Node, DartType> types = new LinkedHashMap<Node, DartType>();
-  final Set<Element> checkedParameters = new Set<Element>();
-  final Set<Node> superUses = new Set<Node>();
+  final Set<Element> checkedParameters = new LinkedHashSet<Element>();
+  final Set<Node> superUses = new LinkedHashSet<Node>();
+  final Set<Element> backendDependencies = new LinkedHashSet<Element>();
+  final int hashCode = ++hashCodeCounter;
+  static int hashCodeCounter = 0;
 
   TreeElementMapping(this.currentElement);
 
   operator []=(Node node, Element element) {
     assert(invariant(node, () {
       if (node is FunctionExpression) {
         return !node.modifiers.isExternal();
       }
       return true;
     }));
@@ skipping 74 matching lines @@
     selectors[node.inToken] = selector;
   }
 
   Selector getCurrentSelector(ForIn node) {
     return selectors[node.inToken];
   }
 
   bool isParameterChecked(Element element) {
     return checkedParameters.contains(element);
   }
+
+  void registerBackendDependency(Element element) {
+    backendDependencies.add(element);
+  }
+
+  String toString() => 'TreeElementMapping($currentElement)';
 }
 
 class ResolverTask extends CompilerTask {
   ResolverTask(Compiler compiler) : super(compiler);
 
   String get name => 'Resolver';
 
   TreeElements resolve(Element element) {
     return measure(() {
       if (Elements.isErroneousElement(element)) return null;
@@ skipping 302 matching lines @@
       error(element.modifiers.getStatic(),
             MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
     }
     ResolverVisitor visitor = visitorFor(element);
     initializerDo(tree, visitor.visit);
 
     if (Elements.isStaticOrTopLevelField(element)) {
       if (tree.asSendSet() != null) {
         // TODO(ngeoffray): We could do better here by using the
         // constant handler to figure out if it's a lazy field or not.
-        compiler.backend.registerLazyField();
+        compiler.backend.registerLazyField(visitor.mapping);
       }
     }
 
     // Perform various checks as side effect of "computing" the type.
     element.computeType(compiler);
 
     return visitor.mapping;
   }
 
   TreeElements resolveParameter(Element element) {
@@ skipping 1077 matching lines @@
               new TypedefType.userProvidedBadType(typdef, arguments.toLink()));
         } else {
           if (arguments.isEmpty) {
             type = typdef.rawType;
           } else {
            type = new TypedefType(typdef, arguments.toLink());
           }
         }
       } else if (element.isTypeVariable()) {
         if (enclosingElement.isInStaticMember()) {
-          compiler.backend.registerThrowRuntimeError();
+          compiler.backend.registerThrowRuntimeError(
+              // TODO(ahe): Get the TreeElements for the current element.
+              compiler.globalDependencies);
           compiler.reportWarning(node,
               MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER.message(
                   {'typeVariableName': node}));
           type = new MalformedType(
               new ErroneousElementX(
                   MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
                   {'typeVariableName': node},
                   typeName.source, enclosingElement),
                   element.computeType(compiler));
         } else {
@@ skipping 170 matching lines @@
         error(node, MessageKind.INVALID_USE_OF_SUPER);
       }
       return null;
     } else {
       Element element = lookup(node, node.source);
       if (element == null) {
         if (!inInstanceContext) {
           element = warnAndCreateErroneousElement(node, node.source,
                                                   MessageKind.CANNOT_RESOLVE,
                                                   {'name': node});
-          compiler.backend.registerThrowNoSuchMethod();
+          compiler.backend.registerThrowNoSuchMethod(mapping);
         }
       } else if (element.isErroneous()) {
         // Use the erroneous element.
       } else {
         if ((element.kind.category & allowedCategory) == 0) {
           // TODO(ahe): Improve error message. Need UX input.
           error(node, MessageKind.GENERIC,
                 {'text': "is not an expression $element"});
         }
       }
       if (!Elements.isUnresolved(element) && element.isClass()) {
         ClassElement classElement = element;
         classElement.ensureResolved(compiler);
       }
       return useElement(node, element);
     }
   }
 
   Element visitTypeAnnotation(TypeAnnotation node) {
     DartType type = resolveTypeAnnotation(node);
     if (type != null) {
       if (inCheckContext) {
-        compiler.enqueuer.resolution.registerIsCheck(type);
+        compiler.enqueuer.resolution.registerIsCheck(type, mapping);
       }
       return type.element;
     }
     return null;
   }
 
   Element defineElement(Node node, Element element,
                         {bool doAddToScope: true}) {
     compiler.ensure(element != null);
     mapping[node] = element;
@@ skipping 165 matching lines @@
     enclosingElement = function;
     // Run the body in a fresh statement scope.
     StatementScope oldStatementScope = statementScope;
     statementScope = new StatementScope();
     visit(node.body);
     statementScope = oldStatementScope;
 
     scope = oldScope;
     enclosingElement = previousEnclosingElement;
 
-    world.registerInstantiatedClass(compiler.functionClass);
+    world.registerInstantiatedClass(compiler.functionClass, mapping);
   }
 
   visitIf(If node) {
     visit(node.condition);
     visit(node.thenPart);
     visit(node.elsePart);
   }
 
   static bool isLogicalOperator(Identifier op) {
     String str = op.source.stringValue;
@@ skipping 57 matching lines @@
       // [target] may be null which means invoking noSuchMethod on
       // super.
       if (target == null) {
         target = warnAndCreateErroneousElement(
             node, name, MessageKind.NO_SUCH_SUPER_MEMBER,
             {'className': currentClass, 'memberName': name});
         // We still need to register the invocation, because we might
         // call [:super.noSuchMethod:] that does a
         // [:InvocationMirror.invokeOn:].
         world.registerDynamicInvocation(selector.name, selector);
-        compiler.backend.registerSuperNoSuchMethod();
+        compiler.backend.registerSuperNoSuchMethod(mapping);
       }
     } else if (Elements.isUnresolved(resolvedReceiver)) {
       return null;
     } else if (resolvedReceiver.isClass()) {
       ClassElement receiverClass = resolvedReceiver;
       receiverClass.ensureResolved(compiler);
       if (node.isOperator) {
         // When the resolved receiver is a class, we can have two cases:
         //  1) a static send: C.foo, or
         //  2) an operator send, where the receiver is a class literal: 'C + 1'.
         // The following code that looks up the selector on the resolved
         // receiver will treat the second as the invocation of a static operator
         // if the resolved receiver is not null.
         return null;
       }
       target = receiverClass.lookupLocalMember(name);
       if (target == null || target.isInstanceMember()) {
-        compiler.backend.registerThrowNoSuchMethod();
+        compiler.backend.registerThrowNoSuchMethod(mapping);
         // TODO(johnniwinther): With the simplified [TreeElements] invariant,
         // try to resolve injected elements if [currentClass] is in the patch
         // library of [receiverClass].
 
         // TODO(karlklose): this should be reported by the caller of
         // [resolveSend] to select better warning messages for getters and
         // setters.
         MessageKind kind = (target == null)
             ? MessageKind.METHOD_NOT_FOUND
             : MessageKind.MEMBER_NOT_STATIC;
         return warnAndCreateErroneousElement(node, name, kind,
                                              {'className': receiverClass.name,
                                               'memberName': name});
       }
     } else if (identical(resolvedReceiver.kind, ElementKind.PREFIX)) {
       PrefixElement prefix = resolvedReceiver;
       target = prefix.lookupLocalMember(name);
       if (Elements.isUnresolved(target)) {
-        compiler.backend.registerThrowNoSuchMethod();
+        compiler.backend.registerThrowNoSuchMethod(mapping);
         return warnAndCreateErroneousElement(
             node, name, MessageKind.NO_SUCH_LIBRARY_MEMBER,
             {'libraryName': prefix.name, 'memberName': name});
       } else if (target.kind == ElementKind.CLASS) {
         ClassElement classElement = target;
         classElement.ensureResolved(compiler);
       }
     }
     return target;
   }
@@ skipping 94 matching lines @@
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = node.isPropertyAccess || node.isCall;
     Element target = resolveSend(node);
     sendIsMemberAccess = oldSendIsMemberAccess;
 
     if (!Elements.isUnresolved(target)) {
       if (target.isAbstractField()) {
         AbstractFieldElement field = target;
         target = field.getter;
         if (target == null && !inInstanceContext) {
-          compiler.backend.registerThrowNoSuchMethod();
+          compiler.backend.registerThrowNoSuchMethod(mapping);
           target =
               warnAndCreateErroneousElement(node.selector, field.name,
                                             MessageKind.CANNOT_RESOLVE_GETTER);
         }
       } else if (target.impliesType() && !sendIsMemberAccess) {
-        compiler.backend.registerTypeLiteral();
+        compiler.backend.registerTypeLiteral(mapping);
       }
     }
 
     bool resolvedArguments = false;
     if (node.isOperator) {
       String operatorString = node.selector.asOperator().source.stringValue;
       if (operatorString == 'is' || operatorString == 'as') {
         assert(node.arguments.tail.isEmpty);
         DartType type = resolveTypeTest(node.arguments.head);
         if (type != null) {
           if (operatorString == 'as') {
-            compiler.enqueuer.resolution.registerAsCheck(type);
+            compiler.enqueuer.resolution.registerAsCheck(type, mapping);
           } else {
-            compiler.enqueuer.resolution.registerIsCheck(type);
+            compiler.enqueuer.resolution.registerIsCheck(type, mapping);
           }
         }
         resolvedArguments = true;
       } else if (identical(operatorString, '?')) {
         Element parameter = mapping[node.receiver];
         if (parameter == null
             || !identical(parameter.kind, ElementKind.PARAMETER)) {
           error(node.receiver, MessageKind.PARAMETER_NAME_EXPECTED);
         } else {
           mapping.checkedParameters.add(parameter);
@@ skipping 33 matching lines @@
         world.registerJsCall(node, this);
       }
     }
 
     // TODO(ngeoffray): Warn if target is null and the send is
     // unqualified.
     useElement(node, target);
     registerSend(selector, target);
     if (node.isPropertyAccess) {
       // It might be the closurization of a method.
-      world.registerInstantiatedClass(compiler.functionClass);
+      world.registerInstantiatedClass(compiler.functionClass, mapping);
     }
     return node.isPropertyAccess ? target : null;
   }
 
   void warnArgumentMismatch(Send node, Element target) {
-    compiler.backend.registerThrowNoSuchMethod();
+    compiler.backend.registerThrowNoSuchMethod(mapping);
     // TODO(karlklose): we can be more precise about the reason of the
     // mismatch.
     warning(node.argumentsNode, MessageKind.INVALID_ARGUMENTS,
             {'methodName': target.name});
   }
 
   /// Callback for native enqueuer to parse a type.  Returns [:null:] on error.
   DartType resolveTypeFromString(String typeName) {
     Element element = scope.lookup(new SourceString(typeName));
     if (element == null) return null;
@@ skipping 10 matching lines @@
     String source = operatorName.stringValue;
     bool isComplex = !identical(source, '=');
     if (!Elements.isUnresolved(target)) {
       if (target.isAbstractField()) {
         AbstractFieldElement field = target;
         setter = field.setter;
         getter = field.getter;
         if (setter == null && !inInstanceContext) {
           setter = warnAndCreateErroneousElement(
               node.selector, field.name, MessageKind.CANNOT_RESOLVE_SETTER);
-          compiler.backend.registerThrowNoSuchMethod();
+          compiler.backend.registerThrowNoSuchMethod(mapping);
         }
         if (isComplex && getter == null && !inInstanceContext) {
           getter = warnAndCreateErroneousElement(
               node.selector, field.name, MessageKind.CANNOT_RESOLVE_GETTER);
-          compiler.backend.registerThrowNoSuchMethod();
+          compiler.backend.registerThrowNoSuchMethod(mapping);
         }
       } else if (target.impliesType()) {
-        compiler.backend.registerThrowNoSuchMethod();
+        compiler.backend.registerThrowNoSuchMethod(mapping);
       } else if (target.modifiers.isFinal() || target.modifiers.isConst()) {
         setter = warnAndCreateErroneousElement(
             node.selector, target.name, MessageKind.CANNOT_RESOLVE_SETTER);
-        compiler.backend.registerThrowNoSuchMethod();
+        compiler.backend.registerThrowNoSuchMethod(mapping);
       } else if (isComplex && target.name == const SourceString('[]=')) {
         getter = target.getEnclosingClass().lookupMember(
             const SourceString('[]'));
         if (getter == null) {
           getter = warnAndCreateErroneousElement(
               node, setter.name, MessageKind.CANNOT_RESOLVE_INDEX);
-          compiler.backend.registerThrowNoSuchMethod();
+          compiler.backend.registerThrowNoSuchMethod(mapping);
         }
       }
     }
 
     visit(node.argumentsNode);
 
     // TODO(ngeoffray): Check if the target can be assigned.
     // TODO(ngeoffray): Warn if target is null and the send is
     // unqualified.
 
@@ skipping 44 matching lines @@
       // the use of classes. Wouldn't it be simpler if we just did?
       if (!target.isClass()) {
         // [target] might be the implementation element and only declaration
         // elements may be registered.
         world.registerStaticUse(target.declaration);
       }
     }
   }
 
   visitLiteralInt(LiteralInt node) {
-    world.registerInstantiatedClass(compiler.intClass);
+    world.registerInstantiatedClass(compiler.intClass, mapping);
   }
 
   visitLiteralDouble(LiteralDouble node) {
-    world.registerInstantiatedClass(compiler.doubleClass);
+    world.registerInstantiatedClass(compiler.doubleClass, mapping);
   }
 
   visitLiteralBool(LiteralBool node) {
-    world.registerInstantiatedClass(compiler.boolClass);
+    world.registerInstantiatedClass(compiler.boolClass, mapping);
   }
 
   visitLiteralString(LiteralString node) {
-    world.registerInstantiatedClass(compiler.stringClass);
+    world.registerInstantiatedClass(compiler.stringClass, mapping);
   }
 
   visitLiteralNull(LiteralNull node) {
-    world.registerInstantiatedClass(compiler.nullClass);
+    world.registerInstantiatedClass(compiler.nullClass, mapping);
   }
 
   visitStringJuxtaposition(StringJuxtaposition node) {
-    world.registerInstantiatedClass(compiler.stringClass);
+    world.registerInstantiatedClass(compiler.stringClass, mapping);
     node.visitChildren(this);
   }
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       visit(link.head);
     }
   }
 
   visitOperator(Operator node) {
@@ skipping 35 matching lines @@
     { // This entire block is temporary code per the above TODO.
       FunctionElement targetImplementation = redirectionTarget.implementation;
       FunctionExpression function = targetImplementation.parseNode(compiler);
       if (function.body != null && function.body.asReturn() != null
           && function.body.asReturn().isRedirectingFactoryBody) {
         unimplemented(node.expression, 'redirecing to redirecting factory');
       }
     }
     world.registerStaticUse(redirectionTarget);
     world.registerInstantiatedClass(
-        redirectionTarget.enclosingElement.declaration);
+        redirectionTarget.enclosingElement.declaration, mapping);
   }
 
   visitThrow(Throw node) {
     if (!inCatchBlock && node.expression == null) {
       error(node, MessageKind.THROW_WITHOUT_EXPRESSION);
     }
-    compiler.backend.registerThrow();
+    compiler.backend.registerThrow(mapping);
     visit(node.expression);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     VariableDefinitionsVisitor visitor =
         new VariableDefinitionsVisitor(compiler, node, this,
                                        ElementKind.VARIABLE);
     // Ensure that we set the type of the [VariableListElement] since it depends
     // on the current scope. If the current scope is a [MethodScope] or
     // [BlockScope] it will not be available for the
@@ skipping 21 matching lines @@
   visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
     FunctionElement constructor = resolveConstructor(node);
     resolveSelector(node.send);
     resolveArguments(node.send.argumentsNode);
     useElement(node.send, constructor);
     if (Elements.isUnresolved(constructor)) return constructor;
     Selector callSelector = mapping.getSelector(node.send);
     if (!callSelector.applies(constructor, compiler)) {
       warnArgumentMismatch(node.send, constructor);
-      compiler.backend.registerThrowNoSuchMethod();
+      compiler.backend.registerThrowNoSuchMethod(mapping);
     }
     compiler.withCurrentElement(constructor, () {
       FunctionExpression tree = constructor.parseNode(compiler);
       compiler.resolver.resolveConstructorImplementation(constructor, tree);
     });
 
     if (constructor.defaultImplementation != constructor) {
       // Support for deprecated interface support.
       // TODO(ngeoffray): Remove once we remove such support.
       world.registerStaticUse(constructor.declaration);
       world.registerInstantiatedClass(
-          constructor.getEnclosingClass().declaration);
+          constructor.getEnclosingClass().declaration, mapping);
       constructor = constructor.defaultImplementation;
     }
     // [constructor.defaultImplementation] might be the implementation element
     // and only declaration elements may be registered.
     world.registerStaticUse(constructor.declaration);
     ClassElement cls = constructor.getEnclosingClass();
     // [cls] might be the implementation element and only declaration elements
     // may be registered.
-    world.registerInstantiatedType(mapping.getType(node));
+    world.registerInstantiatedType(mapping.getType(node), mapping);
     if (cls.isAbstract(compiler)) {
-      compiler.backend.registerAbstractClassInstantiation();
+      compiler.backend.registerAbstractClassInstantiation(mapping);
     }
     // [cls] might be the declaration element and we want to include injected
     // members.
     cls.implementation.forEachInstanceField(
         (ClassElement enclosingClass, Element member) {
           world.addToWorkList(member);
         },
         includeBackendMembers: false,
         includeSuperMembers: true);
     return null;
@@ skipping 38 matching lines @@
     }
   }
 
   DartType resolveTypeAnnotation(TypeAnnotation node) {
     Function report = typeRequired ? error : warning;
     DartType type = typeResolver.resolveTypeAnnotation(
         node, scope, enclosingElement,
         onFailure: report, whenResolved: useType);
     if (type == null) return null;
     if (inCheckContext) {
-      compiler.enqueuer.resolution.registerIsCheck(type);
+      compiler.enqueuer.resolution.registerIsCheck(type, mapping);
     }
     if (typeRequired || inCheckContext) {
       if (type is InterfaceType) {
         InterfaceType itf = type;
         itf.typeArguments.forEach((DartType argument) {
           analyzeTypeArgument(type, argument);
         });
       }
       // TODO(ngeoffray): Also handle T a (in checked mode).
     }
     return type;
   }
 
   visitModifiers(Modifiers node) {
     // TODO(ngeoffray): Implement this.
     unimplemented(node, 'modifiers');
   }
 
   visitLiteralList(LiteralList node) {
-    world.registerInstantiatedClass(compiler.listClass);
+    world.registerInstantiatedClass(compiler.listClass, mapping);
     NodeList arguments = node.typeArguments;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
       if (nodes.isEmpty) {
         error(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
       } else {
         resolveTypeRequired(nodes.head);
         for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
           error(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
           resolveTypeRequired(nodes.head);
         }
       }
     }
     visit(node.elements);
   }
 
   visitConditional(Conditional node) {
     node.visitChildren(this);
   }
 
   visitStringInterpolation(StringInterpolation node) {
-    world.registerInstantiatedClass(compiler.stringClass);
-    compiler.backend.registerStringInterpolation();
+    world.registerInstantiatedClass(compiler.stringClass, mapping);
+    compiler.backend.registerStringInterpolation(mapping);
     node.visitChildren(this);
   }
 
   visitStringInterpolationPart(StringInterpolationPart node) {
     registerImplicitInvocation(const SourceString('toString'), 0);
     node.visitChildren(this);
   }
 
   visitBreakStatement(BreakStatement node) {
     TargetElement target;
@@ skipping 124 matching lines @@
       }
     });
     if (!targetElement.isTarget && identical(mapping[body], targetElement)) {
       // If the body is itself a break or continue for another target, it
       // might have updated its mapping to the target it actually does target.
       mapping.remove(body);
     }
   }
 
   visitLiteralMap(LiteralMap node) {
-    world.registerInstantiatedClass(compiler.mapClass);
+    world.registerInstantiatedClass(compiler.mapClass, mapping);
     if (node.isConst()) {
-      compiler.backend.registerConstantMap();
+      compiler.backend.registerConstantMap(mapping);
     }
     node.visitChildren(this);
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     node.visitChildren(this);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
@@ skipping 60 matching lines @@
     continueLabels.forEach((String key, LabelElement label) {
       if (!label.isContinueTarget) {
         TargetElement targetElement = label.target;
         SwitchCase switchCase = targetElement.statement;
         mapping.remove(switchCase);
         mapping.remove(label.label);
       }
     });
     // TODO(ngeoffray): We should check here instead of the SSA backend if
     // there might be an error.
-    compiler.backend.registerFallThroughError();
+    compiler.backend.registerFallThroughError(mapping);
   }
 
   visitSwitchCase(SwitchCase node) {
     node.labelsAndCases.accept(this);
     visitIn(node.statements, new BlockScope(scope));
   }
 
   visitCaseMatch(CaseMatch node) {
     visit(node.expression);
   }
 
   visitTryStatement(TryStatement node) {
     visit(node.tryBlock);
     if (node.catchBlocks.isEmpty && node.finallyBlock == null) {
       // TODO(ngeoffray): The precise location is
       // node.getEndtoken.next. Adjust when issue #1581 is fixed.
       error(node, MessageKind.NO_CATCH_NOR_FINALLY);
     }
     visit(node.catchBlocks);
     visit(node.finallyBlock);
   }
 
   visitCatchBlock(CatchBlock node) {
-    compiler.backend.registerCatchStatement();
+    compiler.backend.registerCatchStatement(mapping);
     // Check that if catch part is present, then
     // it has one or two formal parameters.
     if (node.formals != null) {
       if (node.formals.isEmpty) {
         error(node, MessageKind.EMPTY_CATCH_DECLARATION);
       }
       if (!node.formals.nodes.tail.isEmpty) {
         if (!node.formals.nodes.tail.tail.isEmpty) {
           for (Node extra in node.formals.nodes.tail.tail) {
             error(extra, MessageKind.EXTRA_CATCH_DECLARATION);
           }
         }
-        compiler.backend.registerStackTraceInCatch();
+        compiler.backend.registerStackTraceInCatch(mapping);
       }
 
       // Check that the formals aren't optional and that they have no
       // modifiers or type.
       for (Link<Node> link = node.formals.nodes;
            !link.isEmpty;
            link = link.tail) {
         // If the formal parameter is a node list, it means that it is a
         // sequence of optional parameters.
         NodeList nodeList = link.head.asNodeList();
@@ skipping 524 matching lines @@
   }
 
   SourceString visitSendSet(SendSet node) {
     assert(node.arguments.tail.isEmpty); // Sanity check
     resolver.visit(node.arguments.head);
     return visit(node.selector);
   }
 
   SourceString visitIdentifier(Identifier node) {
     // The variable is initialized to null.
-    resolver.world.registerInstantiatedClass(compiler.nullClass);
+    resolver.world.registerInstantiatedClass(compiler.nullClass,
+                                             resolver.mapping);
     return node.source;
   }
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       SourceString name = visit(link.head);
       VariableElement element =
           new VariableElementX(name, variables, kind, link.head);
       resolver.defineElement(link.head, element);
     }
@@ skipping 218 matching lines @@
   ConstructorResolver(Compiler compiler, this.resolver) : super(compiler);
 
   visitNode(Node node) {
     throw 'not supported';
   }
 
   failOrReturnErroneousElement(Element enclosing, Node diagnosticNode,
                                SourceString targetName, MessageKind kind,
                                Map arguments) {
     if (kind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
-      compiler.backend.registerThrowNoSuchMethod();
+      compiler.backend.registerThrowNoSuchMethod(resolver.mapping);
     } else {
-      compiler.backend.registerThrowRuntimeError();
+      compiler.backend.registerThrowRuntimeError(resolver.mapping);
     }
     if (inConstContext) {
       error(diagnosticNode, kind, arguments);
     } else {
       ResolutionWarning warning  = new ResolutionWarning(kind, arguments);
       compiler.reportWarning(diagnosticNode, warning);
       return new ErroneousElementX(kind, arguments, targetName, enclosing);
     }
   }
 
@@ skipping 129 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }