Fix for using enums as InterfaceType(s) when resynthesize from Kernel.

pkg/analyzer/lib/src/dart/element/element.dart

 // Copyright (c) 2014, 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 file.
 
 library analyzer.src.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 754 matching lines @@
         return true;
       }
     }
     return false;
   }
 
   @override
   List<InterfaceType> get interfaces {
     if (_interfaces == null) {
       if (_kernel != null) {
-        _interfaces = _kernel.implementedTypes
-            .map((k) => enclosingUnit._kernelContext.getInterfaceType(this, k))
-            .toList(growable: false);
+        var context = enclosingUnit._kernelContext;
+        _interfaces = context.getInterfaceTypes(this, _kernel.implementedTypes);
       }
       if (_unlinkedClass != null) {
         ResynthesizerContext context = enclosingUnit.resynthesizerContext;
         _interfaces = _unlinkedClass.interfaces
             .map((EntityRef t) => context.resolveTypeRef(this, t))
             .where(_isClassInterfaceType)
             .toList(growable: false);
       }
     }
     return _interfaces ?? const <InterfaceType>[];
@@ skipping 114 matching lines @@
     _assertNotResynthesized(_unlinkedClass);
     setModifier(Modifier.MIXIN_APPLICATION, isMixinApplication);
   }
 
   @override
   List<InterfaceType> get mixins {
     if (_mixins == null) {
       if (_kernel != null) {
         _initializeKernelMixins();
         var context = enclosingUnit._kernelContext;
-        _mixins = _kernelMixins.map((k) {
-          return context.getInterfaceType(this, k);
-        }).toList(growable: false);
+        _mixins = context.getInterfaceTypes(this, _kernelMixins);
       }
       if (_unlinkedClass != null) {
         ResynthesizerContext context = enclosingUnit.resynthesizerContext;
         _mixins = _unlinkedClass.mixins
             .map((EntityRef t) => context.resolveTypeRef(this, t))
             .where(_isClassInterfaceType)
             .toList(growable: false);
       }
     }
     return _mixins ?? const <InterfaceType>[];
@@ skipping 5265 matching lines @@
   List<List<kernel.VariableDeclaration>> getFunctionTypeParameters(
       kernel.FunctionType functionType);
 
   /**
    * Return the [InterfaceType] for the given Kernel [type], or `null` if the
    * [type] does not correspond to an [InterfaceType].
    */
   InterfaceType getInterfaceType(ElementImpl context, kernel.Supertype type);
 
   /**
+   * Return the [InterfaceType]s for the given Kernel [types], skipping
+   * the elements that don't correspond to an [InterfaceType].
+   */
+  List<InterfaceType> getInterfaceTypes(
+      ElementImpl context, List<kernel.Supertype> types);
+
+  /**
    * Return the [ConstructorElementImpl] to which the given [kernelConstructor]
    * or [kernelFactory] redirects.
    */
   ConstructorElementImpl getRedirectedConstructor(
       kernel.Constructor kernelConstructor, kernel.Procedure kernelFactory);
 
   /**
    * Return the [DartType] for the given Kernel [type], or `null` if the [type]
    * does not correspond to a [DartType].
    */
@@ skipping 3805 matching lines @@
 
   @override
   DartObject computeConstantValue() => null;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _initializer?.accept(visitor);
   }
 }