Remove signature classes from the VM.

runtime/vm/class_finalizer.h

 // 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.
 
 #ifndef VM_CLASS_FINALIZER_H_
 #define VM_CLASS_FINALIZER_H_
 
 #include "vm/allocation.h"
 #include "vm/growable_array.h"
 #include "vm/object.h"
@@ skipping 42 matching lines @@
                                     const Script& script,
                                     const Type& type,
                                     const char* format, ...)
        PRINTF_ATTRIBUTE(4, 5);
 
   // Mark the given type as malbounded.
   // If not null, prepend prev_error to the error message built from the format
   // string and its arguments.
   static void FinalizeMalboundedType(const Error& prev_error,
                                      const Script& script,
-                                     const Type& type,
+                                     const AbstractType& type,
                                      const char* format, ...)
        PRINTF_ATTRIBUTE(4, 5);
 
   // Return false if we still have classes pending to be finalized.
   static bool AllClassesFinalized();
 
   // Return whether processing pending classes (ObjectStore::pending_classes_)
   // failed. The function returns true if the processing was successful.
   // If processing fails, an error message is set in the sticky error field
   // in the object store.
   static bool ProcessPendingClasses();
 
   // Finalize the types appearing in the declaration of class 'cls', i.e. its
   // type parameters and their upper bounds, its super type and interfaces.
   // Note that the fields and functions have not been parsed yet (unless cls
   // is an anonymous top level class).
   static void FinalizeTypesInClass(const Class& cls);
 
   // Finalize the class including its fields and functions.
   static void FinalizeClass(const Class& cls);
 
 #if defined(DART_NO_SNAPSHOT)
   // Verify that the classes have been properly prefinalized. This is
   // needed during bootstrapping where the classes have been preloaded.
   static void VerifyBootstrapClasses();
 #endif  // defined(DART_NO_SNAPSHOT).
 
   // Resolve the class of the type, but not the type's type arguments.
-  static void ResolveTypeClass(const Class& cls, const AbstractType& type);
+  // May promote the type from Type to FunctionType.
+  static RawAbstractType* ResolveTypeClass(const Class& cls, const Type& type);
 
   // Resolve the type and target of the redirecting factory.
   static void ResolveRedirectingFactory(const Class& cls,
                                         const Function& factory);
 
   // Apply the mixin type to the mixin application class.
   static void ApplyMixinType(const Class& mixin_app_class,
                              PendingTypes* pending_types = NULL);
 
  private:
   static void AllocateEnumValues(const Class& enum_cls);
   static bool IsSuperCycleFree(const Class& cls);
-  static bool IsTypeCycleFree(const Class& cls,
-                              const AbstractType& type,
-                              GrowableArray<intptr_t>* visited);
-  static bool IsAliasCycleFree(const Class& cls,
-                               GrowableArray<intptr_t>* visited);
+  static bool IsTypedefCycleFree(const Class& cls,
+                                 const AbstractType& type,
+                                 GrowableArray<intptr_t>* visited);
   static bool IsMixinCycleFree(const Class& cls,
                                GrowableArray<intptr_t>* visited);
   static void CheckForLegalConstClass(const Class& cls);
   static RawClass* ResolveClass(const Class& cls,
                                 const UnresolvedClass& unresolved_class);
-  static void ResolveType(const Class& cls, const AbstractType& type);
+  static RawAbstractType* ResolveType(const Class& cls,
+                                      const AbstractType& type);
   static void ResolveRedirectingFactoryTarget(
       const Class& cls,
       const Function& factory,
       const GrowableObjectArray& visited_factories);
   static void CloneMixinAppTypeParameters(const Class& mixin_app_class);
   static void ApplyMixinAppAlias(const Class& mixin_app_class,
                                  const TypeArguments& instantiator);
   static void ApplyMixinMembers(const Class& cls);
   static void CreateForwardingConstructors(
       const Class& mixin_app,
       const Class& mixin_cls,
       const GrowableObjectArray& cloned_funcs);
   static void CollectTypeArguments(const Class& cls,
                                    const Type& type,
                                    const GrowableObjectArray& collected_args);
   static RawType* ResolveMixinAppType(const Class& cls,
                                       const MixinAppType& mixin_app_type);
   static void ResolveSuperTypeAndInterfaces(const Class& cls,
                                             GrowableArray<intptr_t>* visited);
   static void FinalizeTypeParameters(const Class& cls,
                                      PendingTypes* pending_types = NULL);
+  static intptr_t ExpandAndFinalizeTypeArguments(const Class& cls,
+                                                 const AbstractType& type,
+                                                 PendingTypes* pending_types);
   static void FinalizeTypeArguments(const Class& cls,
                                     const TypeArguments& arguments,
                                     intptr_t num_uninitialized_arguments,
                                     Error* bound_error,
                                     PendingTypes* pending_types,
                                     TrailPtr trail);
   static void CheckRecursiveType(const Class& cls,
-                                 const Type& type,
+                                 const AbstractType& type,
                                  PendingTypes* pending_types);
-  static void CheckTypeBounds(const Class& cls, const Type& type);
+  static void CheckTypeBounds(const Class& cls, const AbstractType& type);
   static void CheckTypeArgumentBounds(const Class& cls,
                                       const TypeArguments& arguments,
                                       Error* bound_error);
   static void ResolveUpperBounds(const Class& cls);
   static void FinalizeUpperBounds(const Class& cls);
-  static void ResolveAndFinalizeSignature(const Class& cls,
-                                          const Function& function);
+  static void ResolveSignature(const Class& cls, const Function& function);
+  static void FinalizeSignature(const Class& cls, const Function& function);
   static void ResolveAndFinalizeMemberTypes(const Class& cls);
   static void PrintClassInformation(const Class& cls);
   static void CollectInterfaces(
       const Class& cls, GrowableArray<const Class*>* collected);
 
   static void MarkTypeMalformed(const Error& prev_error,
                                 const Script& script,
                                 const Type& type,
                                 const char* format,
                                 va_list args);
   static void ReportError(const Error& error);
   static void ReportError(const Class& cls,
                           intptr_t token_pos,
                           const char* format, ...) PRINTF_ATTRIBUTE(3, 4);
   static void ReportErrors(const Error& prev_error,
                            const Class& cls,
                            intptr_t token_pos,
                            const char* format, ...) PRINTF_ATTRIBUTE(4, 5);
 
   // Verify implicit offsets recorded in the VM for direct access to fields of
   // Dart instances (e.g: _TypedListView, _ByteDataView).
   static void VerifyImplicitFieldOffsets();
 };
 
 }  // namespace dart
 
 #endif  // VM_CLASS_FINALIZER_H_