Follow factory redirections when checking case expressions.

sdk/lib/_internal/compiler/implementation/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 3447 matching lines @@
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     node.visitChildren(this);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
 
+  DartType typeOfConstant(Constant constant) {
+    if (constant.isInt()) return compiler.intClass.rawType;
+    if (constant.isBool()) return compiler.boolClass.rawType;
+    if (constant.isDouble()) return compiler.doubleClass.rawType;
+    if (constant.isString()) return compiler.stringClass.rawType;
+    if (constant.isNull()) return compiler.nullClass.rawType;
+    if (constant.isFunction()) return compiler.functionClass.rawType;
+    assert(constant.isObject());
+    ObjectConstant objectConstant = constant;
+    return objectConstant.type;
+  }
+
+  bool overridesEquals(DartType type) {
+    ClassElement cls = type.element;
+    Element equals = cls.lookupMember('==');
+    return equals.getEnclosingClass() != compiler.objectClass;
+  }
+
+  void checkCaseExpressions(SwitchStatement node) {
+    TargetElement breakElement = getOrCreateTargetElement(node);
+    Map<String, LabelElement> continueLabels = <String, LabelElement>{};
+
+    Link<Node> cases = node.cases.nodes;
+    SwitchCase switchCase = cases.head;
+    CaseMatch firstCase = null;
+    DartType firstCaseType = null;
+    bool hasReportedProblem = false;
+
+    for (Link<Node> cases = node.cases.nodes;
+         !cases.isEmpty;
+         cases = cases.tail) {
+      SwitchCase switchCase = cases.head;
+
+      for (Node labelOrCase in switchCase.labelsAndCases) {
+        CaseMatch caseMatch = labelOrCase.asCaseMatch();
+        if (caseMatch == null) continue;
+
+        // Analyze the constant.
+        Constant constant = mapping.getConstant(caseMatch.expression);
+        assert(invariant(node, constant != null,
+            message: 'No constant computed for $node'));
+
+        DartType caseType = typeOfConstant(constant);
+
+        if (firstCaseType == null) {
+          firstCase = caseMatch;
+          firstCaseType = caseType;
+
+          // We only report the bad type on the first class element. All others
+          // get a "type differs" error.
+          if (caseType.element == compiler.doubleClass) {
+            compiler.reportError(node,
+                                 MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
+                                 {'type': "double"});
+          } else if (caseType.element == compiler.functionClass) {
+            compiler.reportError(node, MessageKind.SWITCH_CASE_FORBIDDEN,
+                                 {'type': "Function"});
+          } else if (constant.isObject() && overridesEquals(caseType)) {
+            compiler.reportError(firstCase.expression,
+                MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
+                {'type': caseType});
+          }
+        } else {
+          if (caseType != firstCaseType) {
+            if (!hasReportedProblem) {
+              compiler.reportError(
+                  node,
+                  MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL,
+                  {'type': firstCaseType});
+              compiler.reportInfo(
+                  firstCase.expression,
+                  MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
+                  {'type': firstCaseType});
+              hasReportedProblem = true;
+            }
+            compiler.reportInfo(
+                caseMatch.expression,
+                MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
+                {'type': caseType});
+          }
+        }
+      }
+    }
+  }
+
   visitSwitchStatement(SwitchStatement node) {
     node.expression.accept(this);
 
     TargetElement breakElement = getOrCreateTargetElement(node);
     Map<String, LabelElement> continueLabels = <String, LabelElement>{};
     Link<Node> cases = node.cases.nodes;
     while (!cases.isEmpty) {
       SwitchCase switchCase = cases.head;
       for (Node labelOrCase in switchCase.labelsAndCases) {
         CaseMatch caseMatch = labelOrCase.asCaseMatch();
@@ skipping 31 matching lines @@
         mapping[label] = labelElement;
         continueLabels[labelName] = labelElement;
       }
       cases = cases.tail;
       // Test that only the last case, if any, is a default case.
       if (switchCase.defaultKeyword != null && !cases.isEmpty) {
         error(switchCase, MessageKind.INVALID_CASE_DEFAULT);
       }
     }
 
+    addDeferredAction(enclosingElement, () {
+      checkCaseExpressions(node);
+    });
+
     statementScope.enterSwitch(breakElement, continueLabels);
     node.cases.accept(this);
     statementScope.exitSwitch();
 
     // Clean-up unused labels.
     continueLabels.forEach((String key, LabelElement label) {
       if (!label.isContinueTarget) {
         TargetElement targetElement = label.target;
         SwitchCase switchCase = targetElement.statement;
         mapping.remove(switchCase);
@@ skipping 1015 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }