Fix for invalid 'extends/implements/with SomeEnum'.

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 712 matching lines @@
     }
     return false;
   }
 
   @override
   List<InterfaceType> get interfaces {
     if (_unlinkedClass != null && _interfaces == null) {
       ResynthesizerContext context = enclosingUnit.resynthesizerContext;
       _interfaces = _unlinkedClass.interfaces
           .map((EntityRef t) => context.resolveTypeRef(t, this))
-          .where((DartType type) => type is InterfaceType)
+          .where(_isClassInterfaceType)
           .toList(growable: false);
     }
     return _interfaces ?? const <InterfaceType>[];
   }
 
   void set interfaces(List<InterfaceType> interfaces) {
     _assertNotResynthesized(_unlinkedClass);
     _interfaces = interfaces;
   }
 
@@ skipping 86 matching lines @@
     _assertNotResynthesized(_unlinkedClass);
     setModifier(Modifier.MIXIN_APPLICATION, isMixinApplication);
   }
 
   @override
   List<InterfaceType> get mixins {
     if (_unlinkedClass != null && _mixins == null) {
       ResynthesizerContext context = enclosingUnit.resynthesizerContext;
       _mixins = _unlinkedClass.mixins
           .map((EntityRef t) => context.resolveTypeRef(t, this))
-          .where((DartType type) => type is InterfaceType)
+          .where(_isClassInterfaceType)
           .toList(growable: false);
     }
     return _mixins ?? const <InterfaceType>[];
   }
 
   void set mixins(List<InterfaceType> mixins) {
     _assertNotResynthesized(_unlinkedClass);
     _mixins = mixins;
   }
 
@@ skipping 13 matching lines @@
     }
     return offset;
   }
 
   @override
   InterfaceType get supertype {
     if (_unlinkedClass != null && _supertype == null) {
       if (_unlinkedClass.supertype != null) {
         DartType type = enclosingUnit.resynthesizerContext
             .resolveTypeRef(_unlinkedClass.supertype, this);
-        if (type is InterfaceType) {
+        if (_isClassInterfaceType(type)) {
           _supertype = type;
         } else {
           _supertype = context.typeProvider.objectType;
         }
       } else if (_unlinkedClass.hasNoSupertype) {
         return null;
       } else {
         _supertype = context.typeProvider.objectType;
       }
     }
@@ skipping 383 matching lines @@
       }
     }
     supertypes = element.mixins;
     for (int i = 0; i < supertypes.length; i++) {
       if (_safeIsOrInheritsProxy(supertypes[i].element, visited)) {
         return true;
       }
     }
     return false;
   }
+
+  /**
+   * Return `true` if the given [type] is a class [InterfaceType].
+   */
+  static bool _isClassInterfaceType(DartType type) {
+    return type is InterfaceType && !type.element.isEnum;

[Brian Wilkerson, 2017/01/28 17:18:39]

Personally, I'd rather have a method like this be defined on DartType so that
everyone can use it without recreating / copying it.

+  }
 }
 
 /**
  * A concrete implementation of a [CompilationUnitElement].
  */
 class CompilationUnitElementImpl extends UriReferencedElementImpl
     implements CompilationUnitElement {
   /**
    * The context in which this unit is resynthesized, or `null` if the
    * element is not resynthesized a summary.
@@ skipping 7330 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }