Implement type checks for switch expression

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 6006 matching lines @@
   ASSERT(!equal_op.IsNull());
   cls = equal_op.Owner();
   return !cls.IsObjectClass();
 }
 
 
 // Check that all case expressions are of the same type, either int, String,
 // 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) {
+RawClass* Parser::CheckCaseExpressions(
+    const GrowableArray<LiteralNode*>& values) {
   const intptr_t num_expressions = values.length();
   if (num_expressions == 0) {
-    return;
+    return Object::dynamic_class();
   }
   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;
@@ skipping 14 matching lines @@
       // 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.
       if (ImplementsEqualOperator(val)) {
         ErrorMsg(val_pos,
             "type class of case expression must not implement operator ==");
       }
     }
   }
+  if (first_value.IsInteger()) {
+    return Type::Handle(Type::IntType()).type_class();
+  } else if (first_value.IsString()) {
+    return Type::Handle(Type::StringType()).type_class();
+  }
+  return first_value.clazz();
 }
 
 
 CaseNode* Parser::ParseCaseClause(LocalVariable* switch_expr_value,
                                   GrowableArray<LiteralNode*>* case_expr_values,
                                   SourceLabel* case_label) {
   TRACE_PARSER("ParseCaseClause");
   bool default_seen = false;
   const intptr_t case_pos = TokenPos();
   // The case expressions node sequence does not own the enclosing scope.
@@ skipping 78 matching lines @@
       SourceLabel::New(switch_pos, label_name, SourceLabel::kSwitch);
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   const intptr_t expr_pos = TokenPos();
   AstNode* switch_expr = ParseExpr(kAllowConst, kConsumeCascades);
   ExpectToken(Token::kRPAREN);
   ExpectToken(Token::kLBRACE);
   OpenBlock();
   current_block_->scope->AddLabel(label);
 
-  // Store switch expression in temporary local variable.
+  // Store switch expression in temporary local variable. The type of the
+  // variable is set to dynamic. It will later be patched to match the
+  // type of the case clause expressions. Therefore, we have to allocate
+  // a new type representing dynamic and can't reuse the canonical
+  // type object for dynamic.
+  const Type& temp_var_type =
+      Type::ZoneHandle(Type::New(Class::Handle(Object::dynamic_class()),
+                                 TypeArguments::Handle(),
+                                 expr_pos));
+  temp_var_type.SetIsFinalized();
   LocalVariable* temp_variable =
-      new LocalVariable(expr_pos,
-                        Symbols::SwitchExpr(),
-                        Type::ZoneHandle(Type::DynamicType()));
+      new LocalVariable(expr_pos,  Symbols::SwitchExpr(), temp_var_type);
   current_block_->scope->AddVariable(temp_variable);
   AstNode* save_switch_expr =
       new StoreLocalNode(expr_pos, temp_variable, switch_expr);
   current_block_->statements->Add(save_switch_expr);
 
   // Parse case clauses
   bool default_seen = false;
   GrowableArray<LiteralNode*> case_expr_values;
   while (true) {
     // Check for statement label
@@ skipping 32 matching lines @@
     } else if (CurrentToken() != Token::kRBRACE) {
       ErrorMsg("'case' or '}' expected");
     } else if (case_label != NULL) {
       ErrorMsg("expecting at least one case clause after label");
     } else {
       break;
     }
   }
 
   // Check that all expressions in case clauses are of the same class,
-  // or implement int, double or String.
-  CheckCaseExpressions(case_expr_values);
+  // or implement int, double or String. Patch the type of the temporary
+  // variable holding the switch expression to match the type of the
+  // case clause constants.
+  temp_var_type.set_type_class(
+      Class::Handle(CheckCaseExpressions(case_expr_values)));
 
   // Check for unresolved label references.
   SourceLabel* unresolved_label =
       current_block_->scope->CheckUnresolvedLabels();
   if (unresolved_label != NULL) {
     ErrorMsg("unresolved reference to label '%s'",
              unresolved_label->name().ToCString());
   }
 
   SequenceNode* switch_body = CloseBlock();
@@ skipping 4341 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart