Code review changes for ngeoffray's comments on r28278

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 256 matching lines @@
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       directLocals[closureData.thisElement] = thisInstruction;
     }
 
     // If this method is an intercepted method, add the extra
     // parameter to it, that is the actual receiver for intercepted
     // classes, or the same as [:this:] for non-intercepted classes.
     ClassElement cls = element.getEnclosingClass();
     JavaScriptBackend backend = compiler.backend;
+
+    // When the class extends a native class, the instance is pre-constructed
+    // and passed to the generative constructor factory function as a parameter.
+    // Instead of allocating and initializing the object, the constructor
+    // 'upgrades' the native subclass object by initializing the Dart fields.
     bool isNativeUpgradeFactory = element.isGenerativeConstructor()
         && Elements.isNativeOrExtendsNative(cls);
     if (backend.isInterceptedMethod(element)) {
       bool isInterceptorClass = backend.isInterceptorClass(cls.declaration);
       SourceString name = isInterceptorClass
           ? const SourceString('receiver')
           : const SourceString('_');
       Element parameter = new InterceptedElement(
           cls.computeType(compiler), name, element);
       HParameterValue value = new HParameterValue(parameter);
       builder.graph.explicitReceiverParameter = value;
       builder.graph.entry.addAfter(
           directLocals[closureData.thisElement], value);
       if (isInterceptorClass) {
         // Only use the extra parameter in intercepted classes.
         directLocals[closureData.thisElement] = value;
       }
       value.instructionType = builder.getTypeOfThis();
     } else if (isNativeUpgradeFactory) {
-      bool isInterceptorClass = backend.isInterceptorClass(cls.declaration);
       Element parameter = new InterceptedElement(
           cls.computeType(compiler), const SourceString('receiver'), element);
       HParameterValue value = new HParameterValue(parameter);
       builder.graph.explicitReceiverParameter = value;
       builder.graph.entry.addAtEntry(value);
       // Unlike `this`, receiver is nullable since direct calls to generative
       // constructor call the constructor with `null`.
       value.instructionType = new HType.exact(cls, compiler);
     }
   }
@@ skipping 1301 matching lines @@
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, Element member) {
           compiler.withCurrentElement(member, () {
             TreeElements definitions = compiler.analyzeElement(member);
             Node node = member.parseNode(compiler);
             SendSet assignment = node.asSendSet();
             if (assignment == null) {
               // Unassigned fields of native classes are not initialized to
               // prevent overwriting pre-initialized native properties.
               if (!Elements.isNativeOrExtendsNative(classElement)) {
-                HInstruction value = graph.addConstantNull(compiler);
-                fieldValues[member] = value;
+                fieldValues[member] = graph.addConstantNull(compiler);
               }
             } else {
               Node right = assignment.arguments.head;
               TreeElements savedElements = elements;
               elements = definitions;
               // In case the field initializer uses closures, run the
               // closure to class mapper.
               compiler.closureToClassMapper.computeClosureToClassMapping(
                   member, node, elements);
               inlinedFrom(member, () => right.accept(this));
               elements = savedElements;
-              HInstruction value = pop();
-              fieldValues[member] = value;
+              fieldValues[member] = pop();
             }
           });
         });
   }
 
   /**
    * 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
@@ skipping 3948 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;
   }
 }