- Support for patching of class methods and fields.

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 239 matching lines @@
                intptr_t token_position)
     : script_(script),
       tokens_iterator_(TokenStream::Handle(script.tokens()), token_position),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       current_function_(function),
       innermost_function_(Function::Handle(function.raw())),
-      current_class_(Class::Handle(current_function_.owner())),
+      current_class_(Class::Handle(current_function_.Owner())),
       library_(Library::Handle(current_class_.library())),
       try_blocks_list_(NULL),
       expression_temp_(NULL)  {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!function.IsNull());
   if (FLAG_enable_type_checks) {
     EnsureExpressionTemp();
   }
 }
 
@@ skipping 378 matching lines @@
   }
 }
 
 
 void Parser::ParseFunction(ParsedFunction* parsed_function) {
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate->long_jump_base()->IsSafeToJump());
   ASSERT(parsed_function != NULL);
   const Function& func = parsed_function->function();
-  const Class& cls = Class::Handle(isolate, func.owner());
-  const Script& script = Script::Handle(isolate, cls.script());
+  const Script& script = Script::Handle(isolate, func.script());
   Parser parser(script, func, func.token_pos());
   SequenceNode* node_sequence = NULL;
   Array& default_parameter_values = Array::Handle(isolate, Array::null());
   switch (func.kind()) {
     case RawFunction::kRegularFunction:
     case RawFunction::kClosureFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
     case RawFunction::kConstructor:
       node_sequence = parser.ParseFunc(func, default_parameter_values);
@@ skipping 59 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);
 
   const String& field_name = *ExpectIdentifier("field name expected");
-  const Class& field_class = Class::Handle(func.owner());
+  const Class& field_class = Class::Handle(func.Owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupStaticField(field_name));
 
   // Static const fields must have an initializer.
   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
@@ skipping 84 matching lines @@
 }
 
 
 // Create AstNodes for an implicit instance getter method:
 //   LoadLocalNode 0 ('this');
 //   LoadInstanceFieldNode (field_name);
 //   ReturnNode (field's value);
 SequenceNode* Parser::ParseInstanceGetter(const Function& func) {
   TRACE_PARSER("ParseInstanceGetter");
   ParamList params;
-  ASSERT(current_class().raw() == func.owner());
+  ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(TokenPos()));
   ASSERT(func.num_fixed_parameters() == 1);  // receiver.
   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);
 
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   LoadLocalNode* load_receiver = new LoadLocalNode(TokenPos(), receiver);
   // TokenPos() returns the function's token position which points to the
   // name of the field;
   ASSERT(IsIdentifier());
   const String& field_name = *CurrentLiteral();
-  const Class& field_class = Class::Handle(func.owner());
+  const Class& field_class = Class::Handle(func.Owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupInstanceField(field_name));
 
   LoadInstanceFieldNode* load_field =
       new LoadInstanceFieldNode(TokenPos(), load_receiver, field);
 
   ReturnNode* return_node = new ReturnNode(TokenPos(), load_field);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 // Create AstNodes for an implicit instance setter method:
 //   LoadLocalNode 0 ('this')
 //   LoadLocalNode 1 ('value')
 //   SetInstanceField (field_name);
 //   ReturnNode (void);
 SequenceNode* Parser::ParseInstanceSetter(const Function& func) {
   TRACE_PARSER("ParseInstanceSetter");
   // TokenPos() returns the function's token position which points to
   // the name of the field; we can use it to form the field_name.
   const String& field_name = *CurrentLiteral();
-  const Class& field_class = Class::ZoneHandle(func.owner());
+  const Class& field_class = Class::ZoneHandle(func.Owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupInstanceField(field_name));
   const AbstractType& field_type = AbstractType::ZoneHandle(field.type());
 
   ParamList params;
-  ASSERT(current_class().raw() == func.owner());
+  ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(TokenPos()));
   params.AddFinalParameter(TokenPos(),
                            &String::ZoneHandle(Symbols::Value()),
                            &field_type);
   ASSERT(func.num_fixed_parameters() == 2);  // receiver, value.
   ASSERT(func.num_optional_parameters() == 0);
   ASSERT(AbstractType::Handle(func.result_type()).IsVoidType());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
@@ skipping 279 matching lines @@
   }
   String& native_name = *CurrentLiteral();
   ConsumeToken();
   ExpectSemicolon();
   return native_name;
 }
 
 
 void Parser::CheckFunctionIsCallable(intptr_t token_pos,
                                      const Function& function) {
-  if (Class::Handle(function.owner()).is_interface()) {
+  if (Class::Handle(function.Owner()).is_interface()) {
     ErrorMsg(token_pos, "cannot call function of interface '%s'",
         function.ToFullyQualifiedCString());
   }
 }
 
 
 // Resolve and return the dynamic function of the given name in the superclass.
 // If it is not found, return noSuchMethod and set is_no_such_method to true.
 RawFunction* Parser::GetSuperFunction(intptr_t token_pos,
                                       const String& name,
@@ skipping 570 matching lines @@
   ASSERT(func.IsConstructor());
   const intptr_t ctor_pos = TokenPos();
 
   // Implicit 'this' is the only parameter/local variable.
   OpenFunctionBlock(func);
 
   // Parse expressions of instance fields that have an explicit
   // initializers.
   GrowableArray<FieldInitExpression> initializers;
   GrowableArray<Field*> initialized_fields;
-  Class& cls = Class::Handle(func.owner());
+  Class& cls = Class::Handle(func.Owner());
   ParseInitializedInstanceFields(cls, &initializers, &initialized_fields);
 
   LocalVariable* receiver = new LocalVariable(
       ctor_pos,
       String::ZoneHandle(Symbols::This()),
       Type::ZoneHandle(Type::DynamicType()));
   current_block_->scope->AddVariable(receiver);
 
   LocalVariable* phase_parameter = new LocalVariable(
        ctor_pos,
@@ skipping 25 matching lines @@
 
 // Parser is at the opening parenthesis of the formal parameter declaration
 // of function. Parse the formal parameters, initializers and code.
 SequenceNode* Parser::ParseConstructor(const Function& func,
                                        Array& default_parameter_values) {
   TRACE_PARSER("ParseConstructor");
   ASSERT(func.IsConstructor());
   ASSERT(!func.IsFactory());
   ASSERT(!func.is_static());
   ASSERT(!func.IsLocalFunction());
-  const Class& cls = Class::Handle(func.owner());
+  const Class& cls = Class::Handle(func.Owner());
   ASSERT(!cls.IsNull());
 
   if (CurrentToken() == Token::kCLASS) {
     // Special case: implicit constructor.
     // The parser adds an implicit default constructor when a class
     // does not have any explicit constructor or factory (see
     // Parser::CheckConstructors). The token position of this implicit
     // constructor points to the 'class' keyword, which is followed
     // by the name of the class (which is also the constructor name).
     // There is no source text to parse. We just build the
     // sequence node by hand.
     return MakeImplicitConstructor(func);
   }
 
   OpenFunctionBlock(func);
   ParamList params;
   const bool allow_explicit_default_values = true;
   ASSERT(CurrentToken() == Token::kLPAREN);
 
   // Add implicit receiver parameter which is passed the allocated
   // but uninitialized instance to construct.
-  ASSERT(current_class().raw() == func.owner());
+  ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(TokenPos()));
 
   // Add implicit parameter for construction phase.
   params.AddFinalParameter(
       TokenPos(),
       &String::ZoneHandle(Symbols::PhaseParameter()),
       &Type::ZoneHandle(Type::IntInterface()));
 
   if (func.is_const()) {
     params.SetImplicitlyFinal();
@@ skipping 228 matching lines @@
   ASSERT(!func.IsConstructor());
   OpenFunctionBlock(func);  // Build local scope for function.
 
   ParamList params;
   // Static functions do not have a receiver.
   // An instance closure may capture and access the receiver, but via the
   // context and not via the first formal parameter.
   // The first parameter of a factory is the AbstractTypeArguments vector of
   // the type of the instance to be allocated.
   if (!func.is_static() && !func.IsClosureFunction()) {
-    ASSERT(current_class().raw() == func.owner());
+    ASSERT(current_class().raw() == func.Owner());
     params.AddReceiver(ReceiverType(TokenPos()));
   } else if (func.IsFactory()) {
     params.AddFinalParameter(
         TokenPos(),
         &String::ZoneHandle(Symbols::TypeArgumentsParameter()),
         &Type::ZoneHandle(Type::DynamicType()));
   }
   ASSERT((CurrentToken() == Token::kLPAREN) || func.IsGetterFunction());
   const bool allow_explicit_default_values = true;
   if (!func.IsGetterFunction()) {
@@ skipping 509 matching lines @@
     if (!field->has_static) {
       String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
       getter = Function::New(getter_name, RawFunction::kImplicitGetter,
                              field->has_static,
                              field->has_final,
                              /* is_abstract = */ false,
                              /* is_external = */ false,
                              current_class(),
                              field->name_pos);
       ParamList params;
-      ASSERT(current_class().raw() == getter.owner());
+      ASSERT(current_class().raw() == getter.Owner());
       params.AddReceiver(ReceiverType(TokenPos()));
       getter.set_result_type(*field->type);
       AddFormalParamsToFunction(&params, getter);
       members->AddFunction(getter);
       if (!field->has_final) {
         // Build a setter accessor for non-const fields.
         String& setter_name = String::Handle(Field::SetterSymbol(*field->name));
         setter = Function::New(setter_name, RawFunction::kImplicitSetter,
                                field->has_static,
                                field->has_final,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                current_class(),
                                field->name_pos);
         ParamList params;
-        ASSERT(current_class().raw() == setter.owner());
+        ASSERT(current_class().raw() == setter.Owner());
         params.AddReceiver(ReceiverType(TokenPos()));
         params.AddFinalParameter(TokenPos(),
                                  &String::ZoneHandle(Symbols::Value()),
                                  field->type);
         setter.set_result_type(Type::Handle(Type::VoidType()));
         AddFormalParamsToFunction(&params, setter);
         members->AddFunction(setter);
       }
     }
 
@@ skipping 262 matching lines @@
     UnexpectedToken();
   }
   current_member_ = NULL;
   members->AddMember(member);
 }
 
 
 void Parser::ParseClassDefinition(const GrowableObjectArray& pending_classes) {
   TRACE_PARSER("ParseClassDefinition");
   const intptr_t class_pos = TokenPos();
+  bool is_patch = false;
+  if (is_patch_source() &&
+      (CurrentToken() == Token::kIDENT) &&
+      CurrentLiteral()->Equals("patch")) {
+    ConsumeToken();
+    is_patch = true;
+  }
   ExpectToken(Token::kCLASS);
   const intptr_t classname_pos = TokenPos();
   String& class_name = *ExpectTypeIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing class '%s'\n", class_name.ToCString());
   }
   Class& cls = Class::Handle();
   Object& obj = Object::Handle(library_.LookupObject(class_name));
   if (obj.IsNull()) {
+    if (is_patch) {
+      ErrorMsg(classname_pos, "missing class '%s' cannot be patched",
+               class_name.ToCString());
+    }
     cls = Class::New(class_name, script_, classname_pos);
     library_.AddClass(cls);
   } else {
     if (!obj.IsClass()) {
       ErrorMsg(classname_pos, "'%s' is already defined",
                class_name.ToCString());
     }
     cls ^= obj.raw();
     if (cls.is_interface()) {
-      ErrorMsg(classname_pos, "'%s' is already defined as interface",
-               class_name.ToCString());
-    } else if (cls.functions() != Object::empty_array()) {
+      ErrorMsg(classname_pos, "'%s' %s",
+               class_name.ToCString(),
+               is_patch ?
+                   "is already defined as interface" :
+                   "interface cannot be patched");
+    } else if (!is_patch && (cls.functions() != Object::empty_array())) {
       ErrorMsg(classname_pos, "class '%s' is already defined",
                class_name.ToCString());

[siva, 2012/08/15 00:16:04]

I suppose it is an error to have multiple patch classes also right similar to
regular classes? i.e:

class A { .....} seen
patch class A { .... } seen
patch class A { ..... } this would be an error.

[Ivan Posva, 2012/08/15 06:50:39]

Currently this error cannot be identified as I am not adding the patch class to
the library and thus I have no means of finding this error condition. I should
get to this when addressing the better error checking when merging the member
definitions in ApplyPatch.

+    } else if (is_patch) {
+      String& patch = String::Handle(Symbols::New("patch "));
+      patch = String::Concat(patch, class_name);
+      patch = Symbols::New(patch);
+      cls = Class::New(patch, script_, classname_pos);
+    } else {
+      // Not patching a class, but it has been found. This must be one of the
+      // pre-registered classes from object.cc or a duplicate definition.
+      if (cls.functions() != Object::empty_array()) {
+        ErrorMsg(classname_pos, "class '%s' is already defined",
+                 class_name.ToCString());
+      }

[siva, 2012/08/15 00:16:04]

There seems to be a duplication of this is already defined check, it was done
above in the if (!is_patch && ..) statement.

[Ivan Posva, 2012/08/15 06:50:40]

Merge-conflict resolution error. Thanks for noticing, fixing...

+      // Pre-registered classes need their scripts connected at this time.
+      cls.set_script(script_);
     }
-    // Pre-registered classes need their scripts connected at this time.
-    cls.set_script(script_);
   }
   ASSERT(!cls.IsNull());
   ASSERT(cls.functions() == Object::empty_array());
   set_current_class(cls);
   ParseTypeParameters(cls);
   Type& super_type = Type::Handle();
   if (CurrentToken() == Token::kEXTENDS) {
     ConsumeToken();
     const intptr_t type_pos = TokenPos();
     const AbstractType& type = AbstractType::Handle(
@@ skipping 25 matching lines @@
     AddInterfaces(interfaces_pos, cls, interfaces);
   }
 
   ExpectToken(Token::kLBRACE);
   ClassDesc members(cls, class_name, false, class_pos);
   while (CurrentToken() != Token::kRBRACE) {
     ParseClassMemberDefinition(&members);
   }
   ExpectToken(Token::kRBRACE);
 
-  CheckConstructors(&members);
+  if (!is_patch) {
+    // Do not install implicit constructors.

[hausner, 2012/08/14 18:25:06]

Why? 

[Ivan Posva, 2012/08/15 06:50:40]

If a patch class does not patch a constructor, it should not be adding an
implicit constructor. I will split the CheckConstructors into two:
AddImplicitConstructor and CheckConstructors to not conflate the two things.

+    CheckConstructors(&members);
+  }
 
   Array& array = Array::Handle();
   array = Array::MakeArray(members.fields());
   cls.SetFields(array);
 
   // Creating a new array for functions marks the class as parsed.
   array = Array::MakeArray(members.functions());
   cls.SetFunctions(array);
 
-  pending_classes.Add(cls, Heap::kOld);
+  if (!is_patch) {
+    pending_classes.Add(cls, Heap::kOld);
+  } else {
+    // Lookup the patched class and apply the changes.
+    obj = library_.LookupObject(class_name);
+    Class::Cast(obj).ApplyPatch(cls);
+  }
 }
 
 
 // 1. Add an implicit constructor if no explicit constructor is present.
 // 2. Check for cycles in constructor redirection.
 void Parser::CheckConstructors(ClassDesc* class_desc) {
   // Add an implicit constructor if no explicit constructor is present.
   if (!class_desc->has_constructor()) {
     // The implicit constructor is unnamed, has no explicit parameter,
     // and contains a supercall in the initializer list.
     String& ctor_name = String::ZoneHandle(
         String::Concat(class_desc->class_name(),
                        String::Handle(Symbols::Dot())));
     ctor_name = Symbols::New(ctor_name);
     // The token position for the implicit constructor is the 'class'
     // keyword of the constructor's class.
     Function& ctor = Function::Handle(
         Function::New(ctor_name,
                       RawFunction::kConstructor,
                       /* is_static = */ false,
                       /* is_const = */ false,
                       /* is_abstract = */ false,
                       /* is_external = */ false,
                       current_class(),
                       class_desc->token_pos()));
     ParamList params;
     // Add implicit 'this' parameter.
-    ASSERT(current_class().raw() == ctor.owner());
+    ASSERT(current_class().raw() == ctor.Owner());
     params.AddReceiver(ReceiverType(TokenPos()));
     // Add implicit parameter for construction phase.
     params.AddFinalParameter(
         TokenPos(),
         &String::ZoneHandle(Symbols::PhaseParameter()),
         &Type::ZoneHandle(Type::IntInterface()));
 
     AddFormalParamsToFunction(&params, ctor);
     // The body of the constructor cannot modify the type of the constructed
     // instance, which is passed in as the receiver.
@@ skipping 659 matching lines @@
 
 
 void Parser::ParseTopLevelAccessor(TopLevel* top_level) {
   TRACE_PARSER("ParseTopLevelAccessor");
   const bool is_static = true;
   bool is_external = false;
   bool is_patch = false;
   AbstractType& result_type = AbstractType::Handle();
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
-      (CurrentLiteral()->Equals("patch"))) {
+      CurrentLiteral()->Equals("patch")) {
     ConsumeToken();
     is_patch = true;
   } else if (CurrentToken() == Token::kEXTERNAL) {
     ConsumeToken();
     is_external = true;
   }
   bool is_getter = (CurrentToken() == Token::kGET);
   if (CurrentToken() == Token::kGET ||
       CurrentToken() == Token::kSET) {
     ConsumeToken();
@@ skipping 271 matching lines @@
       ParseClassDefinition(pending_classes);
     } else if ((CurrentToken() == Token::kTYPEDEF) &&
                (LookaheadToken(1) != Token::kLPAREN)) {
       ParseFunctionTypeAlias(pending_classes);
     } else if (CurrentToken() == Token::kINTERFACE) {
       ParseInterfaceDefinition(pending_classes);
     } else if ((CurrentToken() == Token::kABSTRACT) &&
         (LookaheadToken(1) == Token::kCLASS)) {
       ConsumeToken();  // Consume and ignore 'abstract'.
       ParseClassDefinition(pending_classes);
+    } else if (is_patch_source() &&
+               (CurrentToken() == Token::kIDENT) &&
+               CurrentLiteral()->Equals("patch") &&
+               (LookaheadToken(1) == Token::kCLASS)) {
+      ParseClassDefinition(pending_classes);
     } else {
       set_current_class(toplevel_class);
       if (IsVariableDeclaration()) {
         ParseTopLevelVariable(&top_level);
       } else if (IsFunctionDeclaration()) {
         ParseTopLevelFunction(&top_level);
       } else if (IsTopLevelAccessor()) {
         ParseTopLevelAccessor(&top_level);
       } else if (CurrentToken() == Token::kEOS) {
         break;
@@ skipping 142 matching lines @@
     }
   }
 }
 
 
 // Builds ReturnNode/NativeBodyNode for a native function.
 void Parser::ParseNativeFunctionBlock(const ParamList* params,
                                       const Function& func) {
   func.set_is_native(true);
   TRACE_PARSER("ParseNativeFunctionBlock");
-  const Class& cls = Class::Handle(func.owner());
+  const Class& cls = Class::Handle(func.Owner());
   const int num_parameters = params->parameters->length();
   const bool is_instance_closure = func.IsImplicitInstanceClosureFunction();
   int num_params_for_resolution = num_parameters;
 
   // Parse the function name out.
   const intptr_t native_pos = TokenPos();
   const String& native_name = ParseNativeDeclaration();
 
   if (is_instance_closure) {
     num_params_for_resolution += 1;  // account for 'this' when resolving.
@@ skipping 2903 matching lines @@
       selector = new LoadIndexedNode(bracket_pos, array, index);
     } else if (CurrentToken() == Token::kLPAREN) {
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary = left->AsPrimaryNode();
         const intptr_t primary_pos = primary->token_pos();
         if (primary->primary().IsFunction()) {
           Function& func = Function::CheckedHandle(primary->primary().raw());
           String& func_name = String::ZoneHandle(func.name());
           if (func.is_static()) {
             // Parse static function call.
-            Class& cls = Class::Handle(func.owner());
+            Class& cls = Class::Handle(func.Owner());
             selector = ParseStaticCall(cls, func_name, primary_pos);
           } else {
             // Dynamic function call on implicit "this" parameter.
             if (current_function().is_static()) {
               ErrorMsg(primary_pos,
                        "cannot access instance method '%s' "
                        "from static function",
                        func_name.ToCString());
             }
             selector = ParseInstanceCall(LoadReceiver(primary_pos), func_name);
@@ skipping 535 matching lines @@
     }
   }
   if (!obj.IsNull()) {
     ASSERT(obj.IsFunction());
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
     return new StaticGetterNode(qual_ident.ident_pos,
                                 NULL,
                                 false,
-                                Class::ZoneHandle(func.owner()),
+                                Class::ZoneHandle(func.Owner()),
                                 *qual_ident.ident);
   }
   if (qual_ident.lib_prefix != NULL) {
     return NULL;
   }
   // Lexically unresolved primary identifiers are referenced by their name.
   return new PrimaryNode(qual_ident.ident_pos, *qual_ident.ident);
 }
 
 
@@ skipping 175 matching lines @@
     }
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     intptr_t pos, Function& constructor,
     const AbstractTypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
-    const Class& constructor_class = Class::Handle(constructor.owner());
+    const Class& constructor_class = Class::Handle(constructor.Owner());
     ASSERT(!constructor_class.IsNull());
     ASSERT(constructor_class.is_finalized());
     // Do not report the expected vs. actual number of type arguments, because
     // the type argument vector is flattened and raw types are allowed.
     if (type_arguments.Length() != constructor_class.NumTypeArguments()) {
       ErrorMsg(pos, "wrong number of type arguments passed to constructor");
     }
   }
 }
 
@@ skipping 1196 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart