Build entire program with kernel for conversion to ssa.

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 1227 matching lines @@
       InterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return new ir.InvalidExpression();
   }
 
   @override
   ir.PropertyGet visitDynamicPropertyGet(
       Send node, Node receiver, Name name, _) {
-    return new ir.PropertyGet(visitForValue(receiver), nameToIrName(name));
+    return associateNode(
+        new ir.PropertyGet(visitForValue(receiver), nameToIrName(name)), node);
   }
 
   @override
   ir.MethodInvocation visitDynamicPropertyInvoke(
       Send node, Node receiver, NodeList arguments, Selector selector, _) {
-    return buildInvokeSelector(
-        visitForValue(receiver), selector, buildArguments(arguments));
+    return associateNode(
+        buildInvokeSelector(
+            visitForValue(receiver), selector, buildArguments(arguments)),
+        node);
   }
 
   @override
   ir.Expression handleDynamicCompounds(
       Send node, Node receiver, Name name, CompoundRhs rhs, _) {
     ir.Expression receiverNode =
         receiver == null ? new ir.ThisExpression() : visitForValue(receiver);
-    return buildCompound(
-        PropertyAccessor.make(receiverNode, nameToIrName(name), null, null),
-        rhs);
+    ir.Expression compound = associateNode(
+        buildCompound(
+            PropertyAccessor.make(receiverNode, nameToIrName(name), null, null),
+            rhs),
+        node);
+    if (compound is ir.VariableSet) {
+      associateNode(compound.value, node);

[Siggi Cherem (dart-lang), 2016/09/13 23:48:19]

in this case, should both compound and compound.value have the associated node?
or should it only be the .value?

[Harry Terkelsen, 2016/09/14 00:07:24]

I think you're right, if it is a compound assignment then only the value should
be associated with the node

+    }
+    return compound;
   }
 
   @override
   ir.PropertySet visitDynamicPropertySet(
       SendSet node, Node receiver, Name name, Node rhs, _) {
     ir.Expression value = visitForValue(rhs);
     return new ir.PropertySet(
         visitForValue(receiver), nameToIrName(name), value);
   }
 
@@ skipping 31 matching lines @@
   }
 
   ir.MethodInvocation buildBinaryOperator(
       Node left, String operator, Node right) {
     ir.Name name = kernel.irName(operator, currentElement);
     return makeBinary(visitForValue(left), name, null, visitForValue(right));
   }
 
   @override
   ir.MethodInvocation visitEquals(Send node, Node left, Node right, _) {
-    return buildBinaryOperator(left, '==', right);
+    return associateNode(buildBinaryOperator(left, '==', right), node);
   }
 
   @override
   ir.MethodInvocation visitExpressionInvoke(Send node, Node expression,
       NodeList arguments, CallStructure callStructure, _) {
-    return buildCall(visitForValue(expression), callStructure, arguments);
+    return associateNode(
+        buildCall(visitForValue(expression), callStructure, arguments), node);
   }
 
   @override
   IrFunction visitFactoryConstructorDeclaration(FunctionExpression node,
       ConstructorElement constructor, NodeList parameters, Node body, _) {
     return buildIrFunction(ir.ProcedureKind.Factory, constructor, body);
   }
 
   @override
   ir.InvocationExpression visitFactoryConstructorInvoke(
@@ skipping 215 matching lines @@
         kernel.functionToIr(superConstructor), new ir.Arguments.empty());
   }
 
   Accessor buildIndexAccessor(Node receiver, Node index) {
     return IndexAccessor.make(
         visitForValue(receiver), visitForValue(index), null, null);
   }
 
   @override
   ir.Expression visitIndex(Send node, Node receiver, Node index, _) {
-    return buildIndexAccessor(receiver, index).buildSimpleRead();
+    return associateNode(
+        buildIndexAccessor(receiver, index).buildSimpleRead(), node);
   }
 
   ir.Expression buildIndexPostfix(Accessor accessor, IncDecOperator operator) {
     ir.Name name = kernel.irName(operator.selectorName, currentElement);
     return accessor.buildPostfixIncrement(name, voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitIndexPostfix(
       Send node, Node receiver, Node index, IncDecOperator operator, _) {
     return buildIndexPostfix(buildIndexAccessor(receiver, index), operator);
   }
 
   ir.Expression buildIndexPrefix(Accessor accessor, IncDecOperator operator) {
     ir.Name name = kernel.irName(operator.selectorName, currentElement);
     return accessor.buildPrefixIncrement(name, voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitIndexPrefix(
       Send node, Node receiver, Node index, IncDecOperator operator, _) {
     return buildIndexPrefix(buildIndexAccessor(receiver, index), operator);
   }
 
   @override
   ir.Expression visitIndexSet(
       SendSet node, Node receiver, Node index, Node rhs, _) {
-    return buildIndexAccessor(receiver, index)
-        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
+    return associateNode(
+        buildIndexAccessor(receiver, index)
+            .buildAssignment(visitForValue(rhs), voidContext: isVoidContext),
+        node);
   }
 
   ir.Initializer buildInitializingFormal(InitializingFormalElement parameter) {
     FieldElement field = parameter.fieldElement;
     if (kernel.isSyntheticError(field)) {
       return new ir.InvalidInitializer();
     } else {
       return new ir.FieldInitializer(
           kernel.fieldToIr(field), buildLocalGet(parameter));
     }
@@ skipping 105 matching lines @@
       case CompoundKind.ASSIGNMENT:
         return accessor.buildCompoundAssignment(name, visitForValue(rhs.rhs),
             voidContext: isVoidContext);
     }
   }
 
   @override
   ir.Expression handleLocalCompounds(
       SendSet node, LocalElement local, CompoundRhs rhs, _,
       {bool isSetterValid}) {
-    return buildCompound(new VariableAccessor(getLocal(local)), rhs);
+    ir.Expression compound = associateNode(
+        buildCompound(new VariableAccessor(getLocal(local)), rhs), node);
+    if (compound is ir.VariableSet) {
+      associateNode(compound.value, node);
+    }
+    return compound;
   }
 
   @override
   ir.VariableSet handleLocalSet(
       SendSet node, LocalElement element, Node rhs, _) {
     return new ir.VariableSet(getLocal(element), visitForValue(rhs));
   }
 
   @override
   ir.VariableSet handleImmutableLocalSet(
@@ skipping 29 matching lines @@
     return internalError(node, "NamedParameterDeclaration");
   }
 
   @override
   ir.Not visitNot(Send node, Node expression, _) {
     return new ir.Not(visitForValue(expression));
   }
 
   @override
   ir.Not visitNotEquals(Send node, Node left, Node right, _) {
-    return new ir.Not(buildBinaryOperator(left, '==', right));
+    return associateNode(
+        new ir.Not(associateNode(buildBinaryOperator(left, '==', right), node)),
+        node);
   }
 
   @override
   ir.Initializer visitOptionalInitializingFormalDeclaration(
       VariableDefinitions node,
       Node definition,
       InitializingFormalElement parameter,
       ConstantExpression defaultValue,
       int index,
       _) {
@@ skipping 15 matching lines @@
   @override
   visitParameterDeclaration(VariableDefinitions node, Node definition,
       ParameterElement parameter, int index, _) {
     // Shouldn't be called, we handle parameters via [FunctionSignture].
     return internalError(node, "ParameterDeclaration");
   }
 
   @override
   ir.MethodInvocation handleLocalInvoke(Send node, LocalElement element,
       NodeList arguments, CallStructure callStructure, _) {
-    return buildCall(buildLocalGet(element), callStructure, arguments);
+    return associateNode(
+        buildCall(buildLocalGet(element), callStructure, arguments), node);
   }
 
   @override
   ir.Expression handleLocalSetIfNulls(
       SendSet node, LocalElement local, Node rhs, _,
       {bool isSetterValid}) {
     return new VariableAccessor(getLocal(local)).buildNullAwareAssignment(
         visitForValue(rhs),
         voidContext: isVoidContext);
   }
@@ skipping 81 matching lines @@
   }
 
   @override
   ir.Expression handleStaticFieldGet(Send node, FieldElement field, _) {
     return buildStaticGet(field);
   }
 
   @override
   ir.MethodInvocation handleStaticFieldInvoke(Send node, FieldElement field,
       NodeList arguments, CallStructure callStructure, _) {
-    return buildCall(buildStaticGet(field), callStructure, arguments);
+    return associateNode(
+        buildCall(buildStaticGet(field), callStructure, arguments), node);
   }
 
   @override
   ir.Expression handleStaticFieldSet(
       SendSet node, FieldElement field, Node rhs, _) {
     return buildStaticFieldSet(field, rhs);
   }
 
   @override
   ir.Expression handleStaticSetIfNulls(
@@ skipping 471 matching lines @@
     return buildSuperMethodInvoke(method, arguments);
   }
 
   @override
   ir.SuperMethodInvocation visitSuperMethodInvoke(
       Send node,
       MethodElement method,
       NodeList arguments,
       CallStructure callStructure,
       _) {
-    return buildSuperMethodInvoke(method, arguments);
+    return associateNode(buildSuperMethodInvoke(method, arguments), node);
   }
 
   @override
   ir.Expression visitSuperMethodSet(
       Send node, MethodElement method, Node rhs, _) {
     return buildSuperPropertyAccessor(method)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
@@ skipping 53 matching lines @@
       Send node, NodeList arguments, CallStructure callStructure, _) {
     return buildCall(new ir.ThisExpression(), callStructure, arguments);
   }
 
   Accessor buildThisPropertyAccessor(Name name) {
     return new ThisPropertyAccessor(nameToIrName(name), null, null);
   }
 
   @override
   ir.Expression visitThisPropertyGet(Send node, Name name, _) {
-    return buildThisPropertyAccessor(name).buildSimpleRead();
+    return associateNode(
+        buildThisPropertyAccessor(name).buildSimpleRead(), node);
   }
 
   @override
   ir.MethodInvocation visitThisPropertyInvoke(
       Send node, NodeList arguments, Selector selector, _) {
-    return buildInvokeSelector(
-        new ir.ThisExpression(), selector, buildArguments(arguments));
+    return associateNode(
+        buildInvokeSelector(
+            new ir.ThisExpression(), selector, buildArguments(arguments)),
+        node);
   }
 
   @override
   ir.Expression visitThisPropertySet(SendSet node, Name name, Node rhs, _) {
     return buildThisPropertyAccessor(name)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitTopLevelConstantDeclaration(VariableDefinitions node,
@@ skipping 97 matching lines @@
   @override
   ir.Expression handleTypeLiteralConstantSetIfNulls(
       SendSet node, ConstantExpression constant, Node rhs, _) {
     // Degenerate case: ignores [rhs] as a type literal is never null.
     return buildTypeLiteral(constant);
   }
 
   @override
   ir.MethodInvocation visitUnary(
       Send node, UnaryOperator operator, Node expression, _) {
-    return new ir.MethodInvocation(
-        visitForValue(expression),
-        kernel.irName(operator.selectorName, currentElement),
-        new ir.Arguments.empty());
+    return associateNode(
+        new ir.MethodInvocation(
+            visitForValue(expression),
+            kernel.irName(operator.selectorName, currentElement),
+            new ir.Arguments.empty()),
+        node);
   }
 
   @override
   visitConditionalUri(ConditionalUri node) {
     // Shouldn't be called, handled by library loader.
     return internalError(node, "ConditionalUri");
   }
 
   @override
   visitDottedName(DottedName node) {
@@ skipping 112 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)";
   }
 }