Add support for 'Dynamic' type in the VM.

runtime/vm/parser.cc

 // Copyright (c) 2011, 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 772 matching lines @@
     parameter.is_final = true;
   }
   if ((parameter.type == NULL) && (CurrentToken() == Token::kVOID)) {
     ConsumeToken();
     // This must later be changed to a closure type if we recognize
     // a closure/function type parameter. We check this at the end
     // of ParseFormalParameter.
     parameter.type = &Type::ZoneHandle(Type::VoidType());
   }
   if (parameter.type == NULL) {
-    // At this point, we must see an identifier for the type or the
+    // At this point, we must see 'Dynamic' or an identifier for the type or the
     // function parameter.
-    if (CurrentToken() != Token::kIDENT) {
+    if ((CurrentToken() != Token::kIDENT) &&
+        (CurrentToken() != Token::kDYNAMIC)) {
       ErrorMsg("parameter name or type expected");
     }
     // We have not seen a parameter type yet, so we check if the next
-    // identifier could represent a type before parsing it.
+    // token could represent a type before parsing it.
     Token::Kind follower = LookaheadToken(1);
-    // We have an identifier followed by a 'follower' token.
+    // We have 'Dynamic' or an identifier followed by a 'follower' token.
     // We either parse a type or assume that no type is specified.
-    if ((follower == Token::kLT) ||  // Parameterized type.
+    if ((CurrentToken() == Token::kDYNAMIC) ||  // Dynamic type.
+        (follower == Token::kLT) ||  // Parameterized type.
         (follower == Token::kPERIOD) ||  // Qualified class name of type.
         (follower == Token::kIDENT) ||  // Parameter name following a type.
         (follower == Token::kTHIS)) {  // Field parameter following a type.
       parameter.type = &Type::ZoneHandle(
           ParseType(is_top_level_ ? kCanResolve : kMustResolve));
     } else {
       parameter.type = &Type::ZoneHandle(Type::DynamicType());
     }
   }
   if (!this_seen && (CurrentToken() == Token::kTHIS)) {
@@ skipping 1261 matching lines @@
         &Type::ZoneHandle(Type::NewRawType(Class::Handle(members->clazz())));
   }
   // Optionally parse a type.
   if (CurrentToken() == Token::kVOID) {
     if (member.has_var || member.has_factory) {
       ErrorMsg("void not expected");
     }
     ConsumeToken();
     ASSERT(member.type == NULL);
     member.type = &Type::ZoneHandle(Type::VoidType());
-  } else if (CurrentToken() == Token::kIDENT) {
+  } else if ((CurrentToken() == Token::kIDENT) ||
+             (CurrentToken() == Token::kDYNAMIC)) {
     // This is either a type name or the name of a method/constructor/field.
     if (member.type == NULL) {
       // We have not seen a member type yet, so we check if the next
       // identifier could represent a type before parsing it.
       Token::Kind follower = LookaheadToken(1);
-      // We have an identifier followed by a 'follower' token.
+      // We have 'Dynamic' or an identifier followed by a 'follower' token.
       // We either parse a type or assume that no type is specified.
-      if ((follower == Token::kLT) ||  // Parameterized type.
+      if ((CurrentToken() == Token::kDYNAMIC) ||  // Dynamic type.
+          (follower == Token::kLT) ||  // Parameterized type.
           (follower == Token::kGET) ||  // Getter following a type.
           (follower == Token::kSET) ||  // Setter following a type.
           (follower == Token::kOPERATOR) ||  // Operator following a type.
           (follower == Token::kIDENT)  ||  // Member name following a type.
           ((follower == Token::kPERIOD) &&    // Qualified class name of type,
            (LookaheadToken(3) != Token::kLPAREN))) {  // but not a named constr.
         ASSERT(is_top_level_);
         member.type = &Type::ZoneHandle(ParseType(kCanResolve));
       }
     }
@@ skipping 235 matching lines @@
     }
   }
 }
 
 
 // Look ahead to detect if we are seeing ident [ TypeParameters ] "(".
 // We need this lookahead to distinguish between the optional return type
 // and the alias name of a function type alias.
 // Token position remains unchanged.
 bool Parser::IsFunctionTypeAliasName() {
+  if (CurrentToken() == Token::kDYNAMIC) {
+    return false;
+  }
   if ((CurrentToken() == Token::kIDENT) &&
       (LookaheadToken(1) == Token::kLPAREN)) {
     return true;
   }
   const intptr_t saved_pos = token_index_;
   bool is_alias_name = false;
   if ((CurrentToken() == Token::kIDENT)  &&
       (LookaheadToken(1) == Token::kLT)) {
     ConsumeToken();
     if (IsTypeParameter() && (CurrentToken() == Token::kLPAREN)) {
@@ skipping 218 matching lines @@
   }
 }
 
 
 void Parser::ParseTypeParameters(const Class& cls) {
   if (CurrentToken() == Token::kLT) {
     GrowableArray<String*> type_parameters;
     GrowableArray<Type*> type_parameter_extends;
     do {
       ConsumeToken();
-      if (CurrentToken() != Token::kIDENT) {
+      if ((CurrentToken() != Token::kDYNAMIC) &&
+          (CurrentToken() != Token::kIDENT)) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
       ConsumeToken();
       Type& type_extends = Type::ZoneHandle(Type::DynamicType());
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
         type_extends = ParseType(kCanResolve);
       }
       type_parameters.Add(&type_parameter_name);
@@ skipping 128 matching lines @@
 
 
 void Parser::ParseTopLevelFunction(TopLevel* top_level) {
   Type& result_type = Type::Handle(Type::DynamicType());
   const bool is_static = true;
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else {
     // Parse optional type.
-    if ((CurrentToken() == Token::kIDENT) &&
-        (LookaheadToken(1) != Token::kLPAREN)) {
+    if ((CurrentToken() == Token::kDYNAMIC) ||
+        ((CurrentToken() == Token::kIDENT) &&
+         (LookaheadToken(1) != Token::kLPAREN))) {
       result_type = ParseType(kCanResolve);
     }
   }
   const intptr_t name_pos = token_index_;
   const String& func_name = *ExpectIdentifier("function name expected");
 
   if (library_.LookupObject(func_name) != Object::null()) {
     ErrorMsg(name_pos, "'%s' is already defined", func_name.ToCString());
   }
 
@@ skipping 514 matching lines @@
 RawType* Parser::ParseFinalVarOrType(TypeSpecification type_specification,
                                      TypeResolution type_resolution) {
   if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     return Type::DynamicType();
   }
   if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     type_specification = kIsOptional;
   }
+  if (CurrentToken() == Token::kDYNAMIC) {
+    ConsumeToken();
+    return Type::DynamicType();
+  }
   if (CurrentToken() != Token::kIDENT) {
     if (type_specification == kIsOptional) {
       return Type::DynamicType();
     } else {
       ErrorMsg("identifier expected");
     }
   }
   if (type_specification == kIsOptional) {
     Token::Kind follower = LookaheadToken(1);
     // We have an identifier followed by a 'follower' token.
@@ skipping 48 matching lines @@
 AstNode* Parser::ParseFunctionStatement(bool is_literal) {
   TRACE_PARSER("ParseFunctionStatement");
   Type& result_type = Type::Handle();
   const String* variable_name = NULL;
   const String* function_name = NULL;
 
   result_type = Type::DynamicType();
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
-  } else if ((CurrentToken() == Token::kIDENT) &&
-             (LookaheadToken(1) != Token::kLPAREN)) {
+  } else if ((CurrentToken() == Token::kDYNAMIC) ||
+             ((CurrentToken() == Token::kIDENT) &&
+              (LookaheadToken(1) != Token::kLPAREN))) {
     result_type = ParseType(kMustResolve);
   }
   intptr_t ident_pos = token_index_;
   if (CurrentToken() == Token::kIDENT) {
     variable_name = CurrentLiteral();
     function_name = variable_name;
     ConsumeToken();
   } else {
     if (!is_literal) {
       ErrorMsg("function name expected");
@@ skipping 2705 matching lines @@
     } else {
       ASSERT(primary->primary().IsClass());
       ErrorMsg(ident_pos, "illegal reference to class or interface '%s'",
                ident.ToCString());
     }
   }
   return var_or_field;
 }
 
 
-// Parses type = [ident "."] ident ["<" type { "," type } ">"].
+// Parses type = "Dynamic" | ([ident "."] ident ["<" type { "," type } ">"]).
 // Returns the class object if the type can be resolved. Otherwise, either give
 // an error if type resolution was required, or return the unresolved name as a
 // string object.
 RawType* Parser::ParseType(TypeResolution type_resolution) {
+  if (CurrentToken() == Token::kDYNAMIC) {
+    ConsumeToken();
+    return Type::DynamicType();
+  }
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
   QualIdent type_name;
   intptr_t type_pos = token_index_;
   ParseQualIdent(&type_name);
   if (type_name.local_scope_ident) {
     ErrorMsg(type_pos, "Using '%s' in this context is invalid",
              type_name.ident->ToCString());
   }
@@ skipping 308 matching lines @@
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
 
   // The grammar allows for an optional ('.' identifier)?, which is a named
   // constructor. For that reason, we cannot unconditionally call
   // ParseType(kMustResolve) after we see an identifier, because the named
   // constructor would be misinterpreted as a qualified type name.
   // TODO(regis): Revisit once we correctly support qualified identifiers.
   // For now, we inline a customized version of ParseType(kMustResolve).
+  // Note that the inline version of ParseType correctly refuses 'Dynamic'.
   Type& type = Type::Handle();
   Class& type_class = Class::ZoneHandle();
   String& type_class_name = String::Handle();
   TypeArguments& type_arguments = TypeArguments::ZoneHandle();
   String* named_constructor = NULL;
   intptr_t  type_pos = token_index_;
   QualIdent type_name;
   ParseQualIdent(&type_name);
   if (type_name.local_scope_ident) {
     ErrorMsg(type_pos, "Using '%s' in this context is invalid",
@@ skipping 583 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart