Set type argument vector at compile time in type of closure parameters; this

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 420 matching lines @@
 void ClassFinalizer::FinalizeType(const Type& type) {
   ASSERT(type.IsResolved());
   if (type.IsFinalized()) {
     return;
   }
 
   // At this point, we can only have a parameterized_type.
   ParameterizedType& parameterized_type = ParameterizedType::Handle();
   parameterized_type ^= type.raw();
 
-  if (parameterized_type.is_being_finalized()) {
+  if (parameterized_type.IsBeingFinalized()) {
     ReportError("type '%s' illegally refers to itself\n",
                 String::Handle(parameterized_type.Name()).ToCString());
   }
 
   // Mark type as being finalized in order to detect illegal self reference.
   parameterized_type.set_is_being_finalized();
 
   // Finalize the current type arguments of the type, which are still the
   // parsed type arguments.
   TypeArguments& arguments =
@@ skipping 81 matching lines @@
 // are canonicalized and finalized upon creation, since all the types they
 // reference are already resolved.
 void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
                                                  const Function& function) {
   // Resolve result type.
   Type& type = Type::Handle(function.result_type());
   type = ResolveType(cls, type);
   function.set_result_type(type);
   FinalizeType(type);
   // Resolve formal parameter types.
-  intptr_t num_parameters = function.NumberOfParameters();
-  for (intptr_t p = 0; p < num_parameters; p++) {
-    type = function.ParameterTypeAt(p);
+  const intptr_t num_parameters = function.NumberOfParameters();
+  for (intptr_t i = 0; i < num_parameters; i++) {
+    type = function.ParameterTypeAt(i);
     type = ResolveType(cls, type);
-    function.SetParameterTypeAt(p, type);
+    function.SetParameterTypeAt(i, type);
     FinalizeType(type);
   }
 }
 
 
 static bool FuncNameExistsInSuper(const Class& cls,
                                   const String& name) {
   Class& super_class = Class::Handle();
   Function& function = Function::Handle();
   super_class = cls.SuperClass();
@@ skipping 77 matching lines @@
     }
     if (function.kind() == RawFunction::kSetterFunction) {
       name = String::New("set:");
       name = String::SubString(func_name, name.Length());
       if (FuncNameExistsInSuper(cls, name)) {
         ReportError("'%s' overrides a function in the super class.\n",
                     func_name.ToCString());
       }
     }
   }
-  // Resolve type of signature function.
+  // Resolve the signature type if this class is a signature class.
   if (cls.IsSignatureClass()) {
-    ResolveAndFinalizeSignature(cls,
-                                Function::Handle(cls.signature_function()));
+    const Type& signature_type = Type::Handle(cls.SignatureType());
+    FinalizeType(signature_type);
   }
 }
 
 
 void ClassFinalizer::FinalizeClass(const Class& cls) {
   if (cls.is_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("Finalize %s\n", cls.ToCString());
@@ skipping 317 matching lines @@
   ASSERT(msg_buffer != NULL);
   va_list args;
   va_start(args, format);
   OS::VSNPrint(msg_buffer, kBufferLength, format, args);
   va_end(args);
   isolate->long_jump_base()->Jump(1, msg_buffer);
   UNREACHABLE();
 }
 
 }  // namespace dart