Remove shouldCompareConstValues.

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 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 13 matching lines @@
 import '../../reflective_tests.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(ResynthTest);
 }
 
 @reflectiveTest
 class ResynthTest extends ResolverTestCase {
   Set<Source> otherLibrarySources = new Set<Source>();
-  bool shouldCompareConstValues = false;
 
   /**
    * Determine the analysis options that should be used for this test.
    */
   AnalysisOptionsImpl get options =>
       new AnalysisOptionsImpl()..enableGenericMethods = true;
 
   void addLibrary(String uri) {
     otherLibrarySources.add(analysisContext2.sourceFactory.forUri(uri));
   }
@@ skipping 618 matching lines @@
     compareElements(resynthesized, original, desc);
     expect(resynthesized.uri, original.uri);
     expect(resynthesized.uriOffset, original.uriOffset, reason: desc);
     expect(resynthesized.uriEnd, original.uriEnd, reason: desc);
   }
 
   void compareVariableElements(VariableElementImpl resynthesized,
       VariableElementImpl original, String desc) {
     compareElements(resynthesized, original, desc);
     compareTypes(resynthesized.type, original.type, desc);
-    // TODO(scheglov) enable for any ConstVariableElement
-    if (shouldCompareConstValues) {
-      if (original is ConstVariableElement) {
-        compareConstantExpressions(resynthesized.constantInitializer,
-            original.constantInitializer, desc);
-      }
+    if (original is ConstVariableElement) {
+      compareConstantExpressions(resynthesized.constantInitializer,
+          original.constantInitializer, desc);
     }
   }
 
   /**
    * 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`.
    */
@@ skipping 387 matching lines @@
 
   test_class_type_parameters_f_bound_simple() {
     checkLibrary('class C<T extends U, U> {}');
   }
 
   test_classes() {
     checkLibrary('class C {} class D {}');
   }
 
   test_const_invokeConstructor_generic_named() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 class C<K, V> {
   const C.named(K k, V v);
 }
 const V = const C<int, String>.named(1, '222');
 ''');
   }
 
   test_const_invokeConstructor_generic_named_imported() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C<K, V> {
   const C.named(K k, V v);
 }
 ''');
     checkLibrary(r'''
 import 'a.dart';
 const V = const C<int, String>.named(1, '222');
 ''');
   }
 
   test_const_invokeConstructor_generic_named_imported_withPrefix() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C<K, V> {
   const C.named(K k, V v);
 }
 ''');
     checkLibrary(r'''
 import 'a.dart' as p;
 const V = const p.C<int, String>.named(1, '222');
 ''');
   }
 
   test_const_invokeConstructor_generic_unnamed() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 class C<K, V> {
   const C();
 }
 const V = const C<int, String>();
 ''');
   }
 
   test_const_invokeConstructor_generic_unnamed_imported() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C<K, V> {
   const C();
 }
 ''');
     checkLibrary(r'''
 import 'a.dart';
 const V = const C<int, String>();
 ''');
   }
 
   test_const_invokeConstructor_generic_unnamed_imported_withPrefix() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C<K, V> {
   const C();
 }
 ''');
     checkLibrary(r'''
 import 'a.dart' as p;
 const V = const p.C<int, String>();
 ''');
   }
 
   test_const_invokeConstructor_named() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 class C {
   const C.named(bool a, int b, int c, {String d, double e});
 }
 const V = const C.named(true, 1, 2, d: 'ccc', e: 3.4);
 ''');
   }
 
   test_const_invokeConstructor_named_imported() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C {
   const C.named();
 }
 ''');
     checkLibrary(r'''
 import 'a.dart';
 const V = const C.named();
 ''');
   }
 
   test_const_invokeConstructor_named_imported_withPrefix() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C {
   const C.named();
 }
 ''');
     checkLibrary(r'''
 import 'a.dart' as p;
 const V = const p.C.named();
 ''');
   }
 
   test_const_invokeConstructor_unnamed() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 class C {
   const C();
 }
 const V = const C();
 ''');
   }
 
   test_const_invokeConstructor_unnamed_imported() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C {
   const C();
 }
 ''');
     checkLibrary(r'''
 import 'a.dart';
 const V = const C();
 ''');
   }
 
   test_const_invokeConstructor_unnamed_imported_withPrefix() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C {
   const C();
 }
 ''');
     checkLibrary(r'''
 import 'a.dart' as p;
 const V = const p.C();
 ''');
   }
 
   test_const_length_ofClassConstField() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 class C {
   static const String F = '';
 }
 const int v = C.F.length;
 ''');
   }
 
   test_const_length_ofClassConstField_imported() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C {
   static const String F = '';
 }
 ''');
     checkLibrary(r'''
 import 'a.dart';
 const int v = C.F.length;
 ''');
   }
 
   test_const_length_ofClassConstField_imported_withPrefix() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C {
   static const String F = '';
 }
 ''');
     checkLibrary(r'''
 import 'a.dart' as p;
 const int v = p.C.F.length;
 ''');
   }
 
   test_const_length_ofStringLiteral() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 const v = 'abc'.length;
 ''');
   }
 
   test_const_length_ofTopLevelVariable() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 const String S = 'abc';
 const v = S.length;
 ''');
   }
 
   test_const_length_ofTopLevelVariable_imported() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 const String S = 'abc';
 ''');
     checkLibrary(r'''
 import 'a.dart';
 const v = S.length;
 ''');
   }
 
   test_const_length_ofTopLevelVariable_imported_withPrefix() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 const String S = 'abc';
 ''');
     checkLibrary(r'''
 import 'a.dart' as p;
 const v = p.S.length;
 ''');
   }
 
   test_const_length_staticMethod() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 class C {
   static int length() => 42;
 }
 const v = C.length;
 ''');
   }
 
   test_const_parameterDefaultValue_initializingFormal_functionTyped() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 class C {
   final x;
   const C({this.x: foo});
 }
 int foo() => 42;
 ''');
   }
 
   test_const_parameterDefaultValue_initializingFormal_named() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 class C {
   final x;
   const C({this.x: 1 + 2});
 }
 ''');
   }
 
   test_const_parameterDefaultValue_initializingFormal_positional() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 class C {
   final x;
   const C([this.x = 1 + 2]);
 }
 ''');
   }
 
   test_const_parameterDefaultValue_normal() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 class C {
   const C.positional([p = 1 + 2]);
   const C.named({p: 1 + 2});
   void methodPositional([p = 1 + 2]) {}
   void methodNamed({p: 1 + 2}) {}
 }
 ''');
   }
 
   test_const_reference_staticField() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 class C {
   static const int F = 42;
 }
 const V = C.F;
 ''');
   }
 
   test_const_reference_staticField_imported() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C {
   static const int F = 42;
 }
 ''');
     checkLibrary(r'''
 import 'a.dart';
 const V = C.F;
 ''');
   }
 
   test_const_reference_staticField_imported_withPrefix() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C {
   static const int F = 42;
 }
 ''');
     checkLibrary(r'''
 import 'a.dart' as p;
 const V = p.C.F;
 ''');
   }
 
   test_const_reference_staticMethod() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 class C {
   static int m(int a, String b) => 42;
 }
 const V = C.m;
 ''');
   }
 
   test_const_reference_staticMethod_imported() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C {
   static int m(int a, String b) => 42;
 }
 ''');
     checkLibrary(r'''
 import 'a.dart';
 const V = C.m;
 ''');
   }
 
   test_const_reference_staticMethod_imported_withPrefix() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C {
   static int m(int a, String b) => 42;
 }
 ''');
     checkLibrary(r'''
 import 'a.dart' as p;
 const V = p.C.m;
 ''');
   }
 
   test_const_reference_topLevelFunction() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 foo() {}
 const V = foo;
 ''');
   }
 
   test_const_reference_topLevelFunction_imported() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 foo() {}
 ''');
     checkLibrary(r'''
 import 'a.dart';
 const V = foo;
 ''');
   }
 
   test_const_reference_topLevelFunction_imported_withPrefix() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 foo() {}
 ''');
     checkLibrary(r'''
 import 'a.dart' as p;
 const V = p.foo;
 ''');
   }
 
   test_const_reference_topLevelVariable() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 const A = 1;
 const B = A + 2;
 ''');
   }
 
   test_const_reference_topLevelVariable_imported() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 const A = 1;
 ''');
     checkLibrary(r'''
 import 'a.dart';
 const B = A + 2;
 ''');
   }
 
   test_const_reference_topLevelVariable_imported_withPrefix() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 const A = 1;
 ''');
     checkLibrary(r'''
 import 'a.dart' as p;
 const B = p.A + 2;
 ''');
   }
 
   test_const_reference_type() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 class C {}
 class D<T> {}
 enum E {a, b, c}
 typedef F(int a, String b);
 const vDynamic = dynamic;
 const vNull = Null;
 const vObject = Object;
 const vClass = C;
 const vGenericClass = D;
 const vEnum = E;
 const vFunctionTypeAlias = F;
 ''');
   }
 
   test_const_reference_type_imported() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C {}
 enum E {a, b, c}
 typedef F(int a, String b);
 ''');
     checkLibrary(r'''
 import 'a.dart';
 const vClass = C;
 const vEnum = E;
 const vFunctionTypeAlias = F;
 ''');
   }
 
   test_const_reference_type_imported_withPrefix() {
-    shouldCompareConstValues = true;
     addLibrarySource(
         '/a.dart',
         r'''
 class C {}
 enum E {a, b, c}
 typedef F(int a, String b);
 ''');
     checkLibrary(r'''
 import 'a.dart' as p;
 const vClass = p.C;
 const vEnum = p.E;
 const vFunctionTypeAlias = p.F;
 ''');
   }
 
   test_const_topLevel_binary() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 const vEqual = 1 == 2;
 const vAnd = true && false;
 const vOr = false || true;
 const vBitXor = 1 ^ 2;
 const vBitAnd = 1 & 2;
 const vBitOr = 1 | 2;
 const vBitShiftLeft = 1 << 2;
 const vBitShiftRight = 1 >> 2;
 const vAdd = 1 + 2;
 const vSubtract = 1 - 2;
 const vMiltiply = 1 * 2;
 const vDivide = 1 / 2;
 const vFloorDivide = 1 ~/ 2;
 const vModulo = 1 % 2;
 const vGreater = 1 > 2;
 const vGreaterEqual = 1 >= 2;
 const vLess = 1 < 2;
 const vLessEqual = 1 <= 2;
 ''');
   }
 
   test_const_topLevel_conditional() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 const vConditional = (1 == 2) ? 11 : 22;
 ''');
   }
 
   test_const_topLevel_identical() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 const vIdentical = (1 == 2) ? 11 : 22;
 ''');
   }
 
   test_const_topLevel_literal() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 const vNull = null;
 const vBoolFalse = false;
 const vBoolTrue = true;
 const vInt = 1;
 const vIntLong = 0x9876543210987654321;
 const vDouble = 2.3;
 const vString = 'abc';
 const vStringConcat = 'aaa' 'bbb';
 const vStringInterpolation = 'aaa ${true} ${42} bbb';
 const vSymbol = #aaa.bbb.ccc;
 ''');
   }
 
   test_const_topLevel_prefix() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 const vNotEqual = 1 != 2;
 const vNot = !true;
 const vNegate = -1;
 const vComplement = ~1;
 ''');
   }
 
   test_const_topLevel_typedList() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 const vNull = const <Null>[];
 const vDynamic = const <dynamic>[1, 2, 3];
 const vInterfaceNoTypeParameters = const <int>[1, 2, 3];
 const vInterfaceNoTypeArguments = const <List>[];
 const vInterfaceWithTypeArguments = const <List<String>>[];
 const vInterfaceWithTypeArguments2 = const <Map<int, List<String>>>[];
 ''');
   }
 
   test_const_topLevel_typedList_imported() {
-    shouldCompareConstValues = true;
     addLibrarySource('/a.dart', 'class C {}');
     checkLibrary(r'''
 import 'a.dart';
 const v = const <C>[];
 ''');
   }
 
   test_const_topLevel_typedList_importedWithPrefix() {
-    shouldCompareConstValues = true;
     addLibrarySource('/a.dart', 'class C {}');
     checkLibrary(r'''
 import 'a.dart' as p;
 const v = const <p.C>[];
 ''');
   }
 
   test_const_topLevel_typedMap() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 const vDynamic1 = const <dynamic, int>{};
 const vDynamic2 = const <int, dynamic>{};
 const vInterface = const <int, String>{};
 const vInterfaceWithTypeArguments = const <int, List<String>>{};
 ''');
   }
 
   test_const_topLevel_untypedList() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 const v = const [1, 2, 3];
 ''');
   }
 
   test_const_topLevel_untypedMap() {
-    shouldCompareConstValues = true;
     checkLibrary(r'''
 const v = const {0: 'aaa', 1: 'bbb', 2: 'ccc'};
 ''');
   }
 
   test_constructor_documented() {
     checkLibrary('''
 class C {
   /**
    * Docs
@@ skipping 961 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }