Disallow double in case clauses and const map literal keys

runtime/vm/parser.cc

 // 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.
 
 #include "vm/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 6024 matching lines @@
   if (label != NULL) {
     current_block_->statements->Add(if_node);
     SequenceNode* sequence = CloseBlock();
     sequence->set_label(label);
     if_node = sequence;
   }
   return if_node;
 }
 
 
+// Return true if the type class of the given value implements the
+// == operator.
+static bool ImplementsEqualOperator(const Instance& value) {
+  Class& cls = Class::Handle(value.clazz());
+  const Function& equal_op = Function::Handle(
+      Resolver::ResolveDynamicAnyArgs(cls, Symbols::EqualOperator()));
+  ASSERT(!equal_op.IsNull());
+  cls = equal_op.Owner();
+  return !cls.IsObjectClass();
+}
+
+
 // Check that all case expressions are of the same type, either int, String,
-// double or any other class that does not override the == operator.
+// or any other class that does not override the == operator.
 // The expressions are compile-time constants and are thus in the form
 // of a LiteralNode.
 void Parser::CheckCaseExpressions(const GrowableArray<LiteralNode*>& values) {
   const intptr_t num_expressions = values.length();
   if (num_expressions == 0) {
     return;
   }
   const Instance& first_value = values[0]->literal();
   for (intptr_t i = 0; i < num_expressions; i++) {
     const Instance& val = values[i]->literal();
     const intptr_t val_pos = values[i]->token_pos();
     if (first_value.IsInteger()) {
       if (!val.IsInteger()) {
         ErrorMsg(val_pos, "expected case expression of type int");
       }
       continue;
     }
     if (first_value.IsString()) {
       if (!val.IsString()) {
         ErrorMsg(val_pos, "expected case expression of type String");
       }
       continue;
     }
-    if (first_value.IsDouble()) {
-      if (!val.IsDouble()) {
-        ErrorMsg(val_pos, "expected case expression of type double");
-      }
-      continue;
+    if (val.IsDouble()) {
+      ErrorMsg(val_pos, "case expression may not be of type double");
     }
     if (val.clazz() != first_value.clazz()) {
       ErrorMsg(val_pos, "all case expressions must be of same type");
     }
     if (i == 0) {
       // The value is of some type other than int, String or double.
       // Check that the type class does not override the == operator.
       // Check this only in the first loop iteration since all values
       // are of the same type, which we check above.
-      Class& cls = Class::Handle(val.clazz());
-      const Function& equal_op = Function::Handle(
-          Resolver::ResolveDynamicAnyArgs(cls, Symbols::EqualOperator()));
-      ASSERT(!equal_op.IsNull());
-      cls = equal_op.Owner();
-      if (!cls.IsObjectClass()) {
+      if (ImplementsEqualOperator(val)) {
         ErrorMsg(val_pos,
             "type class of case expression must not implement operator ==");
       }
     }
   }
 }
 
 
 CaseNode* Parser::ParseCaseClause(LocalVariable* switch_expr_value,
                                   GrowableArray<LiteralNode*>* case_expr_values,
@@ skipping 3396 matching lines @@
     const intptr_t key_pos = TokenPos();
     AstNode* key = ParseExpr(is_const, kConsumeCascades);
     if (FLAG_enable_type_checks &&
         !is_const &&
         !key_type.IsDynamicType()) {
       key = new AssignableNode(key_pos,
                                key,
                                key_type,
                                Symbols::ListLiteralElement());
     }
+    if (is_const) {
+      ASSERT(key->IsLiteralNode());
+      const Instance& key_value = key->AsLiteralNode()->literal();
+      if (key_value.IsDouble()) {
+        ErrorMsg(key_pos, "key value must not be of type double");
+      }
+      if (!key_value.IsInteger() &&
+          !key_value.IsString() &&
+          ImplementsEqualOperator(key_value)) {
+        ErrorMsg(key_pos, "key value must not implement operator ==");
+      }
+    }
     ExpectToken(Token::kCOLON);
     const intptr_t value_pos = TokenPos();
     AstNode* value = ParseExpr(is_const, kConsumeCascades);
     SetAllowFunctionLiterals(saved_mode);
     if (FLAG_enable_type_checks &&
         !is_const &&
         !value_type.IsDynamicType()) {
       value = new AssignableNode(value_pos,
                                  value,
                                  value_type,
@@ skipping 1088 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart