Add propagated types to summary files.

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/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 244 matching lines @@
    * The [LinkedUnit] from which elements are currently being resynthesized.
    */
   LinkedUnit linkedUnit;
 
   /**
    * The [UnlinkedUnit] from which elements are currently being resynthesized.
    */
   UnlinkedUnit unlinkedUnit;
 
   /**
+   * Map from slot id to the corresponding [TypeRef] object for linked types
+   * (i.e. propagated and inferred types).
+   */
+  Map<int, TypeRef> linkedTypeMap;
+
+  /**
    * Map of top level elements that have been resynthesized so far.  The first
    * key is the URI of the compilation unit; the second is the name of the top
    * level element.
    */
   final Map<String, Map<String, Element>> resummarizedElements =
       <String, Map<String, Element>>{};
 
   /**
    * Type parameters for the generic class, typedef, or executable currently
    * being resynthesized, if any.  If multiple entities with type parameters
@@ skipping 578 matching lines @@
     // 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;
   }
 
   /**
+   * Build the appropriate [DartType] object corresponding to a slot id in the
+   * [LinkedUnit.types] table.
+   */
+  DartType buildLinkedType(int slot) {
+    if (slot == 0) {
+      // A slot id of 0 means there is no [DartType] object to build.
+      return null;
+    }
+    TypeRef type = linkedTypeMap[slot];
+    if (type == null) {
+      // A missing entry in [LinkedUnit.types] means there is no [DartType]
+      // stored in this slot.
+      return null;
+    }
+    return buildType(type);
+  }
+
+  /**
    * Resynthesize a [ParameterElement].
    */
   ParameterElement buildParameter(UnlinkedParam serializedParameter) {
     ParameterElementImpl parameterElement;
     if (serializedParameter.isInitializingFormal) {
       parameterElement = new FieldFormalParameterElementImpl.forNameAndOffset(
           serializedParameter.name, serializedParameter.nameOffset)
         ..field = fields[serializedParameter.name];
     } else {
       parameterElement = new ParameterElementImpl(
@@ skipping 67 matching lines @@
     if (type.paramReference != 0) {
       // TODO(paulberry): make this work for generic methods.
       return currentTypeParameters[
           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];
       LinkedReference referenceResolution =
           linkedUnit.references[type.reference];
+      String name;
+      if (type.reference < unlinkedUnit.references.length) {
+        name = unlinkedUnit.references[type.reference].name;
+      } else {
+        name = referenceResolution.name;
+      }
       ElementLocationImpl location;
       if (referenceResolution.dependency != 0) {
         location = getReferencedLocation(
             linkedLibrary.dependencies[referenceResolution.dependency],
             referenceResolution.unit,
-            reference.name);
+            name);
       } else if (referenceResolution.kind == ReferenceKind.unresolved) {
         return summaryResynthesizer.typeProvider.undefinedType;
-      } else if (reference.name.isEmpty) {
+      } else if (name.isEmpty) {
         return summaryResynthesizer.typeProvider.dynamicType;
       } else {
         String referencedLibraryUri = librarySource.uri.toString();
         String partUri;
         if (referenceResolution.unit != 0) {
           String uri = unlinkedUnits[0].publicNamespace.parts[
               referenceResolution.unit - 1];
           Source partSource =
               summaryResynthesizer.sourceFactory.resolveUri(librarySource, uri);
           partUri = partSource.uri.toString();
         } else {
           partUri = referencedLibraryUri;
         }
         location = new ElementLocationImpl.con3(
-            <String>[referencedLibraryUri, partUri, reference.name]);
+            <String>[referencedLibraryUri, partUri, name]);
       }
       List<DartType> typeArguments = const <DartType>[];
       if (referenceResolution.numTypeParameters != 0) {
         typeArguments = <DartType>[];
         for (int i = 0; i < referenceResolution.numTypeParameters; i++) {
           if (i < type.typeArguments.length) {
             typeArguments.add(buildType(type.typeArguments[i]));
           } else {
             typeArguments.add(summaryResynthesizer.typeProvider.dynamicType);
           }
         }
       }
       switch (referenceResolution.kind) {
         case ReferenceKind.classOrEnum:
           return new InterfaceTypeImpl.elementWithNameAndArgs(
               new ClassElementHandle(summaryResynthesizer, location),
-              reference.name,
+              name,
               typeArguments);
         case ReferenceKind.typedef:
           return new FunctionTypeImpl.elementWithNameAndArgs(
               new FunctionTypeAliasElementHandle(
                   summaryResynthesizer, location),
-              reference.name,
+              name,
               typeArguments,
               typeArguments.isNotEmpty);
         default:
           // TODO(paulberry): figure out how to handle this case (which should
           // only occur in the event of erroneous code).
           throw new UnimplementedError();
       }
     }
   }
 
@@ skipping 72 matching lines @@
 
   /**
    * Handle the parts that are common to top level variables and fields.
    */
   void buildVariableCommonParts(PropertyInducingElementImpl element,
       UnlinkedVariable serializedVariable) {
     element.type = buildType(serializedVariable.type);
     element.const3 = serializedVariable.isConst;
     element.final2 = serializedVariable.isFinal;
     element.hasImplicitType = serializedVariable.hasImplicitType;
+    element.propagatedType =
+        buildLinkedType(serializedVariable.propagatedTypeSlot);
     buildDocumentation(element, serializedVariable.documentationComment);
   }
 
   /**
    * Finish creating a [TypeParameterElement] by deserializing its bound.
    */
   void finishTypeParameter(UnlinkedTypeParam serializedTypeParameter,
       TypeParameterElementImpl typeParameterElement) {
     if (serializedTypeParameter.bound != null) {
       typeParameterElement.bound = buildType(serializedTypeParameter.bound);
@@ skipping 28 matching lines @@
         <String>[referencedLibraryUri, partUri, name]);
   }
 
   /**
    * Populate a [CompilationUnitElement] by deserializing all the elements
    * contained in it.
    */
   void populateUnit(CompilationUnitElementImpl unit, int unitNum) {
     linkedUnit = linkedLibrary.units[unitNum];
     unlinkedUnit = unlinkedUnits[unitNum];
+    linkedTypeMap = <int, TypeRef>{};
+    for (TypeRef t in linkedUnit.types) {
+      linkedTypeMap[t.slot] = t;
+    }
     unitHolder = new ElementHolder();
     unlinkedUnit.classes.forEach(buildClass);
     unlinkedUnit.enums.forEach(buildEnum);
     unlinkedUnit.executables.forEach(buildExecutable);
     unlinkedUnit.typedefs.forEach(buildTypedef);
     unlinkedUnit.variables.forEach(buildVariable);
     String absoluteUri = unit.source.uri.toString();
     unit.accessors = unitHolder.accessors;
     unit.enums = unitHolder.enums;
     unit.functions = unitHolder.functions;
@@ skipping 19 matching lines @@
     for (FunctionElement function in unit.functions) {
       elementMap[function.name] = function;
     }
     for (PropertyAccessorElementImpl accessor in unit.accessors) {
       elementMap[accessor.identifier] = accessor;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     linkedUnit = null;
     unlinkedUnit = null;
+    linkedTypeMap = null;
   }
 }