kernel->ssa: Implement for-loops and while-loops

pkg/compiler/lib/src/ssa/builder_kernel.dart

 // Copyright (c) 2016, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/kernel.dart';
+import '../resolution/tree_elements.dart';
 import '../tree/dartstring.dart';
 import '../types/masks.dart';
 import '../universe/selector.dart';
 
 import 'graph_builder.dart';
 import 'kernel_ast_adapter.dart';
 import 'kernel_string_builder.dart';
 import 'locals_handler.dart';
+import 'loop_handler.dart';
 import 'nodes.dart';
 import 'ssa_branch_builder.dart';
 
 class SsaKernelBuilderTask extends CompilerTask {
   final JavaScriptBackend backend;
   final SourceInformationStrategy sourceInformationFactory;
 
   String get name => 'SSA kernel builder';
 
   SsaKernelBuilderTask(JavaScriptBackend backend, this.sourceInformationFactory)
       : backend = backend,
         super(backend.compiler.measurer);
 
   HGraph build(CodegenWorkItem work) {
     return measure(() {
       AstElement element = work.element.implementation;
       Kernel kernel = backend.kernelTask.kernel;
       KernelSsaBuilder builder = new KernelSsaBuilder(element, work.resolvedAst,
           backend.compiler, work.registry, sourceInformationFactory, kernel);
       return builder.build();
     });
   }
 }
 
 class KernelSsaBuilder extends ir.Visitor with GraphBuilder {
   ir.Node target;
   final AstElement targetElement;
   final ResolvedAst resolvedAst;
-  final Compiler compiler;
   final CodegenRegistry registry;
 
   JavaScriptBackend get backend => compiler.backend;
 
+  TreeElements get elements => resolvedAst.elements;
+
   SourceInformationBuilder sourceInformationBuilder;
   KernelAstAdapter astAdapter;
+  LoopHandler<ir.Node> loopHandler;
 
   KernelSsaBuilder(
       this.targetElement,
       this.resolvedAst,
-      this.compiler,
+      Compiler compiler,
       this.registry,
       SourceInformationStrategy sourceInformationFactory,
       Kernel kernel) {
+    this.compiler = compiler;
+    this.loopHandler = new KernelLoopHandler(this);
     graph.element = targetElement;
     // TODO(het): Should sourceInformationBuilder be in GraphBuilder?
     this.sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(resolvedAst);
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     this.localsHandler = new LocalsHandler(this, targetElement, null, compiler);
     this.astAdapter = new KernelAstAdapter(kernel, compiler.backend,
         resolvedAst, kernel.nodeToAst, kernel.nodeToElement);
     Element originTarget = targetElement;
@@ skipping 116 matching lines @@
       value = pop();
       // TODO(het): Check or trust the type of value
     }
     // TODO(het): Add source information
     // TODO(het): Set a return value instead of closing the function when we
     // support inlining.
     closeAndGotoExit(new HReturn(value, null));
   }
 
   @override
+  void visitForStatement(ir.ForStatement forStatement) {
+    assert(isReachable);
+    assert(forStatement.body != null);
+    void buildInitializer() {
+      for (ir.VariableDeclaration declaration in forStatement.variables) {
+        declaration.accept(this);
+      }
+    }
+
+    HInstruction buildCondition() {
+      if (forStatement.condition == null) {
+        return graph.addConstantBool(true, compiler);
+      }
+      forStatement.condition.accept(this);
+      return popBoolified();
+    }
+
+    void buildUpdate() {
+      for (ir.Expression expression in forStatement.updates) {
+        expression.accept(this);
+        assert(!isAborted());
+        // The result of the update instruction isn't used, and can just
+        // be dropped.
+        pop();
+      }
+    }
+
+    void buildBody() {
+      forStatement.body.accept(this);
+    }
+
+    loopHandler.handleLoop(
+        forStatement, buildInitializer, buildCondition, buildUpdate, buildBody);
+  }
+
+  @override
+  void visitWhileStatement(ir.WhileStatement whileStatement) {
+    assert(isReachable);
+    HInstruction buildCondition() {
+      whileStatement.condition.accept(this);
+      return popBoolified();
+    }
+
+    loopHandler.handleLoop(whileStatement, () {}, buildCondition, () {}, () {
+      whileStatement.body.accept(this);
+    });
+  }
+
+  @override
   void visitIfStatement(ir.IfStatement ifStatement) {
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler);
     brancher.handleIf(
         () => ifStatement.condition.accept(this),
         () => ifStatement.then.accept(this),
         () => ifStatement.otherwise?.accept(this));
   }
 
   @override
   void visitConditionalExpression(ir.ConditionalExpression conditional) {
@@ skipping 354 matching lines @@
     push(new HNot(popBoolified(), backend.boolType));
   }
 
   @override
   void visitStringConcatenation(ir.StringConcatenation stringConcat) {
     KernelStringBuilder stringBuilder = new KernelStringBuilder(this);
     stringConcat.accept(stringBuilder);
     stack.add(stringBuilder.result);
   }
 }