Stub implementation of patch invariants for the patch refactoring.

lib/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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 149 matching lines @@
   SsaBuilderTask(JavaScriptBackend backend)
     : interceptors = new Interceptors(backend.compiler),
       emitter = backend.emitter,
       functionsCalledInLoop = new Set<FunctionElement>(),
       selectorsCalledInLoop = new Map<SourceString, Selector>(),
       backend = backend,
       super(backend.compiler);
 
   HGraph build(WorkItem work) {
     return measure(() {
-      Element element = work.element;
+      Element element = work.element.implementation;
       HInstruction.idCounter = 0;
       ConstantSystem constantSystem = compiler.backend.constantSystem;
       SsaBuilder builder = new SsaBuilder(constantSystem, this, work);
       HGraph graph;
       ElementKind kind = element.kind;
       if (kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
         graph = compileConstructor(builder, work);
       } else if (kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY ||
                  kind === ElementKind.FUNCTION ||
                  kind === ElementKind.GETTER ||
                  kind === ElementKind.SETTER) {
-        graph = builder.buildMethod(work.element);
+        graph = builder.buildMethod(element);
       } else if (kind === ElementKind.FIELD) {
-        graph = builder.buildLazyInitializer(work.element);
+        graph = builder.buildLazyInitializer(element);
       }
       assert(graph.isValid());
       if (kind !== ElementKind.FIELD) {
-        bool inLoop = functionsCalledInLoop.contains(element);
+        bool inLoop = functionsCalledInLoop.contains(element.declaration);
         if (!inLoop) {
           Selector selector = selectorsCalledInLoop[element.name];
           inLoop = selector !== null && selector.applies(element, compiler);
         }
         graph.calledInLoop = inLoop;
 
-        // If there is an estimate of the parameter types assume these types when
-        // compiling.
+        // If there is an estimate of the parameter types assume these types
+        // when compiling.
         OptionalParameterTypes defaultValueTypes = null;
         FunctionSignature signature = element.computeSignature(compiler);
         if (signature.optionalParameterCount > 0) {
           defaultValueTypes =
               new OptionalParameterTypes(signature.optionalParameterCount);
           int index = 0;
           signature.forEachOptionalParameter((Element parameter) {
             Constant defaultValue = compiler.compileVariable(parameter);
             HType type = HGraph.mapConstantTypeToSsaType(defaultValue);
             defaultValueTypes.update(index, parameter.name, type);
             index++;
           });
         }
         HTypeList parameterTypes =
-            backend.optimisticParameterTypes(element, defaultValueTypes);
+            backend.optimisticParameterTypes(element.declaration,
+                                             defaultValueTypes);
         if (!parameterTypes.allUnknown) {
           int i = 0;
           signature.forEachParameter((Element param) {
             builder.parameters[param].guaranteedType = parameterTypes[i++];
           });
         }
         backend.registerParameterTypesOptimization(
             element, parameterTypes, defaultValueTypes);
       }
 
@@ skipping 12 matching lines @@
         compiler.tracer.traceCompilation(name, work.compilationContext);
         compiler.tracer.traceGraph('builder', graph);
       }
       return graph;
     });
   }
 
   HGraph compileConstructor(SsaBuilder builder, WorkItem work) {
     // The body of the constructor will be generated in a separate function.
     final ClassElement classElement = work.element.getEnclosingClass();
-    return builder.buildFactory(classElement, work.element);
+    return builder.buildFactory(classElement, work.element.implementation);
   }
 }
 
 /**
  * Keeps track of locals (including parameters and phis) when building. The
  * 'this' reference is treated as parameter and hence handled by this class,
  * too.
  */
 class LocalsHandler {
   /**
@@ skipping 90 matching lines @@
       // [readLocal] uses the [boxElement] to find its box. By replacing it
       // behind its back we can still get to the old values.
       updateLocal(boxElement, oldBox);
       HInstruction oldValue = readLocal(boxedVariable);
       updateLocal(boxElement, newBox);
       updateLocal(boxedVariable, oldValue);
     }
     updateLocal(boxElement, newBox);
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [function] must be an implementation element.
+   */
   void startFunction(FunctionElement function,
                      FunctionExpression node) {
+    assert(invariant(node, function.isImplementation));
     Compiler compiler = builder.compiler;
     closureData = compiler.closureToClassMapper.computeClosureToClassMapping(
             node, builder.elements);
     FunctionSignature signature = function.computeSignature(compiler);
     signature.forEachParameter((Element element) {
       HInstruction parameter = new HParameterValue(element);
       builder.add(parameter);
       builder.parameters[element] = parameter;
       directLocals[element] = parameter;
       parameter.guaranteedType =
@@ skipping 523 matching lines @@
   void disableMethodInterception() {
     assert(methodInterceptionEnabled);
     methodInterceptionEnabled = false;
   }
 
   void enableMethodInterception() {
     assert(!methodInterceptionEnabled);
     methodInterceptionEnabled = true;
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [functionElement] must be an implementation element.
+   */
   HGraph buildMethod(FunctionElement functionElement) {
+    assert(invariant(functionElement, functionElement.isImplementation));
     FunctionExpression function = functionElement.parseNode(compiler);
+    assert(function !== null);
+    assert(function.modifiers === null || !function.modifiers.isExternal());
+    assert(elements[function] !== null);
     openFunction(functionElement, function);
     function.body.accept(this);
     return closeFunction();
   }
 
   HGraph buildLazyInitializer(VariableElement variable) {
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
     close(new HGoto()).addSuccessor(block);
     open(block);
     SendSet node = variable.parseNode(compiler);
     Link<Node> link = node.arguments;
     assert(!link.isEmpty() && link.tail.isEmpty());
     visit(link.head);
     HInstruction value = pop();
     value = potentiallyCheckType(value, variable);
     close(new HReturn(value)).addSuccessor(graph.exit);
     graph.finalize();
     return graph;
   }
 
   /**
    * Returns the constructor body associated with the given constructor or
    * creates a new constructor body, if none can be found.
    *
    * Returns [:null:] if the constructor does not have a body.
    */
   ConstructorBodyElement getConstructorBody(FunctionElement constructor) {
     assert(constructor.isGenerativeConstructor());
+    assert(invariant(constructor, constructor.isImplementation));
     if (constructor is SynthesizedConstructorElement) return null;
     FunctionExpression node = constructor.parseNode(compiler);
-    // If we know the body doesn't have any code, we don't generate
-    // it.
+    // If we know the body doesn't have any code, we don't generate it.
     if (node.body.asBlock() !== null) {
       NodeList statements = node.body.asBlock().statements;
       if (statements.isEmpty()) return null;
     }
     ClassElement classElement = constructor.getEnclosingClass();
     ConstructorBodyElement bodyElement;
     for (Link<Element> backendMembers = classElement.backendMembers;
          !backendMembers.isEmpty();
          backendMembers = backendMembers.tail) {
       Element backendMember = backendMembers.head;
       if (backendMember.isGenerativeConstructorBody()) {
         ConstructorBodyElement body = backendMember;
         if (body.constructor == constructor) {
           bodyElement = backendMember;
           break;
         }
       }
     }
     if (bodyElement === null) {
       bodyElement = new ConstructorBodyElement(constructor);
+      // [:resolveMethodElement:] require the passed element to be a
+      // declaration.
       TreeElements treeElements =
-          compiler.resolver.resolveMethodElement(constructor);
-      compiler.enqueuer.codegen.addToWorkList(bodyElement, treeElements);
+          compiler.resolver.resolveMethodElement(constructor.declaration);
       classElement.backendMembers =
           classElement.backendMembers.prepend(bodyElement);
+      compiler.enqueuer.codegen.addToWorkList(bodyElement.declaration,
+                                              treeElements);
     }
     assert(bodyElement.isGenerativeConstructorBody());
     return bodyElement;
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [function] must be an implementation element.
+   */
   InliningState enterInlinedMethod(PartialFunctionElement function,
                                    Selector selector,
                                    Link<Node> arguments) {
+    assert(invariant(function, function.isImplementation));
+
     // Once we start to compile the arguments we must be sure that we don't
     // abort.
     List<HInstruction> compiledArguments = new List<HInstruction>();
     bool succeeded = addStaticSendArgumentsToList(selector,
                                                   arguments,
                                                   function,
                                                   compiledArguments);
     assert(succeeded);
 
     InliningState state =
         new InliningState(function, returnElement, elements, stack);
     inliningStack.add(state);
     sourceElementStack.add(function);
     stack = <HInstruction>[];
     returnElement = new Element(const SourceString("result"),
                                 ElementKind.VARIABLE,
                                 function);
     localsHandler.updateLocal(returnElement,
                               graph.addConstantNull(constantSystem));
     elements = compiler.enqueuer.resolution.getCachedElements(function);
+    assert(elements !== null);
     FunctionSignature signature = function.computeSignature(compiler);
     int index = 0;
     signature.forEachParameter((Element parameter) {
       HInstruction argument = compiledArguments[index++];
       localsHandler.updateLocal(parameter, argument);
       potentiallyCheckType(argument, parameter);
     });
     return state;
   }
 
   void leaveInlinedMethod(InliningState state) {
     InliningState poppedState = inliningStack.removeLast();
     assert(state == poppedState);
     FunctionElement poppedElement = sourceElementStack.removeLast();
     assert(poppedElement == poppedState.function);
     elements = state.oldElements;
     stack.add(localsHandler.readLocal(returnElement));
     returnElement = state.oldReturnElement;
     assert(stack.length == 1);
     state.oldStack.add(stack[0]);
     stack = state.oldStack;
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   */
   bool tryInlineMethod(Element element,
                        Selector selector,
                        Link<Node> arguments) {
+    // Ensure that [element] is an implementation element.
+    element = element.implementation;
     // TODO(floitsch): we should be able to inline inside lazy initializers.
     if (!currentElement.isFunction()) return false;
     // TODO(floitsch): we should be able to inline getters, setters and
     // constructor bodies.
     if (!element.isFunction()) return false;
     // TODO(floitsch): find a cleaner way to know if the element is a function
     // containing nodes.
     // [PartialFunctionElement]s are [FunctionElement]s that have [Node]s.
     if (element is !PartialFunctionElement) return false;
     if (inliningStack.length > MAX_INLINING_DEPTH) return false;
     // Don't inline recursive calls. We use the same elements for the inlined
     // functions and would thus clobber our local variables.
-    if (work.element == element) return false;
+    // Use [:element.declaration:] since [work.element] is always a declaration.
+    if (work.element == element.declaration) return false;
     for (int i = 0; i < inliningStack.length; i++) {
       if (inliningStack[i].function == element) return false;
     }
     // TODO(ngeoffray): Inlining currently does not work in the presence of
     // private calls.
     if (currentLibrary != element.getLibrary()) return false;
     PartialFunctionElement function = element;
     int sourceSize =
         function.endToken.charOffset - function.beginToken.charOffset;
     if (sourceSize > MAX_INLINING_SOURCE_SIZE) return false;
     if (!selector.applies(function, compiler)) return false;
     FunctionExpression functionExpression = function.parseNode(compiler);
     TreeElements newElements =
         compiler.enqueuer.resolution.getCachedElements(function);
     if (newElements === null) {
       compiler.internalError("Element not resolved: $function");
     }
     if (!InlineWeeder.canBeInlined(functionExpression, newElements)) {
       return false;
     }
 
     InliningState state = enterInlinedMethod(function, selector, arguments);
     functionExpression.body.accept(this);
     leaveInlinedMethod(state);
     return true;
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * 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) {
+    assert(invariant(constructor, constructor.isImplementation));
     constructors.addLast(constructor);
 
     List<HInstruction> compiledArguments = new List<HInstruction>();
     bool succeeded = addStaticSendArgumentsToList(selector,
                                                   arguments,
                                                   constructor,
                                                   compiledArguments);
     if (!succeeded) {
       // Non-matching super and redirects are compile-time errors and thus
       // checked by the resolver.
@@ skipping 23 matching lines @@
     buildInitializers(constructor, constructors, fieldValues);
     elements = oldElements;
   }
 
   /**
    * Run through the initializers and inline all field initializers. Recursively
    * inlines super initializers.
    *
    * The constructors of the inlined initializers is added to [constructors]
    * with sub constructors having a lower index than super constructors.
+   *
+   * Invariant: The [constructor] and elements in [constructors] must all be
+   * implementation elements.
    */
   void buildInitializers(FunctionElement constructor,
                          List<FunctionElement> constructors,
                          Map<Element, HInstruction> fieldValues) {
+    assert(invariant(constructor, constructor.isImplementation));
     FunctionExpression functionNode = constructor.parseNode(compiler);
 
     bool foundSuperOrRedirect = false;
 
     if (functionNode.initializers !== null) {
       Link<Node> initializers = functionNode.initializers.nodes;
       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.
@@ skipping 17 matching lines @@
           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 != compiler.objectClass) {
+      if (!enclosingClass.isObject(compiler)) {
         assert(superClass !== null);
         assert(superClass.resolutionState == STATE_DONE);
         Selector selector =
             new Selector.call(superClass.name, enclosingClass.getLibrary(), 0);
         FunctionElement target = superClass.lookupConstructor(superClass.name);
         if (target === null) {
           compiler.internalError("no default constructor available");
         }
-        inlineSuperOrRedirect(target,
+        inlineSuperOrRedirect(target.implementation,
                               selector,
                               const EmptyLink<Node>(),
                               constructors,
                               fieldValues);
       }
     }
   }
 
   /**
    * Run through the fields of [cls] and add their potential
    * initializers.
+   *
+   * Invariant: [classElement] must be a declaration element.
    */
   void buildFieldInitializers(ClassElement classElement,
                               Map<Element, HInstruction> fieldValues) {
+    assert(invariant(classElement, classElement.isDeclaration));
     classElement.forEachInstanceField(
         includeBackendMembers: true,
         includeSuperMembers: false,
         f: (ClassElement enclosingClass, Element member) {
       TreeElements definitions = compiler.analyzeElement(member);
       Node node = member.parseNode(compiler);
       SendSet assignment = node.asSendSet();
       HInstruction value;
       if (assignment === null) {
         value = graph.addConstantNull(constantSystem);
@@ skipping 11 matching lines @@
 
 
   /**
    * Build the factory function corresponding to the constructor
    * [functionElement]:
    *  - Initialize fields with the values of the field initializers of the
    *    current constructor and super constructors or constructors redirected
    *    to, starting from the current constructor.
    *  - Call the the constructor bodies, starting from the constructor(s) in the
    *    super class(es).
+   *
+   * Invariants: [classElement] must be a declaration element, and
+   * [functionElement] must be an implementation element.
    */
   HGraph buildFactory(ClassElement classElement,
                       FunctionElement functionElement) {
+    assert(invariant(classElement, classElement.isDeclaration));
+    assert(invariant(functionElement, functionElement.isImplementation));
     FunctionExpression function = functionElement.parseNode(compiler);
     // Note that constructors (like any other static function) do not need
     // to deal with optional arguments. It is the callers job to provide all
     // arguments as if they were positional.
 
     // The initializer list could contain closures.
     openFunction(functionElement, function);
 
     Map<Element, HInstruction> fieldValues = new Map<Element, HInstruction>();
 
@@ skipping 37 matching lines @@
       if (compiler.world.needsRti(classElement)) {
       classElement.typeVariables.forEach((TypeVariableType typeVariable) {
         inputs.add(localsHandler.directLocals[typeVariable.element]);
       });
       callSetRuntimeTypeInfo(classElement, inputs, newObject);
     }
 
     // Generate calls to the constructor bodies.
     for (int index = constructors.length - 1; index >= 0; index--) {
       FunctionElement constructor = constructors[index];
+      assert(invariant(functionElement, constructor.isImplementation));
       ConstructorBodyElement body = getConstructorBody(constructor);
       if (body === null) continue;
       List bodyCallInputs = <HInstruction>[];
       bodyCallInputs.add(newObject);
-      int arity = body.functionSignature.parameterCount;
-      body.functionSignature.forEachParameter((parameter) {
+      FunctionSignature functionSignature = body.computeSignature(compiler);
+      int arity = functionSignature.parameterCount;
+      functionSignature.forEachParameter((parameter) {
         bodyCallInputs.add(localsHandler.readLocal(parameter));
       });
       // TODO(ahe): The constructor name is statically resolved. See
       // SsaCodeGenerator.visitInvokeDynamicMethod. Is there a cleaner
       // way to do this?
-      SourceString name = new SourceString(backend.namer.getName(body));
+      SourceString name =
+          new SourceString(backend.namer.getName(body.declaration));
       // TODO(kasperl): This seems fishy. We shouldn't be inventing all
       // these selectors. Maybe the resolver can do more of the work
       // for us here?
       LibraryElement library = body.getLibrary();
       Selector selector = new Selector.call(name, library, arity);
       add(new HInvokeDynamicMethod(selector, bodyCallInputs));
     }
     close(new HReturn(newObject)).addSuccessor(graph.exit);
     return closeFunction();
   }
@@ skipping 37 matching lines @@
 
     // Create the instruction that parameter checks will use.
     check = new HNot(check);
     add(check);
 
     ClosureClassMap closureData = localsHandler.closureData;
     Element checkResultElement = closureData.parametersWithSentinel[element];
     localsHandler.updateLocal(checkResultElement, check);
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [functionElement] must be the implementation element.
+   */
   void openFunction(FunctionElement functionElement,
                     FunctionExpression node) {
+    assert(invariant(functionElement, functionElement.isImplementation));
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
     localsHandler.startFunction(functionElement, node);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
 
     FunctionSignature params = functionElement.computeSignature(compiler);
     params.forEachParameter((Element element) {
@@ skipping 714 matching lines @@
       if (element.isField() && !element.isAssignable()) {
         // A static final or const. Get its constant value and inline it if
         // the value can be compiled eagerly.
         value = compiler.compileVariable(element);
       }
       if (value != null) {
         stack.add(graph.addConstant(value));
       } else if (element.isField() && compiler.isLazilyInitialized(element)) {
         push(new HLazyStatic(element));
       } else {
-        push(new HStatic(element));
+        // TODO(5346): Try to avoid the need for calling [declaration] before
+        // creating an [HStatic].
+        push(new HStatic(element.declaration));
         if (element.isGetter()) {
           push(new HInvokeStatic(<HInstruction>[pop()]));
         }
       }
     } else if (Elements.isInstanceSend(send, elements)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceGetterWithCompiledReceiver(send, receiver);
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
-      push(new HStatic(element));
+      // TODO(5346): Try to avoid the need for calling [declaration] before
+      // creating an [HStatic].
+      push(new HStatic(element.declaration));
       // TODO(ahe): This should be registered in codegen.
       compiler.enqueuer.codegen.registerGetOfStaticFunction(element);
     } else if (Elements.isErroneousElement(element)) {
       // An erroneous element indicates an unresolved static getter.
       generateThrowNoSuchMethod(send,
                                 getTargetName(element, 'get'),
                                 const EmptyLink<Node>());
     } else {
       stack.add(localsHandler.readLocal(element));
     }
@@ skipping 199 matching lines @@
       // selectors with the same named arguments.
       List<SourceString> orderedNames = selector.getOrderedNamedArguments();
       for (SourceString name in orderedNames) {
         list.add(instructions[name]);
       }
     }
   }
 
   /**
    * Returns true if the arguments were compatible with the function signature.
+   *
+   * Invariant: [element] must be an implementation element.
    */
   bool addStaticSendArgumentsToList(Selector selector,
                                     Link<Node> arguments,
                                     FunctionElement element,
                                     List<HInstruction> list) {
+    assert(invariant(element, element.isImplementation));
+
     HInstruction compileArgument(Node argument) {
       visit(argument);
       return pop();
     }
 
     HInstruction compileConstant(Element parameter) {
       Constant constant;
       TreeElements calleeElements =
           compiler.enqueuer.resolution.getCachedElements(element);
       if (calleeElements.isParameterChecked(parameter)) {
@@ skipping 206 matching lines @@
                       node: node.argumentsNode);
     }
     Node closure = node.arguments.head;
     Element element = elements[closure];
     if (!Elements.isStaticOrTopLevelFunction(element)) {
       compiler.cancel(
           'JS_TO_CLOSURE requires a static or top-level method',
           node: closure);
     }
     FunctionElement function = element;
-    FunctionSignature params = function.computeSignature(compiler);
+    // TODO(johnniwinther): Try to eliminate the need to distinguish declaration
+    // and implementation signatures. Currently it is need because the
+    // signatures have different elements for parameters.
+    FunctionSignature params
+        = function.implementation.computeSignature(compiler);
     if (params.optionalParameterCount !== 0) {
       compiler.cancel(
           'JS_TO_CLOSURE does not handle closure with optional parameters',
           node: closure);
     }
     visit(closure);
     List<HInstruction> inputs = <HInstruction>[pop()];
     String invocationName = backend.namer.closureInvocationName(
         new Selector.callClosure(params.requiredParameterCount));
     push(new HForeign(new DartString.literal('#.$invocationName'),
@@ skipping 46 matching lines @@
     if (element !== null && element === work.element) {
       graph.isRecursiveMethod = true;
     }
     super.visitSend(node);
   }
 
   visitSuperSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (element === null) return generateSuperNoSuchMethodSend(node);
-    HInstruction target = new HStatic(element);
+    // TODO(5346): Try to avoid the need for calling [declaration] before
+    // creating an [HStatic].
+    HInstruction target = new HStatic(element.declaration);
     HInstruction context = localsHandler.readThis();
     add(target);
     var inputs = <HInstruction>[target, context];
     if (node.isPropertyAccess) {
       push(new HInvokeSuper(inputs));
     } else if (element.isFunction() || element.isGenerativeConstructor()) {
+      // TODO(5347): Try to avoid the need for calling [implementation] before
+      // calling [addStaticSendArgumentsToList].
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
-                                                    element, inputs);
+                                                    element.implementation,
+                                                    inputs);
       if (!succeeded) {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
         compiler.cancel('Unimplemented non-matching static call', node);
       }
       push(new HInvokeSuper(inputs));
     } else {
       target = new HInvokeSuper(inputs);
       add(target);
       inputs = <HInstruction>[target];
@@ skipping 117 matching lines @@
       }
     }
 
     Element constructor = elements[node];
     Selector selector = elements.getSelector(node);
     if (compiler.enqueuer.resolution.getCachedElements(constructor) === null) {
       compiler.internalError("Unresolved element: $constructor", node: node);
     }
     FunctionElement functionElement = constructor;
     constructor = functionElement.defaultImplementation;
-    HInstruction target = new HStatic(constructor);
+    // TODO(5346): Try to avoid the need for calling [declaration] before
+    // creating an [HStatic].
+    HInstruction target = new HStatic(constructor.declaration);
     add(target);
     var inputs = <HInstruction>[];
     inputs.add(target);
+    // TODO(5347): Try to avoid the need for calling [implementation] before
+    // calling [addStaticSendArgumentsToList].
     bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
-                                                  constructor, inputs);
+                                                  constructor.implementation,
+                                                  inputs);
     if (!succeeded) {
       // TODO(ngeoffray): Match the VM behavior and throw an
       // exception at runtime.
       compiler.cancel('Unimplemented non-matching static call', node: node);
     }
 
     TypeAnnotation annotation = node.getTypeAnnotation();
     if (annotation == null) {
       compiler.internalError("malformed send in new expression");
     }
@@ skipping 23 matching lines @@
     if (element.isErroneous()) {
       generateThrowNoSuchMethod(node, getTargetName(element), node.arguments);
       return;
     }
     if (element === compiler.assertMethod && !compiler.enableUserAssertions) {
       stack.add(graph.addConstantNull(constantSystem));
       return;
     }
     compiler.ensure(!element.isGenerativeConstructor());
     if (element.isFunction()) {
-      if (tryInlineMethod(element, selector, node.arguments)) return;
+      if (tryInlineMethod(element, selector, node.arguments)) {
+        return;
+      }
 
       HInstruction target = new HStatic(element);
       add(target);
       var inputs = <HInstruction>[target];
+      // TODO(5347): Try to avoid the need for calling [implementation] before
+      // calling [addStaticSendArgumentsToList].
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
-                                                    element, inputs);
+                                                    element.implementation,
+                                                    inputs);
       if (!succeeded) {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
         compiler.cancel('Unimplemented non-matching static call', node: node);
       }
       HInvokeStatic instruction = new HInvokeStatic(inputs);
       // TODO(ngeoffray): Only do this if knowing the return type is
       // useful.
       HType returnType =
           builder.backend.optimisticReturnTypesWithRecompilationOnTypeChange(
@@ skipping 1185 matching lines @@
   void visitTryStatement(Node node) {
     tooDifficult = true;
   }
 
   void visitThrow(Node node) {
     tooDifficult = true;
   }
 }
 
 class InliningState {
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [function] must be an implementation element.
+   */
   final PartialFunctionElement function;
   final Element oldReturnElement;
   final TreeElements oldElements;
   final List<HInstruction> oldStack;
 
   InliningState(this.function,
                 this.oldReturnElement,
                 this.oldElements,
-                this.oldStack);
+                this.oldStack) {
+    assert(function.isImplementation);
+  }
 }
 
 class SsaBranch {
   final SsaBranchBuilder branchBuilder;
   final HBasicBlock block;
   LocalsHandler startLocals;
   LocalsHandler exitLocals;
   SubGraph graph;
 
   SsaBranch(this.branchBuilder) : block = new HBasicBlock();
@@ skipping 216 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;
   }
 }