Fix crash reported in http://code.google.com/p/dart/issues/detail?id=9949.

sdk/lib/_internal/compiler/implementation/ssa/builder.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 ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 1170 matching lines @@
    * Invariant: [constructor] and [constructors] must all be implementation
    * elements.
    */
   void inlineSuperOrRedirect(FunctionElement constructor,
                              Selector selector,
                              Link<Node> arguments,
                              List<FunctionElement> constructors,
                              Map<Element, HInstruction> fieldValues,
                              FunctionElement inlinedFromElement,
                              Node callNode) {
+    constructor = constructor.implementation;
     compiler.withCurrentElement(constructor, () {
-      assert(invariant(constructor, constructor.isImplementation));
       constructors.add(constructor);
 
       List<HInstruction> compiledArguments = new List<HInstruction>();
       bool succeeded =
           inlinedFrom(inlinedFromElement,
                        () => addStaticSendArgumentsToList(selector,
                                                           arguments,
                                                           constructor,
                                                           compiledArguments));
       if (!succeeded) {
@@ skipping 102 matching lines @@
       for (Link<Node> link = initializers; !link.isEmpty; link = link.tail) {
         assert(link.head is Send);
         if (link.head is !SendSet) {
           // A super initializer or constructor redirection.
           Send call = link.head;
           assert(Initializers.isSuperConstructorCall(call) ||
                  Initializers.isConstructorRedirect(call));
           FunctionElement target = elements[call];
           Selector selector = elements.getSelector(call);
           Link<Node> arguments = call.arguments;
-          inlineSuperOrRedirect(target, selector, arguments, constructors,
-                                fieldValues, constructor, call);
+          inlineSuperOrRedirect(target,
+                                selector,
+                                arguments,
+                                constructors,
+                                fieldValues,
+                                constructor,
+                                call);
           foundSuperOrRedirect = true;
         } else {
           // A field initializer.
           SendSet init = link.head;
           Link<Node> arguments = init.arguments;
           assert(!arguments.isEmpty && arguments.tail.isEmpty);
           inlinedFrom(constructor, () {
             visit(arguments.head);
           });
           fieldValues[elements[init]] = pop();
         }
       }
     }
 
     if (!foundSuperOrRedirect) {
       // No super initializer found. Try to find the default constructor if
       // the class is not Object.
       ClassElement enclosingClass = constructor.getEnclosingClass();
       ClassElement superClass = enclosingClass.superclass;
       if (!enclosingClass.isObject(compiler)) {
         assert(superClass != null);
         assert(superClass.resolutionState == STATE_DONE);
         Selector selector =
             new Selector.callDefaultConstructor(enclosingClass.getLibrary());
         // TODO(johnniwinther): Should we find injected constructors as well?
         FunctionElement target = superClass.lookupConstructor(selector);
         if (target == null) {
           compiler.internalError("no default constructor available");
         }
-        inlineSuperOrRedirect(target.implementation,
+        inlineSuperOrRedirect(target,
                               selector,
                               const Link<Node>(),
                               constructors,
                               fieldValues,
                               constructor,
                               functionNode);
       }
     }
   }
 
@@ skipping 3869 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }