Fix code generation issue with new factory syntax.

runtime/vm/code_generator_ia32.cc

 // Copyright (c) 2011, 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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 2237 matching lines @@
   __ popl(CTX);
   // Result is in EAX.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 // Pushes the type arguments of the instantiator on the stack.
 void CodeGenerator::GenerateInstantiatorTypeArguments(intptr_t token_index) {
-  const Class& instantiator_class =
-      Class::Handle(parsed_function().function().owner());
+  Class& instantiator_class = Class::Handle();
+  Function& outer_function =
+      Function::Handle(parsed_function().function().raw());
+  while (outer_function.IsLocalFunction()) {
+    outer_function = outer_function.parent_function();
+  }
+  if (outer_function.IsFactory()) {
+    instantiator_class = outer_function.signature_class();
+  } else {
+    instantiator_class = outer_function.owner();
+  }
   if (instantiator_class.NumTypeParameters() == 0) {
     // The type arguments are compile time constants.
     TypeArguments& type_arguments = TypeArguments::ZoneHandle();
+    // TODO(regis): Temporary type should be allocated in new gen heap.
     Type& type = Type::Handle(
         Type::NewParameterizedType(instantiator_class, type_arguments));
     String& errmsg = String::Handle();
     type = ClassFinalizer::FinalizeAndCanonicalizeType(type, &errmsg);
     if (!errmsg.IsNull()) {
       ErrorMsg(token_index, errmsg.ToCString());
     }
     type_arguments = type.arguments();
     __ PushObject(type_arguments);
   } else {
     ASSERT(parsed_function().instantiator() != NULL);
     parsed_function().instantiator()->Visit(this);
-    if (!parsed_function().function().IsInFactoryScope()) {
+    if (!outer_function.IsFactory()) {
       __ popl(EAX);  // Pop instantiator.
       // The instantiator is the receiver of the caller, which is not a factory.
       // The receiver cannot be null; extract its TypeArguments object.
       // Note that in the factory case, the instantiator is the first parameter
       // of the factory, i.e. already a TypeArguments object.
       intptr_t type_arguments_instance_field_offset =
           instantiator_class.type_arguments_instance_field_offset();
       ASSERT(type_arguments_instance_field_offset != Class::kNoTypeArguments);
       __ movl(EAX, FieldAddress(EAX, type_arguments_instance_field_offset));
       __ pushl(EAX);
@@ skipping 14 matching lines @@
 // parameterized class.
 // Note that a class without proper type parameters may still be parameterized,
 // e.g. class A extends Array<int>.
 void CodeGenerator::GenerateTypeArguments(ConstructorCallNode* node,
                                           bool requires_type_arguments) {
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   // Instantiate the type arguments if necessary.
   if (node->type_arguments().IsNull() ||
       node->type_arguments().IsInstantiated()) {
-    if (node->constructor().IsFactory() || requires_type_arguments) {
+    if (requires_type_arguments) {
       // A factory requires the type arguments as first parameter.
       __ PushObject(node->type_arguments());
       if (!node->constructor().IsFactory()) {
         // The allocator additionally requires the instantiator type arguments.
         __ pushl(raw_null);  // Null instantiator.
       }
     }
   } else {
     // The type arguments are uninstantiated.
-    ASSERT(node->constructor().IsFactory() || requires_type_arguments);
+    ASSERT(requires_type_arguments);
     GenerateInstantiatorTypeArguments(node->token_index());
     __ popl(EAX);  // Pop instantiator.
     // EAX is the instantiator TypeArguments object (or null).
     // If EAX is null, no need to instantiate the type arguments, use null, and
     // allocate an object of a raw type.
     Label type_arguments_instantiated, type_arguments_uninstantiated;
     __ cmpl(EAX, raw_null);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
 
     // Instantiate non-null type arguments.
@@ skipping 35 matching lines @@
       __ Bind(&type_arguments_instantiated);
       __ pushl(EAX);  // Instantiated type arguments.
       __ pushl(raw_null);  // Null instantiator.
       __ Bind(&type_arguments_pushed);
     }
   }
 }
 
 
 void CodeGenerator::VisitConstructorCallNode(ConstructorCallNode* node) {
-  const Class& cls = Class::ZoneHandle(node->constructor().owner());
-  const bool requires_type_arguments = cls.HasTypeArguments();
-  GenerateTypeArguments(node, requires_type_arguments);
   if (node->constructor().IsFactory()) {
+    const bool requires_type_arguments = true;  // Always first arg to factory.
+    GenerateTypeArguments(node, requires_type_arguments);
     // The top of stack is an instantiated TypeArguments object (or null).
     int num_args = node->arguments()->length() + 1;  // +1 to include type args.
     node->arguments()->Visit(this);
     // Call the factory.
     __ LoadObject(ECX, node->constructor());
     __ LoadObject(EDX, ArgumentsDescriptor(num_args,
                                            node->arguments()->names()));
     GenerateCall(node->token_index(), &StubCode::CallStaticFunctionLabel());
     // Factory constructor returns object in EAX.
     __ addl(ESP, Immediate(num_args * kWordSize));
     if (IsResultNeeded(node)) {
       __ pushl(EAX);
     }
     return;
   }
 
+  const Class& cls = Class::ZoneHandle(node->constructor().owner());
+  const bool requires_type_arguments = cls.HasTypeArguments();
+  GenerateTypeArguments(node, requires_type_arguments);
+
   // If cls is parameterized, the type arguments and the instantiator's
   // type arguments are on the stack.
   const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls));
   const ExternalLabel label(cls.ToCString(), stub.EntryPoint());
   GenerateCall(node->token_index(), &label);
   if (requires_type_arguments) {
     __ popl(ECX);  // Pop type arguments.
     __ popl(ECX);  // Pop instantiator type arguments.
   }
 
@@ skipping 331 matching lines @@
   const Class& cls = Class::Handle(parsed_function_.function().owner());
   const Script& script = Script::Handle(cls.script());
   Parser::ReportMsg(script, token_index, "Error", error_msg, format, args);
   Isolate::Current()->long_jump_base()->Jump(1, error_msg);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32