implement kernel -> ssa for simple binary expression

pkg/compiler/lib/src/kernel/kernel_visitor.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.md file.
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/frontend/accessors.dart'
     show
         Accessor,
         IndexAccessor,
         NullAwarePropertyAccessor,
@@ skipping 181 matching lines @@
   final Map<JumpTarget, ir.LabeledStatement> breakTargets =
       <JumpTarget, ir.LabeledStatement>{};
 
   final Map<LocalElement, ir.VariableDeclaration> locals =
       <LocalElement, ir.VariableDeclaration>{};
 
   final Map<CascadeReceiver, ir.VariableGet> cascadeReceivers =
       <CascadeReceiver, ir.VariableGet>{};
 
   final Map<ir.Node, Element> nodeToElement = <ir.Node, Element>{};
+  final Map<ir.Node, Node> nodeToAst = <ir.Node, Node>{};
 
-  ir.Node associate(ir.Node node, Element element) {
+  ir.Node associateElement(ir.Node node, Element element) {
     nodeToElement[node] = element;
     return node;
   }
 
-  final Map<ir.Node, Node> nodeToAst = <ir.Node, Node>{};
+  ir.Node associateNode(ir.Node node, Node ast) {
+    nodeToAst[node] = ast;
+    return node;
+  }
 
   bool isVoidContext = false;
 
   KernelVisitor(this.currentElement, this.elements, this.kernel);
 
   KernelVisitor get sendVisitor => this;
 
   KernelVisitor get declVisitor => this;
 
   ir.TreeNode visitForValue(Expression node) {
@@ skipping 904 matching lines @@
 
   @override
   ir.AsExpression visitAs(Send node, Node expression, DartType type, _) {
     return new ir.AsExpression(
         visitForValue(expression), kernel.typeToIr(type));
   }
 
   @override
   ir.MethodInvocation visitBinary(
       Send node, Node left, BinaryOperator operator, Node right, _) {
-    return buildBinaryOperator(left, operator.selectorName, right);
+    return associateNode(
+        buildBinaryOperator(left, operator.selectorName, right), node);
   }
 
   ir.Expression buildConstructorInvoke(NewExpression node, {bool isConst}) {
     ConstructorElement constructor = elements[node.send];
     ConstructorTarget target =
         kernel.computeEffectiveTarget(constructor, elements.getType(node));
     NodeList arguments = node.send.argumentsNode;
     if (kernel.isSyntheticError(target.element)) {
       return new ir.MethodInvocation(new ir.InvalidExpression(),
           kernel.irName("call", currentElement), buildArguments(arguments));
@@ skipping 771 matching lines @@
     if (setterKind == CompoundSetter.INVALID) {
       setter = null;
     }
     return buildStaticAccessor(getter, setter).buildNullAwareAssignment(
         visitForValue(rhs),
         voidContext: isVoidContext);
   }
 
   ir.VariableDeclaration getLocal(LocalElement local) {
     return locals.putIfAbsent(local, () {
-      return associate(
+      return associateElement(
           new ir.VariableDeclaration(local.name,
               initializer: null,
               type: typeToIrHack(local.type),
               isFinal: local.isFinal,
               isConst: local.isConst),
           local);
     });
   }
 
   ir.FunctionNode buildFunctionNode(FunctionElement function, Node bodyNode) {
@@ skipping 55 matching lines @@
           break;
 
         default:
           internalError(
               function, "Unknown async maker: ${function.asyncMarker}");
           break;
       }
     }
     ir.Statement body =
         (bodyNode == null) ? null : buildStatementInBlock(bodyNode);
-    return associate(
+    return associateElement(
         new ir.FunctionNode(body,
             asyncMarker: asyncMarker,
             returnType: returnType,
             typeParameters: typeParameters,
             positionalParameters: positionalParameters,
             namedParameters: namedParameters,
             requiredParameterCount: requiredParameterCount),
         function);
   }
 
@@ skipping 697 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }