Resynthesize mixins 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 13 matching lines @@
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:kernel/kernel.dart' as kernel;
+import 'package:kernel/type_algebra.dart' as kernel;
 
 /**
  * Assert that the given [object] is null, which in the places where this
  * function is called means that the element is not resynthesized.
  */
 void _assertNotResynthesized(Object object) {
   // TODO(scheglov) I comment this check for now.
   // When we make a decision about switch to the new analysis driver,
   // we will need to rework the analysis code to don't call the setters
   // or restore / inline it.
@@ skipping 366 matching lines @@
    * The unlinked representation of the class in the summary.
    */
   final UnlinkedClass _unlinkedClass;
 
   /**
    * The kernel of the element.
    */
   final kernel.Class _kernel;
 
   /**
+   * The actual supertype extracted from desugared [_kernel].
+   */
+  kernel.Supertype _kernelSupertype;
+
+  /**
+   * The mixed-in types extracted from desugared [_kernel].
+   */
+  List<kernel.Supertype> _kernelMixins;
+
+  /**
    * The superclass of the class, or `null` for [Object].
    */
   InterfaceType _supertype;
 
   /**
    * The type defined by the class.
    */
   InterfaceType _type;
 
   /**
@@ skipping 354 matching lines @@
       return _unlinkedClass.isAbstract;
     }
     return hasModifier(Modifier.ABSTRACT);
   }
 
   @override
   bool get isEnum => false;
 
   @override
   bool get isMixinApplication {
+    if (_kernel != null) {
+      return _kernel.mixedInType != null;
+    }
     if (_unlinkedClass != null) {
       return _unlinkedClass.isMixinApplication;
     }
     return hasModifier(Modifier.MIXIN_APPLICATION);
   }
 
   @override
   bool get isOrInheritsProxy =>
       _safeIsOrInheritsProxy(this, new HashSet<ClassElement>());
 
@@ skipping 70 matching lines @@
   /**
    * Set whether this class is a mixin application.
    */
   void set mixinApplication(bool isMixinApplication) {
     _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(this, t))
-          .where(_isClassInterfaceType)
-          .toList(growable: false);
+    if (_mixins == null) {
+      if (_kernel != null) {
+        _initializeKernelMixins();
+        var context = enclosingUnit._kernelContext;
+        _mixins = _kernelMixins.map((k) {
+          return context.getInterfaceType(this, k);
+        }).toList(growable: false);
+      }
+      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>[];
   }
 
   void set mixins(List<InterfaceType> mixins) {
     _assertNotResynthesized(_unlinkedClass);
     _mixins = mixins;
   }
 
   @override
@@ skipping 13 matching lines @@
     if (offset == 0 && _unlinkedClass != null) {
       return _unlinkedClass.nameOffset;
     }
     return offset;
   }
 
   @override
   InterfaceType get supertype {
     if (_supertype == null) {
       if (_kernel != null) {
-        if (_kernel.supertype != null) {
+        _initializeKernelMixins();
+        if (_kernelSupertype != null) {
           _supertype = enclosingUnit._kernelContext
-              .getInterfaceType(this, _kernel.supertype);
+              .getInterfaceType(this, _kernelSupertype);
           _supertype ??= context.typeProvider.objectType;
         } else {
           return null;
         }
       }
       if (_unlinkedClass != null) {
         if (_unlinkedClass.supertype != null) {
           DartType type = enclosingUnit.resynthesizerContext
               .resolveTypeRef(this, _unlinkedClass.supertype);
           if (_isClassInterfaceType(type)) {
@@ skipping 285 matching lines @@
           implicitParameters[i] = implicitParameter;
         }
         implicitConstructor.parameters = implicitParameters;
       }
       implicitConstructor.enclosingElement = this;
       return implicitConstructor;
     }).toList(growable: false);
   }
 
   /**
+   * Extract actual supertypes and mixed-in types from [_kernel].
+   */
+  void _initializeKernelMixins() {
+    if (_kernelSupertype == null) {
+      _kernelMixins = <kernel.Supertype>[];
+      kernel.Supertype supertype = _kernel.supertype;
+      if (supertype != null) {
+        if (_kernel.mixedInType != null) {
+          _kernelMixins.add(_kernel.mixedInType);
+        }
+        while (supertype.classNode.isSyntheticMixinImplementation) {
+          var superNode = supertype.classNode;
+          var substitute = kernel.Substitution.fromSupertype(supertype);
+          var thisMixin = substitute.substituteSupertype(superNode.mixedInType);
+          _kernelMixins.add(thisMixin);
+          supertype = substitute.substituteSupertype(superNode.supertype);
+        }
+        _kernelMixins = _kernelMixins.reversed.toList();
+      }
+      _kernelSupertype = supertype;
+    }
+  }
+
+  /**
    * Resynthesize explicit fields and property accessors and fill [_fields] and
    * [_accessors] with explicit and implicit elements.
    */
   void _resynthesizeFieldsAndPropertyAccessors() {
     assert(_fields == null);
     assert(_accessors == null);
     var explicitFields = <FieldElement>[];
     var implicitAccessors = <PropertyAccessorElement>[];
     var explicitAccessors = <PropertyAccessorElement>[];
     var implicitFields = <String, FieldElementImpl>{};
@@ skipping 478 matching lines @@
     this._typeAliases = typeAliases;
   }
 
   @override
   TypeParameterizedElementMixin get typeParameterContext => null;
 
   @override
   List<ClassElement> get types {
     if (_kernelContext != null) {
       _types ??= _kernelContext.library.classes
+          .where((k) => !k.isSyntheticMixinImplementation)
           .map((k) => new ClassElementImpl.forKernel(this, k))
           .toList(growable: false);
     }
     if (_unlinkedUnit != null) {
       _types ??= _unlinkedUnit.classes
           .map((c) => new ClassElementImpl.forSerialized(c, this))
           .toList(growable: false);
     }
     return _types ?? const <ClassElement>[];
   }
@@ skipping 7553 matching lines @@
 
   @override
   DartObject computeConstantValue() => null;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _initializer?.accept(visitor);
   }
 }