Add missing type finalization for function literals not assigned to a function

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 4226 matching lines @@
   if (function.IsNull() || (function.token_pos() != function_pos) ||
       (function.parent_function() != innermost_function().raw())) {
     is_new_closure = true;
     function = Function::NewClosureFunction(*function_name,
                                             innermost_function(),
                                             function_pos);
     function.set_result_type(result_type);
     current_class().AddClosureFunction(function);
   }
 
-  // The function type does not need to be determined at compile time, unless
-  // the closure is assigned to a function variable and type checks are enabled.
-  // At run time, the function type is derived from the signature class of the
-  // closure function and from the type arguments of the instantiator.
+  // The function type needs to be finalized at compile time, since the closure
+  // may be type checked at run time when assigned to a function variable,
+  // passed as a function argument, or returned as a function result.
 
   LocalVariable* function_variable = NULL;
   Type& function_type = Type::ZoneHandle();
   if (variable_name != NULL) {
     // Since the function type depends on the signature of the closure function,
     // it cannot be determined before the formal parameter list of the closure
     // function is parsed. Therefore, we set the function type to a new
     // parameterized type to be patched after the actual type is known.
     // We temporarily use the class of the Function interface.
     const Class& unknown_signature_class = Class::Handle(
@@ skipping 48 matching lines @@
   // 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();
   }
 
+  // Since the signature type is cached by the signature class, it may have
+  // been finalized already.
+  Type& signature_type = Type::Handle(signature_class.SignatureType());
+  const AbstractTypeArguments& signature_type_arguments =
+      AbstractTypeArguments::Handle(signature_type.arguments());
+
+  if (!signature_type.IsFinalized()) {
+    signature_type ^= ClassFinalizer::FinalizeType(
+        signature_class, signature_type, ClassFinalizer::kCanonicalize);
+    // The call to ClassFinalizer::FinalizeType may have
+    // extended the vector of type arguments.
+    ASSERT(signature_type_arguments.IsNull() ||
+           (signature_type_arguments.Length() ==
+            signature_class.NumTypeArguments()));
+    // The signature_class should not have changed.
+    ASSERT(signature_type.type_class() == signature_class.raw());
+  }
+
   if (variable_name != NULL) {
-    // Patch the function type now that the signature is known.
-    // We need to create a new type for proper finalization, since the existing
-    // type is already marked as finalized.
-    Type& signature_type = Type::Handle(signature_class.SignatureType());
-    const AbstractTypeArguments& signature_type_arguments =
-        AbstractTypeArguments::Handle(signature_type.arguments());
-
-    // Since the signature type is cached by the signature class, it may have
-    // been finalized already.
-    if (!signature_type.IsFinalized()) {
-      signature_type ^= ClassFinalizer::FinalizeType(
-          signature_class, signature_type, ClassFinalizer::kCanonicalize);
-      // The call to ClassFinalizer::FinalizeType may have
-      // extended the vector of type arguments.
-      ASSERT(signature_type_arguments.IsNull() ||
-             (signature_type_arguments.Length() ==
-              signature_class.NumTypeArguments()));
-      // The signature_class should not have changed.
-      ASSERT(signature_type.type_class() == signature_class.raw());
-    }
-
-    // Now patch the function type of the variable.
+    // Patch the function type of the variable now that the signature is known.
     function_type.set_type_class(signature_class);
     function_type.set_arguments(signature_type_arguments);
 
     // The function variable type should have been patched above.
     ASSERT((function_variable == NULL) ||
            (function_variable->type().raw() == function_type.raw()));
   }
 
   // The code generator does not compile the closure function when visiting
   // a ClosureNode. The generated code allocates a new Closure object containing
@@ skipping 4307 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart