Properly resynthesize ClassElementImpl.hasBeenInferred.

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 24 matching lines @@
 }
 
 @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 get options =>
+  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));
   }
 
@@ skipping 170 matching lines @@
           resynthesized.accessors[i],
           original.accessors[i],
           '$desc accessor ${original.accessors[i].name}');
     }
     expect(resynthesized.methods.length, original.methods.length);
     for (int i = 0; i < resynthesized.methods.length; i++) {
       compareMethodElements(resynthesized.methods[i], original.methods[i],
           '$desc.${original.methods[i].name}');
     }
     compareTypes(resynthesized.type, original.type, desc);
+    expect(resynthesized.hasBeenInferred, original.hasBeenInferred,
+        reason: desc);
   }
 
   void compareCompilationUnitElements(CompilationUnitElementImpl resynthesized,
       CompilationUnitElementImpl original) {
     String desc = 'Compilation unit ${original.source.uri}';
     compareUriReferencedElements(resynthesized, original, desc);
     expect(resynthesized.source, original.source);
     expect(resynthesized.librarySource, original.librarySource);
     expect(resynthesized.types.length, original.types.length);
     for (int i = 0; i < resynthesized.types.length; i++) {
@@ skipping 832 matching lines @@
         print('Linked $path: ${JSON.encode(canonicalize(lib))}');
       });
     }
     return new _TestSummaryResynthesizer(
         null,
         analysisContext,
         analysisContext.typeProvider,
         analysisContext.sourceFactory,
         unlinkedSummaries,
         linkedSummaries,
-        options.strongMode);
+        createOptions().strongMode);
   }
 
   fail_library_hasExtUri() {
     checkLibrary('import "dart-ext:doesNotExist.dart";');
   }
 
   ElementImpl getActualElement(Element element, String desc) {
     if (element == null) {
       return null;
     } else if (element is ElementImpl) {
@@ skipping 24 matching lines @@
       String uri,
       LibraryElement original) {
     LibraryElementImpl resynthesized = resynthesizer.getLibraryElement(uri);
     checkMinimalResynthesisWork(resynthesizer, original);
     return resynthesized;
   }
 
   @override
   void setUp() {
     super.setUp();
-    resetWithOptions(options);
+    resetWithOptions(createOptions());
   }
 
   test_class_abstract() {
     checkLibrary('abstract class C {}');
   }
 
   test_class_alias() {
     checkLibrary('class C = D with E, F; class D {} class E {} class F {}');
   }
 
@@ skipping 1360 matching lines @@
   test_constructor_redirected_thisInvocation_unnamed_generic() {
     checkLibrary('''
 class C<T> {
   C();
   C.named() : this();
 }
 ''');
   }
 
   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(
         encodeLibraryElement(original), uri, original);
     checkLibraryElements(original, resynthesized);
   }
 
   test_enum_documented() {
     checkLibrary('''
@@ skipping 238 matching lines @@
 
   test_function_return_type_implicit() {
     checkLibrary('f() => null;');
   }
 
   test_function_return_type_void() {
     checkLibrary('void f() {}');
   }
 
   test_function_type_parameter() {
-    resetWithOptions(new AnalysisOptionsImpl()..enableGenericMethods = true);
+    resetWithOptions(createOptions()..enableGenericMethods = true);
     checkLibrary('T f<T, U>(U u) => null;');
   }
 
   test_function_type_parameter_with_function_typed_parameter() {
-    resetWithOptions(new AnalysisOptionsImpl()..enableGenericMethods = true);
+    resetWithOptions(createOptions()..enableGenericMethods = true);
     checkLibrary('void f<T, U>(T x(U u)) {}');
   }
 
   test_functions() {
     checkLibrary('f() {} g() {}');
   }
 
   test_generic_gClass_gMethodStatic() {
-    resetWithOptions(new AnalysisOptionsImpl()..enableGenericMethods = true);
+    resetWithOptions(createOptions()..enableGenericMethods = true);
     checkLibrary('''
 class C<T, U> {
   static void m<V, W>(V v, W w) {
     void f<X, Y>(V v, W w, X x, Y y) {
     }
   }
 }
 ''');
   }
 
@@ skipping 179 matching lines @@
     checkLibrary('''
 class C<U, V> {
   void set x(value) {
     print(() => () => 0);
   }
 }
 ''');
   }
 
   test_inferred_function_type_in_generic_closure() {
-    if (!options.strongMode) {
+    if (!createOptions().strongMode) {
       // The test below uses generic comment syntax because proper generic
       // method syntax doesn't support generic closures.  So it can only run in
       // strong mode.
       // TODO(paulberry): once proper generic method syntax supports generic
       // closures, rewrite the test below without using generic comment syntax,
       // and remove this hack.  See dartbug.com/25819
       return;
     }
     // In the code below, `<U, V>() => () => 0` has an inferred return type of
     // `() => int`, with 3 (unused) type parameters.
     checkLibrary('''
 f<T>() {
   print(/*<U, V>*/() => () => 0);
 }
 ''');
   }
 
   test_inferred_generic_function_type_in_generic_closure() {
-    if (!options.strongMode) {
+    if (!createOptions().strongMode) {
       // The test below uses generic comment syntax because proper generic
       // method syntax doesn't support generic closures.  So it can only run in
       // strong mode.
       // TODO(paulberry): once proper generic method syntax supports generic
       // closures, rewrite the test below without using generic comment syntax,
       // and remove this hack.  See dartbug.com/25819
       return;
     }
     // In the code below, `<U, V>() => <W, X, Y, Z>() => 0` has an inferred
     // return type of `() => int`, with 7 (unused) type parameters.
@@ skipping 435 matching lines @@
 
   test_method_parameter_return_type() {
     checkLibrary('class C { f(int g()) {} }');
   }
 
   test_method_parameter_return_type_void() {
     checkLibrary('class C { f(void g()) {} }');
   }
 
   test_method_type_parameter() {
-    resetWithOptions(new AnalysisOptionsImpl()..enableGenericMethods = true);
+    resetWithOptions(createOptions()..enableGenericMethods = true);
     checkLibrary('class C { T f<T, U>(U u) => null; }');
   }
 
   test_method_type_parameter_in_generic_class() {
-    resetWithOptions(new AnalysisOptionsImpl()..enableGenericMethods = true);
+    resetWithOptions(createOptions()..enableGenericMethods = true);
     checkLibrary('class C<T, U> { V f<V, W>(T t, U u, W w) => null; }');
   }
 
   test_method_type_parameter_with_function_typed_parameter() {
-    resetWithOptions(new AnalysisOptionsImpl()..enableGenericMethods = true);
+    resetWithOptions(createOptions()..enableGenericMethods = true);
     checkLibrary('class C { void f<T, U>(T x(U u)) {} }');
   }
 
   test_nested_generic_functions_in_generic_class_with_function_typed_params() {
     checkLibrary('''
 class C<T, U> {
   void g<V, W>() {
     void h<X, Y>(void p(T t, U u, V v, W w, X x, Y y)) {
     }
   }
@@ skipping 157 matching lines @@
 
   test_setter_inferred_type_top_level_implicit_return() {
     checkLibrary('set f(int value) {}');
   }
 
   test_setters() {
     checkLibrary('void set x(int value) {} set y(value) {}');
   }
 
   test_syntheticFunctionType_genericClosure() {
-    if (!options.strongMode) {
+    if (!createOptions().strongMode) {
       // The test below uses generic comment syntax because proper generic
       // method syntax doesn't support generic closures.  So it can only run in
       // strong mode.
       // TODO(paulberry): once proper generic method syntax supports generic
       // closures, rewrite the test below without using generic comment syntax,
       // and remove this hack.  See dartbug.com/25819
       return;
     }
     checkLibrary('''
 final v = f() ? /*<T>*/(T t) => 0 : /*<T>*/(T t) => 1;
 bool f() => true;
 ''');
   }
 
   test_syntheticFunctionType_genericClosure_inGenericFunction() {
-    if (!options.strongMode) {
+    if (!createOptions().strongMode) {
       // The test below uses generic comment syntax because proper generic
       // method syntax doesn't support generic closures.  So it can only run in
       // strong mode.
       // TODO(paulberry): once proper generic method syntax supports generic
       // closures, rewrite the test below without using generic comment syntax,
       // and remove this hack.  See dartbug.com/25819
       return;
     }
     checkLibrary('''
 void f<T, U>(bool b) {
@@ skipping 392 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }