Check const map literal keys and switch case exprs using type of constant.

editor/tools/plugins/com.google.dart.engine_test/src/com/google/dart/engine/resolver/CompileTimeErrorCodeTest.java

 /*
  * Copyright (c) 2013, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
  * 
  * http://www.eclipse.org/legal/epl-v10.html
  * 
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
@@ skipping 317 matching lines @@
   public void test_conflictingTypeVariableAndMember_setter() throws Exception {
     Source source = addSource(createSource(//
         "class A<T> {",
         "  set T(x) {}",
         "}"));
     resolve(source);
     assertErrors(source, CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER);
     verify(source);
   }
 
+  public void test_consistentCaseExpressionTypes_dynamic() throws Exception {
+    // Even though A.S and S have a static type of "dynamic", we should see
+    // that they match 'abc', because they are constant strings.
+    Source source = addSource(createSource(//
+        "class A {",
+        "  static const S = 'A.S';",
+        "}",
+        "",
+        "const S = 'S';",
+        "",
+        "foo(var p) {",
+        "  switch (p) {",
+        "    case S:",
+        "      break;",
+        "    case A.S:",
+        "      break;",
+        "    case 'abc':",
+        "      break;",
+        "  }",
+        "}"));
+    resolve(source);
+    assertNoErrors(source);
+    verify(source);
+  }
+
   public void test_constConstructorWithNonConstSuper_explicit() throws Exception {
     Source source = addSource(createSource(//
         "class A {",
         "  A();",
         "}",
         "class B extends A {",
         "  const B(): super();",
         "}"));
     resolve(source);
     assertErrors(source, CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER);
@@ skipping 300 matching lines @@
         "  operator ==(other) => false;",
         "}",
         "main() {",
         "  const {const A() : 0};",
         "}"));
     resolve(source);
     assertErrors(source, CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS);
     verify(source);
   }
 
+  public void test_constMapKeyTypeImplementsEquals_dynamic() throws Exception {
+    // Note: static type of B.a is "dynamic", but actual type of the const
+    // object is A.  We need to make sure we examine the actual type when
+    // deciding whether there is a problem with operator==.
+    Source source = addSource(createSource(//
+        "class A {",
+        "  const A();",
+        "  operator ==(other) => false;",
+        "}",
+        "class B {",
+        "  static const a = const A();",
+        "}",
+        "main() {",
+        "  const {B.a : 0};",
+        "}"));
+    resolve(source);
+    assertErrors(source, CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS);
+    verify(source);
+  }
+
   public void test_constMapKeyTypeImplementsEquals_super() throws Exception {
     Source source = addSource(createSource(//
         "class A {",
         "  const A();",
         "  operator ==(other) => false;",
         "}",
         "class B extends A {",
         "  const B();",
         "}",
         "main() {",
@@ skipping 1180 matching lines @@
         "      break;",
         "    case 'a':",
         "      break;",
         "  }",
         "}"));
     resolve(source);
     assertErrors(source, CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES);
     verify(source);
   }
 
+  public void test_inconsistentCaseExpressionTypes_dynamic() throws Exception {
+    // Even though A.S and S have a static type of "dynamic", we should see
+    // that they fail to match 3, because they are constant strings.
+    Source source = addSource(createSource(//
+        "class A {",
+        "  static const S = 'A.S';",
+        "}",
+        "",
+        "const S = 'S';",
+        "",
+        "foo(var p) {",
+        "  switch (p) {",
+        "    case 3:",
+        "      break;",
+        "    case S:",
+        "      break;",
+        "    case A.S:",
+        "      break;",
+        "  }",
+        "}"));
+    resolve(source);
+    assertErrors(
+        source,
+        CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES,
+        CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES);
+    verify(source);
+  }
+
   public void test_inconsistentCaseExpressionTypes_repeated() throws Exception {
     Source source = addSource(createSource(//
         "f(var p) {",
         "  switch (p) {",
         "    case 1:",
         "      break;",
         "    case 'a':",
         "      break;",
         "    case 'b':",
         "      break;",
@@ skipping 2445 matching lines @@
     assertErrors(source, CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR);
     verify(source);
     reset();
   }
 
   private void check_wrongNumberOfParametersForOperator1(String name) throws Exception {
     check_wrongNumberOfParametersForOperator(name, "");
     check_wrongNumberOfParametersForOperator(name, "a, b");
   }
 }