implement kernel -> ssa for simple binary expression

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';
@@ skipping 77 matching lines @@
         sourceInformationBuilder.buildVariableDeclaration();
     this.localsHandler =
         new LocalsHandler(this, functionElement, null, compiler);
     this.astAdapter = new KernelAstAdapter(compiler.backend, resolvedAst,
         visitor.nodeToAst, visitor.nodeToElement, kernel.functions);
   }
 
   HGraph build() {
     // TODO(het): no reason to do this here...
     HInstruction.idCounter = 0;
-    if (function.kind == ir.ProcedureKind.Method) {
+    if (function.kind == ir.ProcedureKind.Method ||
+        function.kind == ir.ProcedureKind.Operator) {
       buildMethod(function, functionElement);
     } else {
       compiler.reporter.internalError(
           functionElement,
           "Unable to convert this kind of Kernel "
           "procedure to SSA: ${function.kind}");
     }
     assert(graph.isValid());
     return graph;
   }
 
   /// 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);
-    // TODO(het): Register parameters with a locals handler
     localsHandler.startFunction(functionElement, resolvedAst.node);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
   }
 
   void closeFunction() {
     if (!isAborted()) closeAndGotoExit(new HGoto());
     graph.finalize();
   }
@@ skipping 67 matching lines @@
   visitNullLiteral(ir.NullLiteral nullLiteral) {
     stack.add(graph.addConstantNull(compiler));
   }
 
   @override
   visitVariableGet(ir.VariableGet variableGet) {
     LocalElement local = astAdapter.getElement(variableGet.variable);
     stack.add(localsHandler.readLocal(local));
   }
 
+  // TODO(het): Also extract type arguments
+  /// Extracts the list of instructions for the expressions in the arguments.
+  List<HInstruction> _visitArguments(ir.Arguments arguments) {
+    List<HInstruction> result = <HInstruction>[];
+
+    for (ir.Expression argument in arguments.positional) {
+      argument.accept(this);
+      result.add(pop());
+    }
+    for (ir.NamedExpression argument in arguments.named) {
+      argument.value.accept(this);
+      result.add(pop());
+    }
+
+    return result;
+  }
+
   @override
   visitStaticInvocation(ir.StaticInvocation invocation) {
-    List<HInstruction> inputs = <HInstruction>[];
-
-    for (ir.Expression argument in invocation.arguments.positional) {
-      argument.accept(this);
-      inputs.add(pop());
-    }
-    for (ir.NamedExpression argument in invocation.arguments.named) {
-      argument.value.accept(this);
-      inputs.add(pop());
-    }
-
     ir.Procedure target = invocation.target;
     bool targetCanThrow = astAdapter.getCanThrow(target);
     TypeMask typeMask = astAdapter.returnTypeOf(target);
 
+    var arguments = _visitArguments(invocation.arguments);
+
     HInstruction instruction = new HInvokeStatic(
-        astAdapter.getElement(target).declaration, inputs, typeMask,
+        astAdapter.getElement(target).declaration, arguments, typeMask,
         targetCanThrow: targetCanThrow);
     instruction.sideEffects = astAdapter.getSideEffects(target);
 
     push(instruction);
   }
 
+  // TODO(het): Decide when to inline
+  @override
+  visitMethodInvocation(ir.MethodInvocation invocation) {
+    invocation.receiver.accept(this);
+    HInstruction receiver = pop();
+
+    List<HInstruction> arguments = <HInstruction>[receiver]
+      ..addAll(_visitArguments(invocation.arguments));
+
+    List<HInstruction> inputs = <HInstruction>[];
+
+    bool isIntercepted = astAdapter.isIntercepted(invocation);
+    if (isIntercepted) {
+      HInterceptor interceptor =
+          new HInterceptor(receiver, backend.nonNullType);
+      add(interceptor);
+      inputs.add(interceptor);
+    }
+    inputs.addAll(arguments);
+
+    TypeMask type = astAdapter.selectorTypeOf(invocation);
+
+    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();
   }
 }