Reapply "Simplify generated code for trivial bailout methods".

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 301 matching lines @@
   void startFunction(FunctionElement function,
                      FunctionExpression node) {
 
     ClosureTranslator translator = new ClosureTranslator(builder);
     closureData = translator.translate(node);
 
     FunctionSignature params = function.computeSignature(builder.compiler);
     params.forEachParameter((Element element) {
       HInstruction parameter = new HParameterValue(element);
       builder.add(parameter);
-      builder.potentiallyCheckType(parameter, element);
+      builder.parameters[element] = parameter;
       directLocals[element] = parameter;
     });
 
     enterScope(node);
 
     // If the freeVariableMapping is not empty, then this function was a
     // nested closure that captures variables. Redirect the captured
     // variables to fields in the closure.
     closureData.freeVariableMapping.forEach((Element from, Element to) {
       redirectElement(from, to);
@@ skipping 107 matching lines @@
       }
       res.guaranteedType = cachedTypeOfThis;
     }
     return res;
   }
 
   HParameterValue getActivationParameter(Element element) {
     // If the element is a parameter, we already have a
     // HParameterValue for it. We cannot create another one because
     // it could then have another name than the real parameter. And
-    // the other one would not not it is just a copy of the real
+    // the other one would not know it is just a copy of the real
     // parameter.
-    if (element.isParameter()) return directLocals[element];
+    if (element.isParameter()) return builder.parameters[element];
 
     return builder.activationVariables.putIfAbsent(element, () {
       HParameterValue parameter = new HParameterValue(element);
       builder.graph.entry.addAtExit(parameter);
       return parameter;
     });
   }
 
   /**
    * Sets the [element] to [value]. If the element is boxed or stored in a
@@ skipping 323 matching lines @@
 }
 
 class SsaBuilder extends ResolvedVisitor implements Visitor {
   final SsaBuilderTask builder;
   final Interceptors interceptors;
   final WorkItem work;
   bool methodInterceptionEnabled;
   HGraph graph;
   LocalsHandler localsHandler;
   HInstruction rethrowableException;
+  Map<Element, HParameterValue> parameters;
 
   Map<TargetElement, JumpHandler> jumpTargets;
 
   /**
    * Variables stored in the current activation. These variables are
    * being updated in try/catch blocks, and should be
    * accessed indirectly through HFieldGet and HFieldSet.
    */
   Map<Element, HParameterValue> activationVariables;
 
@@ skipping 14 matching lines @@
 
   SsaBuilder(SsaBuilderTask builder, WorkItem work)
     : this.builder = builder,
       this.work = work,
       interceptors = builder.interceptors,
       methodInterceptionEnabled = true,
       graph = new HGraph(),
       stack = new List<HInstruction>(),
       activationVariables = new Map<Element, HParameterValue>(),
       jumpTargets = new Map<TargetElement, JumpHandler>(),
+      parameters = new Map<Element, HParameterValue>(),
       super(work.resolutionTree) {
     localsHandler = new LocalsHandler(this);
   }
 
   void disableMethodInterception() {
     assert(methodInterceptionEnabled);
     methodInterceptionEnabled = false;
   }
 
   void enableMethodInterception() {
@@ skipping 229 matching lines @@
 
   void openFunction(FunctionElement functionElement,
                     FunctionExpression node) {
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
     localsHandler.startFunction(functionElement, node);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
+
+    // Put the type checks in the first successor of the entry,
+    // because that is where the type guards will also be inserted.
+    // This way we ensure that a type guard will dominate the type
+    // check.
+    FunctionSignature params = functionElement.computeSignature(compiler);
+    params.forEachParameter((Element element) {
+      HInstruction newParameter = potentiallyCheckType(
+          localsHandler.directLocals[element], element);
+      localsHandler.directLocals[element] = newParameter;
+    });
   }
 
   HInstruction potentiallyCheckType(HInstruction original,
                                     Element sourceElement) {
     if (!compiler.enableTypeAssertions) return original;
 
     Type type = sourceElement.computeType(compiler);
     if (type === null) return original;
     if (type.element === compiler.dynamicClass) return original;
     if (type.element === compiler.objectClass) return original;
@@ skipping 2361 matching lines @@
   void visitNodeList(NodeList node) {
      node.visitChildren(this);
   }
 
   HInstruction concat(HInstruction left, HInstruction right) {
     HInstruction instruction = new HStringConcat(left, right, node);
     builder.add(instruction);
     return instruction;
   }
 }