Remove last inlining restrictions.

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 1168 matching lines @@
     LocalsHandler newLocalsHandler = new LocalsHandler(this);
     newLocalsHandler.closureData =
         compiler.closureToClassMapper.computeClosureToClassMapping(
             function, function.parseNode(compiler), elements);
     int argumentIndex = 0;
     if (isInstanceMember) {
       newLocalsHandler.updateLocal(newLocalsHandler.closureData.thisElement,
                                    compiledArguments[argumentIndex++]);
     }
 
+    FunctionSignature signature = function.computeSignature(compiler);
+    signature.orderedForEachParameter((Element parameter) {
+      HInstruction argument = compiledArguments[argumentIndex++];
+      newLocalsHandler.updateLocal(parameter, argument);
+    });
+
     ClassElement enclosing = function.getEnclosingClass();
-    FunctionSignature signature = function.computeSignature(compiler);
-    int parameterCount = signature.parameterCount;
-    // If [function] is a generative constructor body, we need to add
-    // 1 for the new instance.
-    int typeArgumentIndex = parameterCount + (isInstanceMember ? 1 : 0);
     if ((function.isConstructor() || function.isGenerativeConstructorBody())
         && backend.needsRti(enclosing)) {
       enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
-        HInstruction argument = compiledArguments[typeArgumentIndex++];
+        HInstruction argument = compiledArguments[argumentIndex++];
         newLocalsHandler.updateLocal(typeVariable.element, argument);
       });
     }
-    assert(typeArgumentIndex == compiledArguments.length);
-
-    // Check the type of the arguments.  This must be done after setting up the
-    // type variables in the [localsHandler] because the checked types may
-    // contain type variables.
-    signature.orderedForEachParameter((Element parameter) {
-      HInstruction argument = compiledArguments[argumentIndex++];
-      newLocalsHandler.updateLocal(parameter, argument);
-      potentiallyCheckType(argument, parameter.computeType(compiler));
-    });
-    assert(argumentIndex == parameterCount + (isInstanceMember ? 1 : 0));
+    assert(argumentIndex == compiledArguments.length);
 
     // TODO(kasperl): Bad smell. We shouldn't be constructing elements here.
     returnElement = new ElementX(const SourceString("result"),
                                  ElementKind.VARIABLE,
                                  function);
     newLocalsHandler.updateLocal(returnElement,
                                  graph.addConstantNull(constantSystem));
     elements = compiler.enqueuer.resolution.getCachedElements(function);
     assert(elements != null);
     returnType = signature.returnType;
@@ skipping 27 matching lines @@
                        Node currentNode) {
     // We cannot inline a method from a deferred library into a method
     // which isn't deferred.
     // TODO(ahe): But we should still inline into the same
     // connected-component of the deferred library.
     if (compiler.deferredLoadTask.isDeferred(element)) return false;
 
     if (compiler.disableInlining) return false;
     // Ensure that [element] is an implementation element.
     element = element.implementation;
-    // TODO(floitsch): we should be able to inline inside lazy initializers.
-    if (currentElement.isField()) 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
         && !element.isGenerativeConstructorBody()) {
       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.
@@ skipping 25 matching lines @@
     if (newElements == null) {
       compiler.internalError("Element not resolved: $function");
     }
 
     if (canBeInlined == null) {
       canBeInlined = InlineWeeder.canBeInlined(functionExpression, newElements);
       backend.canBeInlined[function] = canBeInlined;
       if (!canBeInlined) return false;
     }
 
-    // We cannot inline methods with type variables in the signature in checked
-    // mode, because we currently do not have access to the type variables
-    // through the locals.
-    // TODO(karlklose): remove this and enable inlining of these methods.
-    if (compiler.enableTypeAssertions
-        && !element.isGenerativeConstructorBody()
-        && element.computeType(compiler).containsTypeVariables) {
-      return false;
-    }
-
     assert(canBeInlined);
     // Add an explicit null check on the receiver before doing the
     // inlining. We use [element] to get the same name in the NoSuchMethodError
     // message as if we had called it.
     if (element.isInstanceMember()
         && !element.isGenerativeConstructorBody()
         && (selector.mask == null || selector.mask.isNullable)) {
       addWithPosition(
           new HFieldGet(element, providedArguments[0]), currentNode);
     }
     InliningState state = enterInlinedMethod(
         function, selector, argumentsNodes, providedArguments, currentNode);
+
     inlinedFrom(element, () {
+      FunctionSignature signature = element.computeSignature(compiler);
+      signature.orderedForEachParameter((Element parameter) {
+        HInstruction argument = localsHandler.readLocal(parameter);
+        potentiallyCheckType(argument, parameter.computeType(compiler));
+      });
       element.isGenerativeConstructor()
           ? buildFactory(element)
           : functionExpression.body.accept(this);
     });
+
     leaveInlinedMethod(state);
     return true;
   }
 
   inlinedFrom(Element element, f()) {
     assert(element is FunctionElement || element is VariableElement);
     return compiler.withCurrentElement(element, () {
       sourceElementStack.add(element);
       var result = f();
       sourceElementStack.removeLast();
@@ skipping 4051 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;
   }
 }