Implement updated method overriding rules in the vm.

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 438 matching lines @@
                          const AbstractType* type) {
     this->num_fixed_parameters++;
     ParamDesc param;
     param.name_pos = name_pos;
     param.name = name;
     param.is_final = true;
     param.type = type;
     this->parameters->Add(param);
   }
 
-  void AddReceiver(const Type* receiver_type, intptr_t token_pos) {
+  void AddReceiver(const AbstractType* receiver_type, intptr_t token_pos) {
     ASSERT(this->parameters->is_empty());
     AddFinalParameter(token_pos, &Symbols::This(), receiver_type);
   }
 
   void SetImplicitlyFinal() {
     implicitly_final = true;
   }
 
   int num_fixed_parameters;
   int num_optional_parameters;
@@ skipping 539 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;
   // func.token_pos() points to the name of the field.
   intptr_t ident_pos = func.token_pos();
   ASSERT(current_class().raw() == func.Owner());
-  params.AddReceiver(ReceiverType(), ident_pos);
+  params.AddReceiver(ReceiverType(current_class()), ident_pos);
   ASSERT(func.num_fixed_parameters() == 1);  // receiver.
   ASSERT(!func.HasOptionalParameters());
   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);
@@ skipping 23 matching lines @@
   // func.token_pos() points to the name of the field.
   intptr_t ident_pos = func.token_pos();
   const String& field_name = *CurrentLiteral();
   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());
-  params.AddReceiver(ReceiverType(), ident_pos);
+  params.AddReceiver(ReceiverType(current_class()), ident_pos);
   params.AddFinalParameter(ident_pos,
                            &Symbols::Value(),
                            &field_type);
   ASSERT(func.num_fixed_parameters() == 2);  // receiver, value.
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(func.result_type()).IsVoidType());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
@@ skipping 12 matching lines @@
 }
 
 
 SequenceNode* Parser::ParseMethodExtractor(const Function& func) {
   TRACE_PARSER("ParseMethodExtractor");
   ParamList params;
 
   const intptr_t ident_pos = func.token_pos();
   ASSERT(func.token_pos() == 0);
   ASSERT(current_class().raw() == func.Owner());
-  params.AddReceiver(ReceiverType(), ident_pos);
+  params.AddReceiver(ReceiverType(current_class()), ident_pos);
   ASSERT(func.num_fixed_parameters() == 1);  // Receiver.
   ASSERT(!func.HasOptionalParameters());
 
   // 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(ident_pos, receiver);
 
   ClosureNode* closure = new ClosureNode(
       ident_pos,
       Function::ZoneHandle(func.extracted_method_closure()),
       load_receiver,
       NULL);
 
   ReturnNode* return_node = new ReturnNode(ident_pos, closure);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 void Parser::BuildDispatcherScope(const Function& func,
                                   const ArgumentsDescriptor& desc,
                                   Array& default_values) {
   ParamList params;
   // Receiver first.
   intptr_t token_pos = func.token_pos();
-  params.AddReceiver(ReceiverType(), token_pos);
+  params.AddReceiver(ReceiverType(current_class()), token_pos);
   // Remaining positional parameters.
   intptr_t i = 1;
   for (; i < desc.PositionalCount(); ++i) {
     ParamDesc p;
     char name[64];
     OS::SNPrint(name, 64, ":p%"Pd, i);
     p.name = &String::ZoneHandle(Symbols::New(name));
     p.type = &Type::ZoneHandle(Type::DynamicType());
     params.parameters->Add(p);
     params.num_fixed_parameters++;
@@ skipping 1139 matching lines @@
              ctor_name.ToCString(),
              error_message.ToCString());
   }
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
 }
 
 
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsConstructor());
+  ASSERT(func.Owner() == current_class().raw());
   const intptr_t ctor_pos = TokenPos();
   OpenFunctionBlock(func);
-  const Class& cls = Class::Handle(func.Owner());
 
   LocalVariable* receiver = new LocalVariable(
-      ctor_pos,
-      Symbols::This(),
-      Type::ZoneHandle(Type::DynamicType()));
+      ctor_pos, Symbols::This(), *ReceiverType(current_class()));
   current_block_->scope->AddVariable(receiver);
 
   LocalVariable* phase_parameter = new LocalVariable(
-       ctor_pos,
-       Symbols::PhaseParameter(),
-       Type::ZoneHandle(Type::SmiType()));
+      ctor_pos, Symbols::PhaseParameter(), Type::ZoneHandle(Type::SmiType()));
   current_block_->scope->AddVariable(phase_parameter);
 
   // Parse expressions of instance fields that have an explicit
   // initializer expression.
   // The receiver must not be visible to field initializer expressions.
   receiver->set_invisible(true);
   GrowableArray<Field*> initialized_fields;
-  ParseInitializedInstanceFields(cls, receiver, &initialized_fields);
+  ParseInitializedInstanceFields(
+      current_class(), receiver, &initialized_fields);
   receiver->set_invisible(false);
 
   // If the class of this implicit constructor is a mixin application class,
   // it is a forwarding constructor of the mixin. The forwarding
   // constructor initializes the instance fields that have initializer
   // expressions and then calls the respective super constructor with
   // the same name and number of parameters.
   ArgumentListNode* forwarding_args = NULL;
-  if (cls.mixin() != Type::null()) {
+  if (current_class().mixin() != Type::null()) {
     // At this point we don't support forwarding constructors
     // that have optional parameters because we don't know the default
     // values of the optional parameters. We would have to compile the super
     // constructor to get the default values. Also, the spec is not clear
     // whether optional parameters are even allowed in this situation.
     // TODO(hausner): Remove this limitation if the language spec indeed
     // allows optional parameters.
     if (func.HasOptionalParameters()) {
       ErrorMsg(ctor_pos,
                "forwarding constructors must not have optional parameters");
     }
 
     // Prepare user-defined arguments to be forwarded to super call.
     // The first user-defined argument is at position 2.
     forwarding_args = new ArgumentListNode(ctor_pos);
     for (int i = 2; i < func.NumParameters(); i++) {
       LocalVariable* param = new LocalVariable(
           ctor_pos,
           String::ZoneHandle(func.ParameterNameAt(i)),
           Type::ZoneHandle(Type::DynamicType()));
       current_block_->scope->AddVariable(param);
       forwarding_args->Add(new LoadLocalNode(ctor_pos, param));
     }
   }
 
-  GenerateSuperConstructorCall(cls, receiver, forwarding_args);
-  CheckConstFieldsInitialized(cls);
+  GenerateSuperConstructorCall(current_class(), receiver, forwarding_args);
+  CheckConstFieldsInitialized(current_class());
 
   // Empty constructor body.
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 // Helper function to make the first num_variables variables in the
 // given scope visible/invisible.
 static void SetInvisible(LocalScope* scope, int num_variables, bool invisible) {
@@ skipping 27 matching lines @@
   }
 
   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());
-  params.AddReceiver(ReceiverType(), func.token_pos());
+  params.AddReceiver(ReceiverType(current_class()), func.token_pos());
 
   // Add implicit parameter for construction phase.
   params.AddFinalParameter(
       TokenPos(),
       &Symbols::PhaseParameter(),
       &Type::ZoneHandle(Type::SmiType()));
 
   if (func.is_const()) {
     params.SetImplicitlyFinal();
   }
@@ skipping 239 matching lines @@
   if (func.IsClosureFunction()) {
     // The first parameter of a closure function is the closure object.
     ASSERT(!func.is_const());  // Closure functions cannot be const.
     params.AddFinalParameter(
         TokenPos(),
         &Symbols::ClosureParameter(),
         &Type::ZoneHandle(Type::DynamicType()));
   } else if (!func.is_static()) {
     // Static functions do not have a receiver.
     ASSERT(current_class().raw() == func.Owner());
-    params.AddReceiver(ReceiverType(), func.token_pos());
+    params.AddReceiver(ReceiverType(current_class()), func.token_pos());
   } else if (func.IsFactory()) {
     // The first parameter of a factory is the AbstractTypeArguments vector of
     // the type of the instance to be allocated.
     params.AddFinalParameter(
         TokenPos(),
         &Symbols::TypeArgumentsParameter(),
         &Type::ZoneHandle(Type::DynamicType()));
   }
   ASSERT((CurrentToken() == Token::kLPAREN) || func.IsGetterFunction());
   const bool allow_explicit_default_values = true;
@@ skipping 201 matching lines @@
 
   // Parse the formal parameters.
   const bool are_implicitly_final = method->has_const;
   const bool allow_explicit_default_values = true;
   const intptr_t formal_param_pos = TokenPos();
   method->params.Clear();
   // Static functions do not have a receiver.
   // The first parameter of a factory is the AbstractTypeArguments vector of
   // the type of the instance to be allocated.
   if (!method->has_static || method->IsConstructor()) {
-    method->params.AddReceiver(ReceiverType(), formal_param_pos);
+    method->params.AddReceiver(ReceiverType(current_class()), formal_param_pos);
   } else if (method->IsFactory()) {
     method->params.AddFinalParameter(
         formal_param_pos,
         &Symbols::TypeArgumentsParameter(),
         &Type::ZoneHandle(Type::DynamicType()));
   }
   // Constructors have an implicit parameter for the construction phase.
   if (method->IsConstructor()) {
     method->params.AddFinalParameter(
         TokenPos(),
@@ skipping 330 matching lines @@
       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());
-      params.AddReceiver(ReceiverType(), field->name_pos);
+      params.AddReceiver(ReceiverType(current_class()), field->name_pos);
       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());
-        params.AddReceiver(ReceiverType(), field->name_pos);
+        params.AddReceiver(ReceiverType(current_class()), field->name_pos);
         params.AddFinalParameter(TokenPos(),
                                  &Symbols::Value(),
                                  field->type);
         setter.set_result_type(Type::Handle(Type::VoidType()));
         AddFormalParamsToFunction(&params, setter);
         members->AddFunction(setter);
       }
     }
 
     if (CurrentToken() != Token::kCOMMA) {
@@ skipping 110 matching lines @@
     member.name_pos = TokenPos();
     member.name = CurrentLiteral();  // Unqualified identifier.
     ConsumeToken();
     if (member.has_factory) {
       // The factory name may be qualified, but the first identifier must match
       // the name of the immediately enclosing class.
       if (!member.name->Equals(members->class_name())) {
         ErrorMsg(member.name_pos, "factory name must be '%s'",
                  members->class_name().ToCString());
       }
-      // Do not bypass class resolution by using current_class() directly, since
-      // it may be a patch class.
-      const Object& result_type_class = Object::Handle(
-          UnresolvedClass::New(LibraryPrefix::Handle(),
-                               *member.name,
-                               member.name_pos));
-      // The type arguments of the result type are the type parameters of the
-      // current class. Note that in the case of a patch class, they are copied
-      // from the class being patched.
-      member.type = &Type::ZoneHandle(Type::New(
-          result_type_class,
-          TypeArguments::Handle(current_class().type_parameters()),
-          member.name_pos));
     } else if (member.has_static) {
       ErrorMsg(member.name_pos, "constructor cannot be static");
     }
+    if (member.type != NULL) {
+      ErrorMsg(member.name_pos, "constructor must not specify return type");
+    }
+    // Do not bypass class resolution by using current_class() directly, since
+    // it may be a patch class.
+    const Object& result_type_class = Object::Handle(
+        UnresolvedClass::New(LibraryPrefix::Handle(),
+                             *member.name,
+                             member.name_pos));
+    // The type arguments of the result type are the type parameters of the
+    // current class. Note that in the case of a patch class, they are copied
+    // from the class being patched.
+    member.type = &Type::ZoneHandle(Type::New(
+        result_type_class,
+        TypeArguments::Handle(current_class().type_parameters()),
+        member.name_pos));
+
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
     *member.name = String::Concat(*member.name, Symbols::Dot());
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
       member.constructor_name = ExpectIdentifier("identifier expected");
       *member.name = String::Concat(*member.name, *member.constructor_name);
     }
     // Ensure that names are symbols.
     *member.name = Symbols::New(*member.name);
-    if (member.type == NULL) {
-      ASSERT(!member.has_factory);
-      // The body of the constructor cannot modify the type arguments of the
-      // constructed instance, which is passed in as a hidden parameter.
-      // Therefore, there is no need to set the result type to be checked.
-      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) && !member.has_var &&
              (LookaheadToken(1) != Token::kLPAREN) &&
              (LookaheadToken(1) != Token::kASSIGN) &&
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON)) {
     ConsumeToken();
     member.kind = RawFunction::kGetterFunction;
@@ skipping 263 matching lines @@
   if (need_implicit_constructor) {
     AddImplicitConstructor(cls);
   }
 
   if (cls.is_patch()) {
     // Apply the changes to the patched class looked up above.
     Object& obj = Object::Handle(library_.LookupLocalObject(class_name));
     // The patched class must not be finalized yet.
     const Class& orig_class = Class::Cast(obj);
     ASSERT(!orig_class.is_finalized());
-    const char* err_msg = orig_class.ApplyPatch(cls);
-    if (err_msg != NULL) {
-      ErrorMsg(class_pos, "applying patch failed with '%s'", err_msg);
+    Error& error = Error::Handle();
+    if (!orig_class.ApplyPatch(cls, &error)) {
+      AppendErrorMsg(error, class_pos, "applying patch failed");
     }
   }
 }
 
 
 // Add an implicit constructor to the given class.
 void Parser::AddImplicitConstructor(const Class& cls) {
   // The implicit constructor is unnamed, has no explicit parameter.
   String& ctor_name = String::ZoneHandle(cls.Name());
   ctor_name = String::Concat(ctor_name, Symbols::Dot());
   ctor_name = Symbols::New(ctor_name);
   // To indicate that this is an implicit constructor, we set the
   // token position and end token position of the function
   // to the token position of the class.
   Function& ctor = Function::Handle(
       Function::New(ctor_name,
                     RawFunction::kConstructor,
                     /* is_static = */ false,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     cls,
                     cls.token_pos()));
   ctor.set_end_token_pos(ctor.token_pos());
 
   ParamList params;
-  // Add implicit 'this' parameter. We don't care about the specific type
-  // and just specify dynamic.
-  const Type& receiver_type = Type::Handle(Type::DynamicType());
-  params.AddReceiver(&receiver_type, cls.token_pos());
+  // Add implicit 'this' parameter.
+  const AbstractType* receiver_type = ReceiverType(cls);
+  params.AddReceiver(receiver_type, cls.token_pos());
   // Add implicit parameter for construction phase.
   params.AddFinalParameter(cls.token_pos(),
                            &Symbols::PhaseParameter(),
                            &Type::ZoneHandle(Type::SmiType()));
 
   AddFormalParamsToFunction(&params, ctor);
   // The body of the constructor cannot modify the type of the constructed
   // instance, which is passed in as the receiver.
-  ctor.set_result_type(receiver_type);
+  ctor.set_result_type(*receiver_type);
   cls.AddFunction(ctor);
 }
 
 
 // Check for cycles in constructor redirection. Also check whether a
 // named constructor collides with the name of another class member.
 void Parser::CheckConstructors(ClassDesc* class_desc) {
   // Check for cycles in constructor redirection.
   const GrowableArray<MemberDesc>& members = class_desc->members();
   for (int i = 0; i < members.length(); i++) {
@@ skipping 70 matching lines @@
   if (CurrentToken() != Token::kWITH) {
     ErrorMsg("mixin application 'with Type' expected");
   }
   type = ParseMixins(type);
 
   // TODO(hausner): treat the mixin application as an alias, not as a base
   // class whose super class is the mixin application!
   mixin_application.set_super_type(type);
   mixin_application.set_is_synthesized_class();
 
-  AddImplicitConstructor(mixin_application);
+  // This mixin application typedef needs an implicit constructor, but it is
+  // too early to call 'AddImplicitConstructor(mixin_application)' here,
+  // because this class should be lazily compiled.
   if (CurrentToken() == Token::kIMPLEMENTS) {
     ParseInterfaceList(mixin_application);
   }
   ExpectSemicolon();
   pending_classes.Add(mixin_application, Heap::kOld);
 }
 
 
 // Look ahead to detect if we are seeing ident [ TypeParameters ] "(".
 // We need this lookahead to distinguish between the optional return type
@@ skipping 1117 matching lines @@
 // Populate the parameter type array and parameter name array of the function
 // with the formal parameter types and names.
 void Parser::AddFormalParamsToFunction(const ParamList* params,
                                        const Function& func) {
   ASSERT((params != NULL) && (params->parameters != NULL));
   ASSERT((params->num_optional_parameters > 0) ==
          (params->has_optional_positional_parameters ||
           params->has_optional_named_parameters));
   if (!Utils::IsInt(16, params->num_fixed_parameters) ||
       !Utils::IsInt(16, params->num_optional_parameters)) {
-    ErrorMsg(func.token_pos(), "too many formal parameters");
+    const Script& script = Script::Handle(Class::Handle(func.Owner()).script());
+    const Error& error = Error::Handle(FormatErrorMsg(
+        script, func.token_pos(), "Error", "too many formal parameters"));
+    ErrorMsg(error);
   }
   func.set_num_fixed_parameters(params->num_fixed_parameters);
   func.SetNumOptionalParameters(params->num_optional_parameters,
                                 params->has_optional_positional_parameters);
   const int num_parameters = params->parameters->length();
   ASSERT(num_parameters == func.NumParameters());
   func.set_parameter_types(Array::Handle(Array::New(num_parameters,
                                                     Heap::kOld)));
   func.set_parameter_names(Array::Handle(Array::New(num_parameters,
                                                     Heap::kOld)));
   for (int i = 0; i < num_parameters; i++) {
     ParamDesc& param_desc = (*params->parameters)[i];
-    ASSERT(is_top_level_ || param_desc.type->IsResolved());
     func.SetParameterTypeAt(i, *param_desc.type);
     func.SetParameterNameAt(i, *param_desc.name);
   }
 }
 
 
 // Populate local scope with the formal parameters.
 void Parser::AddFormalParamsToScope(const ParamList* params,
                                     LocalScope* scope) {
   ASSERT((params != NULL) && (params->parameters != NULL));
@@ skipping 1946 matching lines @@
   va_start(args, format);
   const Error& error = Error::Handle(
       FormatError(script_, TokenPos(), "Error", format, args));
   va_end(args);
   isolate()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void Parser::ErrorMsg(const Error& error) {
-  isolate()->long_jump_base()->Jump(1, error);
+  Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void Parser::AppendErrorMsg(
       const Error& prev_error, intptr_t token_pos, const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(FormatErrorWithAppend(
       prev_error, script_, token_pos, "Error", format, args));
@@ skipping 1392 matching lines @@
   if (is_top_level_) {
     return (current_member_ != NULL) &&
            current_member_->has_static && !current_member_->has_factory;
   }
   ASSERT(!current_function().IsNull());
   return
       current_function().is_static() && !current_function().IsInFactoryScope();
 }
 
 
-const Type* Parser::ReceiverType() const {
-  ASSERT(!current_class().IsNull());
+const AbstractType* Parser::ReceiverType(const Class& cls) {
+  ASSERT(!cls.IsNull());
   TypeArguments& type_arguments = TypeArguments::Handle();
-  if (current_class().NumTypeParameters() > 0) {
-    type_arguments = current_class().type_parameters();
+  if (cls.NumTypeParameters() > 0) {
+    type_arguments = cls.type_parameters();
   }
-  Type& type = Type::ZoneHandle(
-      Type::New(current_class(), type_arguments, current_class().token_pos()));
-  if (!is_top_level_ || current_class().is_type_finalized()) {
+  AbstractType& type = AbstractType::ZoneHandle(
+      Type::New(cls, type_arguments, cls.token_pos()));
+  if (cls.is_type_finalized()) {
     type ^= ClassFinalizer::FinalizeType(
-        current_class(), type, ClassFinalizer::kCanonicalizeWellFormed);
+        cls, type, ClassFinalizer::kCanonicalizeWellFormed);
+    // Note that the receiver type may now be a malbounded type.
   }
   return &type;
 }
 
 
 bool Parser::IsInstantiatorRequired() const {
   ASSERT(!current_function().IsNull());
   if (current_function().is_static() &&
       !current_function().IsInFactoryScope()) {
     return false;
@@ skipping 1917 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart