Proper handling of built-in identifiers

runtime/vm/parser.cc

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// 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"
 #include "vm/dart_api_impl.h"
@@ skipping 227 matching lines @@
   }
 }
 
 
 Token::Kind Parser::CurrentToken() {
   if (token_kind_ == Token::kILLEGAL) {
     token_kind_ = tokens_.KindAt(token_index_);
     if (token_kind_ == Token::kERROR) {
       ErrorMsg(token_index_, CurrentLiteral()->ToCString());
     }
-    if (Token::IsPseudoKeyword(token_kind_) && !is_top_level_) {
-      token_kind_ = Token::kIDENT;
-    }
   }
   CompilerStats::num_token_checks++;
   return token_kind_;
 }
 
 
 Token::Kind Parser::LookaheadToken(int num_tokens) {
   CompilerStats::num_tokens_lookahead++;
   CompilerStats::num_token_checks++;
   return tokens_.KindAt(token_index_ + num_tokens);
@@ skipping 368 matching lines @@
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
   ASSERT(func.num_optional_parameters() == 0);
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Static const fields must have an initializer.
-  ExpectToken(Token::kIDENT);
+  ExpectIdentifier("field name expected");
   ExpectToken(Token::kASSIGN);
 
   // We don't want to use ParseConstExpr() here because we don't want
   // the constant folding code to create, compile and execute a code
   // fragment to evaluate the expression. Instead, we just make sure
   // the static const field initializer is a constant expression and
   // leave the evaluation to the getter function.
   const intptr_t expr_pos = token_index_;
   AstNode* expr = ParseExpr(kAllowConst);
   if (expr->EvalConstExpr() == NULL) {
@@ skipping 19 matching lines @@
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   LoadLocalNode* load_receiver = new LoadLocalNode(token_index_, *receiver);
   // token_index_ is the function's token position which points to the name of
   // the field;
-  ASSERT(CurrentToken() == Token::kIDENT);
+  ASSERT(IsIdentifier());
   const String& field_name = *CurrentLiteral();
   const Class& field_class = Class::Handle(func.owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupInstanceField(field_name));
 
   LoadInstanceFieldNode* load_field =
       new LoadInstanceFieldNode(token_index_, load_receiver, field);
 
   ReturnNode* return_node = new ReturnNode(token_index_, load_field);
   current_block_->statements->Add(return_node);
@@ skipping 115 matching lines @@
   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
     // function parameter.
-    if (CurrentToken() != Token::kIDENT) {
+    if (!IsIdentifier()) {
       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::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.
+        Token::IsIdentifier(follower) ||  // Parameter name following a type.
         (follower == Token::kTHIS)) {  // Field parameter following a type.
       parameter.type = &AbstractType::ZoneHandle(
           ParseType(is_top_level_ ? kCanResolve : kMustResolve));
     } else {
       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) {
-    ErrorMsg("parameter name expected");
-  }
-  parameter.name = CurrentLiteral();
   parameter.name_pos = token_index_;
-  ConsumeToken();
+  parameter.name = ExpectIdentifier("parameter name expected");
+
   if (parameter.is_field_initializer) {
     params->has_field_initializer = true;
   }
 
   if (CurrentToken() == Token::kLPAREN) {
     // This parameter is probably a closure. If we saw the keyword 'var'
     // or 'final', a closure is not legal here and we ignore the
     // opening parens.
     if (!var_seen && !parameter.is_final) {
       // The parsed parameter type is actually the function result type.
@@ skipping 522 matching lines @@
   const Array& fields = Array::Handle(cls.fields());
   Field& f = Field::Handle();
   const intptr_t saved_pos = token_index_;
   for (int i = 0; i < fields.Length(); i++) {
     f ^= fields.At(i);
     if (!f.is_static() && f.has_initializer()) {
       Field& field = Field::ZoneHandle();
       field ^= fields.At(i);
       intptr_t field_pos = field.token_index();
       SetPosition(field_pos);
-      ASSERT(CurrentToken() == Token::kIDENT);
+      ASSERT(IsIdentifier());
       ConsumeToken();
       ExpectToken(Token::kASSIGN);
       AstNode* init_expr = ParseConstExpr();
       ASSERT(init_expr != NULL);
       FieldInitExpression initializer;
       initializer.inst_field = &field;
       initializer.expr = init_expr;
       initializers->Add(initializer);
     }
   }
@@ skipping 510 matching lines @@
       ExpectToken(Token::kASSIGN);
       SetAllowFunctionLiterals(false);
       SkipExpr();
       SetAllowFunctionLiterals(true);
     }
   } while (CurrentToken() == Token::kCOMMA);
 }
 
 
 void Parser::ParseQualIdent(QualIdent* qual_ident) {
-  ASSERT(CurrentToken() == Token::kIDENT);
+  ASSERT(IsIdentifier());
   if (!is_top_level_) {
     bool is_local_ident = ResolveIdentInLocalScope(token_index_,
                                                    *CurrentLiteral(),
                                                    NULL);
     qual_ident->ident_pos = token_index_;
     qual_ident->ident = CurrentLiteral();
     qual_ident->lib_prefix = NULL;
     qual_ident->qualifier = NULL;
     qual_ident->is_local_scope_ident = is_local_ident;
     ConsumeToken();
@@ skipping 334 matching lines @@
     field->name_pos = this->token_index_;
     field->name = ExpectIdentifier("field name expected");
   }
   ExpectSemicolon();
 }
 
 
 void Parser::ParseClassMemberDefinition(ClassDesc* members) {
   MemberDesc member;
   current_member_ = &member;
-  if (CurrentToken() == Token::kABSTRACT) {
+  if ((CurrentToken() == Token::kABSTRACT) &&
+      (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
     member.has_abstract = true;
   }
-  if (CurrentToken() == Token::kSTATIC) {
+  if ((CurrentToken() == Token::kSTATIC) &&
+      (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
     member.has_static = true;
   }
   if (CurrentToken() == Token::kCONST) {
     ConsumeToken();
     member.has_const = true;
   } else if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     member.has_final = true;
   }
@@ skipping 27 matching lines @@
     if ((member.type == NULL) && !member.has_factory) {
       // 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 either parse a type or assume that no type is specified.
       if ((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.
+          (Token::IsIdentifier(follower))  ||  // 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 = &AbstractType::ZoneHandle(ParseType(kCanResolve));
       }
     }
   }
   // Optionally parse a (possibly named) constructor name or factory.
-  if ((CurrentToken() == Token::kIDENT) &&
+  if (IsIdentifier() &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
     member.name = CurrentLiteral();
     member.name_pos = this->token_index_;
     ConsumeToken();
     if (member.has_factory) {
       String& qualifier = String::Handle();
       if (CurrentToken() == Token::kPERIOD) {
         LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
         lib_prefix = current_class().LookupLibraryPrefix(*member.name);
         if (!lib_prefix.IsNull()) {
@@ skipping 49 matching lines @@
       member.type = &Type::ZoneHandle(Type::DynamicType());
     } else {
       // The type can only be already set in the factory case.
       if (!member.has_factory) {
         ErrorMsg(member.name_pos, "constructor must not specify return type");
       }
     }
     if (CurrentToken() != Token::kLPAREN) {
       ErrorMsg("left parenthesis expected");
     }
-  } else if (CurrentToken() == Token::kGET) {
+  } else if ((CurrentToken() == Token::kGET) &&
+             (LookaheadToken(1) != Token::kLPAREN) && !member.has_var) {
     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 DynamicType.
-  } else if (CurrentToken() == Token::kSET) {
+  } else if ((CurrentToken() == Token::kSET) &&
+             (LookaheadToken(1) != Token::kLPAREN) && !member.has_var)  {
     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::DynamicType());
     }
-  } else if (CurrentToken() == Token::kOPERATOR) {
+  } else if ((CurrentToken() == Token::kOPERATOR) &&
+             (LookaheadToken(1) != Token::kLPAREN) && !member.has_var) {
     ConsumeToken();
     if (!Token::CanBeOverloaded(CurrentToken())) {
       ErrorMsg("invalid operator overloading");
     }
     if (member.has_static) {
       ErrorMsg("operator overloading functions cannot be static");
     }
     member.kind = RawFunction::kFunction;
     member.name_pos = this->token_index_;
     member.name =
         &String::ZoneHandle(String::NewSymbol(Token::Str(CurrentToken())));
     ConsumeToken();
-  } else if (CurrentToken() == Token::kIDENT) {
+  } else if (IsIdentifier()) {
     member.name = CurrentLiteral();
     member.name_pos = token_index_;
     ConsumeToken();
   } else {
     ErrorMsg("identifier expected");
   }
 
   ASSERT(member.name != NULL);
   if (CurrentToken() == Token::kLPAREN) {
     if (members->is_interface() && member.has_static) {
@@ skipping 29 matching lines @@
   current_member_ = NULL;
   members->AddMember(member);
 }
 
 
 void Parser::ParseClassDefinition(GrowableArray<const Class*>* classes) {
   TRACE_PARSER("ParseClassDefinition");
   const intptr_t class_pos = token_index_;
   ExpectToken(Token::kCLASS);
   const intptr_t classname_pos = token_index_;
-  String& class_name = *ExpectIdentifier("class name expected");
+  String& class_name = *ExpectTypeIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing class '%s'\n", class_name.ToCString());
   }
   Class& cls = Class::ZoneHandle();
   Object& obj = Object::Handle(library_.LookupObject(class_name));
   if (obj.IsNull()) {
     cls = Class::New(class_name, script_);
     library_.AddClass(cls);
   } else {
     if (!obj.IsClass()) {
@@ skipping 121 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::kIDENT) &&
-      (LookaheadToken(1) == Token::kLPAREN)) {
+  if (IsIdentifier() && (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)) {
+  if (IsIdentifier() && (LookaheadToken(1) == Token::kLT)) {
     ConsumeToken();
     if (IsTypeParameter() && (CurrentToken() == Token::kLPAREN)) {
       is_alias_name = true;
     }
   }
   SetPosition(saved_pos);
   return is_alias_name;
 }
 
 
 void Parser::ParseFunctionTypeAlias(GrowableArray<const Class*>* classes) {
   TRACE_PARSER("ParseFunctionTypeAlias");
   ExpectToken(Token::kTYPEDEF);
 
   AbstractType& result_type = Type::Handle(Type::DynamicType());
   const 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");
-  }
   const intptr_t alias_name_pos = token_index_;
-  const String* alias_name = CurrentLiteral();
-  ConsumeToken();
+  const String* alias_name =
+      ExpectTypeIdentifier("function alias name expected");
 
   // Allocate an interface to hold the type parameters and their 'extends'
   // constraints. Make it the owner of the function type descriptor.
   const Class& alias_owner = Class::Handle(
       Class::New(String::Handle(String::NewSymbol(":alias_owner")),
                  Script::Handle()));
   alias_owner.set_is_interface();
   set_current_class(alias_owner);
   ParseTypeParameters(alias_owner);
   if (CurrentToken() != Token::kLPAREN) {
@@ skipping 56 matching lines @@
   ExpectSemicolon();
   classes->Add(&function_type_alias);
 }
 
 
 void Parser::ParseInterfaceDefinition(GrowableArray<const Class*>* classes) {
   TRACE_PARSER("ParseInterfaceDefinition");
   const intptr_t interface_pos = token_index_;
   ExpectToken(Token::kINTERFACE);
   const intptr_t interfacename_pos = token_index_;
-  String& interface_name = *ExpectIdentifier("interface name expected");
+  String& interface_name = *ExpectTypeIdentifier("interface name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing interface '%s'\n", interface_name.ToCString());
   }
   Class& interface = Class::ZoneHandle();
   Object& obj = Object::Handle(library_.LookupObject(interface_name));
   if (obj.IsNull()) {
     interface = Class::NewInterface(interface_name, script_);
     library_.AddClass(interface);
   } else {
     if (!obj.IsClass()) {
@@ skipping 522 matching lines @@
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("library url expected");
     }
     const String& url = *CurrentLiteral();
     ConsumeToken();
     String& prefix = String::Handle();
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
-      const String& kPrefix = String::Handle(String::NewSymbol("prefix"));
-      if ((CurrentToken() != Token::kIDENT) ||
-          !kPrefix.Equals(*CurrentLiteral())) {
+      if (!IsLiteral("prefix")) {
         ErrorMsg("prefix: expected");
       }
       ConsumeToken();
       ExpectToken(Token::kCOLON);
       if (CurrentToken() != Token::kSTRING) {
         ErrorMsg("prefix expected");
       }
       prefix = CurrentLiteral()->raw();
       // TODO(asiva): Need to also check that prefix is not a reserved keyword.
       if (!Scanner::IsIdent(prefix)) {
@@ skipping 78 matching lines @@
   toplevel_class.set_library(library_);
 
   if (is_library_source()) {
     ParseLibraryDefinition();
   }
 
   while (true) {
     set_current_class(Class::Handle());  // No current class.
     if (CurrentToken() == Token::kCLASS) {
       ParseClassDefinition(&classes);
-    } else if (CurrentToken() == Token::kTYPEDEF) {
+    } else if ((CurrentToken() == Token::kTYPEDEF) &&
+               (LookaheadToken(1) != Token::kLPAREN)) {
       ParseFunctionTypeAlias(&classes);
     } else if (CurrentToken() == Token::kINTERFACE) {
       ParseInterfaceDefinition(&classes);
     } else if (IsVariableDeclaration()) {
       set_current_class(toplevel_class);
       ParseTopLevelVariable(&top_level);
     } else if (IsTopLevelFunction()) {
       set_current_class(toplevel_class);
       ParseTopLevelFunction(&top_level);
     } else if (IsTopLevelAccessor()) {
@@ skipping 216 matching lines @@
                             AstNode* object,
                             const String& name) {
   return new InstanceGetterNode(token_index_, object, name);
 }
 
 
 // Returns ast nodes of the variable initialization.
 AstNode* Parser::ParseVariableDeclaration(
     const AbstractType& type, bool is_final) {
   TRACE_PARSER("ParseVariableDeclaration");
-  ASSERT(CurrentToken() == Token::kIDENT);
+  ASSERT(IsIdentifier());
   const intptr_t ident_pos = token_index_;
   LocalVariable* variable =
       new LocalVariable(ident_pos, *CurrentLiteral(), type);
   ASSERT(current_block_ != NULL);
   ASSERT(current_block_->scope != NULL);
   ConsumeToken();  // Variable identifier.
   AstNode* initialization = NULL;
   if (CurrentToken() == Token::kASSIGN) {
     // Variable initialization.
     const intptr_t assign_pos = token_index_;
@@ skipping 32 matching lines @@
     return Type::DynamicType();
   }
   if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     type_specification = kIsOptional;
   }
   if (CurrentToken() != Token::kIDENT) {
     if (type_specification == kIsOptional) {
       return Type::DynamicType();
     } else {
-      ErrorMsg("identifier expected");
+      ErrorMsg("type name 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.
+        !Token::IsIdentifier(follower) &&  // Variable name following a type.
         (follower != Token::kTHIS)) {  // Field parameter following a type.
       return Type::DynamicType();
     }
   }
   return ParseType(type_resolution);
 }
 
 
 // Returns ast nodes of the variable initialization. Variables without an
 // explicit initializer are initialized to null. If several variables are
 // declared, the individual initializers are collected in a sequence node.
 AstNode* Parser::ParseVariableDeclarationList() {
   TRACE_PARSER("ParseVariableDeclarationList");
   bool is_final = (CurrentToken() == Token::kFINAL);
   const AbstractType& type = AbstractType::ZoneHandle(
       ParseFinalVarOrType(kIsMandatory, kMustResolve));
-  if (CurrentToken() != Token::kIDENT) {
+  if (!IsIdentifier()) {
     ErrorMsg("identifier expected");
   }
 
   AstNode* initializers = ParseVariableDeclaration(type, is_final);
   ASSERT(initializers != NULL);
   while (CurrentToken() == Token::kCOMMA) {
     ConsumeToken();
-    if (CurrentToken() != Token::kIDENT) {
+    if (!IsIdentifier()) {
       ErrorMsg("identifier expected after comma");
     }
     // We have a second initializer. Allocate a sequence node now.
     // The sequence does not own the current scope. Set its own scope to NULL.
     SequenceNode* sequence = NodeAsSequenceNode(initializers->token_index(),
                                                 initializers,
                                                 NULL);
     sequence->Add(ParseVariableDeclaration(type, is_final));
     initializers = sequence;
   }
   return initializers;
 }
 
 
 AstNode* Parser::ParseFunctionStatement(bool is_literal) {
   TRACE_PARSER("ParseFunctionStatement");
   AbstractType& result_type = AbstractType::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)) {
     result_type = ParseType(kMustResolve);
   }
   const intptr_t ident_pos = token_index_;
-  if (CurrentToken() == Token::kIDENT) {
+  if (IsIdentifier()) {
     variable_name = CurrentLiteral();
     function_name = variable_name;
     ConsumeToken();
   } else {
     if (!is_literal) {
       ErrorMsg("function name expected");
     }
     const String& anonymous_function_name =
         String::ZoneHandle(String::NewSymbol("function"));
     function_name = &anonymous_function_name;
@@ skipping 170 matching lines @@
       ConsumeToken();
     } while (nesting_level > 0);
     if (nesting_level < 0) {
       return false;
     }
   }
   return true;
 }
 
 
+// Returns true if the current token is kIDENT or a pseudo-keyword.
+bool Parser::IsIdentifier() {
+  return Token::IsIdentifier(CurrentToken());
+}
+
+
 // Returns true if the next tokens can be parsed as a type with optional
 // type parameters. Current token position is not restored.
 bool Parser::IsOptionalType() {
   if (CurrentToken() == Token::kIDENT) {
     QualIdent type_name;
     ParseQualIdent(&type_name);
     // Check if the type_name has been defined as a variable in a local scope,
     // hiding the type.
     if (type_name.is_local_scope_ident) {
       return false;
@@ skipping 23 matching lines @@
 // Look ahead to detect whether the next tokens should be parsed as
 // a variable declaration. Returns true if we detect the token pattern:
 // ('var' | 'final' | type ident (';' | '=' | ','))
 // Token position remains unchanged.
 bool Parser::IsVariableDeclaration() {
   if ((CurrentToken() == Token::kVAR) ||
       (CurrentToken() == Token::kFINAL)) {
     return true;
   }
   if (CurrentToken() != Token::kIDENT) {
+    // Not a legal type identifier.
     return false;
   }
   const intptr_t saved_pos = token_index_;
   bool is_var_decl = false;
   if (IsOptionalType()) {
-    if (CurrentToken() == Token::kIDENT) {
+    if (IsIdentifier()) {
       ConsumeToken();
       if ((CurrentToken() == Token::kSEMICOLON) ||
           (CurrentToken() == Token::kCOMMA) ||
           (CurrentToken() == Token::kASSIGN)) {
         is_var_decl = true;
       }
     }
   }
   SetPosition(saved_pos);
   return is_var_decl;
 }
 
 
 bool Parser::IsFunctionDeclaration() {
   // A function declaration is like a function literal but it must have
   // a name.
   return (CurrentToken() != Token::kLPAREN) && IsFunctionLiteral();
 }
 
 
 bool Parser::IsTopLevelFunction() {
   // Top-level function declarations can omit the return type. Check for
   // that case separately.
-  return ((CurrentToken() == Token::kIDENT) &&
-      (LookaheadToken(1) == Token::kLPAREN)) ||
-      IsFunctionDeclaration();
+  return (IsIdentifier() &&
+      (LookaheadToken(1) == Token::kLPAREN)) || IsFunctionDeclaration();
 }
 
 
 bool Parser::IsTopLevelAccessor() {
   if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
     return true;
   }
   const intptr_t saved_pos = token_index_;
   if (IsReturnType()) {
     if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
-      if (LookaheadToken(1) == Token::kIDENT) {  // Accessor name.
+      if (Token::IsIdentifier(LookaheadToken(1))) {  // Accessor name.
         SetPosition(saved_pos);
         return true;
       }
     }
   }
   SetPosition(saved_pos);
   return false;
 }
 
 
 bool Parser::IsFunctionLiteral() {
   if (!allow_function_literals_) {
     return false;
   }
   const intptr_t saved_pos = token_index_;
   bool is_function_literal = false;
-  if ((CurrentToken() == Token::kIDENT) &&
-      (LookaheadToken(1) == Token::kLPAREN)) {
+  if (IsIdentifier() && (LookaheadToken(1) == Token::kLPAREN)) {
     ConsumeToken();  // Consume function identifier.
   } else if (IsReturnType()) {
-    if (CurrentToken() != Token::kIDENT) {
+    if (!IsIdentifier()) {
       SetPosition(saved_pos);
       return false;
     }
     ConsumeToken();  // Comsume function identifier.
   }
   if (CurrentToken() == Token::kLPAREN) {
     SkipToMatchingParenthesis();
     if ((CurrentToken() == Token::kLBRACE) ||
         (CurrentToken() == Token::kARROW)) {
       is_function_literal = true;
     }
   }
   SetPosition(saved_pos);
   return is_function_literal;
 }
 
 
 // Current token position is the token after the opening ( of the for
 // statement. Returns true if we recognize a for ( .. in expr)
 // statement.
 bool Parser::IsForInStatement() {
   const intptr_t saved_pos = token_index_;
   bool result = false;
   if (CurrentToken() == Token::kVAR || CurrentToken() == Token::kFINAL) {
     ConsumeToken();
   }
-  if (CurrentToken() == Token::kIDENT) {
+  if (IsIdentifier()) {
     if (LookaheadToken(1) == Token::kIN) {
       result = true;
     } else if (IsOptionalType()) {
-      if (CurrentToken() == Token::kIDENT) {
+      if (IsIdentifier()) {
         ConsumeToken();
       }
       result = (CurrentToken() == Token::kIN);
     }
   }
   SetPosition(saved_pos);
   return result;
 }
 
 
@@ skipping 130 matching lines @@
     ExpectToken(Token::kCOLON);
   }
 
   OpenBlock();
   bool abrupt_completing_seen = false;
   while (true) {
     // Check whether the next statement still belongs to the current case
     // clause. If we see 'case' or 'default', optionally preceeded by
     // a label, or closing brace, we stop parsing statements.
     Token::Kind next_token;
-    if (CurrentToken() == Token::kIDENT &&
-        LookaheadToken(1) == Token::kCOLON) {
+    if (IsIdentifier() && LookaheadToken(1) == Token::kCOLON) {
       next_token = LookaheadToken(2);
     } else {
       next_token = CurrentToken();
     }
     if (next_token == Token::kRBRACE) {
       // End of switch statement.
       break;
     }
     if ((next_token == Token::kCASE) || (next_token == Token::kDEFAULT)) {
       // End of this case clause. If there is a possible fall-through to
@@ skipping 52 matching lines @@
   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;
-    if (CurrentToken() == Token::kIDENT &&
-        LookaheadToken(1) == Token::kCOLON) {
+    if (IsIdentifier() && LookaheadToken(1) == Token::kCOLON) {
       // Case statements start with a label.
       String* label_name = CurrentLiteral();
       const intptr_t label_pos = token_index_;
       ConsumeToken();  // Consume label identifier.
       ConsumeToken();  // Consume colon.
       case_label = current_block_->scope->LocalLookupLabel(*label_name);
       if (case_label == NULL) {
         // Label does not exist yet. Add it to scope of switch statement.
         case_label =
             new SourceLabel(label_pos, *label_name, SourceLabel::kCase);
@@ skipping 338 matching lines @@
 };
 
 
 // Parse the parameter specified in the catch clause.
 void Parser::ParseCatchParameter(CatchParamDesc* catch_param) {
   TRACE_PARSER("ParseCatchParameter");
   ASSERT(catch_param != NULL);
   catch_param->is_final = (CurrentToken() == Token::kFINAL);
   catch_param->type = &AbstractType::ZoneHandle(
       ParseFinalVarOrType(kIsMandatory, kMustResolve));
-  if (CurrentToken() != Token::kIDENT) {
-    ErrorMsg("identifier expected");
-  }
   catch_param->token_index = token_index_;
-  catch_param->var = CurrentLiteral();
-  ConsumeToken();
+  catch_param->var = ExpectIdentifier("identifier expected");
 }
 
 
 // Populate local scope of the catch block with the catch parameters.
 void Parser::AddCatchParamsToScope(const CatchParamDesc& exception_param,
                                    const CatchParamDesc& stack_trace_param,
                                    LocalScope* scope) {
   ASSERT(exception_param.var != NULL);
   LocalVariable* var = new LocalVariable(exception_param.token_index,
                                          *(exception_param.var),
@@ skipping 314 matching lines @@
   return try_catch_node;
 }
 
 
 AstNode* Parser::ParseJump(String* label_name) {
   ASSERT(CurrentToken() == Token::kBREAK || CurrentToken() == Token::kCONTINUE);
   Token::Kind jump_kind = CurrentToken();
   const intptr_t jump_pos = token_index_;
   SourceLabel* target = NULL;
   ConsumeToken();
-  if (CurrentToken() == Token::kIDENT) {
+  if (IsIdentifier()) {
     // Explicit label after break/continue.
     const String& target_name = *CurrentLiteral();
     ConsumeToken();
     // Handle pathological cases first.
     if (label_name != NULL && target_name.Equals(*label_name)) {
       if (jump_kind == Token::kCONTINUE) {
         ErrorMsg(jump_pos, "'continue' jump to label '%s' is illegal",
                  target_name.ToCString());
       }
       // L: break L; is a no-op.
@@ skipping 35 matching lines @@
     ErrorMsg(jump_pos, "'break' to case clause label is illegal");
   }
   if (target->FunctionLevel() != current_block_->scope->function_level()) {
     ErrorMsg(jump_pos, "'%s' target must be in same function context",
              Token::Str(jump_kind));
   }
   return new JumpNode(jump_pos, jump_kind, target);
 }
 
 
+bool Parser::IsDefinedInLexicalScope(const String& ident) {
+  if (ResolveIdentInLocalScope(token_index_, ident, NULL)) {
+    return true;
+  }
+  Object& obj = Object::Handle();
+  obj = library_.LookupObject(ident);
+  return !obj.IsNull();
+}
+
+
 AstNode* Parser::ParseStatement() {
   TRACE_PARSER("ParseStatement");
   AstNode* statement = NULL;
   intptr_t label_pos = 0;
   String* label_name = NULL;
-  if (CurrentToken() == Token::kIDENT) {
+  if (IsIdentifier()) {
     if (LookaheadToken(1) == Token::kCOLON) {
       // Statement starts with a label.
       label_name = CurrentLiteral();
       label_pos = token_index_;
       ASSERT(label_pos > 0);
       ConsumeToken();  // Consume identifier.
       ConsumeToken();  // Consume colon.
     }
   }
   const intptr_t statement_pos = token_index_;
@@ skipping 18 matching lines @@
       }
       AstNode* expr = ParseExpr(kAllowConst);
       statement = new ReturnNode(statement_pos, expr);
     } else {
       statement = new ReturnNode(statement_pos);
     }
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kIF) {
     statement = ParseIfStatement(label_name);
-  } else if (CurrentToken() == Token::kASSERT) {
+  } else if ((CurrentToken() == Token::kASSERT) &&
+             !IsDefinedInLexicalScope(*CurrentLiteral())) {
     statement = ParseAssertStatement();
     ExpectSemicolon();
   } else if (IsVariableDeclaration()) {
     statement = ParseVariableDeclarationList();
     ExpectSemicolon();
   } else if (IsFunctionDeclaration()) {
     statement = ParseFunctionStatement(false);
   } else if (CurrentToken() == Token::kLBRACE) {
     SourceLabel* label = NULL;
     OpenBlock();
@@ skipping 205 matching lines @@
 }
 
 
 void Parser::UnexpectedToken() {
   ErrorMsg("unexpected token '%s'",
            CurrentToken() == Token::kIDENT ?
                CurrentLiteral()->ToCString() : Token::Str(CurrentToken()));
 }
 
 
-String* Parser::ExpectIdentifier(const char* msg) {
+String* Parser::ExpectTypeIdentifier(const char* msg) {
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg(msg);
   }
   String* ident = CurrentLiteral();
   ConsumeToken();
   return ident;
 }
 
+// Check whether current token is an identifier or a built-in identifier.
+String* Parser::ExpectIdentifier(const char* msg) {
+  if (!IsIdentifier()) {
+    ErrorMsg(msg);
+  }
+  String* ident = CurrentLiteral();
+  ConsumeToken();
+  return ident;
+}
+
 
 bool Parser::IsLiteral(const char* literal) {
   const uint8_t* characters = reinterpret_cast<const uint8_t*>(literal);
   intptr_t len = strlen(literal);
-  return (CurrentToken() == Token::kIDENT)
-      && CurrentLiteral()->Equals(characters, len);
+  return IsIdentifier() && CurrentLiteral()->Equals(characters, len);
 }
 
 
 bool Parser::IsIncrementOperator(Token::Kind token) {
   return token == Token::kINCR || token == Token::kDECR;
 }
 
 
 bool Parser::IsPrefixOperator(Token::Kind token) {
   return token == Token::kADD || token == Token::kSUB
@@ skipping 355 matching lines @@
   } else {
     arguments = implicit_arguments;
   }
   GrowableArray<const String*> names;
   bool named_argument_seen = false;
   if (LookaheadToken(1) != Token::kRPAREN) {
     do {
       ASSERT((CurrentToken() == Token::kLPAREN) ||
              (CurrentToken() == Token::kCOMMA));
       ConsumeToken();
-      if ((CurrentToken() == Token::kIDENT) &&
-          (LookaheadToken(1) == Token::kCOLON)) {
+      if (IsIdentifier() && (LookaheadToken(1) == Token::kCOLON)) {
         named_argument_seen = true;
         // The canonicalization of the argument descriptor array built in the
         // code generator requires that the names are symbols, i.e.
         // canonicalized strings.
         ASSERT(CurrentLiteral()->IsSymbol());
         for (int i = 0; i < names.length(); i++) {
           if (CurrentLiteral()->Equals(*names[i])) {
             ErrorMsg("duplicate named argument");
           }
         }
@@ skipping 1363 matching lines @@
   return constructor_name;
 }
 
 
 AstNode* Parser::ParseNewOperator() {
   TRACE_PARSER("ParseNewOperator");
   const intptr_t new_pos = token_index_;
   ASSERT((CurrentToken() == Token::kNEW) || (CurrentToken() == Token::kCONST));
   bool is_const = (CurrentToken() == Token::kCONST);
   ConsumeToken();
-  if (CurrentToken() != Token::kIDENT) {
+  if (!IsIdentifier()) {
     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).
   const intptr_t  type_pos = token_index_;
@@ skipping 240 matching lines @@
 
 AstNode* Parser::ParsePrimary() {
   TRACE_PARSER("ParsePrimary");
   AstNode* primary = NULL;
   if (IsFunctionLiteral()) {
     // The name of a literal function is visible from inside the function, but
     // must not collide with names in the scope declaring the literal.
     OpenBlock();
     primary = ParseFunctionStatement(true);
     CloseBlock();
-  } else if (CurrentToken() == Token::kIDENT) {
+  } else if (IsIdentifier()) {
     QualIdent qual_ident;
     ParseQualIdent(&qual_ident);
     if (qual_ident.is_local_scope_ident) {
       ResolveIdentInLocalScope(qual_ident.ident_pos,
                                *qual_ident.ident,
                                &primary);
     } else {
       if (qual_ident.qualifier == NULL) {
         // This is an unqualified identifier so resolve the identifier
         // locally in the main app library and all libraries imported by it.
@@ skipping 115 matching lines @@
     Instance& value = Instance::ZoneHandle(Compiler::ExecuteOnce(seq));
     if (value.IsNull()) {
       value ^= value.Canonicalize();
     }
     return value;
   }
 }
 
 
 void Parser::SkipFunctionLiteral() {
-  if (CurrentToken() == Token::kIDENT) {
+  if (IsIdentifier()) {
     if (LookaheadToken(1) != Token::kLPAREN) {
       SkipType(true);
     }
     ExpectIdentifier("function name expected");
   }
   if (CurrentToken() == Token::kLPAREN) {
     const bool allow_explicit_default_values = true;
     ParamList ignore_params;
     ParseFormalParameterList(allow_explicit_default_values, &ignore_params);
   }
@@ skipping 57 matching lines @@
       (CurrentToken() == Token::kINDEX)) {
     SkipListLiteral();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipMapLiteral();
   }
 }
 
 
 void Parser::SkipNewOperator() {
   ConsumeToken();  // Skip new or const keyword.
-  if (CurrentToken() == Token::kIDENT) {
+  if (IsIdentifier()) {
     SkipType(false);
     if (CurrentToken() == Token::kLPAREN) {
       SkipActualParameters();
       return;
     }
   }
 }
 
 
 void Parser::SkipStringLiteral() {
@@ skipping 59 matching lines @@
         SkipNewOperator();
       }
       break;
     case Token::kLT:
     case Token::kLBRACE:
     case Token::kLBRACK:
     case Token::kINDEX:
       SkipCompoundLiteral();
       break;
     default:
-      UnexpectedToken();
-      UNREACHABLE();
+      if (IsIdentifier()) {
+        ConsumeToken();  // Handle pseudo-keyword identifiers.
+      } else {
+        UnexpectedToken();
+        UNREACHABLE();
+      }
       break;
   }
 }
 
 
 void Parser::SkipPostfixExpr() {
   SkipPrimary();
   while (true) {
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
@@ skipping 55 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart