Revert "Revert "Build new IR for functions returning a constant.""

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 867 matching lines @@
 
   void close() {
     // The mapping from TargetElement to JumpHandler is no longer needed.
     for (TargetElement target in targetIndexMap.keys) {
       builder.jumpTargets.remove(target);
     }
     super.close();
   }
 }
 
-class SsaBuilder extends ResolvedVisitor implements Visitor {
-  final SsaBuilderTask builder;
-  final JavaScriptBackend backend;
-  final CodegenWorkItem work;
-  final ConstantSystem constantSystem;
-  HGraph graph;
-  LocalsHandler localsHandler;
-  HInstruction rethrowableException;
-  Map<Element, HInstruction> parameters;
-  final RuntimeTypes rti;
-  HParameterValue lastAddedParameter;
-
-  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 [HLocalGet] and [HLocalSet].
-   */
-  Map<Element, HLocalValue> activationVariables;
-
-  // We build the Ssa graph by simulating a stack machine.
-  List<HInstruction> stack;
+/**
+ * This mixin implements functionality that is shared between the [SsaBuilder]
+ * and the [SsaFromIrBuilder] classes.
+ */
+class SsaGraphBuilderMixin {
+  final HGraph graph = new HGraph();
 
   /**
    * The current block to add instructions to. Might be null, if we are
    * visiting dead code, but see [isReachable].
    */
   HBasicBlock _current;
 
   /**
    * The most recently opened block. Has the same value as [_current] while
    * the block is open, but unlike [_current], it isn't cleared when the
    * current block is closed.
    */
   HBasicBlock lastOpenedBlock;
 
   /**
    * Indicates whether the current block is dead (because it has a throw or a
    * return further up).  If this is false, then [_current] may be null.  If the
    * block is dead then it may also be aborted, but for simplicity we only
    * abort on statement boundaries, not in the middle of expressions.  See
    * isAborted.
    */
   bool isReachable = true;
 
+  HBasicBlock get current => _current;
+  void set current(c) {
+    isReachable = c != null;
+    _current = c;
+  }
+
+  HBasicBlock addNewBlock() {
+    HBasicBlock block = graph.addNewBlock();
+    // If adding a new block during building of an expression, it is due to
+    // conditional expressions or short-circuit logical operators.
+    return block;
+  }
+
+  void open(HBasicBlock block) {
+    block.open();
+    current = block;
+    lastOpenedBlock = block;
+  }
+
+  HBasicBlock close(HControlFlow end) {
+    HBasicBlock result = current;
+    current.close(end);
+    current = null;
+    return result;
+  }
+
+  HBasicBlock closeAndGotoExit(HControlFlow end) {
+    HBasicBlock result = current;
+    current.close(end);
+    current = null;
+    result.addSuccessor(graph.exit);
+    return result;
+  }
+
+  void goto(HBasicBlock from, HBasicBlock to) {
+    from.close(new HGoto());
+    from.addSuccessor(to);
+  }
+
+  bool isAborted() {
+    return _current == null;
+  }
+
+  /**
+   * Creates a new block, transitions to it from any current block, and
+   * opens the new block.
+   */
+  HBasicBlock openNewBlock() {
+    HBasicBlock newBlock = addNewBlock();
+    if (!isAborted()) goto(current, newBlock);
+    open(newBlock);
+    return newBlock;
+  }
+
+  void add(HInstruction instruction) {
+    current.add(instruction);
+  }
+}
+
+class SsaBuilder extends ResolvedVisitor with SsaGraphBuilderMixin {
+  final SsaBuilderTask builder;
+  final JavaScriptBackend backend;
+  final CodegenWorkItem work;
+  final ConstantSystem constantSystem;
+  LocalsHandler localsHandler;
+  HInstruction rethrowableException;
+  Map<Element, HInstruction> parameters;
+  final RuntimeTypes rti;
+  HParameterValue lastAddedParameter;
+
+  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 [HLocalGet] and [HLocalSet].
+   */
+  Map<Element, HLocalValue> activationVariables;
+
+  // We build the Ssa graph by simulating a stack machine.
+  List<HInstruction> stack;
+
   /**
    * True if we are visiting the expression of a throw expression.
    */
   bool inThrowExpression = false;
 
   final List<Element> sourceElementStack;
 
   Element get currentElement => sourceElementStack.last.declaration;
   Element get currentNonClosureClass {
     ClassElement cls = currentElement.getEnclosingClass();
@@ skipping 20 matching lines @@
   // types of the type variables in an environment (like the [LocalsHandler]).
   final List<DartType> currentInlinedInstantiations = <DartType>[];
 
   Compiler get compiler => builder.compiler;
   CodeEmitterTask get emitter => builder.emitter;
 
   SsaBuilder(this.constantSystem, SsaBuilderTask builder, CodegenWorkItem work)
     : this.builder = builder,
       this.backend = builder.backend,
       this.work = work,
-      graph = new HGraph(),
       stack = new List<HInstruction>(),
       activationVariables = new Map<Element, HLocalValue>(),
       jumpTargets = new Map<TargetElement, JumpHandler>(),
       parameters = new Map<Element, HInstruction>(),
       sourceElementStack = <Element>[work.element],
       inliningStack = <InliningState>[],
       rti = builder.backend.rti,
       super(work.resolutionTree, builder.compiler) {
     localsHandler = new LocalsHandler(this);
   }
 
   List<InliningState> inliningStack;
 
   Element returnElement;
   DartType returnType;
 
   bool inTryStatement = false;
   int loopNesting = 0;
 
-  HBasicBlock get current => _current;
-  void set current(c) {
-    isReachable = c != null;
-    _current = c;
-  }
-
   Constant getConstantForNode(Node node) {
     ConstantHandler handler = compiler.constantHandler;
     Constant constant = elements.getConstant(node);
     assert(invariant(node, constant != null,
         message: 'No constant computed for $node'));
     return constant;
   }
 
   HInstruction addConstant(Node node) {
     return graph.addConstant(getConstantForNode(node), compiler);
@@ skipping 208 matching lines @@
       assert(succeeded);
     }
 
     // Create the inlining state after evaluating the arguments, that
     // may have an impact on the state of the current method.
     InliningState state = new InliningState(
         function, returnElement, returnType, elements, stack,
         localsHandler, inTryStatement);
     inTryStatement = false;
     LocalsHandler newLocalsHandler = new LocalsHandler(this);
-    newLocalsHandler.closureData =
-        compiler.closureToClassMapper.computeClosureToClassMapping(
-            function, function.parseNode(compiler), elements);
+    if (compiler.irBuilder.hasIr(function)) {
+      // TODO(lry): handle ir functions with nested closure definitions.
+      newLocalsHandler.closureData =
+          new ClosureClassMap(null, null, null, new ThisElement(function));
+    } else {
+      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);
@@ skipping 102 matching lines @@
             && returnType.isEmpty
             && !returnType.isNullable) {
           isReachable = false;
           return false;
         }
       }
 
       return true;
     }
 
-    bool heuristicSayGoodToGo(FunctionExpression functionExpression) {
+    bool heuristicSayGoodToGo(bool canBeInlined(int maxNodes, bool useMax)) {
       // Don't inline recursivly
       if (inliningStack.any((entry) => entry.function == function)) {
         return false;
       }
 
       if (element.isSynthesized) return true;
 
       if (cachedCanBeInlined == true) return cachedCanBeInlined;
 
       if (inThrowExpression) return false;
@@ skipping 11 matching lines @@
 
       // If a method is called only once, and all the methods in the
       // inlining stack are called only once as well, we know we will
       // save on output size by inlining this method.
       TypesInferrer inferrer = compiler.typesTask.typesInferrer;
       if (inferrer.isCalledOnce(element)
           && (inliningStack.every(
                   (entry) => inferrer.isCalledOnce(entry.function)))) {
         useMaxInliningNodes = false;
       }
-      bool canBeInlined = InlineWeeder.canBeInlined(
-          functionExpression, maxInliningNodes, useMaxInliningNodes);
-      if (canBeInlined) {
+      bool canInline = canBeInlined(maxInliningNodes, useMaxInliningNodes);
+      if (canInline) {
         backend.inlineCache.markAsInlinable(element, insideLoop: insideLoop);
       } else {
         backend.inlineCache.markAsNonInlinable(element, insideLoop: insideLoop);
       }
-      return canBeInlined;
+      return canInline;
     }
 
-    void doInlining(FunctionExpression functionExpression) {
+    void doInlining(void visitBody()) {
       // 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(null, providedArguments[0], backend.dynamicType,
                           isAssignable: false),
             currentNode);
       }
       InliningState state = enterInlinedMethod(
           function, selector, providedArguments, currentNode);
 
       inlinedFrom(element, () {
         FunctionElement function = element;
         FunctionSignature signature = function.computeSignature(compiler);
         signature.orderedForEachParameter((Element parameter) {
           HInstruction argument = localsHandler.readLocal(parameter);
           potentiallyCheckType(argument, parameter.computeType(compiler));
         });
         addInlinedInstantiation(instantiatedType);
         if (element.isGenerativeConstructor()) {
           buildFactory(element);
         } else {
-          functionExpression.body.accept(this);
+          visitBody();
         }
         removeInlinedInstantiation(instantiatedType);
       });
       leaveInlinedMethod(state);
     }
 
     if (meetsHardConstraints()) {
-      FunctionExpression functionExpression = function.parseNode(compiler);
-
-      if (heuristicSayGoodToGo(functionExpression)) {
-        doInlining(functionExpression);
-        return true;
+      if (compiler.irBuilder.hasIr(function)) {
+        IrFunction irFunction = compiler.irBuilder.getIr(function);
+        bool canInline(int n, bool b) {
+          return IrInlineWeeder.canBeInlined(irFunction, n, b);
+        }
+        if (heuristicSayGoodToGo(canInline)) {
+          SsaFromIrInliner irInliner = new SsaFromIrInliner(this);
+          doInlining(() => irInliner.visitAll(irFunction.statements));
+          return true;
+        }
+      } else {
+        FunctionExpression functionNode = function.parseNode(compiler);
+        bool canInline(int n, bool b) {
+          return InlineWeeder.canBeInlined(functionNode, n, b);
+        }
+        if (heuristicSayGoodToGo(canInline)) {
+          doInlining(() => functionNode.body.accept(this));
+          return true;
+        }
       }
     }
 
     return false;
   }
 
   addInlinedInstantiation(DartType type) {
     if (type != null) {
       currentInlinedInstantiations.add(type);
     }
@@ skipping 607 matching lines @@
     add(assertIsSubtype);
   }
 
   HGraph closeFunction() {
     // TODO(kasperl): Make this goto an implicit return.
     if (!isAborted()) closeAndGotoExit(new HGoto());
     graph.finalize();
     return graph;
   }
 
-  HBasicBlock addNewBlock() {
-    HBasicBlock block = graph.addNewBlock();
-    // If adding a new block during building of an expression, it is due to
-    // conditional expressions or short-circuit logical operators.
-    return block;
-  }
-
-  void open(HBasicBlock block) {
-    block.open();
-    current = block;
-    lastOpenedBlock = block;
-  }
-
-  HBasicBlock close(HControlFlow end) {
-    HBasicBlock result = current;
-    current.close(end);
-    current = null;
-    return result;
-  }
-
-  HBasicBlock closeAndGotoExit(HControlFlow end) {
-    HBasicBlock result = current;
-    current.close(end);
-    current = null;
-    result.addSuccessor(graph.exit);
-    return result;
-  }
-
-  void goto(HBasicBlock from, HBasicBlock to) {
-    from.close(new HGoto());
-    from.addSuccessor(to);
-  }
-
-  bool isAborted() {
-    return _current == null;
-  }
-
-  /**
-   * Creates a new block, transitions to it from any current block, and
-   * opens the new block.
-   */
-  HBasicBlock openNewBlock() {
-    HBasicBlock newBlock = addNewBlock();
-    if (!isAborted()) goto(current, newBlock);
-    open(newBlock);
-    return newBlock;
-  }
-
-  void add(HInstruction instruction) {
-    current.add(instruction);
-  }
-
   void addWithPosition(HInstruction instruction, Node node) {
     add(attachPosition(instruction, node));
   }
 
   void push(HInstruction instruction) {
     add(instruction);
     stack.add(instruction);
   }
 
   void pushWithPosition(HInstruction instruction, Node node) {
@@ skipping 36 matching lines @@
 
   SourceFileLocation sourceFileLocationForToken(Node node, Token token) {
     Element element = sourceElementStack.last;
     // TODO(johnniwinther): remove the 'element.patch' hack.
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       if (functionElement.patch != null) element = functionElement.patch;
     }
     Script script = element.getCompilationUnit().script;
     SourceFile sourceFile = script.file;
-    SourceFileLocation location = new SourceFileLocation(sourceFile, token);
+    SourceFileLocation location =
+        new TokenSourceFileLocation(sourceFile, token);
     if (!location.isValid()) {
       throw MessageKind.INVALID_SOURCE_FILE_LOCATION.message(
           {'offset': token.charOffset,
            'fileName': sourceFile.filename,
            'length': sourceFile.length});
     }
     return location;
   }
 
   void visit(Node node) {
@@ skipping 3758 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;
   }
 }