[VM generic function types] Properly set the scope function after parsing a

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/hash_table.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 1255 matching lines @@
     // We do this after marking this type as finalized in order to allow a
     // typedef function type to refer to itself via its parameter types and
     // result type.
     if (type.IsFunctionType()) {
       const Type& fun_type = Type::Cast(type);
       const Class& scope_class = Class::Handle(zone, fun_type.type_class());
       if (scope_class.IsTypedefClass()) {
         Function& signature =
             Function::Handle(zone, scope_class.signature_function());
         if (!scope_class.is_type_finalized()) {
-          FinalizeSignature(scope_class, signature);
+          FinalizeSignature(scope_class, signature, finalization);
         }
         // If the function type is a generic typedef, instantiate its signature
         // from its type arguments.
         // Example: typedef F<T> = S Function<S>(T x) has uninstantiated
         // signature (T x) => S.
         // The instantiated signature of F(int) becomes (int x) => S.
         // Note that after this step, the signature of the function type is not
         // identical to the canonical signature of the typedef class anymore.
         if (scope_class.IsGeneric() && !signature.HasInstantiatedSignature()) {
           if (FLAG_trace_type_finalization) {
             THR_Print("Instantiating signature '%s' of typedef '%s'\n",
                       String::Handle(zone, signature.Signature()).ToCString(),
                       String::Handle(zone, fun_type.Name()).ToCString());
           }
           const TypeArguments& instantiator_type_arguments =
               TypeArguments::Handle(zone, fun_type.arguments());
           const TypeArguments& function_type_arguments =
               TypeArguments::Handle(zone, signature.type_parameters());
           signature = signature.InstantiateSignatureFrom(
               instantiator_type_arguments, function_type_arguments, Heap::kOld);
           // Note that if instantiator_type_arguments contains type parameters,
           // as in F<K>, the signature is still uninstantiated (the typedef type
           // parameters were substituted in the signature with typedef type
           // arguments). Note also that the function type parameters were not
           // modified.
-          FinalizeSignature(scope_class, signature);  // Canonicalize signature.
+          FinalizeSignature(scope_class, signature, finalization);
         }
         fun_type.set_signature(signature);
       } else {
-        FinalizeSignature(cls, Function::Handle(zone, fun_type.signature()));
+        FinalizeSignature(cls, Function::Handle(zone, fun_type.signature()),
+                          finalization);
       }
     }
 
     if (FLAG_trace_type_finalization) {
       THR_Print("Marking type '%s' as finalized for class '%s'\n",
                 String::Handle(zone, type.Name()).ToCString(),
                 String::Handle(zone, cls.Name()).ToCString());
     }
     // Mark the type as finalized.
     type.SetIsFinalized();
@@ skipping 2493 matching lines @@
   ProgramVisitor::VisitFunctions(&function_visitor);
 
   class ClearCodeClassVisitor : public ClassVisitor {
     void Visit(const Class& cls) { cls.DisableAllocationStub(); }
   };
   ClearCodeClassVisitor class_visitor;
   ProgramVisitor::VisitClasses(&class_visitor);
 }
 
 }  // namespace dart