Add support for ConstructorElementImpl.isCycleFree to summaries.

pkg/analyzer/lib/src/summary/summarize_ast.dart

 // Copyright (c) 2016, 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.summarize_ast;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
@@ skipping 278 matching lines @@
    * The number of slot ids which have been assigned to this compilation unit.
    */
   int numSlots = 0;
 
   /**
    * The [Block] that is being visited now, or `null` for non-local contexts.
    */
   Block enclosingBlock = null;
 
   /**
-   * Create a slot id for storing a propagated or inferred type.
+   * Create a slot id for storing a propagated or inferred type or const cycle
+   * info.
    */
-  int assignTypeSlot() => ++numSlots;
+  int assignSlot() => ++numSlots;
 
   /**
    * Build a [_Scope] object containing the names defined within the body of a
    * class declaration.
    */
   _Scope buildClassMemberScope(
       String className, NodeList<ClassMember> members) {
     _Scope scope = new _Scope();
     for (ClassMember member in members) {
       if (member is MethodDeclaration) {
@@ skipping 210 matching lines @@
     b.isExternal = isExternal;
     bool isSemanticallyStatic = isTopLevel || isDeclaredStatic;
     if (formalParameters != null) {
       b.parameters = formalParameters.parameters
           .map((FormalParameter p) => p.accept(this))
           .toList();
       if (!isSemanticallyStatic) {
         for (int i = 0; i < formalParameters.parameters.length; i++) {
           if (!b.parameters[i].isFunctionTyped &&
               b.parameters[i].type == null) {
-            b.parameters[i].inferredTypeSlot = assignTypeSlot();
+            b.parameters[i].inferredTypeSlot = assignSlot();
           }
         }
       }
     }
     b.documentationComment = serializeDocumentation(documentationComment);
     b.annotations = serializeAnnotations(annotations);
     if (returnType == null && !isSemanticallyStatic) {
-      b.inferredReturnTypeSlot = assignTypeSlot();
+      b.inferredReturnTypeSlot = assignSlot();
     }
     b.visibleOffset = enclosingBlock?.offset;
     b.visibleLength = enclosingBlock?.length;
     serializeFunctionBody(b, body);
     scopes.removeLast();
     assert(scopes.length == oldScopesLength);
     return b;
   }
 
   /**
@@ skipping 43 matching lines @@
    * [UnlinkedExecutableBuilder], otherwise return `null`.
    */
   UnlinkedExecutableBuilder serializeInitializerFunction(
       Expression expression) {
     if (expression == null) {
       return null;
     }
     UnlinkedExecutableBuilder initializer =
         new UnlinkedExecutableBuilder(nameOffset: expression.offset);
     serializeFunctionBody(initializer, expression);
-    initializer.inferredReturnTypeSlot = assignTypeSlot();
+    initializer.inferredReturnTypeSlot = assignSlot();
     return initializer;
   }
 
   /**
    * Serialize a [FieldFormalParameter], [FunctionTypedFormalParameter], or
    * [SimpleFormalParameter] into an [UnlinkedParam].
    */
   UnlinkedParamBuilder serializeParameter(NormalFormalParameter node) {
     UnlinkedParamBuilder b = new UnlinkedParamBuilder();
     b.name = node.identifier.name;
@@ skipping 158 matching lines @@
       b.annotations = serializeAnnotations(annotations);
       if (variable.isConst ||
           variable.isFinal && isField && !isDeclaredStatic) {
         Expression initializer = variable.initializer;
         if (initializer != null) {
           b.constExpr = serializeConstExpr(initializer);
         }
       }
       if (variable.initializer != null &&
           (variables.isFinal || variables.isConst)) {
-        b.propagatedTypeSlot = assignTypeSlot();
+        b.propagatedTypeSlot = assignSlot();
       }
       bool isSemanticallyStatic = !isField || isDeclaredStatic;
       if (variables.type == null &&
           (variable.initializer != null || !isSemanticallyStatic)) {
-        b.inferredTypeSlot = assignTypeSlot();
+        b.inferredTypeSlot = assignSlot();
       }
       b.visibleOffset = enclosingBlock?.offset;
       b.visibleLength = enclosingBlock?.length;
       b.initializer = serializeInitializerFunction(variable.initializer);
       this.variables.add(b);
     }
   }
 
   @override
   void visitBlock(Block node) {
@@ skipping 61 matching lines @@
                 node.redirectedConstructor.name);
       }
     } else {
       for (ConstructorInitializer initializer in node.initializers) {
         if (initializer is RedirectingConstructorInvocation) {
           b.isRedirectedConstructor = true;
           b.redirectedConstructorName = initializer.constructorName?.name;
         }
       }
     }
-    b.isConst = node.constKeyword != null;
+    if (node.constKeyword != null) {
+      b.isConst = true;
+      b.constCycleSlot = assignSlot();
+    }
     b.isExternal = node.externalKeyword != null;
     b.documentationComment = serializeDocumentation(node.documentationComment);
     b.annotations = serializeAnnotations(node.metadata);
     if (node.constKeyword != null) {
       Set<String> constructorParameterNames =
           node.parameters.parameters.map((p) => p.identifier.name).toSet();
       b.constantInitializers = node.initializers
           .map((ConstructorInitializer initializer) =>
               serializeConstructorInitializer(initializer, (Expression expr) {
                 return serializeConstExpr(expr, constructorParameterNames);
@@ skipping 246 matching lines @@
 /**
  * A [_TypeParameterScope] is a [_Scope] which defines [_ScopedTypeParameter]s.
  */
 class _TypeParameterScope extends _Scope {
   /**
    * Get the number of [_ScopedTypeParameter]s defined in this
    * [_TypeParameterScope].
    */
   int get length => _definedNames.length;
 }