Add propagated types to summary files.

pkg/analyzer/lib/src/summary/summarize_elements.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 serialization.elements;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
@@ skipping 26 matching lines @@
     kind = ReferenceKind.classOrEnum;
   } else if (element is FunctionElement) {
     kind = ReferenceKind.topLevelFunction;
   } else {
     throw new Exception('Unexpected element kind: ${element.runtimeType}');
   }
   return kind;
 }
 
 /**
+ * Type of closures used by [_LibrarySerializer] to defer generation of
+ * [TypeRefBuilder] objects until the end of serialization of a
+ * compilation unit.
+ */
+typedef TypeRefBuilder _SerializeTypeRef();
+
+/**
  * Data structure holding the result of serializing a [LibraryElement].
  */
 class LibrarySerializationResult {
   /**
    * Linked information the given library.
    */
   final LinkedLibraryBuilder linked;
 
   /**
    * Unlinked information for the compilation units constituting the library.
@@ skipping 60 matching lines @@
    */
   List<UnlinkedReferenceBuilder> unlinkedReferences;
 
   /**
    * The linked portion of the "references table".  This is the list of
    * objects which should be written to [LinkedUnit.references].
    */
   List<LinkedReferenceBuilder> linkedReferences;
 
   /**
+   * The number of slot ids which have been assigned to this compilation unit.
+   */
+  int numSlots = 0;
+
+  /**
+   * List of closures which should be invoked at the end of serialization of a
+   * compilation unit, to produce [LinkedUnit.types].
+   */
+  final List<_SerializeTypeRef> deferredLinkedTypes = <_SerializeTypeRef>[];
+
+  /**
    * Index into the "references table" representing an unresolved reference, if
    * such an index exists.  `null` if no such entry has been made in the
    * references table yet.
    */
   int unresolvedReferenceIndex = null;
 
   _CompilationUnitSerializer(
       this.librarySerializer, this.compilationUnit, this.unitNum);
 
   /**
@@ skipping 105 matching lines @@
         }
       }
     }
     unlinkedUnit.variables = variables;
     unlinkedUnit.references = unlinkedReferences;
     linkedUnit.references = linkedReferences;
     unitUri = compilationUnit.source.uri.toString();
   }
 
   /**
+   * Create the [LinkedUnit.types] table based on deferred types that were
+   * found during [addCompilationUnitElements].
+   */
+  void createLinkedTypes() {
+    linkedUnit.types = deferredLinkedTypes
+        .map((_SerializeTypeRef closure) => closure())
+        .toList();
+  }
+
+  /**
    * Compute the appropriate De Bruijn index to represent the given type
    * parameter [type].
    */
   int findTypeParameterIndex(TypeParameterType type, Element context) {
     int index = 0;
     while (context != null) {
       List<TypeParameterElement> typeParameters;
       if (context is ClassElement) {
         typeParameters = context.typeParameters;
       } else if (context is FunctionTypeAliasElement) {
         typeParameters = context.typeParameters;
       } else if (context is ExecutableElement) {
         typeParameters = context.typeParameters;
       }
       if (typeParameters != null) {
         for (int i = 0; i < typeParameters.length; i++) {
           TypeParameterElement param = typeParameters[i];
           if (param == type.element) {
             return index + typeParameters.length - i;
           }
         }
         index += typeParameters.length;
       }
       context = context.enclosingElement;
     }
     throw new StateError('Unbound type parameter $type');
   }
 
   /**
+   * Get the type arguments for the given [type], or `null` if the type has no
+   * type arguments.
+   *
+   * TODO(paulberry): consider adding an abstract getter to [DartType] to do
+   * this.
+   */
+  List<DartType> getTypeArguments(DartType type) {
+    if (type is InterfaceType) {
+      return type.typeArguments;
+    } else if (type is FunctionType) {
+      return type.typeArguments;
+    } else {
+      return null;
+    }
+  }
+
+  /**
    * Serialize the given [classElement], creating an [UnlinkedClass].
    */
   UnlinkedClassBuilder serializeClass(ClassElement classElement) {
     UnlinkedClassBuilder b = new UnlinkedClassBuilder();
     b.name = classElement.name;
     b.nameOffset = classElement.nameOffset;
     b.typeParameters =
         classElement.typeParameters.map(serializeTypeParam).toList();
     if (classElement.supertype == null) {
       b.hasNoSupertype = true;
@@ skipping 237 matching lines @@
       assert(unlinkedReferences.length == linkedReferences.length);
       int index = unlinkedReferences.length;
       unlinkedReferences.add(new UnlinkedReferenceBuilder(name: element.name));
       linkedReferences
           .add(new LinkedReferenceBuilder(kind: ReferenceKind.prefix));
       return index;
     });
   }
 
   /**
+   * Compute the reference index which should be stored in a [TypeRef].
+   *
+   * If [linked] is true, and a new reference has to be created, the reference
+   * will only be stored in [linkedReferences].
+   */
+  int serializeReferenceForType(DartType type, bool linked) {
+    Element element = type.element;
+    LibraryElement dependentLibrary = element.library;
+    if (dependentLibrary == null) {
+      assert(type.isDynamic);
+      if (type is UndefinedTypeImpl) {
+        return serializeUnresolvedReference();
+      } else {
+        return serializeDynamicReference();
+      }
+    } else {
+      return _getElementReferenceId(element, linked: linked);
+    }
+  }
+
+  /**
    * Serialize the given [typedefElement], creating an [UnlinkedTypedef].
    */
   UnlinkedTypedefBuilder serializeTypedef(
       FunctionTypeAliasElement typedefElement) {
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder();
     b.name = typedefElement.name;
     b.nameOffset = typedefElement.nameOffset;
     b.typeParameters =
         typedefElement.typeParameters.map(serializeTypeParam).toList();
     if (!typedefElement.returnType.isVoid) {
@@ skipping 13 matching lines @@
     UnlinkedTypeParamBuilder b = new UnlinkedTypeParamBuilder();
     b.name = typeParameter.name;
     b.nameOffset = typeParameter.nameOffset;
     if (typeParameter.bound != null) {
       b.bound = serializeTypeRef(typeParameter.bound, typeParameter);
     }
     return b;
   }
 
   /**
-   * Serialize the given [type] into a [TypeRef].
+   * Serialize the given [type] into a [TypeRef].  If [slot] is provided,
+   * it should be included in the [TypeRef].  If [linked] is true, any
+   * references that are created will be populated into [linkedReferences] but
+   * [not [unlinkedReferences].
+   *
+   * [context] is the element within which the [TypeRef] will be
+   * interpreted; this is used to serialize type parameters.
    */
-  TypeRefBuilder serializeTypeRef(DartType type, Element context) {
-    TypeRefBuilder b = new TypeRefBuilder();
+  TypeRefBuilder serializeTypeRef(DartType type, Element context,
+      {bool linked: false, int slot}) {
+    TypeRefBuilder b = new TypeRefBuilder(slot: slot);
     if (type is TypeParameterType) {
       b.paramReference = findTypeParameterIndex(type, context);
     } else {
-      Element element = type.element;
-      LibraryElement dependentLibrary = element.library;
-      if (dependentLibrary == null) {
-        assert(type.isDynamic);
-        if (type is UndefinedTypeImpl) {
-          b.reference = serializeUnresolvedReference();
-        } else {
-          b.reference = serializeDynamicReference();
-        }
-      } else {
-        b.reference = _getElementReferenceId(element);
-      }
-      List<DartType> typeArguments;
-      if (type is InterfaceType) {
-        typeArguments = type.typeArguments;
-      } else if (type is FunctionType) {
-        typeArguments = type.typeArguments;
-      }
+      b.reference = serializeReferenceForType(type, linked);
+      List<DartType> typeArguments = getTypeArguments(type);
       if (typeArguments != null) {
         // Trailing type arguments of type 'dynamic' should be omitted.
         int numArgsToSerialize = typeArguments.length;
         while (numArgsToSerialize > 0 &&
             typeArguments[numArgsToSerialize - 1].isDynamic) {
           --numArgsToSerialize;
         }
         if (numArgsToSerialize > 0) {
           List<TypeRefBuilder> serializedArguments = <TypeRefBuilder>[];
           for (int i = 0; i < numArgsToSerialize; i++) {
-            serializedArguments
-                .add(serializeTypeRef(typeArguments[i], context));
+            serializedArguments.add(
+                serializeTypeRef(typeArguments[i], context, linked: linked));
           }
           b.typeArguments = serializedArguments;
         }
       }
     }
     return b;
   }
 
   /**
    * Return the index of the entry in the references table
@@ skipping 30 matching lines @@
     b.isConst = variable.isConst;
     b.hasImplicitType = variable.hasImplicitType;
     b.documentationComment = serializeDocumentation(variable);
     if (variable.isConst && variable is ConstVariableElement) {
       ConstVariableElement constVariable = variable as ConstVariableElement;
       Expression initializer = constVariable.constantInitializer;
       if (initializer != null) {
         b.constExpr = serializeConstExpr(initializer);
       }
     }
+    if (b.isFinal || b.isConst) {
+      b.propagatedTypeSlot = storeLinkedType(variable.propagatedType, variable);
+    } else {
+      // Variable is not propagable.
+      assert(variable.propagatedType == null);
+    }
     return b;
   }
 
-  int _getElementReferenceId(Element element) {
+  /**
+   * Create a slot id for the given [type] (which may be either a propagated
+   * type or an inferred type).  If [type] is not `null`, it is stored in
+   * [linkedTypes] so that once the compilation unit has been fully visited,
+   * it will be serialized to [LinkedUnit.types].
+   *
+   * [context] is the element within which the slot id will appear; this is
+   * used to serialize type parameters.
+   */
+  int storeLinkedType(DartType type, Element context) {
+    int slot = ++numSlots;
+    if (type != null) {
+      deferredLinkedTypes
+          .add(() => serializeTypeRef(type, context, linked: true, slot: slot));
+    }
+    return slot;
+  }
+
+  int _getElementReferenceId(Element element, {bool linked: false}) {
     LibraryElement dependentLibrary = element.library;
     return referenceMap.putIfAbsent(element, () {
-      assert(unlinkedReferences.length == linkedReferences.length);
       CompilationUnitElement unitElement =
           element.getAncestor((Element e) => e is CompilationUnitElement);
       int unit = dependentLibrary.units.indexOf(unitElement);
       assert(unit != -1);
       int numTypeParameters = 0;
       if (element is TypeParameterizedElement) {
         numTypeParameters = element.typeParameters.length;
       }
-      // Figure out a prefix that may be used to refer to the given type.
-      // TODO(paulberry): to avoid subtle relinking inconsistencies we
-      // should use the actual prefix from the AST (a given type may be
-      // reachable via multiple prefixes), but sadly, this information is
-      // not recorded in the element model.
-      int prefixReference = 0;
-      PrefixElement prefix = librarySerializer.prefixMap[element];
-      if (prefix != null) {
-        prefixReference = serializePrefix(prefix);
-      }
-      int index = unlinkedReferences.length;
-      unlinkedReferences.add(new UnlinkedReferenceBuilder(
-          name: element.name, prefixReference: prefixReference));
-      linkedReferences.add(new LinkedReferenceBuilder(
+      LinkedReferenceBuilder linkedReference = new LinkedReferenceBuilder(
           dependency: librarySerializer.serializeDependency(dependentLibrary),
           kind: _getReferenceKind(element),
           unit: unit,
-          numTypeParameters: numTypeParameters));
+          numTypeParameters: numTypeParameters);
+      if (linked) {
+        linkedReference.name = element.name;
+      } else {
+        assert(unlinkedReferences.length == linkedReferences.length);
+        // Figure out a prefix that may be used to refer to the given type.
+        // TODO(paulberry): to avoid subtle relinking inconsistencies we
+        // should use the actual prefix from the AST (a given type may be
+        // reachable via multiple prefixes), but sadly, this information is
+        // not recorded in the element model.
+        int prefixReference = 0;
+        PrefixElement prefix = librarySerializer.prefixMap[element];
+        if (prefix != null) {
+          prefixReference = serializePrefix(prefix);
+        }
+        unlinkedReferences.add(new UnlinkedReferenceBuilder(
+            name: element.name, prefixReference: prefixReference));
+      }
+      int index = linkedReferences.length;
+      linkedReferences.add(linkedReference);
       return index;
     });
   }
 }
 
 /**
  * Instances of this class keep track of intermediate state during
  * serialization of a single constant [Expression].
  */
 class _ConstExprSerializer extends AbstractConstExprSerializer {
@@ skipping 162 matching lines @@
           new _CompilationUnitSerializer(this, libraryElement.parts[i], i + 1));
     }
     for (_CompilationUnitSerializer compilationUnitSerializer
         in compilationUnitSerializers) {
       compilationUnitSerializer.addCompilationUnitElements();
     }
     pb.units = compilationUnitSerializers
         .map((_CompilationUnitSerializer s) => s.linkedUnit)
         .toList();
     pb.dependencies = dependencies;
+    pb.numPrelinkedDependencies = dependencies.length;
+    for (_CompilationUnitSerializer compilationUnitSerializer
+        in compilationUnitSerializers) {
+      compilationUnitSerializer.createLinkedTypes();
+    }
     pb.importDependencies = linkedImports;
     List<String> exportedNames =
         libraryElement.exportNamespace.definedNames.keys.toList();
     exportedNames.sort();
     List<LinkedExportNameBuilder> exportNames = <LinkedExportNameBuilder>[];
     for (String name in exportedNames) {
       if (libraryElement.publicNamespace.definedNames.containsKey(name)) {
         continue;
       }
       Element element = libraryElement.exportNamespace.get(name);
       LibraryElement dependentLibrary = element.library;
       CompilationUnitElement unitElement =
           element.getAncestor((Element e) => e is CompilationUnitElement);
       int unit = dependentLibrary.units.indexOf(unitElement);
       assert(unit != -1);
       ReferenceKind kind = _getReferenceKind(element);
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }