Remove recently introduced FunctionType vm class by merging it into class Type.

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/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 1909 matching lines @@
       // In top-level and mixin functions, the source may be in a different
       // script than the script of the current class. However, we never reparse
       // signature functions (except typedef signature functions), therefore
       // we do not need to keep the correct script via a patch class. Use the
       // actual current class as owner of the signature function.
       const Function& signature_function = Function::Handle(Z,
           Function::NewSignatureFunction(current_class(),
                                          TokenPosition::kNoSource));
       signature_function.set_result_type(result_type);
       AddFormalParamsToFunction(&func_params, signature_function);
-      FunctionType& signature_type =
-          FunctionType::ZoneHandle(Z, signature_function.SignatureType());
+      Type& signature_type =
+          Type::ZoneHandle(Z, signature_function.SignatureType());
       if (!is_top_level_) {
         signature_type ^= ClassFinalizer::FinalizeType(
             current_class(), signature_type, ClassFinalizer::kCanonicalize);
         signature_function.SetSignatureType(signature_type);
       }
       ASSERT(is_top_level_ || signature_type.IsFinalized());
       // A signature type itself cannot be malformed or malbounded, only its
       // signature function's result type or parameter types may be.
       ASSERT(!signature_type.IsMalformed());
       ASSERT(!signature_type.IsMalbounded());
@@ skipping 369 matching lines @@
 ClosureNode* Parser::CreateImplicitClosureNode(const Function& func,
                                                TokenPosition token_pos,
                                                AstNode* receiver) {
   Function& implicit_closure_function =
       Function::ZoneHandle(Z, func.ImplicitClosureFunction());
   if (receiver != NULL) {
     // If we create an implicit instance closure from inside a closure of a
     // parameterized class, make sure that the receiver is captured as
     // instantiator.
     if (current_block_->scope->function_level() > 0) {
-      const FunctionType& signature_type = FunctionType::Handle(Z,
+      const Type& signature_type = Type::Handle(Z,
           implicit_closure_function.SignatureType());
       const Class& scope_class = Class::Handle(Z, signature_type.type_class());
       if (scope_class.IsGeneric()) {
         CaptureInstantiator();
       }
     }
   }
   return new ClosureNode(token_pos, implicit_closure_function, receiver, NULL);
 }
 
@@ skipping 4241 matching lines @@
   }
 
   ParamList closure_params;
   AddSyncGenClosureParameters(&closure_params);
 
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, body);
 
     // Finalize function type.
-    FunctionType& signature_type =
-        FunctionType::Handle(Z, body.SignatureType());
+    Type& signature_type = Type::Handle(Z, body.SignatureType());
     signature_type ^= ClassFinalizer::FinalizeType(
         current_class(), signature_type, ClassFinalizer::kCanonicalize);
     body.SetSignatureType(signature_type);
     ASSERT(AbstractType::Handle(Z, body.result_type()).IsResolved());
     ASSERT(body.NumParameters() == closure_params.parameters->length());
   }
 
   OpenFunctionBlock(body);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   async_temp_scope_ = current_block_->scope;
@@ skipping 111 matching lines @@
     is_new_closure = true;
   }
   // Create the parameter list for the async body closure.
   ParamList closure_params;
   AddAsyncClosureParameters(&closure_params);
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, closure);
 
     // Finalize function type.
-    FunctionType& signature_type =
-        FunctionType::Handle(Z, closure.SignatureType());
+    Type& signature_type = Type::Handle(Z, closure.SignatureType());
     signature_type ^= ClassFinalizer::FinalizeType(
         current_class(), signature_type, ClassFinalizer::kCanonicalize);
     closure.SetSignatureType(signature_type);
     ASSERT(AbstractType::Handle(Z, closure.result_type()).IsResolved());
     ASSERT(closure.NumParameters() == closure_params.parameters->length());
   }
   OpenFunctionBlock(closure);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   async_temp_scope_ = current_block_->scope;
   return closure.raw();
@@ skipping 114 matching lines @@
   }
 
   ParamList closure_params;
   AddAsyncGenClosureParameters(&closure_params);
 
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, closure);
 
     // Finalize function type.
-    FunctionType& signature_type =
-        FunctionType::Handle(Z, closure.SignatureType());
+    Type& signature_type = Type::Handle(Z, closure.SignatureType());
     signature_type ^= ClassFinalizer::FinalizeType(
         current_class(), signature_type, ClassFinalizer::kCanonicalize);
     closure.SetSignatureType(signature_type);
     ASSERT(AbstractType::Handle(Z, closure.result_type()).IsResolved());
     ASSERT(closure.NumParameters() == closure_params.parameters->length());
   }
 
   OpenFunctionBlock(closure);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   async_temp_scope_ = current_block_->scope;
@@ skipping 727 matching lines @@
     if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
       library_.AddFunctionMetadata(function, metadata_pos);
     }
   }
 
   // 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;
-  FunctionType& function_type = FunctionType::ZoneHandle(Z);
+  Type& function_type = Type::ZoneHandle(Z);
   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
     // function type to be patched after the actual type is known.
     // We temporarily use the Closure class as scope class.
     const Class& unknown_scope_class = Class::Handle(Z,
         I->object_store()->closure_class());
-    function_type = FunctionType::New(unknown_scope_class,
-                                      TypeArguments::Handle(Z),
-                                      function,
-                                      function_pos);
+    function_type = Type::New(unknown_scope_class,
+                              TypeArguments::Handle(Z),
+                              function_pos);
+    function_type.set_signature(function);
     function_type.SetIsFinalized();  // No finalization needed.
 
     // Add the function variable to the scope before parsing the function in
     // order to allow self reference from inside the function.
     function_variable = new(Z) LocalVariable(function_pos,
                                              *variable_name,
                                              function_type);
     function_variable->set_is_final();
     ASSERT(current_block_ != NULL);
     ASSERT(current_block_->scope != NULL);
     if (!current_block_->scope->AddVariable(function_variable)) {
       LocalVariable* existing_var =
           current_block_->scope->LookupVariable(function_variable->name(),
                                                 true);
       ASSERT(existing_var != NULL);
       // Use before define cases have already been detected and reported above.
       ASSERT(existing_var->owner() == current_block_->scope);
       ReportError(function_pos, "identifier '%s' already defined",
                   function_variable->name().ToCString());
     }
   }
 
   // Parse the local function.
   SequenceNode* statements = Parser::ParseFunc(function, !is_literal);
   INC_STAT(thread(), num_functions_parsed, 1);
 
   // Now that the local function has formal parameters, lookup the signature
-  FunctionType& signature_type =
-      FunctionType::ZoneHandle(Z, function.SignatureType());
+  Type& signature_type = Type::ZoneHandle(Z, function.SignatureType());
   signature_type ^= ClassFinalizer::FinalizeType(
       current_class(), signature_type, ClassFinalizer::kCanonicalize);
   function.SetSignatureType(signature_type);
 
   // Local functions are registered in the enclosing class, but
   // ignored during class finalization. The enclosing class has
   // already been finalized.
   ASSERT(current_class().is_finalized());
   ASSERT(signature_type.IsFinalized());
 
   // Make sure that the instantiator is captured.
   if ((current_block_->scope->function_level() > 0) &&
       Class::Handle(signature_type.type_class()).IsGeneric()) {
     CaptureInstantiator();
   }
 
-  // A signature type itself cannot be malformed or malbounded, only its
+  // A local signature type itself cannot be malformed or malbounded, only its
   // signature function's result type or parameter types may be.
   ASSERT(!signature_type.IsMalformed());
   ASSERT(!signature_type.IsMalbounded());
 
   if (variable_name != NULL) {
     // Patch the function type of the variable now that the signature is known.
-    function_type.set_scope_class(
-        Class::Handle(Z, signature_type.scope_class()));
+    function_type.set_type_class(
+        Class::Handle(Z, signature_type.type_class()));
     function_type.set_arguments(
         TypeArguments::Handle(Z, signature_type.arguments()));
     ASSERT(function_type.signature() == function.raw());
 
     // The function type was initially marked as instantiated, but it may
     // actually be uninstantiated.
     function_type.ResetIsFinalized();
 
     // The function variable type should have been patched above.
     ASSERT((function_variable == NULL) ||
@@ skipping 5499 matching lines @@
   closure = Function::NewClosureFunction(closure_name,
                                          innermost_function(),
                                          token_pos);
   closure.set_is_generated_body(true);
   closure.set_is_debuggable(false);
   closure.set_is_visible(false);
   closure.set_result_type(Object::dynamic_type());
   AddFormalParamsToFunction(&params, closure);
 
   // Finalize function type.
-  FunctionType& signature_type =
-      FunctionType::Handle(Z, closure.SignatureType());
+  Type& signature_type = Type::Handle(Z, closure.SignatureType());
   signature_type ^= ClassFinalizer::FinalizeType(
       current_class(), signature_type, ClassFinalizer::kCanonicalize);
   closure.SetSignatureType(signature_type);
   // Finalization would be premature when top-level parsing.
   ASSERT(!is_top_level_);
   return closure.raw();
 }
 
 
 static String& BuildConstructorName(const String& type_class_name,
@@ skipping 1246 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME