Update third_party/pkg/kernel version

pkg/compiler/lib/src/kernel/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.md file.
 
 import 'dart:async';
 import 'dart:collection' show Queue;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/checks.dart' show CheckParentPointers;
 
@@ skipping 174 matching lines @@
       ir.Class classNode = new ir.Class(
           name: name,
           isAbstract: cls.isAbstract,
           typeParameters: null,
           implementedTypes: null,
           constructors: null,
           procedures: null,
           fields: null);
       addWork(cls, () {
         if (cls.supertype != null) {
-          classNode.supertype = interfaceTypeToIr(cls.supertype);
+          classNode.supertype = supertypeToIr(cls.supertype);
         }
         if (cls.isMixinApplication) {
           MixinApplicationElement mixinApplication = cls;
-          classNode.mixedInType = interfaceTypeToIr(mixinApplication.mixinType);
+          classNode.mixedInType = supertypeToIr(mixinApplication.mixinType);
         }
         classNode.parent = libraryToIr(cls.library);
         if (cls.isUnnamedMixinApplication) {
           classNode.enclosingLibrary.addClass(classNode);
         }
         cls.implementation
             .forEachMember((ClassElement enclosingClass, Element member) {
           if (member.enclosingClass.declaration != cls) {
             // TODO(het): figure out why impact_test triggers this
             //internalError(cls, "`$member` isn't mine.");
           } else if (member.isConstructor) {
             ConstructorElement constructor = member;
             ir.Member memberNode = functionToIr(member);
             if (!constructor.isRedirectingFactory) {
               classNode.addMember(memberNode);
             }
           } else if (member.isFunction || member.isAccessor) {
             classNode.addMember(functionToIr(member));
           } else if (member.isField) {
             classNode.addMember(fieldToIr(member));
           } else {
             internalError(member, "Unhandled class member: $member");
           }
         });
         classNode.typeParameters.addAll(typeVariablesToIr(cls.typeVariables));
-        for (ir.InterfaceType interface
-            in typesToIr(cls.interfaces.reverse().toList())) {
-          if (interface != classNode.mixedInType) {
-            classNode.implementedTypes.add(interface);
+        for (ir.Supertype supertype
+            in supertypesToIr(cls.interfaces.reverse().toList())) {
+          if (supertype != classNode.mixedInType) {
+            classNode.implementedTypes.add(supertype);
           }
         }
         addWork(cls, () {
           addDefaultInstanceFieldInitializers(classNode);
         });
       });
       addWork(cls.declaration, () {
         for (MetadataAnnotation metadata in cls.declaration.metadata) {
           classNode.addAnnotation(
               const ConstantVisitor().visit(metadata.constant, this));
@@ skipping 38 matching lines @@
 
   ir.InterfaceType interfaceTypeToIr(InterfaceType type) {
     ir.Class cls = classToIr(type.element);
     if (type.typeArguments.isEmpty) {
       return cls.rawType;
     } else {
       return new ir.InterfaceType(cls, typesToIr(type.typeArguments));
     }
   }
 
+  ir.Supertype supertypeToIr(InterfaceType type) {
+    ir.Class cls = classToIr(type.element);
+    if (type.typeArguments.isEmpty) {
+      return cls.asRawSupertype;
+    } else {
+      return new ir.Supertype(cls, typesToIr(type.typeArguments));
+    }
+  }
+
   // TODO(ahe): Remove this method when dart2js support generic type arguments.
   List<ir.TypeParameter> typeParametersNotImplemented() {
     return const <ir.TypeParameter>[];
   }
 
   ir.FunctionType functionTypeToIr(FunctionType type) {
     List<ir.TypeParameter> typeParameters = typeParametersNotImplemented();
     int requiredParameterCount = type.parameterTypes.length;
     List<ir.DartType> positionalParameters =
         new List<ir.DartType>.from(typesToIr(type.parameterTypes))
           ..addAll(typesToIr(type.optionalParameterTypes));
-    Map<String, ir.DartType> namedParameters = <String, ir.DartType>{};
-    for (int i = 0; i < type.namedParameters.length; i++) {
-      namedParameters[type.namedParameters[i]] =
-          typeToIr(type.namedParameterTypes[i]);
-    }
+    List<ir.NamedType> namedParameters = new List<ir.NamedType>.generate(
+        type.namedParameters.length,
+        (i) => new ir.NamedType(
+            type.namedParameters[i], typeToIr(type.namedParameterTypes[i])));
     ir.DartType returnType = typeToIr(type.returnType);
 
     return new ir.FunctionType(positionalParameters, returnType,
         namedParameters: namedParameters,
         typeParameters: typeParameters,
         requiredParameterCount: requiredParameterCount);
   }
 
   ir.TypeParameterType typeVariableTypeToIr(TypeVariableType type) {
     return new ir.TypeParameterType(typeVariableToIr(type.element));
   }
 
   List<ir.DartType> typesToIr(List<DartType> types) {
     List<ir.DartType> result = new List<ir.DartType>(types.length);
     for (int i = 0; i < types.length; i++) {
       result[i] = typeToIr(types[i]);
     }
     return result;
   }
 
+  List<ir.Supertype> supertypesToIr(List<DartType> types) {
+    List<ir.Supertype> result = new List<ir.Supertype>(types.length);
+    for (int i = 0; i < types.length; i++) {
+      result[i] = supertypeToIr(types[i]);
+    }
+    return result;
+  }
+
   ir.DartType typeToIr(DartType type) {
     switch (type.kind) {
       case TypeKind.FUNCTION:
         return functionTypeToIr(type);
 
       case TypeKind.INTERFACE:
         return interfaceTypeToIr(type);
 
       case TypeKind.STATEMENT:
         throw "Internal error: statement type: $type.";
@@ skipping 405 matching lines @@
 }
 
 class ConstructorTarget {
   final ConstructorElement element;
   final DartType type;
 
   ConstructorTarget(this.element, this.type);
 
   String toString() => "ConstructorTarget($element, $type)";
 }