Allowing inlining of static getters and methods in a different library. Also report an error if a g…

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 1147 matching lines @@
    * Documentation wanted -- johnniwinther
    */
   bool tryInlineMethod(Element element,
                        Selector selector,
                        Link<Node> arguments) {
     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.isFunction()) return false;
-    // TODO(floitsch): we should be able to inline getters, setters and
-    // constructor bodies.
-    if (!element.isFunction()) 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) 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.
     // Use [:element.declaration:] since [work.element] is always a declaration.
     if (work.element == element.declaration) return false;
     for (int i = 0; i < inliningStack.length; i++) {
       if (inliningStack[i].function == element) return false;
     }
-    // TODO(ngeoffray): Inlining currently does not work in the presence of
-    // private calls.
-    if (currentLibrary != element.getLibrary()) return false;
     PartialFunctionElement function = element;
     int sourceSize =
         function.endToken.charOffset - function.beginToken.charOffset;
     if (sourceSize > MAX_INLINING_SOURCE_SIZE) return false;
     if (!selector.applies(function, compiler)) return false;
     FunctionExpression functionExpression = function.parseNode(compiler);
     TreeElements newElements =
         compiler.enqueuer.resolution.getCachedElements(function);
     if (newElements == null) {
       compiler.internalError("Element not resolved: $function");
@@ skipping 1272 matching lines @@
       if (element.isField() && !element.isAssignable()) {
         // A static final or const. Get its constant value and inline it if
         // the value can be compiled eagerly.
         value = compileVariable(element);
       }
       if (value != null) {
         stack.add(graph.addConstant(value));
       } else if (element.isField() && isLazilyInitialized(element)) {
         push(new HLazyStatic(element));
       } else {
+        if (element.isGetter()) {
+          Selector selector = elements.getSelector(send);
+          if (tryInlineMethod(element, selector, const Link<Node>())) {
+            return;
+          }
+        }
         // TODO(5346): Try to avoid the need for calling [declaration] before
         // creating an [HStatic].
         push(new HStatic(element.declaration));
         if (element.isGetter()) {
           push(new HInvokeStatic(<HInstruction>[pop()]));
         }
       }
     } else if (Elements.isInstanceSend(send, elements)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceGetterWithCompiledReceiver(send, receiver);
@@ skipping 2607 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;
   }
 }