Small cleanup in parser

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/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 988 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), ident_pos);
+  params.AddReceiver(ReceiverType(), 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), ident_pos);
+  params.AddReceiver(ReceiverType(), 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), ident_pos);
+  params.AddReceiver(ReceiverType(), 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);
@@ skipping 11 matching lines @@
 
 
 SequenceNode* Parser::ParseNoSuchMethodDispatcher(const Function& func) {
   TRACE_PARSER("ParseNoSuchMethodDispatcher");
   ParamList params;
 
   ASSERT(func.IsNoSuchMethodDispatcher());
   intptr_t token_pos = func.token_pos();
   ASSERT(func.token_pos() == 0);
   ASSERT(current_class().raw() == func.Owner());
-  params.AddReceiver(ReceiverType(token_pos), token_pos);
+  params.AddReceiver(ReceiverType(), token_pos);
   ASSERT(func.num_fixed_parameters() == 1);  // Receiver.
   ASSERT(!func.HasOptionalParameters());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   LocalScope* scope = current_block_->scope;
   AddFormalParamsToScope(&params, scope);
 
   // Receiver is local 0.
   LocalVariable* receiver = scope->VariableAt(0);
@@ skipping 1084 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(TokenPos()), func.token_pos());
+  params.AddReceiver(ReceiverType(), 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 238 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(TokenPos()), func.token_pos());
+    params.AddReceiver(ReceiverType(), 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 196 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),
-                               formal_param_pos);
+    method->params.AddReceiver(ReceiverType(), 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(TokenPos()), field->name_pos);
+      params.AddReceiver(ReceiverType(), 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(TokenPos()), field->name_pos);
+        params.AddReceiver(ReceiverType(), 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 4987 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(intptr_t type_pos) const {
+const Type* Parser::ReceiverType() const {
   ASSERT(!current_class().IsNull());
   TypeArguments& type_arguments = TypeArguments::Handle();
   if (current_class().NumTypeParameters() > 0) {
     type_arguments = current_class().type_parameters();
   }
   Type& type = Type::ZoneHandle(
-      Type::New(current_class(), type_arguments, type_pos));
+      Type::New(current_class(), type_arguments, current_class().token_pos()));
   if (!is_top_level_ || current_class().is_type_finalized()) {
     type ^= ClassFinalizer::FinalizeType(
         current_class(), type, ClassFinalizer::kCanonicalizeWellFormed);
   }
   return &type;
 }
 
 
 bool Parser::IsInstantiatorRequired() const {
   ASSERT(!current_function().IsNull());
@@ skipping 1884 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart