kernel -> ssa: implement if-statements

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:compiler/src/ssa/ssa_branch_builder.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart';
 import '../diagnostics/spannable.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/kernel.dart';
@@ skipping 45 matching lines @@
 
 class KernelSsaBuilder extends ir.Visitor with GraphBuilder {
   final IrFunction function;
   final FunctionElement functionElement;
   final ResolvedAst resolvedAst;
   final Compiler compiler;
   final CodegenRegistry registry;
 
   JavaScriptBackend get backend => compiler.backend;
 
-  LocalsHandler localsHandler;
   SourceInformationBuilder sourceInformationBuilder;
   KernelAstAdapter astAdapter;
 
   KernelSsaBuilder(
       this.function,
       this.functionElement,
       this.resolvedAst,
       this.compiler,
       this.registry,
       SourceInformationStrategy sourceInformationFactory,
@@ skipping 25 matching lines @@
     } else {
       compiler.reporter.internalError(
           functionElement,
           "Unable to convert this kind of Kernel "
           "procedure to SSA: ${function.kind}");
     }
     assert(graph.isValid());
     return graph;
   }
 
+  @override
+  HBoolify popBoolified() {
+    HInstruction value = pop();
+    // TODO(het): add boolean conversion type check

[Siggi Cherem (dart-lang), 2016/09/01 23:51:21]

once you do, would this method move to GraphBuilder?

[Harry Terkelsen, 2016/09/02 17:52:27]

Yes, if we also pass in the boolType

+    HInstruction result = new HBoolify(value, backend.boolType);
+    add(result);
+    return result;
+  }
+
+  // TODO(het): This implementation is shared with [SsaBuilder]. Should we just
+  // allow [GraphBuilder] to access `compiler`?

[Siggi Cherem (dart-lang), 2016/09/01 23:51:22]

seems ok, is it only for boolType? We could also just pass that to the builder

[Harry Terkelsen, 2016/09/02 17:52:27]

It's for boolType and for the 'compiler' argument to graph.addConstantNull

+  @override
+  pushCheckNull(HInstruction expression) {
+    push(new HIdentity(
+        expression, graph.addConstantNull(compiler), null, backend.boolType));
+  }
+
   /// Builds a SSA graph for [method].
   void buildMethod(IrFunction method, FunctionElement functionElement) {
     openFunction(method, functionElement);
     method.node.body.accept(this);
     closeFunction();
   }
 
   void openFunction(IrFunction method, FunctionElement functionElement) {
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
@@ skipping 39 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 visitIfStatement(ir.IfStatement ifStatement) {
+    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, compiler);
+    branchBuilder.handleIf(
+        () => ifStatement.condition.accept(this),
+        () => ifStatement.then.accept(this),
+        () => ifStatement.otherwise?.accept(this));
+  }
+
+  @override
   void visitIntLiteral(ir.IntLiteral intLiteral) {
     stack.add(graph.addConstantInt(intLiteral.value, compiler));
   }
 
   @override
   visitDoubleLiteral(ir.DoubleLiteral doubleLiteral) {
     stack.add(graph.addConstantDouble(doubleLiteral.value, compiler));
   }
 
   @override
@@ skipping 88 matching lines @@
   visitThisExpression(ir.ThisExpression thisExpression) {
     stack.add(localsHandler.readThis());
   }
 
   @override
   visitExpressionStatement(ir.ExpressionStatement exprStatement) {
     exprStatement.expression.accept(this);
     pop();
   }
 }