Resynthesize InterfaceType, class type parameters and supertype.

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 793 matching lines @@
     }
     for (ConstructorElement constructor in constructors) {
       if (!constructor.isSynthetic && !constructor.isFactory) {
         return false;
       }
     }
     return true;
   }
 
   @override
+  List<kernel.TypeParameter> get kernelTypeParams => _kernel?.typeParameters;
+
+  @override
   List<ElementAnnotation> get metadata {
     if (_unlinkedClass != null) {
       return _metadata ??=
           _buildAnnotations(enclosingUnit, _unlinkedClass.annotations);
     }
     return super.metadata;
   }
 
   @override
   List<MethodElement> get methods {
@@ skipping 57 matching lines @@
   int get nameOffset {
     int offset = super.nameOffset;
     if (offset == 0 && _unlinkedClass != null) {
       return _unlinkedClass.nameOffset;
     }
     return offset;
   }
 
   @override
   InterfaceType get supertype {
-    if (_unlinkedClass != null && _supertype == null) {
-      if (_unlinkedClass.supertype != null) {
-        DartType type = enclosingUnit.resynthesizerContext
-            .resolveTypeRef(this, _unlinkedClass.supertype);
-        if (_isClassInterfaceType(type)) {
-          _supertype = type;
+    if (_supertype == null) {
+      if (_kernel != null) {
+        if (_kernel.supertype != null) {
+          _supertype = enclosingUnit._kernelContext
+              .getInterfaceType(this, _kernel.supertype);
+          _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)) {
+            _supertype = type;
+          } else {
+            _supertype = context.typeProvider.objectType;
+          }
+        } else if (_unlinkedClass.hasNoSupertype) {
+          return null;
         } else {
           _supertype = context.typeProvider.objectType;
         }
-      } else if (_unlinkedClass.hasNoSupertype) {
-        return null;
-      } else {
-        _supertype = context.typeProvider.objectType;
       }
     }
     return _supertype;
   }
 
   void set supertype(InterfaceType supertype) {
     _assertNotResynthesized(_unlinkedClass);
     _supertype = supertype;
   }
 
@@ skipping 2910 matching lines @@
     return hasModifier(Modifier.GENERATOR);
   }
 
   @override
   bool get isOperator => false;
 
   @override
   bool get isSynchronous => !isAsynchronous;
 
   @override
+  List<kernel.TypeParameter> get kernelTypeParams => null;
+
+  @override
   List<ElementAnnotation> get metadata {
     if (serializedExecutable != null) {
       return _metadata ??=
           _buildAnnotations(enclosingUnit, serializedExecutable.annotations);
     }
     return super.metadata;
   }
 
   @override
   String get name {
@@ skipping 814 matching lines @@
       super.enclosingElement as CompilationUnitElement;
 
   @override
   TypeParameterizedElementMixin get enclosingTypeParameterContext => null;
 
   @override
   CompilationUnitElementImpl get enclosingUnit =>
       _enclosingElement as CompilationUnitElementImpl;
 
   @override
+  List<kernel.TypeParameter> get kernelTypeParams => null;
+
+  @override
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
 
   @override
   List<ElementAnnotation> get metadata {
     if (_unlinkedTypedef != null) {
       return _metadata ??=
           _buildAnnotations(enclosingUnit, _unlinkedTypedef.annotations);
     }
     return super.metadata;
   }
@@ skipping 194 matching lines @@
 
   @override
   TypeParameterizedElementMixin get enclosingTypeParameterContext {
     return _enclosingElement.typeParameterContext;
   }
 
   @override
   String get identifier => '-';
 
   @override
+  List<kernel.TypeParameter> get kernelTypeParams => null;
+
+  @override
   ElementKind get kind => ElementKind.GENERIC_FUNCTION_TYPE;
 
   @override
   List<ParameterElement> get parameters {
     if (_entityRef != null) {
       _parameters ??= ParameterElementImpl.resynthesizeList(
           _entityRef.syntheticParams, this);
     }
     return _parameters ?? const <ParameterElement>[];
   }
@@ skipping 207 matching lines @@
    */
   void set function(GenericFunctionTypeElement function) {
     _assertNotResynthesized(_unlinkedTypedef);
     if (function != null) {
       (function as GenericFunctionTypeElementImpl).enclosingElement = this;
     }
     _function = function;
   }
 
   @override
+  List<kernel.TypeParameter> get kernelTypeParams => null;
+
+  @override
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
 
   @override
   List<ElementAnnotation> get metadata {
     if (_unlinkedTypedef != null) {
       return _metadata ??=
           _buildAnnotations(enclosingUnit, _unlinkedTypedef.annotations);
     }
     return super.metadata;
   }
@@ skipping 437 matching lines @@
       return const <NamespaceCombinator>[];
     }
   }
 }
 
 /**
  * The kernel context in which a library is resynthesized.
  */
 abstract class KernelLibraryResynthesizerContext {
   kernel.Library get library;
+
+  /**
+   * 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 [DartType] for the given Kernel [type], or `null` if the [type]
+   * does not correspond to a [DartType].
+   */
+  DartType getType(ElementImpl context, kernel.DartType type);
 }
 
 /**
  * A concrete implementation of a [LabelElement].
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
   /**
    * A flag indicating whether this label is associated with a `switch`
    * statement.
    */
@@ skipping 2868 matching lines @@
 
   /**
    * The number of type parameters whose scope overlaps this one, and which are
    * declared earlier in the file.
    *
    * TODO(scheglov) make private?
    */
   final int nestingLevel;
 
   /**
+   * The kernel of the element.
+   */
+  final kernel.TypeParameter _kernel;
+
+  /**
    * The type defined by this type parameter.
    */
   TypeParameterType _type;
 
   /**
    * The type representing the bound associated with this parameter, or `null`
    * if this parameter does not have an explicit bound.
    */
   DartType _bound;
 
   /**
    * Initialize a newly created method element to have the given [name] and
    * [offset].
    */
   TypeParameterElementImpl(String name, int offset)
       : _unlinkedTypeParam = null,
         nestingLevel = null,
+        _kernel = null,
         super(name, offset);
 
   /**
+   * Initialize using the given kernel.
+   */
+  TypeParameterElementImpl.forKernel(
+      TypeParameterizedElementMixin enclosingElement, this._kernel)
+      : _unlinkedTypeParam = null,
+        nestingLevel = null,
+        super.forSerialized(enclosingElement);
+
+  /**
    * Initialize a newly created type parameter element to have the given [name].
    */
   TypeParameterElementImpl.forNode(Identifier name)
       : _unlinkedTypeParam = null,
         nestingLevel = null,
+        _kernel = null,
         super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   TypeParameterElementImpl.forSerialized(this._unlinkedTypeParam,
       TypeParameterizedElementMixin enclosingElement, this.nestingLevel)
-      : super.forSerialized(enclosingElement);
+      : _kernel = null,
+        super.forSerialized(enclosingElement);
 
   /**
    * Initialize a newly created synthetic type parameter element to have the
    * given [name], and with [synthetic] set to true.
    */
   TypeParameterElementImpl.synthetic(String name)
       : _unlinkedTypeParam = null,
         nestingLevel = null,
+        _kernel = null,
         super(name, -1) {
     isSynthetic = true;
   }
 
   DartType get bound {
-    if (_unlinkedTypeParam != null) {
-      if (_unlinkedTypeParam.bound == null) {
-        return null;
+    if (_bound == null) {
+      if (_kernel != null) {
+        _bound = enclosingUnit._kernelContext.getType(this, _kernel.bound);
+        // TODO(scheglov) Add a flag for explicit bound.
+        if (_bound != null && _bound.isObject) _bound = null;
       }
-      return _bound ??= enclosingUnit.resynthesizerContext.resolveTypeRef(
-          this, _unlinkedTypeParam.bound,
-          instantiateToBoundsAllowed: false, declaredType: true);
+      if (_unlinkedTypeParam != null) {
+        if (_unlinkedTypeParam.bound == null) {
+          return null;
+        }
+        _bound = enclosingUnit.resynthesizerContext.resolveTypeRef(
+            this, _unlinkedTypeParam.bound,
+            instantiateToBoundsAllowed: false, declaredType: true);
+      }
     }
     return _bound;
   }
 
   void set bound(DartType bound) {
     _assertNotResynthesized(_unlinkedTypeParam);
     _bound = _checkElementOfType(bound);
   }
 
   @override
@@ skipping 22 matching lines @@
   List<ElementAnnotation> get metadata {
     if (_unlinkedTypeParam != null) {
       return _metadata ??=
           _buildAnnotations(enclosingUnit, _unlinkedTypeParam.annotations);
     }
     return super.metadata;
   }
 
   @override
   String get name {
+    if (_kernel != null) {
+      return _kernel.name;
+    }
     if (_unlinkedTypeParam != null) {
       return _unlinkedTypeParam.name;
     }
     return super.name;
   }
 
   @override
   int get nameOffset {
     int offset = super.nameOffset;
     if (offset == 0 && _unlinkedTypeParam != null) {
@@ skipping 85 matching lines @@
   /**
    * Get the type parameter context enclosing this one, if any.
    */
   TypeParameterizedElementMixin get enclosingTypeParameterContext;
 
   /**
    * The unit in which this element is resynthesized.
    */
   CompilationUnitElementImpl get enclosingUnit;
 
+  /**
+   * Get the [kernel.TypeParameter]s declared by this element, or `null` if
+   * this elements isn't from a kernel.
+   */
+  List<kernel.TypeParameter> get kernelTypeParams;
+
   @override
   TypeParameterizedElementMixin get typeParameterContext => this;
 
   /**
    * Find out how many type parameters are in scope in this context.
    */
   int get typeParameterNestingLevel =>
       _nestingLevel ??= unlinkedTypeParams.length +
           (enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0);
 
   @override
   List<TypeParameterElement> get typeParameters {
     if (_typeParameterElements == null) {
+      List<kernel.TypeParameter> kernelParams = kernelTypeParams;
+      if (kernelParams != null) {
+        int numTypeParameters = kernelParams.length;
+        _typeParameterElements =
+            new List<TypeParameterElement>(numTypeParameters);
+        for (int i = 0; i < numTypeParameters; i++) {
+          _typeParameterElements[i] =
+              new TypeParameterElementImpl.forKernel(this, kernelParams[i]);
+        }
+      }
+
       List<UnlinkedTypeParam> unlinkedParams = unlinkedTypeParams;
       if (unlinkedParams != null) {
         int enclosingNestingLevel =
             enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0;
         int numTypeParameters = unlinkedParams.length;
         _typeParameterElements =
             new List<TypeParameterElement>(numTypeParameters);
         for (int i = 0; i < numTypeParameters; i++) {
           _typeParameterElements[i] =
               new TypeParameterElementImpl.forSerialized(
@@ skipping 323 matching lines @@
 
   @override
   DartObject computeConstantValue() => null;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _initializer?.accept(visitor);
   }
 }