Add debugging info for 'this'

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 430 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) {
+  void AddReceiver(const Type* receiver_type, intptr_t token_pos) {
     ASSERT(this->parameters->is_empty());
-    AddFinalParameter(receiver_type->token_pos(),
-                      &Symbols::This(),
-                      receiver_type);
+    AddFinalParameter(token_pos, &Symbols::This(), receiver_type);
   }
 
   void SetImplicitlyFinal() {
     implicitly_final = true;
   }
 
   int num_fixed_parameters;
   int num_optional_parameters;
   bool has_optional_positional_parameters;
   bool has_optional_named_parameters;
@@ skipping 535 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(ident_pos), 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(ident_pos), 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(ident_pos), 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));
+  params.AddReceiver(ReceiverType(token_pos), 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()));
+  params.AddReceiver(ReceiverType(TokenPos()), 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()));
+    params.AddReceiver(ReceiverType(TokenPos()), 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));
+    method->params.AddReceiver(ReceiverType(formal_param_pos),
+                               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()));
+      params.AddReceiver(ReceiverType(TokenPos()), 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()));
+        params.AddReceiver(ReceiverType(TokenPos()), 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 466 matching lines @@
                     /* is_static = */ false,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     cls,
                     cls.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);
+  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);
   cls.AddFunction(ctor);
@@ skipping 6412 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart