Rename the VM internal 'var' type to 'Dynamic' type.

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 305 matching lines @@
     param.name_pos = name_pos;
     param.name = &String::ZoneHandle(String::NewSymbol(name));
     param.is_final = true;
     param.type = type;
     this->parameters->Add(param);
   }
 
   void AddReceiver(intptr_t name_pos) {
     ASSERT(this->parameters->length() == 0);
     // The receiver does not need to be type checked.
-    AddFinalParameter(name_pos, kThisName, &Type::ZoneHandle(Type::VarType()));
+    AddFinalParameter(name_pos,
+                      kThisName,
+                      &Type::ZoneHandle(Type::DynamicType()));
   }
 
   void SetImplicitlyFinal() {
     implicitly_final = true;
   }
 
   int num_fixed_parameters;
   int num_optional_parameters;
   bool has_named_optional_parameters;  // Indicates use of the new syntax.
   bool has_field_initializer;
@@ skipping 424 matching lines @@
   ParamDesc parameter;
   bool var_seen = false;
   bool this_seen = false;
 
   if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     parameter.is_final = true;
   } else if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     var_seen = true;
-    // The parameter type is the 'var' type.
-    parameter.type = &Type::ZoneHandle(Type::VarType());
+    // 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 15 matching lines @@
     Token::Kind follower = LookaheadToken(1);
     // We have 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.
         (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::VarType());
+      parameter.type = &Type::ZoneHandle(Type::DynamicType());
     }
   }
   if (!this_seen && (CurrentToken() == Token::kTHIS)) {
     ConsumeToken();
     ExpectToken(Token::kPERIOD);
     this_seen = true;
     parameter.is_field_initializer = true;
   }
   // At this point, we must see an identifier for the parameter name.
   if (CurrentToken() != Token::kIDENT) {
@@ skipping 633 matching lines @@
 
   // Parse expressions of instance fields that have an explicit
   // initializers.
   GrowableArray<FieldInitExpression> initializers;
   Class& cls = Class::Handle(func.owner());
   ParseInitializedInstanceFields(cls, &initializers);
 
   LocalVariable* receiver = new LocalVariable(
       ctor_pos,
       String::ZoneHandle(String::NewSymbol(kThisName)),
-      Type::ZoneHandle(Type::VarType()));
+      Type::ZoneHandle(Type::DynamicType()));
   current_block_->scope->AddVariable(receiver);
 
   // Now that the "this" parameter is in scope, we can generate the code
   // to strore the initializer expressions in the respective instance fields.
   for (int i = 0; i < initializers.length(); i++) {
     const Field* field = initializers[i].inst_field;
     AstNode* instance = new LoadLocalNode(field->token_index(), *receiver);
     AstNode* field_init =
         new StoreInstanceFieldNode(field->token_index(),
                                    instance,
@@ skipping 581 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 'var' type.
-    member.type = &Type::ZoneHandle(Type::VarType());
+    // The member type is the 'Dynamic' type.
+    member.type = &Type::ZoneHandle(Type::DynamicType());
   } else if (CurrentToken() == Token::kFACTORY) {
     ConsumeToken();
     member.has_factory = true;
     member.has_static = true;
     // The member result type is the type of this class.
     // TODO(regis): What are the type arguments?
     member.type =
         &Type::ZoneHandle(Type::NewRawType(Class::Handle(members->clazz())));
   }
   // Optionally parse a type.
@@ skipping 64 matching lines @@
       }
     }
     if (CurrentToken() != Token::kLPAREN) {
       ErrorMsg("left parenthesis expected");
     }
   } else if (CurrentToken() == Token::kGET) {
     ConsumeToken();
     member.kind = RawFunction::kGetterFunction;
     member.name_pos = this->token_index_;
     member.name = ExpectIdentifier("identifier expected");
-    // If the result type was not specified, it will be set to VarType below.
+    // If the result type was not specified, it will be set to DynamicType.
   } else if (CurrentToken() == Token::kSET) {
     ConsumeToken();
     member.kind = RawFunction::kSetterFunction;
     member.name_pos = this->token_index_;
     member.name = ExpectIdentifier("identifier 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 (member.type == NULL) {
-      member.type = &Type::ZoneHandle(Type::VarType());
+      member.type = &Type::ZoneHandle(Type::DynamicType());
     }
   } else if (CurrentToken() == Token::kOPERATOR) {
     ConsumeToken();
     if (!Token::CanBeOverloaded(CurrentToken())) {
       ErrorMsg("invalid operator overloading");
     }
     if (member.has_static) {
       ErrorMsg("operator overloading functions cannot be static");
     }
     member.kind = RawFunction::kFunction;
@@ skipping 13 matching lines @@
   if (CurrentToken() == Token::kLPAREN) {
     if (members->is_interface() && member.has_static) {
       if (member.has_factory) {
         ErrorMsg("factory constructors are not allowed in interfaces");
       } else {
         ErrorMsg("static methods are not allowed in interfaces");
       }
     }
     // Constructor or method.
     if (member.type == NULL) {
-      member.type = &Type::ZoneHandle(Type::VarType());
+      member.type = &Type::ZoneHandle(Type::DynamicType());
     }
     ParseMethodOrConstructor(members, &member);
   } else if (CurrentToken() ==  Token::kSEMICOLON ||
              CurrentToken() == Token::kCOMMA ||
              CurrentToken() == Token::kASSIGN) {
     // Field definition.
     if (member.type == NULL) {
       if (member.has_final) {
-        member.type = &Type::ZoneHandle(Type::VarType());
+        member.type = &Type::ZoneHandle(Type::DynamicType());
       } else {
         ErrorMsg("missing 'var', 'final' or type in field declaration");
       }
     }
     if (members->is_interface() && member.has_static && !member.has_final) {
       ErrorMsg("static non-final fields are not allowed in interfaces");
     }
     ParseFieldDefinition(members, &member);
   } else {
     UnexpectedToken();
@@ skipping 146 matching lines @@
   }
   SetPosition(saved_pos);
   return is_alias_name;
 }
 
 
 void Parser::ParseFunctionTypeAlias(GrowableArray<const Class*>* classes) {
   TRACE_PARSER("ParseFunctionTypeAlias");
   ExpectToken(Token::kTYPEDEF);
 
-  Type& result_type = Type::Handle(Type::VarType());
+  Type& result_type = Type::Handle(Type::DynamicType());
   intptr_t result_type_pos = token_index_;
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if (!IsFunctionTypeAliasName()) {
     result_type = ParseType(kDoNotResolve);  // No owner class yet.
   }
 
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("function alias name expected");
@@ skipping 200 matching lines @@
   if (CurrentToken() == Token::kLT) {
     GrowableArray<String*> type_parameters;
     GrowableArray<Type*> type_parameter_extends;
     do {
       ConsumeToken();
       if (CurrentToken() != Token::kIDENT) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
       ConsumeToken();
-      Type& type_extends = Type::ZoneHandle(Type::VarType());
+      Type& type_extends = Type::ZoneHandle(Type::DynamicType());
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
         type_extends = ParseType(kCanResolve);
       }
       type_parameters.Add(&type_parameter_name);
       type_parameter_extends.Add(&type_extends);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) ||
         (token == Token::kSAR) ||
@@ skipping 116 matching lines @@
       ConsumeToken();
       break;
     } else {
       ExpectSemicolon();  // Reports error.
     }
   }
 }
 
 
 void Parser::ParseTopLevelFunction(TopLevel* top_level) {
-  Type& result_type = Type::Handle(Type::VarType());
+  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)) {
       result_type = ParseType(kCanResolve);
     }
@@ skipping 34 matching lines @@
 }
 
 
 void Parser::ParseTopLevelAccessor(TopLevel* top_level) {
   const bool is_static = true;
   Type& result_type = Type::Handle();
   bool is_getter = (CurrentToken() == Token::kGET);
   if (CurrentToken() == Token::kGET ||
       CurrentToken() == Token::kSET) {
     ConsumeToken();
-    result_type = Type::VarType();
+    result_type = Type::DynamicType();
   } else {
     if (CurrentToken() == Token::kVOID) {
       ConsumeToken();
       result_type = Type::VoidType();
     } else {
       result_type = ParseType(kCanResolve);
     }
     is_getter = (CurrentToken() == Token::kGET);
     if (CurrentToken() == Token::kGET || CurrentToken() == Token::kSET) {
       ConsumeToken();
@@ skipping 455 matching lines @@
   if (is_final) {
     variable->set_is_final();
   }
   return initialization;
 }
 
 
 // Parses ('var' | 'final' [type] | type).
 // The presence of 'final' must be detected and remembered before the call.
 // If type_specification is kIsOptional, and no type can be parsed, then return
-// the VarType.
+// the DynamicType.
 // If a type is parsed, it is resolved (or not) according to type_resolution.
 RawType* Parser::ParseFinalVarOrType(TypeSpecification type_specification,
                                      TypeResolution type_resolution) {
   if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
-    return Type::VarType();
+    return Type::DynamicType();
   }
   if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     type_specification = kIsOptional;
   }
   if (CurrentToken() != Token::kIDENT) {
     if (type_specification == kIsOptional) {
-      return Type::VarType();
+      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.
     // We either parse a type or return now.
     if ((follower != Token::kLT) &&  // Parameterized type.
         (follower != Token::kPERIOD) &&  // Qualified class name of type.
         (follower != Token::kIDENT) &&  // Variable name following a type.
         (follower != Token::kTHIS)) {  // Field parameter following a type.
-      return Type::VarType();
+      return Type::DynamicType();
     }
   }
   return ParseType(type_resolution);
 }
 
 
 // Returns ast nodes of the variable initialization, or NULL if variables
 // are not initialized. If several variables are declared and initialized,
 // the individual initializers are collected in a sequence node.
 AstNode* Parser::ParseVariableDeclarationList() {
@@ skipping 28 matching lines @@
   return initializers;
 }
 
 
 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::VarType();
+  result_type = Type::DynamicType();
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if ((CurrentToken() == Token::kIDENT) &&
              (LookaheadToken(1) != Token::kLPAREN)) {
     result_type = ParseType(kMustResolve);
   }
   intptr_t ident_pos = token_index_;
   if (CurrentToken() == Token::kIDENT) {
     variable_name = CurrentLiteral();
@@ skipping 529 matching lines @@
     ExpectToken(Token::kRPAREN);
   }
   ExpectToken(Token::kLBRACE);
   OpenBlock();
   current_block_->scope->AddLabel(label);
 
   // Store switch expression in temporary local variable.
   LocalVariable* temp_variable =
       new LocalVariable(expr_pos,
                         String::ZoneHandle(String::NewSymbol(":switch_expr")),
-                        Type::ZoneHandle(Type::VarType()));
+                        Type::ZoneHandle(Type::DynamicType()));
   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;
   while (true) {
     // Check for statement label
     SourceLabel* case_label = NULL;
@@ skipping 111 matching lines @@
   OpenBlock();  // Implicit block around while loop.
 
   // Generate implicit iterator variable and add to scope.
   const String& iterator_name =
       String::ZoneHandle(String::NewSymbol(":for-in-iter"));
   // We could set the type of the implicit iterator variable to Iterator<T>
   // where T is the type of the for loop variable. However, the type error
   // would refer to the compiler generated iterator and could confuse the user.
   // It is better to leave the iterator untyped and postpone the type error
   // until the loop variable is assigned to.
-  const Type& iterator_type = Type::ZoneHandle(Type::VarType());
+  const Type& iterator_type = Type::ZoneHandle(Type::DynamicType());
   LocalVariable* iterator_var =
       new LocalVariable(collection_pos, iterator_name, iterator_type);
   current_block_->scope->AddVariable(iterator_var);
 
   // Generate initialization of iterator variable.
   const String& iterator_method_name =
       String::ZoneHandle(String::NewSymbol(kGetIteratorName));
   ArgumentListNode* no_args = new ArgumentListNode(collection_pos);
   AstNode* get_iterator = new InstanceCallNode(
       collection_pos, collection_expr, iterator_method_name, no_args);
@@ skipping 317 matching lines @@
   // :exception_var and :stacktrace_var get set with the exception object
   // and the stacktrace object when an exception is thrown.
   // These three implicit variables can never be captured variables.
   const String& context_var_name =
       String::ZoneHandle(String::NewSymbol(":saved_context_var"));
   LocalVariable* context_var =
       current_block_->scope->LocalLookupVariable(context_var_name);
   if (context_var == NULL) {
     context_var = new LocalVariable(token_index_,
                                     context_var_name,
-                                    Type::ZoneHandle(Type::VarType()));
+                                    Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(context_var);
   }
   const String& catch_excp_var_name =
       String::ZoneHandle(String::NewSymbol(":exception_var"));
   LocalVariable* catch_excp_var =
       current_block_->scope->LocalLookupVariable(catch_excp_var_name);
   if (catch_excp_var == NULL) {
     catch_excp_var = new LocalVariable(token_index_,
                                        catch_excp_var_name,
-                                       Type::ZoneHandle(Type::VarType()));
+                                       Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(catch_excp_var);
   }
   const String& catch_trace_var_name =
       String::ZoneHandle(String::NewSymbol(":stacktrace_var"));
   LocalVariable* catch_trace_var =
       current_block_->scope->LocalLookupVariable(catch_trace_var_name);
   if (catch_trace_var == NULL) {
     catch_trace_var = new LocalVariable(token_index_,
                                         catch_trace_var_name,
-                                        Type::ZoneHandle(Type::VarType()));
+                                        Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(catch_trace_var);
   }
 
   intptr_t try_pos = token_index_;
   ConsumeToken();  // Consume the 'try'.
 
   SourceLabel* try_label = NULL;
   if (label_name != NULL) {
     try_label = SourceLabel::New(try_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
@@ skipping 77 matching lines @@
                              *trace,
                              new LoadLocalNode(catch_pos, *catch_trace_var)));
     }
 
     ParseStatementSequence();  // Parse the catch handler code.
     current_block_->statements->Add(
         new JumpNode(catch_pos, Token::kCONTINUE, end_catch_label));
     SequenceNode* catch_handler = CloseBlock();
     ExpectToken(Token::kRBRACE);
 
-    if (!exception_param.type->IsVarType()) {  // Has a type specification.
+    if (!exception_param.type->IsDynamicType()) {  // Has a type specification.
       // Now form an 'if type check' as an exception type exists in
       // the catch specifier.
       if (!exception_param.type->IsInstantiated() &&
           (current_block_->scope->function_level() > 0)) {
         // Make sure that the instantiator is captured.
         CaptureReceiver();
       }
       AstNode* exception_type = new TypeNode(catch_pos, *exception_param.type);
       AstNode* exception_var = new LoadLocalNode(catch_pos, *catch_excp_var);
       AstNode* cond_expr = new ComparisonNode(
@@ skipping 471 matching lines @@
 
 
 LocalVariable* Parser::CreateTempConstVariable(intptr_t token_index,
                                                intptr_t token_id,
                                                const char* s) {
   char name[64];
   OS::SNPrint(name, 64, "%s%d", s, token_id);
   LocalVariable* temp =
       new LocalVariable(token_index,
                         String::ZoneHandle(String::NewSymbol(name)),
-                        Type::ZoneHandle(Type::VarType()));
+                        Type::ZoneHandle(Type::DynamicType()));
   temp->set_is_final();
   current_block_->scope->AddVariable(temp);
   return temp;
 }
 
 
 // If 'node' can create side effects, store its result in a temporary variable
 // and return a LoadLocalNode instead.
 // Side effect free nodes are LoadLocalNode and LiteralNode.
 AstNode* Parser::AsSideEffectFreeNode(AstNode* node) {
@@ skipping 1157 matching lines @@
 // as one token of type Token::kINDEX.
 AstNode* Parser::ParseArrayLiteral(intptr_t type_pos,
                                    bool is_const,
                                    const TypeArguments& type_arguments) {
   ASSERT(CurrentToken() == Token::kLBRACK || CurrentToken() == Token::kINDEX);
   intptr_t literal_pos = token_index_;
   bool is_empty_literal = CurrentToken() == Token::kINDEX;
   ConsumeToken();
 
   // If no type arguments are provided, leave them as null, which is equivalent
-  // to using Array<var>. See issue 4966724.
+  // to using Array<Dynamic>. See issue 4966724.
   if (!type_arguments.IsNull()) {
     // For now, only check the number of type arguments. See issue 4975876.
     if (type_arguments.Length() != 1) {
       ASSERT(type_pos >= 0);
       ErrorMsg(type_pos, "wrong number of type arguments for Array literal");
     }
   }
 
   // Parse the array elements. Note: there may be an optional extra
   // comma after the last element.
@@ skipping 93 matching lines @@
   ConsumeToken();
 
   String& map_class_name = String::Handle(
       String::NewSymbol(is_const ? kImmutableMapName : kMutableMapName));
   const Class& map_class = Class::Handle(LookupImplClass(map_class_name));
   ASSERT(!map_class.IsNull());
 
   TypeArguments& map_type_arguments =
       TypeArguments::ZoneHandle(type_arguments.raw());
   // If no type arguments are provided, leave them as null, which is equivalent
-  // to using Map<var, var>. See issue 4966724.
+  // to using Map<Dynamic, Dynamic>. See issue 4966724.
   if (!map_type_arguments.IsNull()) {
     // For now, only check the number of type arguments. See issue 4975876.
     if (map_type_arguments.Length() != 2) {
       ASSERT(type_pos >= 0);
       ErrorMsg(type_pos, "wrong number of type arguments for Map literal");
     }
   }
 
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
@@ skipping 724 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart