Resynthesize untyped List / Map.

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/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
@@ skipping 204 matching lines @@
         expect(resynthesized.isNull, isTrue, reason: desc);
       } else if (original.toBoolValue() != null) {
         expect(resynthesized.toBoolValue(), original.toBoolValue(),
             reason: desc);
       } else if (original.toIntValue() != null) {
         expect(resynthesized.toIntValue(), original.toIntValue(), reason: desc);
       } else if (original.toDoubleValue() != null) {
         expect(resynthesized.toDoubleValue(), original.toDoubleValue(),
             reason: desc);
       } else if (original.toListValue() != null) {
-        fail('Not implemented');
+        List<DartObject> resynthesizedList = resynthesized.toListValue();
+        List<DartObject> originalList = original.toListValue();
+        expect(resynthesizedList, hasLength(originalList.length));
+        for (int i = 0; i < originalList.length; i++) {
+          compareConstantValues(resynthesizedList[i], originalList[i], desc);
+        }
       } else if (original.toMapValue() != null) {
-        fail('Not implemented');
+        Map<DartObject, DartObject> resynthesizedMap =
+            resynthesized.toMapValue();
+        Map<DartObject, DartObject> originalMap = original.toMapValue();
+        expect(resynthesizedMap, hasLength(originalMap.length));
+        originalMap.forEach((originalKey, originalValue) {

[Paul Berry, 2016/01/28 23:43:07]

In Dart, maps are ordered, so there are subtle semantic differences between
e.g.:

    const a = const { 1: 2, 3: 4 }

and:

    const b = const { 3: 4, 1: 2 }

which are detectable at runtime.  This code should make sure that not only does
the key/value mapping match, but the order of keys matches too.

[scheglov, 2016/01/29 17:07:08]

Thanks, I will add better validation.
It turned out that the constant computer returns not ordered HashMap.
This CL should fix the problem: https://codereview.chromium.org/1643253002/

+          DartObject resynthesizedValue = resynthesizedMap[originalKey];
+          compareConstantValues(resynthesizedValue, originalValue, desc);
+        });
       } else if (original.toStringValue() != null) {
         expect(resynthesized.toStringValue(), original.toStringValue(),
             reason: desc);
       } else if (original.toSymbolValue() != null) {
         expect(resynthesized.toSymbolValue(), original.toSymbolValue(),
             reason: desc);
       } else if (original.toTypeValue() != null) {
         fail('Not implemented');
       }
       // TODO(scheglov) implement
@@ skipping 772 matching lines @@
   test_const_topLevel_unary() {
     shouldCompareConstValues = true;
     checkLibrary(r'''
 const vNotEqual = 1 != 2;
 const vNot = !true;
 const vNegate = -1;
 const vComplement = ~1;
 ''');
   }
 
+  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
    */
   C();
 }''');
   }
 
@@ skipping 927 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }