Add support for ConstructorElementImpl.isCycleFree to summaries.

pkg/analyzer/test/src/summary/resynthesize_test.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 test.src.serialization.elements_test;
 
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 21 matching lines @@
 main() {
   groupSep = ' | ';
   runReflectiveTests(ResynthTest);
 }
 
 @reflectiveTest
 class ResynthTest extends ResolverTestCase {
   Set<Source> otherLibrarySources = new Set<Source>();
   bool constantInitializersAreInvalid = false;
 
-  /**
-   * Determine the analysis options that should be used for this test.
-   */
-  AnalysisOptionsImpl createOptions() =>
-      new AnalysisOptionsImpl()..enableGenericMethods = true;
-
   void addLibrary(String uri) {
     otherLibrarySources.add(analysisContext2.sourceFactory.forUri(uri));
   }
 
   void addLibrarySource(String filePath, String contents) {
     otherLibrarySources.add(addNamedSource(filePath, contents));
   }
 
   /**
    * Verify that the given prefix is safe to elide from a resynthesized AST.
@@ skipping 393 matching lines @@
         compareConstAstLists(
             r.typeArguments?.arguments, o.typeArguments?.arguments, desc);
         compareConstAstLists(r.entries, o.entries, desc);
       } else if (o is InstanceCreationExpression &&
           r is InstanceCreationExpression) {
         compareElements(r.staticElement, o.staticElement, desc);
         ConstructorName oConstructor = o.constructorName;
         ConstructorName rConstructor = r.constructorName;
         expect(oConstructor, isNotNull, reason: desc);
         expect(rConstructor, isNotNull, reason: desc);
-        compareConstructorElements(
+        // Note: just compare rConstructor.staticElement and
+        // oConstructor.staticElement as elements, because we just want to
+        // check that they're pointing to the correct elements; we don't want
+        // to check that their constructor initializers match, because that
+        // could lead to infinite regress.
+        compareElements(
             rConstructor.staticElement, oConstructor.staticElement, desc);
         TypeName oType = oConstructor.type;
         TypeName rType = rConstructor.type;
         expect(oType, isNotNull, reason: desc);
         expect(rType, isNotNull, reason: desc);
         compareConstAsts(rType.name, oType.name, desc);
         compareConstAsts(rConstructor.name, oConstructor.name, desc);
         compareConstAstLists(rType.typeArguments?.arguments,
             oType.typeArguments?.arguments, desc);
         compareConstAstLists(
@@ skipping 38 matching lines @@
       }
     }
   }
 
   void compareConstructorElements(ConstructorElement resynthesized,
       ConstructorElement original, String desc) {
     if (original == null && resynthesized == null) {
       return;
     }
     compareExecutableElements(resynthesized, original, desc);
+    ConstructorElementImpl resynthesizedImpl =
+        getActualElement(resynthesized, desc);
+    ConstructorElementImpl originalImpl = getActualElement(original, desc);
     if (original.isConst) {
-      ConstructorElementImpl resynthesizedImpl =
-          getActualElement(resynthesized, desc);
-      ConstructorElementImpl originalImpl = getActualElement(original, desc);
       compareConstAstLists(resynthesizedImpl.constantInitializers,
           originalImpl.constantInitializers, desc);
     }
     if (original.redirectedConstructor == null) {
       expect(resynthesized.redirectedConstructor, isNull, reason: desc);
     } else {
       compareConstructorElements(resynthesized.redirectedConstructor,
           original.redirectedConstructor, '$desc redirectedConstructor');
     }
     checkPossibleMember(resynthesized, original, desc);
     expect(resynthesized.nameEnd, original.nameEnd, reason: desc);
     expect(resynthesized.periodOffset, original.periodOffset, reason: desc);
+    expect(resynthesizedImpl.isCycleFree, originalImpl.isCycleFree,
+        reason: desc);
   }
 
   void compareConstValues(
       DartObject resynthesized, DartObject original, String desc) {
     if (original == null) {
       expect(resynthesized, isNull, reason: desc);
     } else {
       expect(resynthesized, isNotNull, reason: desc);
       compareTypes(resynthesized.type, original.type, desc);
       expect(resynthesized.hasKnownValue, original.hasKnownValue, reason: desc);
@@ skipping 478 matching lines @@
           compareConstAsts(initializer, originalActual.constantInitializer,
               '$desc initializer');
         }
       }
     }
     checkPossibleMember(resynthesized, original, desc);
     checkPossibleLocalElements(resynthesized, original);
   }
 
   /**
+   * Determine the analysis options that should be used for this test.
+   */
+  AnalysisOptionsImpl createOptions() =>
+      new AnalysisOptionsImpl()..enableGenericMethods = true;
+
+  /**
    * Serialize the given [library] into a summary.  Then create a
    * [_TestSummaryResynthesizer] which can deserialize it, along with any
    * references it makes to `dart:core`.
    *
    * Errors will lead to a test failure unless [allowErrors] is `true`.
    */
   _TestSummaryResynthesizer encodeLibrary(LibraryElementImpl library,
       {bool allowErrors: false, bool dumpSummaries: false}) {
     if (!allowErrors) {
       assertNoErrors(library.source);
@@ skipping 1462 matching lines @@
 
   test_constructor_redirected_thisInvocation_unnamed_generic() {
     checkLibrary('''
 class C<T> {
   C();
   C.named() : this();
 }
 ''');
   }
 
+  test_constructor_withCycles_const() {
+    checkLibrary('''
+class C {
+  final x;
+  const C() : x = const D();
+}
+class D {
+  final x;
+  const D() : x = const C();
+}
+''');
+  }
+
+  test_constructor_withCycles_nonConst() {
+    checkLibrary('''
+class C {
+  final x;
+  C() : x = new D();
+}
+class D {
+  final x;
+  D() : x = new C();
+}
+''');
+  }
+
   test_core() {
     if (createOptions().strongMode) {
       // The fake `dart:core` library is always in spec mode, so don't bother
       // trying to check that it resynthesizes properly; it won't.
       return;
     }
     String uri = 'dart:core';
     LibraryElementImpl original =
         resolve2(analysisContext2.sourceFactory.forUri(uri));
     LibraryElementImpl resynthesized = resynthesizeLibraryElement(
@@ skipping 1550 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }