Resynthesize some more types lazily.

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 78 matching lines @@
 
   /**
    * A list containing all of the fields contained in this class.
    */
   List<FieldElement> _fields = FieldElement.EMPTY_LIST;
 
   /**
    * A list containing all of the mixins that are applied to the class being
    * extended in order to derive the superclass of this class.
    */
-  @override
-  List<InterfaceType> mixins = InterfaceType.EMPTY_LIST;
+  List<InterfaceType> _mixins;
 
   /**
    * A list containing all of the interfaces that are implemented by this class.
    */
-  @override
-  List<InterfaceType> interfaces = InterfaceType.EMPTY_LIST;
+  List<InterfaceType> _interfaces;
 
   /**
    * A list containing all of the methods contained in this class.
    */
   List<MethodElement> _methods = MethodElement.EMPTY_LIST;
 
   /**
    * The superclass of the class, or `null` if the class does not have an
    * explicit superclass.
    */
@@ skipping 250 matching lines @@
     }
     for (PropertyAccessorElement accessor in _accessors) {
       if (accessor.isStatic) {
         return true;
       }
     }
     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))
+          .toList();
+    }
+    return _interfaces ?? const <InterfaceType>[];
+  }
+
+  void set interfaces(List<InterfaceType> interfaces) {
+    assert(_unlinkedClass == null);
+    _interfaces = interfaces;
+  }
+
+  @override
   bool get isAbstract {
     if (_unlinkedClass != null) {
       return _unlinkedClass.isAbstract;
     }
     return hasModifier(Modifier.ABSTRACT);
   }
 
   @override
   bool get isEnum => hasModifier(Modifier.ENUM);
 
@@ skipping 64 matching lines @@
 
   /**
    * Set whether this class is a mixin application.
    */
   void set mixinApplication(bool isMixinApplication) {
     assert(_unlinkedClass == null);
     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))
+          .toList();
+    }
+    return _mixins ?? const <InterfaceType>[];
+  }
+
+  void set mixins(List<InterfaceType> mixins) {
+    assert(_unlinkedClass == null);
+    _mixins = mixins;
+  }
+
+  @override
   String get name {
     if (_unlinkedClass != null) {
       return _unlinkedClass.name;
     }
     return super.name;
   }
 
   @override
   int get nameOffset {
     if (_unlinkedClass != null) {
@@ skipping 3181 matching lines @@
   List<ParameterElement> _parameters = ParameterElement.EMPTY_LIST;
 
   /**
    * The return type defined by this type alias.
    */
   DartType _returnType;
 
   /**
    * The type of function defined by this type alias.
    */
-  FunctionType type;
+  FunctionType _type;
 
   /**
    * A list containing all of the type parameters defined for this type.
    */
   List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
 
   /**
    * Initialize a newly created type alias element to have the given name.
    *
    * [name] the name of this element
@@ skipping 119 matching lines @@
     }
     return _returnType;
   }
 
   void set returnType(DartType returnType) {
     assert(_unlinkedTypedef == null);
     _returnType = returnType;
   }
 
   @override
+  FunctionType get type {
+    if (_unlinkedTypedef != null && _type == null) {
+      _type = new FunctionTypeImpl.forTypedef(this);
+    }
+    return _type;
+  }
+
+  void set type(FunctionType type) {
+    assert(_unlinkedTypedef == null);
+    _type = type;
+  }
+
+  @override
   TypeParameterizedElementMixin get typeParameterContext => this;
 
   @override
   List<TypeParameterElement> get typeParameters {
     if (_unlinkedTypedef != null) {
       return super.typeParameters;
     }
     return _typeParameters;
   }
 
@@ skipping 1966 matching lines @@
     return super.name;
   }
 
   @override
   int get nameOffset {
     if (_unlinkedVariable != null) {
       return _unlinkedVariable.nameOffset;
     }
     return super.nameOffset;
   }
+
+  @override
+  DartType get type {
+    if (_unlinkedVariable != null && _type == null) {
+      _type = enclosingUnit.resynthesizerContext.resolveLinkedType(
+              _unlinkedVariable.inferredTypeSlot, typeParameterContext) ??
+          enclosingUnit.resynthesizerContext
+              .resolveTypeRef(_unlinkedVariable.type, typeParameterContext);
+    }
+    return super.type;
+  }
+
+  void set type(DartType type) {
+    assert(_unlinkedVariable == null);
+    _type = type;
+  }
 }
 
 /**
  * A concrete implementation of a [ParameterElement].
  */
 class ParameterElementImpl extends VariableElementImpl
     with ParameterElementMixin
     implements ParameterElement {
   /**
    * The unlinked representation of the parameter in the summary.
@@ skipping 1316 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }