Delay TypeProvider.objectType access until after dart:core resynthesizing.

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 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/element_handle.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 94 matching lines @@
   final SourceFactory sourceFactory;
 
   /**
    * Cache of [Source] objects that have already been converted from URIs.
    */
   final Map<String, Source> _sources = <String, Source>{};
 
   /**
    * The [TypeProvider] used to obtain core types (such as Object, int, List,
    * and dynamic) during resynthesis.
-   *
-   * TODO(paulberry): will this create a chicken-and-egg problem when trying to
-   * resynthesize the core library from summaries?
    */
   final TypeProvider typeProvider;
 
   /**
    * Map of top level elements resynthesized from summaries.  The three map
    * keys are the first three elements of the element's location (the library
    * URI, the compilation unit URI, and the name of the top level declaration).
    */
   final Map<String, Map<String, Map<String, Element>>> _resynthesizedElements =
       <String, Map<String, Map<String, Element>>>{};
 
   /**
    * Map of libraries which have been resynthesized from summaries.  The map
    * key is the library URI.
    */
   final Map<String, LibraryElement> _resynthesizedLibraries =
       <String, LibraryElement>{};
 
-  SummaryResynthesizer(AnalysisContext context, this.getPrelinkedSummary,
-      this.getUnlinkedSummary, this.sourceFactory)
-      : super(context),
-        typeProvider = context.typeProvider;
+  SummaryResynthesizer(AnalysisContext context, this.typeProvider,
+      this.getPrelinkedSummary, this.getUnlinkedSummary, this.sourceFactory)
+      : super(context);
 
   /**
    * Number of libraries that have been resynthesized so far.
    */
   int get resynthesisCount => _resynthesizedLibraries.length;
 
   @override
   Element getElement(ElementLocation location) {
     if (location.components.length == 1) {
       return getLibraryElement(location.components[0]);
@@ skipping 71 matching lines @@
    * Unlinked compilation units constituting the library to be resynthesized.
    */
   final List<UnlinkedUnit> unlinkedUnits;
 
   /**
    * [Source] object for the library to be resynthesized.
    */
   final Source librarySource;
 
   /**
+   * Indicates whether [librarySource] is the `dart:core` library.
+   */
+  bool isCoreLibrary;
+
+  List<ClassElementImpl> delayedObjectSubclasses = <ClassElementImpl>[];

[Paul Berry, 2015/12/24 03:31:09]

Please add a doc comment for this field.  Perhaps something like:

Classes which should have their supertype set to "object" once resynthesis is
complete.  Only used if [isCoreLibrary] is `true`.

[scheglov, 2015/12/24 03:36:06]

Done.

+
+  /**
    * [ElementHolder] into which resynthesized elements should be placed.  This
    * object is recreated afresh for each unit in the library, and is used to
    * populate the [CompilationUnitElement].
    */
   ElementHolder unitHolder;
 
   /**
    * The [PrelinkedUnit] from which elements are currently being resynthesized.
    */
   PrelinkedUnit prelinkedUnit;
@@ skipping 12 matching lines @@
       <String, Map<String, Element>>{};
 
   /**
    * Type parameters for the class or typedef currently being resynthesized.
    *
    * TODO(paulberry): extend this to do the right thing for generic methods.
    */
   List<TypeParameterElement> currentTypeParameters;
 
   _LibraryResynthesizer(this.summaryResynthesizer, this.prelinkedLibrary,
-      this.unlinkedUnits, this.librarySource);
+      this.unlinkedUnits, this.librarySource) {
+    isCoreLibrary = librarySource.uri.toString() == 'dart:core';
+  }
 
   /**
    * Resynthesize a [ClassElement] and place it in [unitHolder].
    */
   void buildClass(UnlinkedClass serializedClass) {
     try {
       currentTypeParameters =
           serializedClass.typeParameters.map(buildTypeParameter).toList();
       for (int i = 0; i < serializedClass.typeParameters.length; i++) {
         finishTypeParameter(
             serializedClass.typeParameters[i], currentTypeParameters[i]);
       }
       ClassElementImpl classElement =
           new ClassElementImpl(serializedClass.name, -1);
       classElement.mixinApplication = serializedClass.isMixinApplication;
       InterfaceTypeImpl correspondingType = new InterfaceTypeImpl(classElement);
       if (serializedClass.supertype != null) {
         classElement.supertype = buildType(serializedClass.supertype);
       } else if (!serializedClass.hasNoSupertype) {
-        classElement.supertype = summaryResynthesizer.typeProvider.objectType;
+        if (isCoreLibrary) {
+          delayedObjectSubclasses.add(classElement);
+        } else {
+          classElement.supertype = summaryResynthesizer.typeProvider.objectType;
+        }
       }
       classElement.interfaces =
           serializedClass.interfaces.map(buildType).toList();
       classElement.mixins = serializedClass.mixins.map(buildType).toList();
       classElement.typeParameters = currentTypeParameters;
       ElementHolder memberHolder = new ElementHolder();
       bool constructorFound = false;
       for (UnlinkedExecutable serializedExecutable
           in serializedClass.executables) {
         switch (serializedExecutable.kind) {
@@ skipping 66 matching lines @@
     constructorElement.factory = serializedExecutable.isFactory;
     constructorElement.const2 = serializedExecutable.isConst;
     holder.addConstructor(constructorElement);
   }
 
   /**
    * Resynthesize the [ClassElement] corresponding to an enum, along with the
    * associated fields and implicit accessors.
    */
   void buildEnum(UnlinkedEnum serializedEnum) {
+    assert(!isCoreLibrary);
     // TODO(paulberry): add offset support (for this element type and others)
     ClassElementImpl classElement =
         new ClassElementImpl(serializedEnum.name, -1);
     classElement.enum2 = true;
     InterfaceType enumType = new InterfaceTypeImpl(classElement);
     classElement.type = enumType;
     classElement.supertype = summaryResynthesizer.typeProvider.objectType;
     ElementHolder memberHolder = new ElementHolder();
     FieldElementImpl indexField = new FieldElementImpl('index', -1);
     indexField.final2 = true;
@@ skipping 185 matching lines @@
       element.setter = setter;
     }
   }
 
   /**
    * Build the implicit field associated with a getter or setter, and place it
    * in [holder].
    */
   FieldElementImpl buildImplicitField(String name, DartType type,
       UnlinkedExecutableKind kind, ElementHolder holder) {
-    if (holder.getField(name) == null) {
-      FieldElementImpl field = new FieldElementImpl(name, -1);
+    FieldElementImpl field = holder.getField(name);
+    if (field == null) {
+      field = new FieldElementImpl(name, -1);
       field.synthetic = true;
       field.final2 = kind == UnlinkedExecutableKind.getter;
       field.type = type;
       holder.addField(field);
       return field;
     } else {
-      // TODO(paulberry): if adding a setter where there was previously
-      // only a getter, remove "final" modifier.
       // TODO(paulberry): what if the getter and setter have a type mismatch?
-      throw new UnimplementedError();
+      field.final2 = false;
+      return field;
     }
   }
 
   /**
    * Build the implicit top level variable associated with a getter or setter,
    * and place it in [holder].
    */
   PropertyInducingElementImpl buildImplicitTopLevelVariable(
       String name, UnlinkedExecutableKind kind, ElementHolder holder) {
     if (holder.getTopLevelVariable(name) == null) {
@@ skipping 70 matching lines @@
       imports.add(buildImport(unlinkedDefiningUnit.imports[i],
           prelinkedLibrary.importDependencies[i]));
     }
     libraryElement.imports = imports;
     libraryElement.exports =
         unlinkedDefiningUnit.exports.map(buildExport).toList();
     populateUnit(definingCompilationUnit, 0);
     for (int i = 0; i < parts.length; i++) {
       populateUnit(parts[i], i + 1);
     }
+    if (isCoreLibrary) {
+      ClassElement objectElement = libraryElement.getType('Object');
+      assert(objectElement != null);
+      for (ClassElementImpl classElement in delayedObjectSubclasses) {
+        classElement.supertype = objectElement.type;
+      }
+    }
     return libraryElement;
   }
 
   /**
    * Resynthesize a [ParameterElement].
    */
   ParameterElement buildParameter(UnlinkedParam serializedParameter) {
     ParameterElementImpl parameterElement =
         new ParameterElementImpl(serializedParameter.name, -1);
     if (serializedParameter.isFunctionTyped) {
@@ skipping 47 matching lines @@
   /**
    * Build a [DartType] object based on an [UnlinkedTypeRef].  This [DartType]
    * may refer to elements in other libraries than the library being
    * deserialized, so handles are used to avoid having to deserialize other
    * libraries in the process.
    */
   DartType buildType(UnlinkedTypeRef type) {
     if (type.paramReference != 0) {
       // TODO(paulberry): make this work for generic methods.
       return currentTypeParameters[
-          currentTypeParameters.length - type.paramReference].type;
+              currentTypeParameters.length - type.paramReference]
+          .type;
     } else {
       // TODO(paulberry): handle references to things other than classes (note:
       // this should only occur in the case of erroneous code).
       // TODO(paulberry): test reference to something inside a part.
       // TODO(paulberry): test reference to something inside a part of the
       // current lib.
       UnlinkedReference reference = unlinkedUnit.references[type.reference];
       PrelinkedReference referenceResolution =
           prelinkedUnit.references[type.reference];
       String referencedLibraryUri;
       String partUri;
       if (referenceResolution.dependency != 0) {
         PrelinkedDependency dependency =
             prelinkedLibrary.dependencies[referenceResolution.dependency];
         Source referencedLibrarySource = summaryResynthesizer.sourceFactory
             .resolveUri(librarySource, dependency.uri);
         referencedLibraryUri = referencedLibrarySource.uri.toString();
         // TODO(paulberry): consider changing Location format so that this is
         // not necessary (2nd string in location should just be the unit
         // number).
         if (referenceResolution.unit != 0) {
           UnlinkedUnit referencedLibraryDefiningUnit =
               summaryResynthesizer.getUnlinkedSummary(referencedLibraryUri);
-          String uri = referencedLibraryDefiningUnit.parts[0].uri;
+          String uri = referencedLibraryDefiningUnit
+              .parts[referenceResolution.unit - 1].uri;
           Source partSource = summaryResynthesizer.sourceFactory
               .resolveUri(referencedLibrarySource, uri);
           partUri = partSource.uri.toString();
         } else {
           partUri = referencedLibraryUri;
         }
       } else if (referenceResolution.kind ==
           PrelinkedReferenceKind.unresolved) {
         return summaryResynthesizer.typeProvider.undefinedType;
       } else if (reference.name.isEmpty) {
@@ skipping 161 matching lines @@
     }
     for (FunctionTypeAliasElement typeAlias in unit.functionTypeAliases) {
       elementMap[typeAlias.name] = typeAlias;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     prelinkedUnit = null;
     unlinkedUnit = null;
   }
 }