Typecheck map and list literals

test/checker/checker_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.
 
 /// General type checking tests
 library ddc.test.checker_test;
 
 import 'package:unittest/compact_vm_config.dart';
 import 'package:unittest/unittest.dart';
 
@@ skipping 1465 matching lines @@
             l2 = /*warning:DownCastDynamic*/l1;
 
             l2 = /*warning:DownCastExact*/new List();
             l2 = /*warning:DownCastExact*/new List(10);
             l2 = /*warning:DownCastExact*/new List.filled(10, 42);
           }
    '''
     });
   });
 
+  test('Type checking literals', () {
+    testChecker({
+      '/main.dart': '''
+          test() {
+            num n = 3;
+            int i = 3;
+            String s = "hello";
+            {
+               List<int> l = <int>[i];
+               l = <int>[/*severe:StaticTypeError*/s];
+               l = <int>[/*info:DownCast*/n];
+               l = <int>[i, /*info:DownCast*/n, /*severe:StaticTypeError*/s];
+            }
+            {
+               List l = [i];
+               l = [s];
+               l = [n];
+               l = [i, n, s];
+            }
+            {
+               Map<String, int> m = <String, int>{s: i};
+               m = <String, int>{s: /*severe:StaticTypeError*/s};
+               m = <String, int>{s: /*info:DownCast*/n};
+               m = <String, int>{s: i,
+                                 s: /*info:DownCast*/n,
+                                 s: /*severe:StaticTypeError*/s};
+            }
+           // TODO(leafp): We can't currently test for key errors since the
+           // error marker binds to the entire entry.
+            {
+               Map m = {s: i};
+               m = {s: s};
+               m = {s: n};
+               m = {s: i,
+                    s: n,
+                    s: s};
+               m = {i: s,
+                    n: s,
+                    s: s};
+            }
+          }
+   '''
+    });
+  });
+
+  test('casts in constant contexts', () {
+    String mk(String error) => '''
+          class A {
+            static const num n = 3.0;
+            static const int i = /*$error*/n;
+            final int fi;
+            const A(num a) : this.fi = /*$error*/a;
+          }
+          class B extends A {
+            const B(Object a) : super(/*$error*/a);
+          }
+          void foo(Object o) {
+            var a = const A(/*$error*/o);
+          }
+     ''';
+    testChecker({'/main.dart': mk("severe:StaticTypeError")},
+        allowConstCasts: false);
+    testChecker({'/main.dart': mk("info:DownCast")}, allowConstCasts: true);
+  });
+
   test('redirecting constructor', () {
     testChecker({
       '/main.dart': '''
           class A {
             A(A x) {}
             A.two() : this(/*severe:StaticTypeError*/3);
           }
        '''
     });
   });
@@ skipping 1143 matching lines @@
         '/main.dart': '''
             class A {}
             class T1 implements A {
                 /*severe:InferableOverride*/toString() {}
             }
          '''
       }, inferFromOverrides: false);
     });
   });
 }