Add support for ConstructorElementImpl.isCycleFree to summaries.

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 'dart:convert';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 228 matching lines @@
    */
   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>[];
 
   /**
+   * List which should be stored in [LinkedUnit.constCycles].
+   */
+  final List<int> constCycles = <int>[];
+
+  /**
    * 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;
 
   /**
    * Index into the "references table" representing the "bottom" type, if such
    * an index exists.  `null` if no such entry has been made in the references
    * table yet.
@@ skipping 128 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].
+   * found during [addCompilationUnitElements].  Also populate
+   * [LinkedUnit.constCycles].
    */
-  void createLinkedTypes() {
+  void createLinkedInfo() {
     buildingLinkedReferences = true;
     linkedUnit.types = deferredLinkedTypes
         .map((_SerializeTypeRef closure) => closure())
         .toList();
+    linkedUnit.constCycles = constCycles;
     buildingLinkedReferences = false;
   }
 
   /**
    * Compute the appropriate De Bruijn index to represent the given type
    * parameter [type].
    */
   int findTypeParameterIndex(TypeParameterType type, Element context) {
     Element originalContext = context;
     int index = 0;
@@ skipping 285 matching lines @@
                 unit: typeLinkedRef.unit, prefixReference: typeId);
             b.redirectedConstructor = new EntityRefBuilder(
                 reference: refId, typeArguments: typeRef.typeArguments);
           } else {
             b.redirectedConstructor = typeRef;
           }
         } else {
           b.redirectedConstructorName = redirectedConstructor.name;
         }
       }
-      if (executableElement.isConst &&
-          executableElement.constantInitializers != null) {
-        Set<String> constructorParameterNames =
-            executableElement.parameters.map((p) => p.name).toSet();
-        b.constantInitializers = executableElement.constantInitializers
-            .map((ConstructorInitializer initializer) =>
-                serializeConstructorInitializer(
-                    initializer,
-                    (expr) =>
-                        serializeConstExpr(expr, constructorParameterNames)))
-            .toList();
+      if (executableElement.isConst) {
+        b.constCycleSlot = storeConstCycle(!executableElement.isCycleFree);
+        if (executableElement.constantInitializers != null) {
+          Set<String> constructorParameterNames =
+              executableElement.parameters.map((p) => p.name).toSet();
+          b.constantInitializers = executableElement.constantInitializers
+              .map((ConstructorInitializer initializer) =>
+                  serializeConstructorInitializer(
+                      initializer,
+                      (expr) =>
+                          serializeConstExpr(expr, constructorParameterNames)))
+              .toList();
+        }
       }
     } else {
       b.kind = UnlinkedExecutableKind.functionOrMethod;
     }
     b.isAbstract = executableElement.isAbstract;
     b.isStatic = executableElement.isStatic &&
         executableElement.enclosingElement is ClassElement;
     b.isExternal = executableElement.isExternal;
     b.documentationComment = serializeDocumentation(executableElement);
     b.annotations = serializeAnnotations(executableElement);
@@ skipping 367 matching lines @@
    * [LinkedUnit.types].
    *
    * [context] is the element within which the slot id will appear; this is
    * used to serialize type parameters.
    */
   int storeInferredType(DartType type, Element context) {
     return storeLinkedType(type.isDynamic ? null : type, context);
   }
 
   /**
+   * Create a new slot id and return it.  If [hasCycle] is `true`, arrange for
+   * the slot id to be included in [LinkedUnit.constCycles].
+   */
+  int storeConstCycle(bool hasCycle) {
+    int slot = ++numSlots;
+    if (hasCycle) {
+      constCycles.add(slot);
+    }
+    return slot;
+  }
+
+  /**
    * 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;
@@ skipping 398 matching lines @@
         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();
+      compilationUnitSerializer.createLinkedInfo();
     }
     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;
   }
 }