Resynthesize CompilationUnitElement.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 452 matching lines @@
 
   /**
    * A list containing all of the methods contained in this class.
    */
   List<MethodElement> _methods;
 
   /**
    * A flag indicating whether the types associated with the instance members of
    * this class have been inferred.
    */
-  bool hasBeenInferred = false;
+  bool _hasBeenInferred = false;
 
   /**
    * Initialize a newly created class element to have the given [name] at the
    * given [offset] in the file that contains the declaration of this element.
    */
   ClassElementImpl(String name, int offset)
       : _unlinkedClass = null,
         super(name, offset);
 
   /**
@@ skipping 165 matching lines @@
     }
     return _fields ?? const <FieldElement>[];
   }
 
   @override
   void set fields(List<FieldElement> fields) {
     assert(_unlinkedClass == null);
     super.fields = fields;
   }
 
+  bool get hasBeenInferred {
+    if (_unlinkedClass != null) {
+      return context.analysisOptions.strongMode;
+    }
+    return _hasBeenInferred;
+  }
+
+  void set hasBeenInferred(bool hasBeenInferred) {
+    assert(_unlinkedClass == null);
+    _hasBeenInferred = hasBeenInferred;
+  }
+
   @override
   bool get hasNonFinalField {
     List<ClassElement> classesToVisit = new List<ClassElement>();
     HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
     classesToVisit.add(this);
     while (!classesToVisit.isEmpty) {
       ClassElement currentElement = classesToVisit.removeAt(0);
       if (visitedClasses.add(currentElement)) {
         // check fields
         for (FieldElement field in currentElement.fields) {
@@ skipping 651 matching lines @@
 
   /**
    * A list containing all of the function type aliases contained in this
    * compilation unit.
    */
   List<FunctionTypeAliasElement> _typeAliases;
 
   /**
    * A list containing all of the types contained in this compilation unit.
    */
-  List<ClassElement> _types = ClassElement.EMPTY_LIST;
+  List<ClassElement> _types;
 
   /**
    * A list containing all of the variables contained in this compilation unit.
    */
   List<TopLevelVariableElement> _variables;
 
   /**
    * A map from offsets to elements of this unit at these offsets.
    */
   final Map<int, Element> _offsetToElementMap = new HashMap<int, Element>();
@@ skipping 219 matching lines @@
     for (FunctionTypeAliasElement typeAlias in typeAliases) {
       (typeAlias as FunctionTypeAliasElementImpl).enclosingElement = this;
     }
     this._typeAliases = typeAliases;
   }
 
   @override
   TypeParameterizedElementMixin get typeParameterContext => null;
 
   @override
-  List<ClassElement> get types => _types;
+  List<ClassElement> get types {
+    if (_unlinkedUnit != null) {
+      _types ??= _unlinkedUnit.classes
+          .map((c) => new ClassElementImpl.forSerialized(c, this))
+          .toList(growable: false);
+    }
+    return _types ?? const <ClassElement>[];
+  }
 
   /**
    * Set the types contained in this compilation unit to the given [types].
    */
   void set types(List<ClassElement> types) {
+    assert(_unlinkedUnit == null);
     for (ClassElement type in types) {
       // Another implementation of ClassElement is _DeferredClassElement,
       // which is used to resynthesize classes lazily. We cannot cast it
       // to ClassElementImpl, and it already can provide correct values of the
       // 'enclosingElement' property.
       if (type is ClassElementImpl) {
         type.enclosingElement = this;
       }
     }
     this._types = types;
@@ skipping 55 matching lines @@
       if (variableImpl.identifier == identifier) {
         return variableImpl;
       }
     }
     for (FunctionElement function in functions) {
       FunctionElementImpl functionImpl = function;
       if (functionImpl.identifier == identifier) {
         return functionImpl;
       }
     }
-    for (FunctionTypeAliasElement typeAlias in _typeAliases) {
+    for (FunctionTypeAliasElement typeAlias in functionTypeAliases) {
       FunctionTypeAliasElementImpl typeAliasImpl = typeAlias;
       if (typeAliasImpl.identifier == identifier) {
         return typeAliasImpl;
       }
     }
-    for (ClassElement type in _types) {
+    for (ClassElement type in types) {
       ClassElementImpl typeImpl = type;
       if (typeImpl.name == identifier) {
         return typeImpl;
       }
     }
     for (ClassElement type in _enums) {
       EnumElementImpl typeImpl = type;
       if (typeImpl.identifier == identifier) {
         return typeImpl;
       }
@@ skipping 14 matching lines @@
     for (ClassElement enumDeclaration in _enums) {
       if (enumDeclaration.name == enumName) {
         return enumDeclaration;
       }
     }
     return null;
   }
 
   @override
   ClassElement getType(String className) {
-    for (ClassElement type in _types) {
+    for (ClassElement type in types) {
       if (type.name == className) {
         return type;
       }
     }
     return null;
   }
 
   /**
    * Replace the given [from] top-level variable with [to] in this compilation unit.
    */
@@ skipping 20 matching lines @@
     annotationMap ??= new HashMap<int, List<ElementAnnotation>>();
     annotationMap[offset] = annotations;
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(accessors, visitor);
     safelyVisitChildren(_enums, visitor);
     safelyVisitChildren(functions, visitor);
-    safelyVisitChildren(_typeAliases, visitor);
-    safelyVisitChildren(_types, visitor);
+    safelyVisitChildren(functionTypeAliases, visitor);
+    safelyVisitChildren(types, visitor);
     safelyVisitChildren(topLevelVariables, visitor);
   }
 }
 
 /**
  * A [FieldElement] for a 'const' or 'final' field that has an initializer.
  *
  * TODO(paulberry): we should rename this class to reflect the fact that it's
  * used for both const and final fields.  However, we shouldn't do so until
  * we've created an API for reading the values of constants; until that API is
@@ skipping 6471 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }