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

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 814 matching lines @@
     params->has_field_initializer = true;
   }
 
   if (CurrentToken() == Token::kLPAREN) {
     // This parameter is probably a closure. If we saw the keyword 'var'
     // or 'final', a closure is not legal here and we ignore the
     // opening parens.
     if (!var_seen && !parameter.is_final) {
       // The parsed parameter type is actually the function result type.
       const Type& result_type = Type::Handle(parameter.type->raw());
+
       // Finish parsing the function type parameter.
       ParamList func_params;
       const bool no_explicit_default_values = false;
       ParseFormalParameterList(no_explicit_default_values, &func_params);
-      // Change the name of the parameter type to be the signature of the
-      // function type.
-      const bool is_static =
-          current_function().IsNull() || current_function().is_static();
+
+      // The field 'is_static' has no meaning for signature functions.
       const Function& signature_function = Function::Handle(
           Function::New(*parameter.name,
                         RawFunction::kSignatureFunction,
-                        is_static,
+                        /* is_static = */ false,
                         /* is_const = */ false,
                         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 class named signature and only create a new class if it does
       // not exist yet.
       Class& signature_class = Class::ZoneHandle(LookupClass(signature));
       if (signature_class.IsNull()) {
         signature_class = Class::NewSignatureClass(signature,
                                                    signature_function,
                                                    script_,
                                                    parameter.name_pos);
         // Record the function signature class in the library.
         library_.AddClass(signature_class);
       }
       ASSERT(!Function::Handle(signature_class.signature_function()).IsNull());
       ASSERT(Class::Handle(signature_function.signature_class()).IsNull());
       signature_function.set_signature_class(signature_class);
-      // The type of the parameter is now the signature class.
-      // TODO(regis): What are the type arguments?
-      parameter.type = &Type::ZoneHandle(Type::NewRawType(signature_class));
-      if (!is_top_level_) {
+
+      // The type of the parameter is now the signature type.
+      parameter.type = &Type::ZoneHandle(signature_class.SignatureType());
+      if (!is_top_level_ && !parameter.type->IsFinalized()) {
         const String& errmsg = String::Handle(
             ClassFinalizer::FinalizeTypeWhileParsing(*parameter.type));
         if (!errmsg.IsNull()) {
           ErrorMsg(errmsg.ToCString());
         }
       }
     }
   }
 
   if (CurrentToken() == Token::kASSIGN) {
@@ skipping 1502 matching lines @@
     result_type = ParseType(kDoNotResolve);  // No owner class yet.
   }
 
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("function alias name expected");
   }
   const intptr_t alias_name_pos = token_index_;
   const String* alias_name = CurrentLiteral();
   ConsumeToken();
 
-  // Allocate a class to hold the type parameters and their 'extends'
+  // Allocate an interface to hold the type parameters and their 'extends'
   // constraints. Make it the owner of the function type descriptor.
   const Class& alias_owner = Class::Handle(
       Class::New(String::Handle(String::NewSymbol("")), Script::Handle()));
+  alias_owner.set_is_interface();
   set_current_class(alias_owner);
   ParseTypeParameters(alias_owner);
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("formal parameter list expected");
   }
 
   // At this point, the type parameters have been parsed, so we can resolve the
   // result type.
   if (!result_type.IsNull() && !result_type.IsResolved()) {
     ResolveTypeFromClass(result_type_pos, alias_owner, &result_type);
   }
   ParamList func_params;
   const bool no_explicit_default_values = false;
   ParseFormalParameterList(no_explicit_default_values, &func_params);
-  // TODO(regis): If no type parameters were specified, the function could be
-  // static. Revisit.
+  // 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,
                     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());
@@ skipping 1020 matching lines @@
   // Make sure that the instantiator is captured.
   if (signature_class.IsParameterized() &&
       (current_block_->scope->function_level() > 0)) {
     CaptureReceiver();
   }
 
   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.
-    TypeArguments& signature_type_arguments = TypeArguments::Handle();
-    if (signature_class.IsParameterized()) {
-      const intptr_t num_type_params = signature_class.NumTypeParameters();
-      const Array& type_params = Array::Handle(
-          signature_class.type_parameters());
-      signature_type_arguments = TypeArguments::NewTypeArray(num_type_params);
-      String& type_param_name = String::Handle();
-      Type& type_param = Type::Handle();
-      for (int i = 0; i < num_type_params; i++) {
-        type_param_name ^= type_params.At(i);
-        type_param = Type::NewTypeParameter(i, type_param_name);
-        signature_type_arguments.SetTypeAt(i, type_param);
+    const Type& signature_type = Type::Handle(signature_class.SignatureType());
+    const TypeArguments& signature_type_arguments = TypeArguments::Handle(
+        signature_type.arguments());
+
+    // Since the signature type is cached by the signature class, it may have
+    // been finalized already.
+    if (!signature_type.IsFinalized()) {
+      const String& errmsg = String::Handle(
+          ClassFinalizer::FinalizeTypeWhileParsing(signature_type));
+      if (!errmsg.IsNull()) {
+        ErrorMsg(errmsg.ToCString());
       }
+      // The call to ClassFinalizer::FinalizeTypeWhileParsing 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());
     }
-    const ParameterizedType& actual_function_type = ParameterizedType::Handle(
-        ParameterizedType::New(signature_class, signature_type_arguments));
-    const String& errmsg = String::Handle(
-        ClassFinalizer::FinalizeTypeWhileParsing(actual_function_type));
-    if (!errmsg.IsNull()) {
-      ErrorMsg(errmsg.ToCString());
-    }
-    // The call to ClassFinalizer::FinalizeTypeWhileParsing may have extended
-    // the vector of type arguments.
-    signature_type_arguments = actual_function_type.arguments();
-    ASSERT(signature_type_arguments.IsNull() ||
-           (signature_type_arguments.Length() ==
-            signature_class.NumTypeArguments()));
-    // The signature_class should not have changed.
-    ASSERT(actual_function_type.type_class() == signature_class.raw());
 
     // Now patch the function type of the variable.
     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()));
   }
 
@@ skipping 3555 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart