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 201 matching lines @@
         HTypeList parameterTypes =
             backend.optimisticParameterTypes(element.declaration,
                                              defaultValueTypes);
         if (!parameterTypes.allUnknown) {
           int i = 0;
           signature.orderedForEachParameter((Element param) {
             builder.parameters[param].guaranteedType = parameterTypes[i++];
           });
         }
         backend.registerParameterTypesOptimization(
-            element, parameterTypes, defaultValueTypes);
+            element.declaration, parameterTypes, defaultValueTypes);
       }
 
       if (compiler.tracer.enabled) {
         String name;
         if (element.isMember()) {
           String className = element.getEnclosingClass().name.slowToString();
           String memberName = element.name.slowToString();
           name = "$className.$memberName";
           if (element.isGenerativeConstructorBody()) {
             name = "$name (body)";
           }
         } else {
           name = "${element.name.slowToString()}";
         }
         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.implementation);
+    return builder.buildFactory(classElement.implementation,
+                                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 711 matching lines @@
       }
     }
     if (bodyElement === null) {
       bodyElement = new ConstructorBodyElement(constructor);
       // [:resolveMethodElement:] require the passed element to be a
       // declaration.
       TreeElements treeElements =
           compiler.resolver.resolveMethodElement(constructor.declaration);
       classElement.backendMembers =
           classElement.backendMembers.prepend(bodyElement);
+
+      if (constructor.isPatch) {
+        // Create origin body element for patched constructors.
+        bodyElement.origin = new ConstructorBodyElement(constructor.origin);
+        bodyElement.origin.patch = bodyElement;
+        classElement.origin.backendMembers =
+            classElement.origin.backendMembers.prepend(bodyElement.origin);
+      }
       compiler.enqueuer.codegen.addToWorkList(bodyElement.declaration,
                                               treeElements);
     }
     assert(bodyElement.isGenerativeConstructorBody());
     return bodyElement;
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
@@ skipping 120 matching lines @@
                                                     compiledArguments);
       if (!succeeded) {
         // Non-matching super and redirects are compile-time errors and thus
         // checked by the resolver.
         compiler.internalError(
             "Parameters and arguments didn't match for super/redirect call",
             element: constructor);
       }
 
       sourceElementStack.add(constructor.enclosingElement);
-      buildFieldInitializers(constructor.enclosingElement, fieldValues);
+      buildFieldInitializers(constructor.enclosingElement.implementation,
+                             fieldValues);
       sourceElementStack.removeLast();
 
       int index = 0;
       FunctionSignature params = constructor.computeSignature(compiler);
       params.orderedForEachParameter((Element parameter) {
         HInstruction argument = compiledArguments[index++];
         localsHandler.updateLocal(parameter, argument);
         // Don't forget to update the field, if the parameter is of the
         // form [:this.x:].
         if (parameter.kind == ElementKind.FIELD_PARAMETER) {
@@ skipping 59 matching lines @@
     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.call(superClass.name, enclosingClass.getLibrary(), 0);
+        // TODO(johnniwinther): Should we find injected constructors as well?
         FunctionElement target = superClass.lookupConstructor(superClass.name);
         if (target === null) {
           compiler.internalError("no default constructor available");
         }
         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.
+   * Invariant: [classElement] must be an implementation element.
    */
   void buildFieldInitializers(ClassElement classElement,
                               Map<Element, HInstruction> fieldValues) {
-    assert(invariant(classElement, classElement.isDeclaration));
+    assert(invariant(classElement, classElement.isImplementation));
     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 12 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.
+   * Invariant: Both [classElement] and [functionElement] must be
+   * implementation elements.
    */
   HGraph buildFactory(ClassElement classElement,
                       FunctionElement functionElement) {
-    assert(invariant(classElement, classElement.isDeclaration));
+    assert(invariant(classElement, classElement.isImplementation));
     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 3109 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;
   }
 }