Support for type dynamic in VM

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 13 matching lines @@
 
 DEFINE_FLAG(bool, constructor_name_check, false,
             "Named constructors may not clash with other members");
 DEFINE_FLAG(bool, enable_asserts, false, "Enable assert statements.");
 DEFINE_FLAG(bool, enable_type_checks, false, "Enable type checks.");
 DEFINE_FLAG(bool, trace_parser, false, "Trace parser operations.");
 DEFINE_FLAG(bool, warning_as_error, false, "Treat warnings as errors.");
 DEFINE_FLAG(bool, silent_warnings, false, "Silence warnings.");
 DEFINE_FLAG(bool, warn_legacy_map_literal, false,
             "Warning on legacy map literal syntax (single type argument)");
+DEFINE_FLAG(bool, warn_legacy_dynamic, false,
+            "Warning on legacy type Dynamic)");
 
 static void CheckedModeHandler(bool value) {
   FLAG_enable_asserts = value;
   FLAG_enable_type_checks = value;
 }
 
 // --enable-checked-mode and --checked both enable checked mode which is
 // equivalent to setting --enable-asserts and --enable-type-checks.
 DEFINE_FLAG_HANDLER(CheckedModeHandler,
                     enable_checked_mode,
@@ skipping 963 matching lines @@
   bool var_seen = false;
   bool this_seen = false;
 
   SkipMetadata();
   if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     parameter.is_final = true;
   } else if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     var_seen = true;
-    // The parameter type is the 'Dynamic' type.
+    // The parameter type is the 'dynamic' type.
     parameter.type = &Type::ZoneHandle(Type::DynamicType());
   }
   if (CurrentToken() == Token::kTHIS) {
     ConsumeToken();
     ExpectToken(Token::kPERIOD);
     this_seen = true;
     parameter.is_field_initializer = true;
   }
   if (params->implicitly_final) {
     parameter.is_final = true;
@@ skipping 1837 matching lines @@
   }
   if (CurrentToken() == Token::kVAR) {
     if (member.has_const) {
       ErrorMsg("identifier expected after 'const'");
     }
     if (member.has_final) {
       ErrorMsg("identifier expected after 'final'");
     }
     ConsumeToken();
     member.has_var = true;
-    // The member type is the 'Dynamic' type.
+    // The member type is the 'dynamic' type.
     member.type = &Type::ZoneHandle(Type::DynamicType());
   } else if (CurrentToken() == Token::kFACTORY) {
     ConsumeToken();
     if (member.has_static) {
       ErrorMsg("factory method cannot be explicitly marked static");
     }
     member.has_factory = true;
     member.has_static = true;
     // The result type depends on the name of the factory method.
   }
@@ skipping 103 matching lines @@
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON))  {
     ConsumeToken();
     member.kind = RawFunction::kSetterFunction;
     member.name_pos = this->TokenPos();
     member.name = ExpectIdentifier("identifier expected");
     if (CurrentToken() != Token::kLPAREN) {
       ErrorMsg("'(' expected");
     }
     // The grammar allows a return type, so member.type is not always NULL here.
-    // If no return type is specified, the return type of the setter is Dynamic.
+    // If no return type is specified, the return type of the setter is dynamic.
     if (member.type == NULL) {
       member.type = &Type::ZoneHandle(Type::DynamicType());
     }
   } else if ((CurrentToken() == Token::kOPERATOR) && !member.has_var &&
              (LookaheadToken(1) != Token::kLPAREN) &&
              (LookaheadToken(1) != Token::kASSIGN) &&
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON)) {
     ConsumeToken();
     if (!Token::CanBeOverloaded(CurrentToken())) {
@@ skipping 656 matching lines @@
     const GrowableObjectArray& types =
         GrowableObjectArray::Handle(GrowableObjectArray::New());
     AbstractType& type = AbstractType::Handle();
     do {
       ConsumeToken();
       type = ParseType(finalization);
       // Only keep the error for the first malformed type argument.
       if (malformed_error->IsNull() && type.IsMalformed()) {
         *malformed_error = type.malformed_error();
       }
-      // Map a malformed type argument to Dynamic, so that malformed types with
+      // Map a malformed type argument to dynamic, so that malformed types with
       // a resolved type class are handled properly in production mode.
       if (type.IsMalformed()) {
         ASSERT(finalization != ClassFinalizer::kCanonicalizeWellFormed);
         if (finalization == ClassFinalizer::kCanonicalizeForCreation) {
           ErrorMsg(*malformed_error);
         }
         type = Type::DynamicType();
       }
       types.Add(type);
     } while (CurrentToken() == Token::kCOMMA);
@@ skipping 1469 matching lines @@
   }
   if ((CurrentToken() != Token::kIDENT) && (CurrentToken() != Token::kCONST)) {
     // Not a legal type identifier or const keyword or metadata.
     return false;
   }
   const intptr_t saved_pos = TokenPos();
   bool is_var_decl = false;
   bool have_type = false;
   if (CurrentToken() == Token::kCONST) {
     ConsumeToken();
-    have_type = true;  // Type is Dynamic.
+    have_type = true;  // Type is dynamic.
   }
   if (IsIdentifier()) {  // Type or variable name.
     Token::Kind follower = LookaheadToken(1);
     if ((follower == Token::kLT) ||  // Parameterized type.
         (follower == Token::kPERIOD) ||  // Qualified class name of type.
         Token::IsIdentifier(follower)) {  // Variable name following a type.
       // We see the beginning of something that could be a type.
       const intptr_t type_pos = TokenPos();
       if (TryParseOptionalType()) {
         have_type = true;
@@ skipping 894 matching lines @@
       exception_param.type =
           &AbstractType::ZoneHandle(Type::DynamicType());
     }
     if (CurrentToken() == Token::kCATCH) {
       ConsumeToken();  // Consume the 'catch'.
       ExpectToken(Token::kLPAREN);
       exception_param.token_pos = TokenPos();
       exception_param.var = ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kCOMMA) {
         ConsumeToken();
-        // TODO(hausner): Make implicit type be StackTrace, not Dynamic.
+        // TODO(hausner): Make implicit type be StackTrace, not dynamic.
         stack_trace_param.type =
             &AbstractType::ZoneHandle(Type::DynamicType());
         stack_trace_param.token_pos = TokenPos();
         stack_trace_param.var = ExpectIdentifier("identifier expected");
       }
       ExpectToken(Token::kRPAREN);
     }
 
     // If a generic "catch all" statement has already been seen then all
     // subsequent catch statements are dead. We issue an error for now,
@@ skipping 488 matching lines @@
            CurrentToken() == Token::kIDENT ?
                CurrentLiteral()->ToCString() : Token::Str(CurrentToken()));
 }
 
 
 String* Parser::ExpectClassIdentifier(const char* msg) {
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("%s", msg);
   }
   String* ident = CurrentLiteral();
-  if (ident->Equals("Dynamic")) {
+  // TODO(hausner): Remove check for 'Dynamic' once support for upper-case
+  // type dynamic is gone.
+  if (ident->Equals("Dynamic") || ident->Equals("dynamic")) {
     ErrorMsg("%s", msg);
   }
   ConsumeToken();
   return ident;
 }
 
 
 // Check whether current token is an identifier or a built-in identifier.
 String* Parser::ExpectIdentifier(const char* msg) {
   if (!IsIdentifier()) {
@@ skipping 1764 matching lines @@
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseType");
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
   QualIdent type_name;
   if (finalization == ClassFinalizer::kIgnore) {
     SkipQualIdent();
   } else {
     ParseQualIdent(&type_name);
+    // TODO(hausner): Remove this once support for legacy type 'Dynamic'
+    // is removed.
+    if ((type_name.lib_prefix == NULL) && type_name.ident->Equals("Dynamic")) {
+      if (FLAG_warn_legacy_dynamic) {
+        Warning(type_name.ident_pos,
+                "legacy type 'Dynamic' found; auto-converting to 'dynamic'");
+      }
+      // Replace with lower-case 'dynamic'.
+      *type_name.ident ^= Symbols::Dynamic();
+    }
     // An identifier cannot be resolved in a local scope when top level parsing.
     if (!is_top_level_ &&
         (type_name.lib_prefix == NULL) &&
         ResolveIdentInLocalScope(type_name.ident_pos, *type_name.ident, NULL)) {
       ErrorMsg(type_name.ident_pos, "using '%s' in this context is invalid",
                type_name.ident->ToCString());
     }
   }
   Object& type_class = Object::Handle();
   // Leave type_class as null if type finalization mode is kIgnore.
   if (finalization != ClassFinalizer::kIgnore) {
     LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
     if (type_name.lib_prefix != NULL) {
       lib_prefix = type_name.lib_prefix->raw();
     }
     type_class = UnresolvedClass::New(lib_prefix,
                                       *type_name.ident,
                                       type_name.ident_pos);
   }
   Error& malformed_error = Error::Handle();
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(ParseTypeArguments(&malformed_error,
                                                        finalization));
   if (finalization == ClassFinalizer::kIgnore) {
     return Type::DynamicType();
   }
   AbstractType& type = AbstractType::Handle(
       Type::New(type_class, type_arguments, type_name.ident_pos));
-  // In production mode, malformed type arguments are mapped to Dynamic.
+  // In production mode, malformed type arguments are mapped to dynamic.
   // In checked mode, a type with malformed type arguments is malformed.
   if (FLAG_enable_type_checks && !malformed_error.IsNull()) {
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type.raw();
     parameterized_type.set_type_class(Class::Handle(Object::dynamic_class()));
     parameterized_type.set_arguments(AbstractTypeArguments::Handle());
     parameterized_type.set_malformed_error(malformed_error);
   }
   if (finalization >= ClassFinalizer::kTryResolve) {
     ResolveTypeFromClass(current_class(), finalization, &type);
@@ skipping 30 matching lines @@
                                   const AbstractTypeArguments& type_arguments) {
   TRACE_PARSER("ParseListLiteral");
   ASSERT(type_pos >= 0);
   ASSERT(CurrentToken() == Token::kLBRACK || CurrentToken() == Token::kINDEX);
   const intptr_t literal_pos = TokenPos();
   bool is_empty_literal = CurrentToken() == Token::kINDEX;
   ConsumeToken();
 
   AbstractType& element_type = Type::ZoneHandle(Type::DynamicType());
   // If no type argument vector is provided, leave it as null, which is
-  // equivalent to using Dynamic as the type argument for the element type.
+  // equivalent to using dynamic as the type argument for the element type.
   if (!type_arguments.IsNull()) {
     ASSERT(type_arguments.Length() > 0);
     // List literals take a single type argument.
     element_type = type_arguments.TypeAt(0);
     if (type_arguments.Length() != 1) {
       ErrorMsg(type_pos,
                "a list literal takes one type argument specifying "
                "the element type");
     }
     if (is_const && !element_type.IsInstantiated()) {
@@ skipping 149 matching lines @@
   TRACE_PARSER("ParseMapLiteral");
   ASSERT(type_pos >= 0);
   ASSERT(CurrentToken() == Token::kLBRACE);
   const intptr_t literal_pos = TokenPos();
   ConsumeToken();
 
   AbstractType& value_type = Type::ZoneHandle(Type::DynamicType());
   AbstractTypeArguments& map_type_arguments =
       AbstractTypeArguments::ZoneHandle(type_arguments.raw());
   // If no type argument vector is provided, leave it as null, which is
-  // equivalent to using Dynamic as the type argument for the value type.
+  // equivalent to using dynamic as the type argument for the value type.
   if (!map_type_arguments.IsNull()) {
     ASSERT(map_type_arguments.Length() > 0);
     // Map literals take two type arguments.
     if (map_type_arguments.Length() < 2) {
       // TODO(hausner): Remove legacy syntax support.
       // We temporarily accept a single type argument.
       if (FLAG_warn_legacy_map_literal) {
         Warning(type_pos,
                 "a map literal takes two type arguments specifying "
                 "the key type and the value type");
@@ skipping 16 matching lines @@
     }
     if (is_const && !value_type.IsInstantiated()) {
       ErrorMsg(type_pos,
                "the type argument of a constant map literal cannot include "
                "a type variable");
     }
   }
   ASSERT(map_type_arguments.IsNull() || (map_type_arguments.Length() == 2));
   map_type_arguments ^= map_type_arguments.Canonicalize();
 
-  // The kv_pair array is temporary and of element type Dynamic. It is passed
+  // The kv_pair array is temporary and of element type dynamic. It is passed
   // to the factory to initialize a properly typed map.
   ArrayNode* kv_pairs =
       new ArrayNode(TokenPos(), Type::ZoneHandle(Type::ListInterface()));
 
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
   const String& dst_name = String::ZoneHandle(Symbols::ListLiteralElement());
   while (CurrentToken() != Token::kRBRACE) {
     AstNode* key = NULL;
     if (CurrentToken() == Token::kSTRING) {
@@ skipping 1050 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart