Associate the correct type to method receivers (instead of Dynamic type).

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 407 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(intptr_t name_pos) {
+  void AddReceiver(const Type* receiver_type) {
     ASSERT(this->parameters->is_empty());
-    // The receiver does not need to be type checked.
-    AddFinalParameter(name_pos,
+    AddFinalParameter(receiver_type->token_pos(),

[hausner, 2012/08/02 23:25:00]

Why are you using the token position of the type, not the token position that is
passed in (typically the call position)?

[regis, 2012/08/02 23:58:37]

The token position is now passed to ReceiverType to build the type, and this
same position is then used here.

Well, that was the idea, but your comment made me realize that the type may get
canonicalized, in which case the token position gets lost.
I'll keep the name_pos as a separate parameter. 

                       &String::ZoneHandle(Symbols::This()),
-                      &Type::ZoneHandle(Type::DynamicType()));
+                      receiver_type);
   }
 
   void SetImplicitlyFinal() {
     implicitly_final = true;
   }
 
   int num_fixed_parameters;
   int num_optional_parameters;
   bool has_named_optional_parameters;  // Indicates use of the new syntax.
   bool has_field_initializer;
@@ skipping 261 matching lines @@
   }
   if (parsed_function->has_expression_temp_var()) {
     node_sequence->scope()->AddVariable(parsed_function->expression_temp_var());
   }
   parsed_function->SetNodeSequence(node_sequence);
 
   // The instantiator may be required at run time for generic type checks or
   // allocation of generic types.
   if (parser.IsInstantiatorRequired()) {
     // In the case of a local function, only set the instantiator if the
-    // receiver was captured.
+    // receiver (or type arguments parameter of a factory) was captured.
+    LocalVariable* instantiator = NULL;
     const bool kTestOnly = true;
-    LocalVariable* receiver =
-        parser.LookupReceiver(node_sequence->scope(), kTestOnly);
+    if (parser.current_function().IsInFactoryScope()) {
+      instantiator = parser.LookupTypeArgumentsParameter(node_sequence->scope(),
+                                                         kTestOnly);
+    } else {
+      instantiator = parser.LookupReceiver(node_sequence->scope(), kTestOnly);
+    }
     if (!parser.current_function().IsLocalFunction() ||
-        ((receiver != NULL) && receiver->is_captured())) {
+        ((instantiator != NULL) && instantiator->is_captured())) {
       parsed_function->set_instantiator(
-          new LoadLocalNode(node_sequence->token_pos(), *receiver));
+          new LoadLocalNode(node_sequence->token_pos(), *instantiator));
     }
   }
 
   parsed_function->set_default_parameter_values(default_parameter_values);
   isolate->set_ast_node_id(prev_ast_node_id);
 }
 
 
 // TODO(regis): Implement support for non-const final static fields (currently
 // supported "final" fields are actually const fields).
@@ skipping 110 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;
-  params.AddReceiver(TokenPos());
+  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);
@@ skipping 24 matching lines @@
   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 Field& field =
       Field::ZoneHandle(field_class.LookupInstanceField(field_name));
   const AbstractType& field_type = AbstractType::ZoneHandle(field.type());
 
   ParamList params;
-  params.AddReceiver(TokenPos());
+  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);
   AddFormalParamsToScope(&params, current_block_->scope);
@@ skipping 155 matching lines @@
       ParseFormalParameterList(no_explicit_default_values, &func_params);
 
       // The field 'is_static' has no meaning for signature functions.
       const Function& signature_function = Function::Handle(
           Function::New(*parameter.name,
                         RawFunction::kSignatureFunction,
                         /* is_static = */ false,
                         /* is_const = */ false,
                         /* is_abstract = */ false,
                         /* is_external = */ false,
+                        current_class(),
                         parameter.name_pos));
-      signature_function.set_owner(current_class());
       signature_function.set_result_type(result_type);
       AddFormalParamsToFunction(&func_params, signature_function);
       const String& signature = String::Handle(signature_function.Signature());
       // Lookup the signature class, i.e. the class whose name is the signature.
       // We only lookup in the current library, but not in its imports, and only
       // create a new canonical signature class if it does not exist yet.
       Class& signature_class = Class::ZoneHandle(
           library_.LookupLocalClass(signature));
       if (signature_class.IsNull()) {
         signature_class = Class::NewSignatureClass(signature,
@@ skipping 342 matching lines @@
                                            AstNode* receiver) {
   Function& implicit_closure_function =
       Function::ZoneHandle(func.ImplicitClosureFunction());
   if (receiver != NULL) {
     // If we create an implicit instance closure from inside a closure of a
     // parameterized class, make sure that the receiver is captured as
     // instantiator.
     if (current_block_->scope->function_level() > 0) {
       const Class& signature_class = Class::Handle(func.signature_class());
       if (signature_class.NumTypeParameters() > 0) {
-        CaptureReceiver();
+        CaptureInstantiator();
       }
     }
   }
   return new ClosureNode(token_pos, implicit_closure_function, receiver, NULL);
 }
 
 
 AstNode* Parser::ParseSuperFieldAccess(const String& field_name) {
   TRACE_PARSER("ParseSuperFieldAccess");
   const intptr_t field_pos = TokenPos();
@@ skipping 385 matching lines @@
 
   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,
        String::ZoneHandle(Symbols::PhaseParameter()),
-       Type::ZoneHandle(Type::DynamicType()));
+       Type::ZoneHandle(Type::IntInterface()));
   current_block_->scope->AddVariable(phase_parameter);
 
   // Now that the "this" parameter is in scope, we can generate the code
   // to strore the initializer expressions in the respective instance fields.
   for (int i = 0; i < initializers.length(); i++) {
     const Field* field = initializers[i].inst_field;
     AstNode* instance = new LoadLocalNode(field->token_pos(), *receiver);
     AstNode* field_init =
         new StoreInstanceFieldNode(field->token_pos(),
                                    instance,
@@ skipping 35 matching lines @@
     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.
-  params.AddReceiver(TokenPos());
+  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::DynamicType()));
+      &Type::ZoneHandle(Type::IntInterface()));
 
   if (func.is_const()) {
     params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
   ASSERT(func.NumberOfParameters() == params.parameters->length());
 
@@ skipping 219 matching lines @@
     return statements;
   }
 
   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. We name this hidden parameter 'this'.
-  const bool has_receiver = !func.IsClosureFunction() &&
-                            (!func.is_static() || func.IsFactory());
-  const bool allow_explicit_default_values = true;
-  if (has_receiver) {
-    params.AddReceiver(TokenPos());
+  // 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());
+    params.AddReceiver(ReceiverType(TokenPos()));
+  } else if (func.IsFactory()) {
+    params.AddFinalParameter(
+        TokenPos(),
+        &String::ZoneHandle(Symbols::TypeArgumentsParameter()),
+        &Type::ZoneHandle(Type::DynamicType()));
   }
   ASSERT(CurrentToken() == Token::kLPAREN);
+  const bool allow_explicit_default_values = true;
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   // The number of parameters and their type are not yet set in local functions,
   // since they are not 'top-level' parsed.
   if (func.IsLocalFunction()) {
     AddFormalParamsToFunction(&params, func);
   }
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
   ASSERT(func.NumberOfParameters() == params.parameters->length());
@@ skipping 12 matching lines @@
   // Populate function scope with the formal parameters.
   AddFormalParamsToScope(&params, current_block_->scope);
 
   if (FLAG_enable_type_checks &&
       (current_block_->scope->function_level() > 0)) {
     // We are parsing, but not compiling, a local function.
     // The instantiator may be required at run time for generic type checks.
     if (IsInstantiatorRequired()) {
       // Make sure that the receiver of the enclosing instance function
       // (or implicit first parameter of an enclosing factory) is marked as
-      // captured if type checks are enabled, because they may access the
-      // receiver to instantiate types.
-      CaptureReceiver();
+      // captured if type checks are enabled, because they may access it to
+      // instantiate types.
+      CaptureInstantiator();
     }
   }
 
   OpenBlock();  // Open a nested scope for the outermost function block.
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
@@ skipping 142 matching lines @@
     ErrorMsg(method->name_pos,
              "'external' method only allowed in class definition");
   }
 
   if (members->FunctionNameExists(*method->name, method->kind)) {
     ErrorMsg(method->name_pos,
              "field or method '%s' already defined", method->name->ToCString());
   }
 
   // Parse the formal parameters.
-  // The first parameter of factory methods is an implicit parameter called
-  // 'this' of type AbstractTypeArguments.
-  const bool has_this_param =
-      !method->has_static || method->IsConstructor() || method->has_factory;
   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();
-  if (has_this_param) {
-    method->params.AddReceiver(formal_param_pos);
+  // 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));
+  } else if (method->has_factory) {
+    method->params.AddFinalParameter(
+        formal_param_pos,
+        &String::ZoneHandle(Symbols::TypeArgumentsParameter()),
+        &Type::ZoneHandle(Type::DynamicType()));
   }
   // Constructors have an implicit parameter for the construction phase.
   if (method->IsConstructor()) {
     method->params.AddFinalParameter(
         TokenPos(),
         &String::ZoneHandle(Symbols::PhaseParameter()),
-        &Type::ZoneHandle(Type::DynamicType()));
+        &Type::ZoneHandle(Type::IntInterface()));
   }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &method->params);
   if (method->IsGetter() || method->IsSetter()) {
     int expected_num_parameters = 0;
     if (method->IsGetter()) {
       expected_num_parameters = (method->has_static) ? 0 : 1;
       method->name = &String::ZoneHandle(Field::GetterSymbol(*method->name));
@@ skipping 136 matching lines @@
   } else {
     function_kind = RawFunction::kRegularFunction;
   }
   Function& func = Function::Handle(
       Function::New(*method->name,
                     function_kind,
                     method->has_static,
                     method->has_const,
                     method->has_abstract,
                     method->has_external,
+                    current_class(),
                     method_pos));
   func.set_result_type(*method->type);
   func.set_end_token_pos(method_end_pos);
 
   // No need to resolve parameter types yet, or add parameters to local scope.
   ASSERT(is_top_level_);
   AddFormalParamsToFunction(&method->params, func);
   members->AddFunction(func);
 }
 
@@ skipping 57 matching lines @@
       }
     }
 
     // Create the field object.
     // TODO(hausner): For now, all static final fields are constant. Remove
     // this when lazy init of static variables is implemented.
     class_field = Field::New(*field->name,
                              field->has_static,
                              field->has_final,
                              field->has_const || field->has_final,
+                             current_class(),
                              field->name_pos);
     class_field.set_type(*field->type);
     class_field.set_has_initializer(has_initializer);
     members->AddField(class_field);
 
     // For static final fields, set value to "uninitialized" and
     // create a kConstImplicitGetter getter method.
     if (field->has_static && has_initializer) {
       class_field.set_value(init_value);
       if (!has_simple_literal) {
         String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
-        getter = Function::New(getter_name, RawFunction::kConstImplicitGetter,
-                               field->has_static, field->has_final,
-                               /* is_abstract */ false,
-                               /* is_external */ false,
+        getter = Function::New(getter_name,
+                               RawFunction::kConstImplicitGetter,
+                               field->has_static,
+                               field->has_final,
+                               /* is_abstract = */ false,
+                               /* is_external = */ false,
+                               current_class(),
                                field->name_pos);
         getter.set_result_type(*field->type);
         members->AddFunction(getter);
       }
     }
 
     // For instance fields, we create implicit getter and setter methods.
     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, false,
-                             /* is_abstract */ false,
+                             field->has_static,
+                             field->has_final,
+                             /* is_abstract = */ false,
+                             /* is_external = */ false,
+                             current_class(),
                              field->name_pos);
       ParamList params;
-      params.AddReceiver(TokenPos());
+      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, false,
-                               /* is_abstract */ false,
+                               field->has_static,
+                               field->has_final,
+                               /* is_abstract = */ false,
+                               /* is_external = */ false,
+                               current_class(),
                                field->name_pos);
         ParamList params;
-        params.AddReceiver(TokenPos());
+        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);
       }
     }
 
     if (CurrentToken() != Token::kCOMMA) {
@@ skipping 358 matching lines @@
     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.
-    params.AddReceiver(TokenPos());
+    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::DynamicType()));
+        &Type::ZoneHandle(Type::IntInterface()));
 
     AddFormalParamsToFunction(&params, ctor);
-    // 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.
-    const AbstractType& result_type = Type::ZoneHandle(Type::DynamicType());
-    ctor.set_result_type(result_type);
+    // The body of the constructor cannot modify the type of the constructed
+    // instance, which is passed in as the receiver.
+    ctor.set_result_type(*((*params.parameters)[0].type));
     class_desc->AddFunction(ctor);
   }
 
   // Check for cycles in constructor redirection.
   const GrowableArray<MemberDesc>& members = class_desc->members();
   for (int i = 0; i < members.length(); i++) {
     MemberDesc* member = &members[i];
     GrowableArray<MemberDesc*> ctors;
     while ((member != NULL) && (member->redirect_name != NULL)) {
       ASSERT(member->IsConstructor());
@@ skipping 84 matching lines @@
   const bool no_explicit_default_values = false;
   ParseFormalParameterList(no_explicit_default_values, &func_params);
   // The field 'is_static' has no meaning for signature functions.
   Function& signature_function = Function::Handle(
       Function::New(*alias_name,
                     RawFunction::kSignatureFunction,
                     /* is_static = */ false,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
+                    alias_owner,
                     alias_name_pos));
-  signature_function.set_owner(alias_owner);
   signature_function.set_result_type(result_type);
   AddFormalParamsToFunction(&func_params, signature_function);
   const String& signature = String::Handle(signature_function.Signature());
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing function type alias '%s'\n",
               signature.ToCString());
   }
   // Lookup the signature class, i.e. the class whose name is the signature.
   // We only lookup in the current library, but not in its imports, and only
   // create a new canonical signature class if it does not exist yet.
@@ skipping 397 matching lines @@
     if (library_.LookupObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "getter for '%s' is already defined",
                var_name.ToCString());
     }
     accessor_name = Field::SetterName(var_name);
     if (library_.LookupObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "setter for '%s' is already defined",
                var_name.ToCString());
     }
 
-    field = Field::New(var_name, is_static, is_final, is_const, name_pos);
+    field = Field::New(
+         var_name, is_static, is_final, is_const, current_class(), name_pos);
     field.set_type(type);
     field.set_value(Instance::Handle(Instance::null()));
     top_level->fields.Add(field);
     library_.AddObject(field, var_name);
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       Instance& field_value = Instance::Handle(Object::sentinel());
       bool has_simple_literal = false;
       if ((is_final || is_const) && (LookaheadToken(1) == Token::kSEMICOLON)) {
         has_simple_literal = IsSimpleLiteral(type, &field_value);
       }
       SkipExpr();
       field.set_value(field_value);
       if (!has_simple_literal) {
         // Create a static const getter.
         String& getter_name = String::ZoneHandle(Field::GetterSymbol(var_name));
-        getter = Function::New(getter_name, RawFunction::kConstImplicitGetter,
-                               is_static, is_final, false, false, name_pos);
+        getter = Function::New(getter_name,
+                               RawFunction::kConstImplicitGetter,
+                               is_static,
+                               is_final,
+                               /* is_abstract = */ false,
+                               /* is_external = */ false,
+                               current_class(),
+                               name_pos);
         getter.set_result_type(type);
         top_level->functions.Add(getter);
       }
 
     } else if (is_final || is_const) {
       ErrorMsg(name_pos, "missing initializer for final or const variable");
     }
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
@@ skipping 61 matching lines @@
     ConsumeToken();
     SkipExpr();
     ExpectSemicolon();
     function_end_pos = TokenPos();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
   } else {
     ErrorMsg("function block expected");
   }
   Function& func = Function::Handle(
-      Function::New(func_name, RawFunction::kRegularFunction,
-                    is_static, false, false, is_external, function_pos));
+      Function::New(func_name,
+                    RawFunction::kRegularFunction,
+                    is_static,
+                    /* is_const = */ false,
+                    /* is_abstract = */ false,
+                    is_external,
+                    current_class(),
+                    function_pos));
   func.set_result_type(result_type);
   func.set_end_token_pos(function_end_pos);
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(func);
   library_.AddObject(func, func_name);
 }
 
 
 void Parser::ParseTopLevelAccessor(TopLevel* top_level) {
   TRACE_PARSER("ParseTopLevelAccessor");
@@ skipping 61 matching lines @@
     ExpectSemicolon();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
   } else {
     ErrorMsg("function block expected");
   }
   Function& func = Function::Handle(
       Function::New(accessor_name,
                     is_getter? RawFunction::kGetterFunction :
                                RawFunction::kSetterFunction,
-                    is_static, false, false, false, accessor_pos));
+                    is_static,
+                    /* is_const = */ false,
+                    /* is_abstract = */ false,
+                    /* is_external = */ false,
+                    current_class(),
+                    accessor_pos));
   func.set_result_type(result_type);
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(func);
   library_.AddObject(func, accessor_name);
 }
 
 
 void Parser::ParseLibraryName() {
   TRACE_PARSER("ParseLibraryName");
   if ((script_.kind() == RawScript::kLibraryTag) &&
@@ skipping 375 matching lines @@
       new ReturnNode(TokenPos(), new NativeBodyNode(TokenPos(),
                                                     native_name,
                                                     native_function,
                                                     num_parameters,
                                                     has_opt_params,
                                                     is_instance_closure)));
 }
 
 
 LocalVariable* Parser::LookupReceiver(LocalScope* from_scope, bool test_only) {
+  ASSERT(!current_function().is_static());
   const String& this_name = String::Handle(Symbols::This());
   return from_scope->LookupVariable(this_name, test_only);
 }
 
 
+LocalVariable* Parser::LookupTypeArgumentsParameter(LocalScope* from_scope,
+                                                    bool test_only) {
+  ASSERT(current_function().IsInFactoryScope());
+  const String& param_name = String::Handle(Symbols::TypeArgumentsParameter());
+  return from_scope->LookupVariable(param_name, test_only);
+}
 LocalVariable* Parser::LookupPhaseParameter() {
   const String& phase_name =
       String::Handle(Symbols::PhaseParameter());
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(phase_name, kTestOnly);
 }
 
 
-void Parser::CaptureReceiver() {
+void Parser::CaptureInstantiator() {
   ASSERT(current_block_->scope->function_level() > 0);
   const bool kTestOnly = false;
-  // Side effect of lookup captures the receiver variable.
-  LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
-  ASSERT(receiver != NULL);
+  // Side effect of lookup captures the instantiator variable.
+  LocalVariable* instantiator = NULL;
+  if (current_function().IsInFactoryScope()) {
+    instantiator = LookupTypeArgumentsParameter(current_block_->scope,
+                                                kTestOnly);
+  } else {
+    instantiator = LookupReceiver(current_block_->scope, kTestOnly);
+  }
+  ASSERT(instantiator != NULL);
 }
 
 
 AstNode* Parser::LoadReceiver(intptr_t token_pos) {
   // A nested function may access 'this', referring to the receiver of the
   // outermost enclosing function.
-  // We should not be loading the receiver from a static scope.
-  ASSERT(!current_function().is_static() ||
-         current_function().IsInFactoryScope());
   const bool kTestOnly = false;
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
   if (receiver == NULL) {
     ErrorMsg(token_pos, "illegal implicit access to receiver 'this'");
   }
   return new LoadLocalNode(TokenPos(), *receiver);
 }
 
 
+AstNode* Parser::LoadTypeArgumentsParameter(intptr_t token_pos) {
+  // A nested function may access ':type_arguments' to use as instantiator,
+  // referring to the implicit first parameter of the outermost enclosing
+  // factory function.
+  const bool kTestOnly = false;
+  LocalVariable* param = LookupTypeArgumentsParameter(current_block_->scope,
+                                                      kTestOnly);
+  ASSERT(param != NULL);
+  return new LoadLocalNode(TokenPos(), *param);
+}
+
+
 AstNode* Parser::CallGetter(intptr_t token_pos,
                             AstNode* object,
                             const String& name) {
   return new InstanceGetterNode(TokenPos(), object, name);
 }
 
 
 // Returns ast nodes of the variable initialization.
 AstNode* Parser::ParseVariableDeclaration(const AbstractType& type,
                                           bool is_final,
@@ skipping 219 matching lines @@
   ASSERT(function.signature_class() == signature_class.raw());
 
   // Local functions are registered in the enclosing class, but
   // ignored during class finalization. The enclosing class has
   // already been finalized.
   ASSERT(current_class().is_finalized());
 
   // Make sure that the instantiator is captured.
   if ((signature_class.NumTypeParameters() > 0) &&
       (current_block_->scope->function_level() > 0)) {
-    CaptureReceiver();
+    CaptureInstantiator();
   }
 
   // Since the signature type is cached by the signature class, it may have
   // been finalized already.
   Type& signature_type = Type::Handle(signature_class.SignatureType());
   AbstractTypeArguments& signature_type_arguments =
       AbstractTypeArguments::Handle(signature_type.arguments());
 
   if (!signature_type.IsFinalized()) {
     signature_type ^= ClassFinalizer::FinalizeType(
@@ skipping 1133 matching lines @@
         new JumpNode(catch_pos, Token::kCONTINUE, end_catch_label));
     SequenceNode* catch_handler = CloseBlock();
     ExpectToken(Token::kRBRACE);
 
     if (!exception_param.type->IsDynamicType()) {  // Has a type specification.
       // Now form an 'if type check' as an exception type exists in
       // the catch specifier.
       if (!exception_param.type->IsInstantiated() &&
           (current_block_->scope->function_level() > 0)) {
         // Make sure that the instantiator is captured.
-        CaptureReceiver();
+        CaptureInstantiator();
       }
       TypeNode* exception_type = new TypeNode(catch_pos, *exception_param.type);
       AstNode* exception_var = new LoadLocalNode(catch_pos, *catch_excp_var);
       if (!exception_type->type().IsInstantiated()) {
         EnsureExpressionTemp();
       }
       AstNode* type_cond_expr = new ComparisonNode(
           catch_pos, Token::kIS, exception_var, exception_type);
       current_block_->statements->Add(
           new IfNode(catch_pos, type_cond_expr, catch_handler, NULL));
@@ skipping 575 matching lines @@
         if ((op_kind == Token::kIS) && (CurrentToken() == Token::kNOT)) {
           ConsumeToken();
           op_kind = Token::kISNOT;
         }
         const intptr_t type_pos = TokenPos();
         const AbstractType& type =
             AbstractType::ZoneHandle(ParseType(ClassFinalizer::kCanonicalize));
         if (!type.IsInstantiated() &&
             (current_block_->scope->function_level() > 0)) {
           // Make sure that the instantiator is captured.
-          CaptureReceiver();
+          CaptureInstantiator();
         }
         right_operand = new TypeNode(type_pos, type);
         if ((op_kind == Token::kIS) && type.IsMalformed()) {
           // Note that a type error is thrown even if the tested value is null
           // in a type test. However, no cast exception is thrown if the value
           // is null in a type cast.
           return ThrowTypeError(type_pos, type);
         }
       }
       if (Token::IsRelationalOperator(op_kind)
@@ skipping 950 matching lines @@
   if (current_function().is_static()) {
     ErrorMsg(field_pos,
              "cannot access instance field '%s' from a static function",
              field_name.ToCString());
   }
 }
 
 
 // If type parameters are currently in scope, return their declaring class,
 // otherwise return null.
-RawClass* Parser::TypeParametersScopeClass() {
+RawClass* Parser::TypeParametersScopeClass() const {
   // Type parameters cannot be referred to from a static function, except from
   // a constructor or from a factory.
   // A constructor is considered as non-static by the compiler.
   if (is_top_level_) {
     if ((current_member_ == NULL) ||
         (current_member_->has_factory || !current_member_->has_static)) {
       return current_class().raw();
     }
   } else {
     if (!current_function().IsNull()) {
       Function& outer_function = Function::Handle(current_function().raw());
       while (outer_function.IsLocalFunction()) {
         outer_function = outer_function.parent_function();
       }
       if (outer_function.IsFactory() || !outer_function.is_static()) {
         return current_class().raw();
       }
     }
   }
   return Class::null();
 }
 
 
+const Type* Parser::ReceiverType(intptr_t type_pos) 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));

[hausner, 2012/08/02 23:25:00]

I don't understand why you have to allocate a new type object each time you add
a receiver to an argument list. Can they not all share the same type object?

[regis, 2012/08/02 23:58:37]

We add this type to the formal parameter list, not to the argument list. So
there are not that many. Also, these types get canonicalized, so they get shared
anyway. 

+  if (!is_top_level_) {
+    type ^= ClassFinalizer::FinalizeType(
+        current_class(), type, ClassFinalizer::kCanonicalizeWellFormed);
+  }
+  return &type;
+}
+
+
 bool Parser::IsInstantiatorRequired() const {
   ASSERT(!current_function().IsNull());
   Function& outer_function = Function::Handle(current_function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory() || !outer_function.is_static()) {
     return current_class().NumTypeParameters() > 0;
   }
   return false;
@@ skipping 186 matching lines @@
         ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
       return true;
     } else if (func.IsStaticFunction()) {
       if (node != NULL) {
         ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
         // The static getter may be changed later into an instance setter.
         AstNode* receiver = NULL;
         const bool kTestOnly = true;
-        if ((!current_function().is_static() ||
-             current_function().IsInFactoryScope()) &&
+        ASSERT(!current_function().IsInFactoryScope());
+        if (!current_function().is_static() &&
             (LookupReceiver(current_block_->scope, kTestOnly) != NULL)) {
           receiver = LoadReceiver(ident_pos);
         }
         *node = new StaticGetterNode(ident_pos,
                                      receiver,
                                      Class::ZoneHandle(isolate, cls.raw()),
                                      ident);
       }
       return true;
     }
@@ skipping 402 matching lines @@
     ASSERT(!list_literal_factory_class.IsNull());
     const String& list_literal_factory_name =
         String::Handle(Symbols::ListLiteralFactory());
     const Function& list_literal_factory = Function::ZoneHandle(
         list_literal_factory_class.LookupFactory(list_literal_factory_name));
     ASSERT(!list_literal_factory.IsNull());
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
-      CaptureReceiver();
+      CaptureInstantiator();
     }
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
     factory_param->Add(list);
     AbstractTypeArguments& canonical_type_arguments =
         AbstractTypeArguments::ZoneHandle(type_arguments.Canonicalize());
     return CreateConstructorCallNode(literal_pos,
                                      canonical_type_arguments,
                                      list_literal_factory,
                                      factory_param);
   }
@@ skipping 202 matching lines @@
     ASSERT(!map_literal_factory_class.IsNull());
     const String& map_literal_factory_name =
         String::Handle(Symbols::MapLiteralFactory());
     const Function& map_literal_factory = Function::ZoneHandle(
         map_literal_factory_class.LookupFactory(map_literal_factory_name));
     ASSERT(!map_literal_factory.IsNull());
     if (!map_type_arguments.IsNull() &&
         !map_type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
-      CaptureReceiver();
+      CaptureInstantiator();
     }
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
     factory_param->Add(kv_pairs);
     return CreateConstructorCallNode(literal_pos,
                                      map_type_arguments,
                                      map_literal_factory,
                                      factory_param);
   }
 }
 
@@ skipping 254 matching lines @@
       new_object = new LiteralNode(new_pos,
                                    Instance::ZoneHandle(const_instance.raw()));
     }
   } else {
     CheckFunctionIsCallable(new_pos, constructor);
     CheckConstructorCallTypeArguments(new_pos, constructor, type_arguments);
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
-      CaptureReceiver();
+      CaptureInstantiator();
     }
     if (type.IsMalformed()) {
       // Compile the throw of a dynamic type error due to a bound error.
       return ThrowTypeError(type_pos, type);
     }
     // If the type argument vector is not instantiated, we verify in checked
     // mode at runtime that it is within its declared bounds.
     new_object = CreateConstructorCallNode(
         new_pos, type_arguments, constructor, arguments);
   }
@@ skipping 576 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart