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

pkg/analyzer/lib/src/kernel/resynthesize.dart

 // Copyright (c) 2017, 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.
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 727 matching lines @@
     var namedParameters = type.namedParameters
         .map((k) => new kernel.VariableDeclaration(k.name, type: k.type))
         .toList(growable: false);
 
     return [positionalParameters, namedParameters];
   }
 
   @override
   InterfaceType getInterfaceType(
       ElementImpl context, kernel.Supertype kernelType) {
+    if (kernelType.classNode.isEnum) {
+      return null;

[Brian Wilkerson, 2017/08/31 19:54:15]

Does this mean that we won't be able to resynthesize enum classes? If so, is
this a temporary situation? 

[scheglov, 2017/08/31 19:55:23]

We can resynthesize enums.
We just should not allow to say that "class C extends MyEnum {}".
This is a compilation error, and we consider this as "class C extends Object
{}".

+    }
     return _getInterfaceType(
         context, kernelType.className.canonicalName, kernelType.typeArguments);
   }
 
   @override
+  List<InterfaceType> getInterfaceTypes(
+      ElementImpl context, List<kernel.Supertype> types) {
+    var interfaceTypes = <InterfaceType>[];
+    for (kernel.Supertype kernelType in types) {
+      InterfaceType interfaceType = getInterfaceType(context, kernelType);
+      if (interfaceType != null) {
+        interfaceTypes.add(interfaceType);
+      }
+    }
+    return interfaceTypes;
+  }
+
+  @override
   ConstructorElementImpl getRedirectedConstructor(
       kernel.Constructor kernelConstructor, kernel.Procedure kernelFactory) {
     if (kernelConstructor != null) {
       for (var initializer in kernelConstructor.initializers) {
         if (initializer is kernel.RedirectingInitializer) {
           return libraryContext.resynthesizer
                   ._getElement(initializer.targetReference.canonicalName)
               as ConstructorElementImpl;
         }
       }
@@ skipping 106 matching lines @@
         for (var typeParameter in ctx.typeParameters) {
           if (typeParameter.name == name) {
             return typeParameter;
           }
         }
       }
     }
     throw new StateError('Not found $kernelTypeParameter in $context');
   }
 }