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: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';
 import '../kernel/kernel_visitor.dart';
 import '../resolution/tree_elements.dart';
 import '../tree/dartstring.dart';
 import '../types/masks.dart';
 
 import 'graph_builder.dart';
 import 'kernel_ast_adapter.dart';
 import 'locals_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);
@@ skipping 26 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
+  HInstruction popBoolified() {
+    HInstruction value = pop();
+    // TODO(het): add boolean conversion type check
+    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`?
+  @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 23 matching lines @@
       }
     }
     assert(!current.isClosed());
     if (stack.isNotEmpty) {
       compiler.reporter
           .internalError(NO_LOCATION_SPANNABLE, 'Non-empty instruction stack');
     }
   }
 
   @override
+  visitExpressionStatement(ir.ExpressionStatement exprStatement) {
+    exprStatement.expression.accept(this);
+    pop();
+  }
+
+  @override
   void visitReturnStatement(ir.ReturnStatement returnStatement) {
     HInstruction value;
     if (returnStatement.expression == null) {
       value = graph.addConstantNull(compiler);
     } else {
       returnStatement.expression.accept(this);
       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 83 matching lines @@
     push(new HInvokeDynamicMethod(astAdapter.getSelector(invocation),
         astAdapter.getTypeMask(invocation), inputs, type, isIntercepted));
   }
 
   @override
   visitThisExpression(ir.ThisExpression thisExpression) {
     stack.add(localsHandler.readThis());
   }
 
   @override
-  visitExpressionStatement(ir.ExpressionStatement exprStatement) {
-    exprStatement.expression.accept(this);
-    pop();
+  visitNot(ir.Not not) {
+    not.operand.accept(this);
+    push(new HNot(popBoolified(), backend.boolType));
   }
 }