Substitute type parameters when evaluating const literal maps/lists.

pkg/analyzer/test/generated/resolver_test.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.resolver_test;
 
 import 'dart:collection';
@@ skipping 441 matching lines @@
         "class C {",
         "  final A a;",
         "  const C(this.a);",
         "}",
         "var v = const C(const B());"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_fieldFormalParameterAssignableToField_list_dynamic() {
+    // [1, 2, 3] has type List<dynamic>, which is a subtype of List<int>.
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(List<int> x);",
+        "}",
+        "var x = const A(const [1, 2, 3]);"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_fieldFormalParameterAssignableToField_list_nonDynamic() {
+    // <int>[1, 2, 3] has type List<int>, which is a subtype of List<num>.
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(List<num> x);",
+        "}",
+        "var x = const A(const <int>[1, 2, 3]);"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_fieldFormalParameterAssignableToField_map_dynamic() {
+    // {1: 2} has type Map<dynamic, dynamic>, which is a subtype of
+    // Map<int, int>.
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(Map<int, int> x);",
+        "}",
+        "var x = const A(const {1: 2});"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_fieldFormalParameterAssignableToField_map_keyDifferent() {
+    // <int, int>{1: 2} has type Map<int, int>, which is a subtype of
+    // Map<num, int>.
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(Map<num, int> x);",
+        "}",
+        "var x = const A(const <int, int>{1: 2});"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_fieldFormalParameterAssignableToField_map_valueDifferent() {
+    // <int, int>{1: 2} has type Map<int, int>, which is a subtype of
+    // Map<int, num>.
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(Map<int, num> x);",
+        "}",
+        "var x = const A(const <int, int>{1: 2});"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_fieldFormalParameterAssignableToField_notype() {
     // If a field is declared without a type, then any value may be assigned to
     // it.
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final x;",
         "  const A(this.x);",
         "}",
         "var v = const A(5);"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_null() {
     // Null is assignable to anything.
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final int x;",
         "  const A(this.x);",
         "}",
         "var v = const A(null);"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_fieldFormalParameterAssignableToField_typeSubstitution() {
+    // foo has the runtime type dynamic -> dynamic, so it should be assignable
+    // to A.f.
+    Source source = addSource(EngineTestCase.createSource([
+        "class A<T> {",
+        "  final T x;",
+        "  const A(this.x);",
+        "}",
+        "var v = const A<int>(3);"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_fieldFormalParameterAssignableToField_typedef() {
     // foo has the runtime type dynamic -> dynamic, so it should be assignable
     // to A.f.
     Source source = addSource(EngineTestCase.createSource([
         "typedef String Int2String(int x);",
         "class A {",
         "  final Int2String f;",
         "  const A(this.f);",
         "}",
         "foo(x) => 1;"
         "var v = const A(foo);"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
-  }
-
-  void test_fieldFormalParameterAssignableToField_typeSubstitution() {
-    // foo has the runtime type dynamic -> dynamic, so it should be assignable
-    // to A.f.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A<T> {",
-        "  final T x;",
-        "  const A(this.x);",
-        "}",
-        "var v = const A<int>(3);"]));
-    resolve(source);
-    assertNoErrors(source);
-    verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final int x;",
         "  const A(this.x);",
         "}",
         "var v = const A('foo');"]));
     resolve(source);
@@ skipping 38 matching lines @@
         "  final B b;",
         "  const C(this.b);",
         "}",
         "var v = const C(const A());"]));
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH]);
     verify([source]);
   }
 
+  void test_fieldFormalParameterNotAssignableToField_list() {
+    // <num>[1, 2, 3] has type List<num>, which is not a subtype of List<int>.
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(List<int> x);",
+        "}",
+        "var x = const A(const <num>[1, 2, 3]);"]));
+    resolve(source);
+    assertErrors(source, [
+        CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH]);
+    verify([source]);
+  }
+
+  void test_fieldFormalParameterNotAssignableToField_map_keyMismatch() {
+    // <num, int>{1: 2} has type Map<num, int>, which is not a subtype of
+    // Map<int, int>.
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(Map<int, int> x);",
+        "}",
+        "var x = const A(const <num, int>{1: 2});"]));
+    resolve(source);
+    assertErrors(source, [
+        CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH]);
+    verify([source]);
+  }
+
+  void test_fieldFormalParameterNotAssignableToField_map_valueMismatch() {
+    // <int, num>{1: 2} has type Map<int, num>, which is not a subtype of
+    // Map<int, int>.
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(Map<int, int> x);",
+        "}",
+        "var x = const A(const <int, num>{1: 2});"]));
+    resolve(source);
+    assertErrors(source, [
+        CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH]);
+    verify([source]);
+  }
+
   void test_fieldFormalParameterNotAssignableToField_optional() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final int x;",
         "  const A([this.x = 'foo']);",
         "}",
         "var v = const A();"]));
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
@@ skipping 22638 matching lines @@
   runReflectiveTests(HintCodeTest);
   runReflectiveTests(MemberMapTest);
   runReflectiveTests(NonErrorResolverTest);
   runReflectiveTests(NonHintCodeTest);
   runReflectiveTests(SimpleResolverTest);
   runReflectiveTests(StaticTypeWarningCodeTest);
   runReflectiveTests(StaticWarningCodeTest);
   runReflectiveTests(StrictModeTest);
   runReflectiveTests(TypePropagationTest);
 }