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

editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/internal/verifier/ErrorVerifier.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 889 matching lines @@
         if (node.getConstKeyword() != null) {
           checkForInvalidTypeArgumentInConstTypedLiteral(
               arguments,
               CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP);
         }
       }
       checkExpectedTwoMapTypeArguments(typeArguments);
       checkForMapTypeNotAssignable(node, typeArguments);
     }
     checkForNonConstMapAsExpressionStatement(node);
-    checkForConstMapKeyExpressionTypeImplementsEquals(node);
     return super.visitMapLiteral(node);
   }
 
   @Override
   public Void visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement previousFunction = enclosingFunction;
     try {
       isInStaticMethod = node.isStatic();
       enclosingFunction = node.getElement();
       SimpleIdentifier identifier = node.getName();
@@ skipping 145 matching lines @@
     isInConstructorInitializer = true;
     try {
       return super.visitSuperConstructorInvocation(node);
     } finally {
       isInConstructorInitializer = false;
     }
   }
 
   @Override
   public Void visitSwitchStatement(SwitchStatement node) {
-    checkForInconsistentCaseExpressionTypes(node);
     checkForSwitchExpressionNotAssignable(node);
     checkForCaseBlocksNotTerminated(node);
     return super.visitSwitchStatement(node);
   }
 
   @Override
   public Void visitThisExpression(ThisExpression node) {
     checkForInvalidReferenceToThis(node);
     return super.visitThisExpression(node);
   }
@@ skipping 1102 matching lines @@
     for (int i = 0; i < lastMember; i++) {
       SwitchMember member = members.get(i);
       if (member instanceof SwitchCase) {
         foundError |= checkForCaseBlockNotTerminated((SwitchCase) member);
       }
     }
     return foundError;
   }
 
   /**
-   * This verifies that the passed switch statement does not have a case expression with the
-   * operator '==' overridden.
-   * 
-   * @param node the switch statement to evaluate
-   * @param type the common type of all 'case' expressions
-   * @return {@code true} if and only if an error code is generated on the passed node
-   * @see CompileTimeErrorCode#CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
-   */
-  private boolean checkForCaseExpressionTypeImplementsEquals(SwitchStatement node, Type type) {
-    if (!implementsEqualsWhenNotAllowed(type)) {
-      return false;
-    }
-    // report error
-    errorReporter.reportErrorForToken(
-        CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS,
-        node.getKeyword(),
-        type.getDisplayName());
-    return true;
-  }
-
-  /**
    * This verifies that the passed method declaration is abstract only if the enclosing class is
    * also abstract.
    * 
    * @param node the method declaration to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONCRETE_CLASS_WITH_ABSTRACT_MEMBER
    */
   private boolean checkForConcreteClassWithAbstractMember(MethodDeclaration node) {
     if (node.isAbstract() && enclosingClass != null && !enclosingClass.isAbstract()) {
       SimpleIdentifier methodName = node.getName();
@@ skipping 541 matching lines @@
    */
   private boolean checkForConstFormalParameter(NormalFormalParameter node) {
     if (node.isConst()) {
       errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_FORMAL_PARAMETER, node);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the all keys of the passed map literal have class type that does not declare
-   * operator <i>==<i>.
-   * 
-   * @param key the map literal to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
-   * @see CompileTimeErrorCode#CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
-   */
-  private boolean checkForConstMapKeyExpressionTypeImplementsEquals(MapLiteral node) {
-    // OK, not const.
-    if (node.getConstKeyword() == null) {
-      return false;
-    }
-    // Check every map entry.
-    boolean hasProblems = false;
-    for (MapLiteralEntry entry : node.getEntries()) {
-      Expression key = entry.getKey();
-      Type type = key.getStaticType();
-      if (implementsEqualsWhenNotAllowed(type)) {
-        errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS,
-            key,
-            type.getDisplayName());
-        hasProblems = true;
-      }
-    }
-    return hasProblems;
-  }
-
-  /**
    * This verifies that the passed instance creation expression is not being invoked on an abstract
    * class.
    * 
    * @param node the instance creation expression to evaluate
    * @param typeName the {@link TypeName} of the {@link ConstructorName} from the
    *          {@link InstanceCreationExpression}, this is the AST node that the error is attached to
    * @param type the type being constructed with this {@link InstanceCreationExpression}
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONST_WITH_ABSTRACT_CLASS
    * @see StaticWarningCode#NEW_WITH_ABSTRACT_CLASS
@@ skipping 831 matching lines @@
     }
     // report problem
     errorReporter.reportErrorForNode(
         CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY,
         node,
         node.getUri());
     return true;
   }
 
   /**
-   * This verifies that the passed switch statement case expressions all have the same type.
-   * 
-   * @param node the switch statement to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
-   * @see CompileTimeErrorCode#INCONSISTENT_CASE_EXPRESSION_TYPES
-   */
-  private boolean checkForInconsistentCaseExpressionTypes(SwitchStatement node) {
-    // TODO(jwren) Revisit this algorithm, should there up to n-1 errors?
-    NodeList<SwitchMember> switchMembers = node.getMembers();
-    boolean foundError = false;
-    Type firstType = null;
-    for (SwitchMember switchMember : switchMembers) {
-      if (switchMember instanceof SwitchCase) {
-        SwitchCase switchCase = (SwitchCase) switchMember;
-        Expression expression = switchCase.getExpression();
-        if (firstType == null) {
-          // TODO(brianwilkerson) This is failing with const variables whose declared type is
-          // dynamic. The problem is that we don't have any way to propagate type information for
-          // the variable.
-          firstType = expression.getBestType();
-        } else {
-          Type nType = expression.getBestType();
-          if (!firstType.equals(nType)) {
-            errorReporter.reportErrorForNode(
-                CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES,
-                expression,
-                expression.toSource(),
-                firstType.getDisplayName());
-            foundError = true;
-          }
-        }
-      }
-    }
-    if (!foundError) {
-      checkForCaseExpressionTypeImplementsEquals(node, firstType);
-    }
-    return foundError;
-  }
-
-  /**
    * For each class declaration, this method is called which verifies that all inherited members are
    * inherited consistently.
    * 
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INCONSISTENT_METHOD_INHERITANCE
    */
   private boolean checkForInconsistentMethodInheritance() {
     // Ensure that the inheritance manager has a chance to generate all errors we may care about,
     // note that we ensure that the interfaces data since there are no errors.
     inheritanceManager.getMapOfMembersInheritedFromInterfaces(enclosingClass);
@@ skipping 2017 matching lines @@
             for (Type typeArgument : interfaceType.getTypeArguments()) {
               addTypeToCheck(typeArgument);
             }
           }
         }
       });
       checked.add(current);
     }
   }
 
-  /**
-   * @return {@code true} if given {@link Type} implements operator <i>==</i>, and it is not
-   *         <i>int</i> or <i>String</i>.
-   */
-  private boolean implementsEqualsWhenNotAllowed(Type type) {
-    // ignore int or String
-    if (type == null || type.equals(intType) || type.equals(typeProvider.getStringType())) {
-      return false;
-    } else if (type.equals(typeProvider.getDoubleType())) {
-      return true;
-    }
-    // prepare ClassElement
-    Element element = type.getElement();
-    if (!(element instanceof ClassElement)) {
-      return false;
-    }
-    ClassElement classElement = (ClassElement) element;
-    // lookup for ==
-    MethodElement method = classElement.lookUpMethod("==", currentLibrary);
-    while (method != null && method.isAbstract()) {
-      ClassElement definingClass = method.getEnclosingElement();
-      if (definingClass == null) {
-        return false;
-      }
-      method = definingClass.lookUpInheritedMethod("==", currentLibrary);
-    }
-    if (method == null || method.getEnclosingElement().getType().isObject()) {
-      return false;
-    }
-    // there is == that we don't like
-    return true;
-  }
-
   private boolean isFunctionType(Type type) {
     if (type.isDynamic() || type.isBottom()) {
       return true;
     } else if (type instanceof FunctionType || type.isDartCoreFunction()) {
       return true;
     } else if (type instanceof InterfaceType) {
       MethodElement callMethod = ((InterfaceType) type).lookUpMethod(
           FunctionElement.CALL_METHOD_NAME,
           currentLibrary);
       return callMethod != null;
@@ skipping 268 matching lines @@
     InterfaceType[] interfaceTypes = classElt.getInterfaces();
     for (InterfaceType interfaceType : interfaceTypes) {
       if (safeCheckForRecursiveInterfaceInheritance(interfaceType.getElement(), path)) {
         return true;
       }
     }
     path.remove(path.size() - 1);
     return false;
   }
 }