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

runtime/lib/mirrors.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 "lib/mirrors.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 235 matching lines @@
   args.SetAt(2, String::Handle(cls.Name()));
   args.SetAt(3, Bool::Get(cls.IsGeneric()));
   args.SetAt(4, cls.IsGeneric() ? is_declaration : Bool::False());
   args.SetAt(5, owner_mirror);
   return CreateMirror(Symbols::_LocalTypedefMirror(), args);
 }
 
 
 static RawInstance* CreateFunctionTypeMirror(const AbstractType& type) {
   ASSERT(type.IsFunctionType());
-  const Class& cls = Class::Handle(FunctionType::Cast(type).scope_class());
-  const Function& func = Function::Handle(FunctionType::Cast(type).signature());
+  const Class& cls = Class::Handle(Type::Cast(type).type_class());
+  const Function& func = Function::Handle(Type::Cast(type).signature());
   const Array& args = Array::Handle(Array::New(3));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
   args.SetAt(1, MirrorReference::Handle(MirrorReference::New(func)));
   args.SetAt(2, type);
   return CreateMirror(Symbols::_LocalFunctionTypeMirror(), args);
 }
 
 
 static RawInstance* CreateMethodMirror(const Function& func,
                                        const Instance& owner_mirror,
@@ skipping 268 matching lines @@
     AbstractType& ref_type = AbstractType::Handle(TypeRef::Cast(type).type());
     ASSERT(!ref_type.IsTypeRef());
     ASSERT(ref_type.IsCanonical());
     return CreateTypeMirror(ref_type);
   }
   ASSERT(type.IsFinalized());
   PROPAGATE_IF_MALFORMED(type);
   ASSERT(type.IsCanonical() || type.IsTypeParameter() || type.IsBoundedType());
 
   if (type.IsFunctionType()) {
-    const Class& scope_class =
-        Class::Handle(FunctionType::Cast(type).scope_class());
+    const Class& scope_class = Class::Handle(Type::Cast(type).type_class());
     if (scope_class.IsTypedefClass()) {
       return CreateTypedefMirror(scope_class,
                                  type, Bool::False(), Object::null_instance());
     } else {
       return CreateFunctionTypeMirror(type);
     }
   }
   if (type.HasResolvedTypeClass()) {
     const Class& cls = Class::Handle(type.type_class());
     // Handle void and dynamic types.
@@ skipping 261 matching lines @@
   VerifyMethodKindShifts();
 
   return CreateIsolateMirror();
 }
 
 
 DEFINE_NATIVE_ENTRY(Mirrors_makeLocalClassMirror, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
   PROPAGATE_IF_MALFORMED(type);
   ASSERT(type.IsFinalized());
-  ASSERT(type.IsFunctionType() || type.HasResolvedTypeClass());
+  ASSERT(type.HasResolvedTypeClass());
   const Class& cls = Class::Handle(type.type_class());
   ASSERT(!cls.IsNull());
   if (cls.IsDynamicClass() || cls.IsVoidClass() || cls.IsTypedefClass()) {
     Exceptions::ThrowArgumentError(type);
     UNREACHABLE();
   }
   return CreateClassMirror(cls,
                            AbstractType::Handle(cls.DeclarationType()),
                            Bool::True(),  // is_declaration
                            Object::null_instance());
@@ skipping 438 matching lines @@
   // ObjectMirror.evaluate this will need to be separated.
   ASSERT(result.IsClosure());
   const Function& func = Function::Handle(Closure::Cast(result).function());
   func.set_is_visible(false);
   func.set_is_debuggable(false);
 
   return result.raw();
 }
 
 DEFINE_NATIVE_ENTRY(TypedefMirror_declaration, 1) {
-  GET_NON_NULL_NATIVE_ARGUMENT(FunctionType, type, arguments->NativeArgAt(0));
-  const Class& cls = Class::Handle(type.scope_class());
+  GET_NON_NULL_NATIVE_ARGUMENT(Type, type, arguments->NativeArgAt(0));
+  ASSERT(type.IsFunctionType());
+  const Class& cls = Class::Handle(type.type_class());
   ASSERT(cls.IsTypedefClass());
   return CreateTypedefMirror(cls,
                              AbstractType::Handle(cls.DeclarationType()),
                              Bool::True(),  // is_declaration
                              Object::null_instance());
 }
 
 DEFINE_NATIVE_ENTRY(InstanceMirror_invoke, 5) {
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic
@@ skipping 736 matching lines @@
     // information is not available.
     script.GetTokenLocation(token_pos, &from_line, NULL);
   }
   // We should always have at least the line number.
   ASSERT(from_line != 0);
   return CreateSourceLocation(uri, from_line, from_col);
 }
 
 
 DEFINE_NATIVE_ENTRY(TypedefMirror_referent, 1) {
-  GET_NON_NULL_NATIVE_ARGUMENT(FunctionType, type, arguments->NativeArgAt(0));
-  const Class& cls = Class::Handle(type.scope_class());
+  GET_NON_NULL_NATIVE_ARGUMENT(Type, type, arguments->NativeArgAt(0));
+  ASSERT(type.IsFunctionType());
+  const Class& cls = Class::Handle(type.type_class());
   ASSERT(cls.IsTypedefClass());
   const Function& sig_func = Function::Handle(cls.signature_function());
-  FunctionType& referent_type = FunctionType::Handle(sig_func.SignatureType());
+  Type& referent_type = Type::Handle(sig_func.SignatureType());
   // If the scope class of the function type is not generic, replace it with
   // Closure class (Function::SignatureType() keeps it).
-  ASSERT(cls.raw() == referent_type.scope_class());
+  ASSERT(cls.raw() == referent_type.type_class());
   if (!cls.IsGeneric()) {
-    referent_type = FunctionType::New(
+    referent_type = Type::New(
         Class::Handle(Isolate::Current()->object_store()->closure_class()),
         TypeArguments::Handle(referent_type.arguments()),
-        sig_func,
         referent_type.token_pos());
+    referent_type.set_signature(sig_func);
     referent_type ^= ClassFinalizer::FinalizeType(
         cls, referent_type, ClassFinalizer::kCanonicalize);
   }
   referent_type ^= InstantiateType(referent_type, type);
   return CreateFunctionTypeMirror(referent_type);
 }
 
 
 DEFINE_NATIVE_ENTRY(ParameterMirror_type, 3) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
@@ skipping 16 matching lines @@
 
 DEFINE_NATIVE_ENTRY(TypeMirror_subtypeTest, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, a, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, b, arguments->NativeArgAt(1));
   return Bool::Get(a.IsSubtypeOf(b, NULL, NULL, Heap::kNew)).raw();
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart