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 177 matching lines @@
         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.
         OptionalParameterTypes defaultValueTypes = null;
-        FunctionSignature signature = element.computeSignature(compiler);
+        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.declaration,
                                              defaultValueTypes);
         if (!parameterTypes.allUnknown) {
           int i = 0;
           signature.forEachParameter((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)";
@@ skipping 736 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.origin != null) {
+        // 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 195 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.
    */
   void buildFieldInitializers(ClassElement classElement,
                               Map<Element, HInstruction> fieldValues) {
     assert(invariant(classElement, classElement.isDeclaration));
     classElement.forEachInstanceField(
         includeBackendMembers: true,
         includeSuperMembers: false,
+        includeInjectedMembers: true,
         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);
       } else {
         Node right = assignment.arguments.head;
         TreeElements savedElements = elements;
@@ skipping 52 matching lines @@
     // Analyze the constructor and all referenced constructors and collect
     // initializers and constructor bodies.
     List<FunctionElement> constructors = <FunctionElement>[functionElement];
     buildInitializers(functionElement, constructors, fieldValues);
 
     // Call the JavaScript constructor with the fields as argument.
     List<HInstruction> constructorArguments = <HInstruction>[];
     classElement.forEachInstanceField(
         includeBackendMembers: true,
         includeSuperMembers: true,
+        includeInjectedMembers: true,
         f: (ClassElement enclosingClass, Element member) {
       constructorArguments.add(
           potentiallyCheckType(fieldValues[member], member));
     });
 
     HForeignNew newObject = new HForeignNew(classElement, constructorArguments);
     add(newObject);
 
     // Create the runtime type information, if needed.
     InterfaceType type = classElement.computeType(compiler);
@@ skipping 3028 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;
   }
 }