Update third_party/pkg/kernel version

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 692 matching lines @@
     ir.DartType guard = computeType(node.type);
     return new ir.Catch(exception, buildStatementInBlock(node.block),
         guard: guard, stackTrace: trace);
   }
 
   @override
   ir.ConditionalExpression visitConditional(Conditional node) {
     return new ir.ConditionalExpression(
         visitForValue(node.condition),
         visitWithCurrentContext(node.thenExpression),
-        visitWithCurrentContext(node.elseExpression));
+        visitWithCurrentContext(node.elseExpression),
+        null);
   }
 
   @override
   ir.Statement visitContinueStatement(ContinueStatement node) {
     JumpTarget target = elements.getTargetOf(node);
     if (target == null || !target.statement.isValidContinueTarget()) {
       // This is a continue in an invalid position.
       return new ir.InvalidStatement();
     }
     ir.SwitchCase switchCase = getContinueSwitchTarget(target);
@@ skipping 581 matching lines @@
         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, null, null)
         : PropertyAccessor.make(visitForValue(receiver), irName, null, null);
-    return accessor.buildNullAwareAssignment(visitForValue(rhs),
+    return accessor.buildNullAwareAssignment(visitForValue(rhs), null,
         voidContext: isVoidContext);
   }
 
   @override
   ir.TypeLiteral visitDynamicTypeLiteralGet(
       Send node, ConstantExpression constant, _) {
     return buildTypeLiteral(constant);
   }
 
   @override
@@ skipping 171 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), null, null);
+        visitForValue(receiver), nameToIrName(name), null, null, null);
   }
 
   @override
   ir.Expression visitIfNotNullDynamicPropertyGet(
       Send node, Node receiver, Name name, _) {
     return buildNullAwarePropertyAccessor(receiver, name).buildSimpleRead();
   }
 
   @override
   ir.Let visitIfNotNullDynamicPropertyInvoke(
       Send node, Node receiverNode, NodeList arguments, Selector selector, _) {
     ir.VariableDeclaration receiver =
         makeOrReuseVariable(visitForValue(receiverNode));
     return makeLet(
         receiver,
         new ir.ConditionalExpression(
             buildIsNull(new ir.VariableGet(receiver)),
             new ir.NullLiteral(),
             buildInvokeSelector(new ir.VariableGet(receiver), selector,
-                buildArguments(arguments))));
+                buildArguments(arguments)),
+            null));
   }
 
   @override
   ir.Expression visitIfNotNullDynamicPropertySet(
       SendSet node, Node receiver, Name name, Node rhs, _) {
     return buildNullAwarePropertyAccessor(receiver, name)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitIfNotNullDynamicPropertySetIfNull(
       Send node, Node receiver, Name name, Node rhs, _) {
     return buildNullAwarePropertyAccessor(receiver, name)
-        .buildNullAwareAssignment(visitForValue(rhs),
+        .buildNullAwareAssignment(visitForValue(rhs), null,
             voidContext: isVoidContext);
   }
 
   ir.LogicalExpression buildLogicalExpression(
       Node left, Operator operator, Node right) {
     return new ir.LogicalExpression(
         visitForValue(left), operator.source, visitForValue(right));
   }
 
   @override
-  ir.LogicalExpression visitIfNull(Send node, Node left, Node right, _) {
-    return buildLogicalExpression(left, node.selector, right);
+  ir.Expression visitIfNull(Send node, Node left, Node right, _) {
+    var leftValue = new ir.VariableDeclaration.forValue(visitForValue(left));
+    return new ir.Let(
+        leftValue,
+        new ir.ConditionalExpression(buildIsNull(new ir.VariableGet(leftValue)),
+            visitForValue(right), new ir.VariableGet(leftValue), null));
   }
 
   @override
   ir.Initializer visitImplicitSuperConstructorInvoke(FunctionExpression node,
       ConstructorElement superConstructor, InterfaceType type, _) {
     if (superConstructor == null) {
       // TODO(ahe): Semantic visitor shouldn't call this.
       return new ir.InvalidInitializer();
     }
     return new ir.SuperInitializer(
@@ skipping 266 matching lines @@
       NodeList arguments, CallStructure callStructure, _) {
     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),
+        visitForValue(rhs), null,
         voidContext: isVoidContext);
   }
 
   @override
   IrFunction visitRedirectingFactoryConstructorDeclaration(
       FunctionExpression node,
       ConstructorElement constructor,
       NodeList parameters,
       DartType redirectionType, // TODO(ahe): Should be InterfaceType.
       ConstructorElement redirectionTarget,
@@ skipping 96 matching lines @@
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       Node rhs,
       _) {
     if (setterKind == CompoundSetter.INVALID) {
       setter = null;
     }
     return buildStaticAccessor(getter, setter).buildNullAwareAssignment(
-        visitForValue(rhs),
+        visitForValue(rhs), null,
         voidContext: isVoidContext);
   }
 
   ir.VariableDeclaration getLocal(LocalElement local) {
     return locals.putIfAbsent(local, () {
       // Currently, initializing formals are not final.
       bool isFinal = local.isFinal && !local.isInitializingFormal;
       return associateElement(
           new ir.VariableDeclaration(local.name,
               initializer: null,
@@ skipping 16 matching lines @@
       FunctionSignature signature = function.functionSignature;
       requiredParameterCount = signature.requiredParameterCount;
       signature.forEachParameter((ParameterElement parameter) {
         ir.VariableDeclaration variable = getLocal(parameter);
         if (parameter.isNamed) {
           namedParameters.add(variable);
         } else {
           positionalParameters.add(variable);
         }
       });
+      namedParameters.sort();
       signature.forEachParameter((ParameterElement parameter) {
         if (!parameter.isOptional) return;
         ir.Expression initializer = visitForValue(parameter.initializer);
         ir.VariableDeclaration variable = getLocal(parameter);
         if (initializer != null) {
           variable.initializer = initializer;
           initializer.parent = variable;
         }
       });
       if (function.isGenerativeConstructor) {
@@ skipping 384 matching lines @@
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       Node rhs,
       _) {
     if (setterKind == CompoundSetter.INVALID) {
       setter = null;
     }
     return buildSuperPropertyAccessor(getter, setter).buildNullAwareAssignment(
-        visitForValue(rhs),
+        visitForValue(rhs), null,
         voidContext: isVoidContext);
   }
 
   @override
   ir.SuperMethodInvocation visitSuperIndex(
       Send node, FunctionElement function, Node index, _) {
     return buildSuperIndexAccessor(index, function).buildSimpleRead();
   }
 
   @override
@@ skipping 208 matching lines @@
   ir.Expression visitTypeVariableTypeLiteralSet(
       SendSet node, TypeVariableElement element, Node rhs, _) {
     return new ReadOnlyAccessor(buildTypeVariable(element))
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitTypeVariableTypeLiteralSetIfNull(
       Send node, TypeVariableElement element, Node rhs, _) {
     return new ReadOnlyAccessor(buildTypeVariable(element))
-        .buildNullAwareAssignment(visitForValue(rhs),
+        .buildNullAwareAssignment(visitForValue(rhs), null,
             voidContext: isVoidContext);
   }
 
   @override
   ir.TypeLiteral visitTypedefTypeLiteralGet(
       Send node, ConstantExpression constant, _) {
     return buildTypeLiteral(constant);
   }
 
   @override
@@ skipping 45 matching lines @@
   @override
   visitForIn(ForIn node) {
     // Shouldn't be called, handled by [visitAsyncForIn] or [visitSyncForIn].
     return internalError(node, "ForIn");
   }
 
   @override
   ir.Expression visitIndexSetIfNull(
       SendSet node, Node receiver, Node index, Node rhs, _) {
     return buildIndexAccessor(receiver, index).buildNullAwareAssignment(
-        visitForValue(rhs),
+        visitForValue(rhs), null,
         voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitSuperIndexSetIfNull(SendSet node, MethodElement getter,
       MethodElement setter, Node index, Node rhs, _) {
     return buildSuperIndexAccessor(index, getter, setter)
-        .buildNullAwareAssignment(visitForValue(rhs),
+        .buildNullAwareAssignment(visitForValue(rhs), null,
             voidContext: isVoidContext);
   }
 
   @override
   ir.Node visitVariableDefinitions(VariableDefinitions definitions) {
     // TODO(ahe): This method is copied from [SemanticDeclarationResolvedMixin]
     // and modified. Perhaps we can find a way to avoid code duplication.
     List<ir.VariableDeclaration> variables = <ir.VariableDeclaration>[];
     computeVariableStructures(definitions,
         (Node node, VariableStructure structure) {
@@ skipping 79 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)";
   }
 }