Add support for ConstructorElementImpl.isCycleFree to summaries.

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 827 matching lines @@
    */
   UnlinkedUnit unlinkedUnit;
 
   /**
    * Map from slot id to the corresponding [EntityRef] object for linked types
    * (i.e. propagated and inferred types).
    */
   Map<int, EntityRef> linkedTypeMap;
 
   /**
+   * Set of slot ids corresponding to const constructors that are part of
+   * cycles.
+   */
+  Set<int> constCycles;
+
+  /**
    * The [CompilationUnitElementImpl] for the compilation unit currently being
    * resynthesized.
    */
   CompilationUnitElementImpl currentCompilationUnit;
 
   /**
    * The [ConstructorElementImpl] for the constructor currently being
    * resynthesized.
    */
   ConstructorElementImpl currentConstructor;
@@ skipping 211 matching lines @@
   /**
    * Resynthesize a [ConstructorElement] and place it in the given [holder].
    * [classType] is the type of the class for which this element is a
    * constructor.
    */
   void buildConstructor(UnlinkedExecutable serializedExecutable,
       ElementHolder holder, InterfaceType classType) {
     assert(serializedExecutable.kind == UnlinkedExecutableKind.constructor);
     currentConstructor = new ConstructorElementImpl(
         serializedExecutable.name, serializedExecutable.nameOffset);
+    currentConstructor.isCycleFree = serializedExecutable.isConst &&
+        !constCycles.contains(serializedExecutable.constCycleSlot);
     if (serializedExecutable.name.isEmpty) {
       currentConstructor.nameEnd =
           serializedExecutable.nameOffset + classType.name.length;
     } else {
       currentConstructor.nameEnd = serializedExecutable.nameEnd;
       currentConstructor.periodOffset = serializedExecutable.periodOffset;
     }
     constructors[serializedExecutable.name] = currentConstructor;
     currentConstructor.returnType = classType;
     buildExecutableCommonParts(currentConstructor, serializedExecutable);
@@ skipping 865 matching lines @@
 
   /**
    * Tear down data structures used during deserialization of a compilation
    * unit.
    */
   void finishUnit() {
     unitHolder = null;
     linkedUnit = null;
     unlinkedUnit = null;
     linkedTypeMap = null;
+    constCycles = null;
     referenceInfos = null;
     currentCompilationUnit = null;
   }
 
   /**
    * Return a list of type arguments corresponding to [currentTypeParameters],
    * skipping the innermost [skipLevels] nesting levels.
    *
    * Type parameters are listed in nesting order from innermost to outermost,
    * and then in declaration order.  So for instance if we are resynthesizing a
@@ skipping 230 matching lines @@
    * Set up data structures for deserializing a compilation unit.
    */
   void prepareUnit(CompilationUnitElementImpl unit, int unitNum) {
     linkedUnit = linkedLibrary.units[unitNum];
     unlinkedUnit = unlinkedUnits[unitNum];
     linkedTypeMap = <int, EntityRef>{};
     currentCompilationUnit = unit;
     for (EntityRef t in linkedUnit.types) {
       linkedTypeMap[t.slot] = t;
     }
+    constCycles = linkedUnit.constCycles.toSet();
     populateReferenceInfos();
     unitHolder = new ElementHolder();
   }
 
   /**
    * Constructor initializers can reference fields and other constructors of
    * the same class, including forward references. So, we need to delay
    * resolution until after class elements are built.
    */
   void resolveConstructorInitializers(ClassElementImpl classElement) {
@@ skipping 223 matching lines @@
     List<DartType> typeArguments = const <DartType>[];
     if (numTypeArguments != 0) {
       typeArguments = <DartType>[];
       for (int i = 0; i < numTypeArguments; i++) {
         typeArguments.add(getTypeArgument(i));
       }
     }
     return typeArguments;
   }
 }