Delay 'supertype' for ClassElementImpl and EnumElementImpl.

pkg/analyzer/lib/src/summary/resynthesize.dart

 // Copyright (c) 2015, 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 summary_resynthesizer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 1014 matching lines @@
    * Indicates whether [librarySource] is the `dart:core` library.
    */
   bool isCoreLibrary;
 
   /**
    * The resynthesized library.
    */
   LibraryElementImpl library;
 
   /**
-   * Classes which should have their supertype set to "object" once
-   * resynthesis is complete.  Only used if [isCoreLibrary] is `true`.
-   */
-  List<ClassElementImpl> delayedObjectSubclasses = <ClassElementImpl>[];
-
-  /**
    * Map of compilation unit elements that have been resynthesized so far.  The
    * key is the URI of the compilation unit.
    */
   final Map<String, CompilationUnitElementImpl> resynthesizedUnits =
       <String, CompilationUnitElementImpl>{};
 
   /**
    * Types with implicit type arguments, which are the same as type parameter
    * bounds (in strong mode), or `dynamic` (in spec mode).
    */
@@ skipping 105 matching lines @@
           unlinkedDefiningUnit.parts[i - 1],
           i);
       partResynthesizers.add(partResynthesizer);
     }
     library.parts = partResynthesizers.map((r) => r.unit).toList();
     // Populate units.
     populateUnit(definingUnitResynthesizer);
     for (_UnitResynthesizer partResynthesizer in partResynthesizers) {
       populateUnit(partResynthesizer);
     }
-    // Update delayed Object class references.
-    if (isCoreLibrary) {
-      ClassElement objectElement = library.getType('Object');
-      assert(objectElement != null);
-      for (ClassElementImpl classElement in delayedObjectSubclasses) {
-        classElement.supertype = objectElement.type;
-      }
-    }
     // Create the synthetic element for `loadLibrary`.
     // Until the client received dart:core and dart:async, we cannot do this,
     // because the TypeProvider is not fully initialized. So, it is up to the
     // Dart SDK client to initialize TypeProvider and finish the dart:core and
     // dart:async libraries creation.
     if (library.name != 'dart.core' && library.name != 'dart.async') {
       library.createLoadLibraryFunction(summaryResynthesizer.typeProvider);
     }
     // Done.
     return library;
@@ skipping 498 matching lines @@
   }
 
   /**
    * Resynthesize a [ClassElement] and place it in [unitHolder].
    */
   void buildClass(UnlinkedClass serializedClass) {
     ClassElement classElement;
     if (libraryResynthesizer.isCoreLibrary &&
         serializedClass.supertype == null) {
       classElement = buildClassImpl(serializedClass, null);
-      if (!serializedClass.hasNoSupertype) {
-        libraryResynthesizer.delayedObjectSubclasses.add(classElement);
-      }
     } else {
       classElement = new _DeferredClassElement(this, unit, serializedClass);
     }
     unitHolder.addType(classElement);
   }
 
   /**
    * Fill the given [ClassElementImpl] with executable elements and fields.
    */
   void buildClassExecutables(
@@ skipping 41 matching lines @@
    * executables are not resynthesized, and [InterfaceTypeImpl] is created
    * around the [handle], so that executables are resynthesized lazily.
    */
   ClassElementImpl buildClassImpl(
       UnlinkedClass serializedClass, ClassElementHandle handle) {
     ClassElementImpl classElement =
         new ClassElementImpl.forSerialized(serializedClass, unit);
     classElement.hasBeenInferred = summaryResynthesizer.strongMode;
     InterfaceTypeImpl correspondingType =
         new InterfaceTypeImpl(handle ?? classElement);
-    if (serializedClass.supertype != null) {
-      classElement.supertype =
-          buildType(serializedClass.supertype, classElement);
-    } else if (!libraryResynthesizer.isCoreLibrary) {
-      classElement.supertype = typeProvider.objectType;
-    }
     // TODO(scheglov) move to ClassElementImpl
     correspondingType.typeArguments = classElement.typeParameterTypes;
     classElement.type = correspondingType;
     // TODO(scheglov) Somehow Observatory shows too much time spent here
     // during DDC run on the large codebase. I would expect only Object here.
     if (handle == null) {
       buildClassExecutables(classElement, serializedClass);
     }
     constructors = null;
     return classElement;
@@ skipping 91 matching lines @@
   /**
    * Resynthesize the [ClassElement] corresponding to an enum, along with the
    * associated fields and implicit accessors.
    */
   void buildEnum(UnlinkedEnum serializedEnum) {
     assert(!libraryResynthesizer.isCoreLibrary);
     EnumElementImpl classElement =
         new EnumElementImpl.forSerialized(serializedEnum, unit);
     InterfaceType enumType = new InterfaceTypeImpl(classElement);
     classElement.type = enumType;
-    classElement.supertype = typeProvider.objectType;
     ElementHolder memberHolder = new ElementHolder();
     // Build the 'index' field.
     FieldElementImpl indexField = new FieldElementImpl('index', -1);
     indexField.final2 = true;
     indexField.synthetic = true;
     indexField.type = typeProvider.intType;
     memberHolder.addField(indexField);
     buildImplicitAccessors(indexField, memberHolder);
     // Build the 'values' field.
     FieldElementImpl valuesField = new ConstFieldElementImpl('values', -1);
@@ skipping 512 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }