roll kernel to latest

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 458 matching lines @@
     if (element == null) {
       Send send = node.declaredIdentifier.asSend();
       if (send == null) {
         return buildStaticAccessor(null);
       }
       // This should be the situation where `node.declaredIdentifier` is
       // unresolved, but in an instance method context. If it is some different
       // situation, the assignment to [ir.PropertyGet] should act as an
       // assertion.
       ir.PropertyGet expression = visitForValue(send);
-      return PropertyAccessor.make(expression.receiver, expression.name);
+      return PropertyAccessor.make(
+          expression.receiver, expression.name, null, null);
     } else if (kernel.isSyntheticError(element)) {
       return buildStaticAccessor(null);
     } else if (element.isGetter) {
       if (element.isInstanceMember) {
-        return new ThisPropertyAccessor(kernel.irName(element.name, element));
+        return new ThisPropertyAccessor(
+            kernel.irName(element.name, element), null, null);
       } else {
         GetterElement getter = element;
         Element setter = getter.setter;
         return buildStaticAccessor(getter, setter);
       }
     } else if (element.isLocal) {
       return new VariableAccessor(getLocal(element));
     } else if (element.isField) {
       return buildStaticAccessor(element);
     } else {
@@ skipping 757 matching lines @@
     return buildInvokeSelector(
         visitForValue(receiver), selector, buildArguments(arguments));
   }
 
   @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)), rhs);
+        PropertyAccessor.make(receiverNode, nameToIrName(name), null, null),
+        rhs);
   }
 
   @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);
   }
 
   @override
   ir.Expression handleDynamicSetIfNulls(
       Send node, Node receiver, Name name, Node rhs, _) {
     ir.Name irName = nameToIrName(name);
     Accessor accessor = (receiver == null)
-        ? new ThisPropertyAccessor(irName)
-        : PropertyAccessor.make(visitForValue(receiver), irName);
+        ? new ThisPropertyAccessor(irName, null, null)
+        : PropertyAccessor.make(visitForValue(receiver), irName, null, null);
     return accessor.buildNullAwareAssignment(visitForValue(rhs),
         voidContext: isVoidContext);
   }
 
   @override
   ir.TypeLiteral visitDynamicTypeLiteralGet(
       Send node, ConstantExpression constant, _) {
     return buildTypeLiteral(constant);
   }
 
   @override
   ir.MethodInvocation visitDynamicTypeLiteralInvoke(
       Send node,
       ConstantExpression constant,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return buildCall(buildTypeLiteral(constant), callStructure, arguments);
   }
 
   @override
   ir.Expression visitDynamicTypeLiteralSet(
       SendSet node, ConstantExpression constant, Node rhs, _) {
     return buildTypeLiteralSet(constant, rhs);
   }
 
   ir.MethodInvocation buildBinaryOperator(
       Node left, String operator, Node right) {
     ir.Name name = kernel.irName(operator, currentElement);
-    return makeBinary(visitForValue(left), name, visitForValue(right));
+    return makeBinary(visitForValue(left), name, null, visitForValue(right));
   }
 
   @override
   ir.MethodInvocation visitEquals(Send node, Node left, Node right, _) {
     return buildBinaryOperator(left, '==', right);
   }
 
   @override
   ir.MethodInvocation visitExpressionInvoke(Send node, Node expression,
       NodeList arguments, CallStructure callStructure, _) {
@@ skipping 159 matching lines @@
       ConstructorElement constructor,
       InterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return buildConstructorInvoke(node, isConst: false);
   }
 
   Accessor buildNullAwarePropertyAccessor(Node receiver, Name name) {
     return new NullAwarePropertyAccessor(
-        visitForValue(receiver), nameToIrName(name));
+        visitForValue(receiver), nameToIrName(name), null, null);
   }
 
   @override
   ir.Expression visitIfNotNullDynamicPropertyGet(
       Send node, Node receiver, Name name, _) {
     return buildNullAwarePropertyAccessor(receiver, name).buildSimpleRead();
   }
 
   @override
   ir.Let visitIfNotNullDynamicPropertyInvoke(
@@ skipping 40 matching lines @@
       ConstructorElement superConstructor, InterfaceType type, _) {
     if (superConstructor == null) {
       // TODO(ahe): Semantic visitor shouldn't call this.
       return new ir.InvalidInitializer();
     }
     return new ir.SuperInitializer(
         kernel.functionToIr(superConstructor), new ir.Arguments.empty());
   }
 
   Accessor buildIndexAccessor(Node receiver, Node index) {
-    return IndexAccessor.make(visitForValue(receiver), visitForValue(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();
   }
 
   ir.Expression buildIndexPostfix(Accessor accessor, IncDecOperator operator) {
     ir.Name name = kernel.irName(operator.selectorName, currentElement);
     return accessor.buildPostfixIncrement(name, voidContext: isVoidContext);
@@ skipping 579 matching lines @@
 
   @override
   ir.InvocationExpression visitStringFromEnvironmentConstructorInvoke(
       NewExpression node, StringFromEnvironmentConstantExpression constant, _) {
     return buildConstructorInvoke(node, isConst: true);
   }
 
   @override
   ir.SuperMethodInvocation visitSuperBinary(Send node, FunctionElement function,
       BinaryOperator operator, Node argument, _) {
-    return new ir.SuperMethodInvocation(kernel.functionToIr(function),
-        new ir.Arguments(<ir.Expression>[visitForValue(argument)]));
+    return new ir.SuperMethodInvocation(
+        kernel.irName(operator.selectorName, currentElement),
+        new ir.Arguments(<ir.Expression>[visitForValue(argument)]),
+        kernel.functionToIr(function));
   }
 
   @override
   ir.Expression visitSuperCompoundIndexSet(
       SendSet node,
       MethodElement getter,
       MethodElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
@@ skipping 17 matching lines @@
       // TODO(ahe): Semantic visitor shouldn't call in this case.
       return new ir.InvalidInitializer();
     }
     return new ir.SuperInitializer(
         kernel.functionToIr(superConstructor), buildArguments(arguments));
   }
 
   ir.SuperMethodInvocation buildSuperEquals(
       FunctionElement function, Node argument) {
     return new ir.SuperMethodInvocation(
-        kernel.functionToIr(function),
+        kernel.irName(function.name, function),
         new ir.Arguments(<ir.Expression>[visitForValue(argument)],
-            types: null, named: null));
+            types: null, named: null),
+        kernel.functionToIr(function));
   }
 
   @override
   ir.SuperMethodInvocation visitSuperEquals(
       Send node, FunctionElement function, Node argument, _) {
     return buildSuperEquals(function, argument);
   }
 
   @override
   ir.Expression handleSuperCompounds(
@@ skipping 60 matching lines @@
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   Accessor buildSuperPropertyAccessor(Element getter, [Element setter]) {
     if (setter == null &&
         getter.isField &&
         !getter.isFinal &&
         !getter.isConst) {
       setter = getter;
     }
+    Element element = getter ?? setter;
     return new SuperPropertyAccessor(
+        kernel.irName(element.name, element),
         (getter == null) ? null : kernel.elementToIr(getter),
         (setter == null) ? null : kernel.elementToIr(setter));
   }
 
   Accessor buildSuperIndexAccessor(Expression index, Element getter,
       [Element setter]) {
     if (setter == null &&
         getter.isField &&
         !getter.isFinal &&
         !getter.isConst) {
@@ skipping 71 matching lines @@
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitSuperMethodGet(Send node, MethodElement method, _) {
     return buildSuperPropertyAccessor(method).buildSimpleRead();
   }
 
   ir.SuperMethodInvocation buildSuperMethodInvoke(
       MethodElement method, NodeList arguments) {
-    return new ir.SuperMethodInvocation(
-        kernel.functionToIr(method), buildArguments(arguments));
+    return new ir.SuperMethodInvocation(kernel.irName(method.name, method),
+        buildArguments(arguments), kernel.functionToIr(method));
   }
 
   @override
   ir.SuperMethodInvocation visitSuperMethodIncompatibleInvoke(
       Send node,
       MethodElement method,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return buildSuperMethodInvoke(method, arguments);
@@ skipping 37 matching lines @@
   @override
   ir.Expression visitSuperSetterSet(
       SendSet node, FunctionElement setter, Node rhs, _) {
     return buildSuperPropertyAccessor(null, setter)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.SuperMethodInvocation visitSuperUnary(
       Send node, UnaryOperator operator, FunctionElement function, _) {
-    return new ir.SuperMethodInvocation(
-        kernel.functionToIr(function), new ir.Arguments.empty());
+    return new ir.SuperMethodInvocation(kernel.irName(function.name, function),
+        new ir.Arguments.empty(), kernel.functionToIr(function));
   }
 
   @override
   ir.Initializer visitThisConstructorInvoke(
       Send node,
       ConstructorElement thisConstructor,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     if (kernel.isSyntheticError(thisConstructor)) {
       return new ir.InvalidInitializer();
     } else {
       return new ir.RedirectingInitializer(
           kernel.functionToIr(thisConstructor), buildArguments(arguments));
     }
   }
 
   @override
   ir.ThisExpression visitThisGet(Identifier node, _) {
     return new ir.ThisExpression();
   }
 
   @override
   ir.MethodInvocation visitThisInvoke(
       Send node, NodeList arguments, CallStructure callStructure, _) {
     return buildCall(new ir.ThisExpression(), callStructure, arguments);
   }
 
   Accessor buildThisPropertyAccessor(Name name) {
-    return new ThisPropertyAccessor(nameToIrName(name));
+    return new ThisPropertyAccessor(nameToIrName(name), null, null);
   }
 
   @override
   ir.Expression visitThisPropertyGet(Send node, Name name, _) {
     return buildThisPropertyAccessor(name).buildSimpleRead();
   }
 
   @override
   ir.MethodInvocation visitThisPropertyInvoke(
       Send node, NodeList arguments, Selector selector, _) {
@@ skipping 245 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)";
   }
 }