Remove signature classes from the VM.

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 422 matching lines @@
   Type& target_type = Type::Handle(target.RedirectionType());
   Function& target_target = Function::Handle(target.RedirectionTarget());
   if (target_target.IsNull()) {
     ASSERT(target_type.IsMalformed());
   } else {
     // If the target type refers to type parameters, substitute them with the
     // type arguments of the redirection type.
     if (!target_type.IsInstantiated()) {
       const TypeArguments& type_args = TypeArguments::Handle(type.arguments());
       Error& bound_error = Error::Handle();
-      target_type ^= target_type.InstantiateFrom(type_args, &bound_error);
+      target_type ^= target_type.InstantiateFrom(
+          type_args, &bound_error, NULL, Heap::kOld);
       if (bound_error.IsNull()) {
         target_type ^= FinalizeType(cls, target_type, kCanonicalize);
       } else {
         ASSERT(target_type.IsInstantiated() && type_args.IsInstantiated());
         const Script& script = Script::Handle(target_class.script());
         FinalizeMalformedType(bound_error, script, target_type,
                               "cannot resolve redirecting factory");
         target_target = Function::null();
       }
     }
   }
   factory.SetRedirectionType(target_type);
   factory.SetRedirectionTarget(target_target);
 }
 
 
-void ClassFinalizer::ResolveTypeClass(const Class& cls,
-                                      const AbstractType& type) {
-  if (type.IsFinalized() || type.HasResolvedTypeClass()) {
-    return;
+RawAbstractType* ClassFinalizer::ResolveTypeClass(const Class& cls,
+                                                  const Type& type) {
+  if (type.IsFinalized()) {
+    return type.raw();
   }
   if (FLAG_trace_type_finalization) {
     THR_Print("Resolve type class of '%s'\n",
               String::Handle(type.Name()).ToCString());
   }
 
   // Type parameters are always resolved in the parser in the correct
   // non-static scope or factory scope. That resolution scope is unknown here.
   // Being able to resolve a type parameter from class cls here would indicate
   // that the type parameter appeared in a static scope. Leaving the type as
   // unresolved is the correct thing to do.
 
-  // Lookup the type class.
-  const UnresolvedClass& unresolved_class =
-      UnresolvedClass::Handle(type.unresolved_class());
-  const Class& type_class =
-      Class::Handle(ResolveClass(cls, unresolved_class));
-
+  // Lookup the type class if necessary.
+  Class& type_class = Class::Handle();
+  if (type.HasResolvedTypeClass()) {
+    type_class = type.type_class();
+  } else {
+    const UnresolvedClass& unresolved_class =
+        UnresolvedClass::Handle(type.unresolved_class());
+    type_class = ResolveClass(cls, unresolved_class);
+    if (type_class.IsNull()) {
+      // The type class could not be resolved. The type is malformed.
+      FinalizeMalformedType(
+          Error::Handle(),  // No previous error.
+          Script::Handle(cls.script()),
+          type,
+          "cannot resolve class '%s' from '%s'",
+          String::Handle(unresolved_class.Name()).ToCString(),
+          String::Handle(cls.Name()).ToCString());
+      return type.raw();
+    }
+  }
+  // Promote the Type to a FunctionType in case its type class is a typedef.
+  if (type_class.IsTypedefClass()) {
+    return FunctionType::New(type_class,
+                             TypeArguments::Handle(type.arguments()),
+                             Function::Handle(type_class.signature_function()),
+                             type.token_pos());
+  }
   // Replace unresolved class with resolved type class.
-  const Type& parameterized_type = Type::Cast(type);
-  if (type_class.IsNull()) {
-    // The type class could not be resolved. The type is malformed.
-    FinalizeMalformedType(
-        Error::Handle(),  // No previous error.
-        Script::Handle(cls.script()),
-        parameterized_type,
-        "cannot resolve class '%s' from '%s'",
-        String::Handle(unresolved_class.Name()).ToCString(),
-        String::Handle(cls.Name()).ToCString());
-    return;
-  }
-  parameterized_type.set_type_class(type_class);
+  type.set_type_class(type_class);
+  return type.raw();
 }
 
 
-void ClassFinalizer::ResolveType(const Class& cls, const AbstractType& type) {
+RawAbstractType* ClassFinalizer::ResolveType(const Class& cls,
+                                             const AbstractType& type) {
   if (type.IsResolved()) {
-    return;
+    return type.raw();
   }
-  ASSERT(type.IsType());
   if (FLAG_trace_type_finalization) {
     THR_Print("Resolve type '%s'\n", String::Handle(type.Name()).ToCString());
   }
-  ResolveTypeClass(cls, type);
-  if (type.IsMalformed()) {
-    ASSERT(type.IsResolved());
-    return;
+  AbstractType& resolved_type = AbstractType::Handle();
+  if (type.IsType()) {
+    resolved_type = ResolveTypeClass(cls, Type::Cast(type));
+    if (resolved_type.IsMalformed()) {
+      ASSERT(resolved_type.IsResolved());
+      return resolved_type.raw();
+    }
+  } else {
+    ASSERT(type.IsFunctionType());
+    const Function& signature =
+        Function::Handle(FunctionType::Cast(type).signature());
+    ResolveSignature(cls, signature);
+    resolved_type = type.raw();
   }
   // Mark type as resolved before resolving its type arguments in order to avoid
   // repeating resolution of recursive types.
-  Type::Cast(type).set_is_resolved();
+  resolved_type.SetIsResolved();
   // Resolve type arguments, if any.
-  const TypeArguments& arguments = TypeArguments::Handle(type.arguments());
+  const TypeArguments& arguments =
+      TypeArguments::Handle(resolved_type.arguments());
   if (!arguments.IsNull()) {
     const intptr_t num_arguments = arguments.Length();
     AbstractType& type_argument = AbstractType::Handle();
     for (intptr_t i = 0; i < num_arguments; i++) {
       type_argument = arguments.TypeAt(i);
-      ResolveType(cls, type_argument);
+      type_argument = ResolveType(cls, type_argument);
+      arguments.SetTypeAt(i, type_argument);
     }
   }
+  return resolved_type.raw();
 }
 
 
 void ClassFinalizer::FinalizeTypeParameters(
     const Class& cls,
     PendingTypes* pending_types) {
   if (FLAG_trace_type_finalization) {
     THR_Print("Finalizing type parameters of '%s'\n",
               String::Handle(cls.Name()).ToCString());
   }
@@ skipping 22 matching lines @@
 // finalized is a non-contractive type, i.e. if the induced type set S of P is
 // not finite, where P is the instantiation of T with its own type parameters.
 // The induced type set S consists of the super types of any type in S as well
 // as the type arguments of any parameterized type in S.
 // The Dart Language Specification does not disallow the declaration and use of
 // non-contractive types (this may change). They are nevertheless disallowed
 // as an implementation restriction in the VM since they cause divergence.
 // A non-contractive type can be detected by looking at the queue of types
 // pending finalization that are mutually recursive with the checked type.
 void ClassFinalizer::CheckRecursiveType(const Class& cls,
-                                        const Type& type,
+                                        const AbstractType& type,
                                         PendingTypes* pending_types) {
   Zone* zone = Thread::Current()->zone();
   if (FLAG_trace_type_finalization) {
     THR_Print("Checking recursive type '%s': %s\n",
               String::Handle(type.Name()).ToCString(),
               type.ToCString());
   }
   const Class& type_cls = Class::Handle(zone, type.type_class());
   const TypeArguments& arguments =
       TypeArguments::Handle(zone, type.arguments());
@@ skipping 35 matching lines @@
         // Reject the non-contractive recursive type.
         const String& type_name = String::Handle(zone, type.Name());
         ReportError(cls, type.token_pos(),
                     "illegal recursive type '%s'", type_name.ToCString());
       }
     }
   }
 }
 
 
+// Expand the type arguments of the given type and finalize its full type
+// argument vector. Return the number of type arguments (0 for a raw type).
+intptr_t ClassFinalizer::ExpandAndFinalizeTypeArguments(
+    const Class& cls,
+    const AbstractType& type,
+    PendingTypes* pending_types) {
+  Zone* Z = Thread::Current()->zone();
+  // The type class does not need to be finalized in order to finalize the type,
+  // however, it must at least be resolved (this was done as part of resolving
+  // the type itself, a precondition to calling FinalizeType).
+  // Also, the interfaces of the type class must be resolved and the type
+  // parameters of the type class must be finalized.
+  Class& type_class = Class::Handle(Z, type.type_class());
+  if (!type_class.is_type_finalized()) {
+    FinalizeTypeParameters(type_class, pending_types);
+    ResolveUpperBounds(type_class);
+  }
+
+  // The finalized type argument vector needs num_type_arguments types.
+  const intptr_t num_type_arguments = type_class.NumTypeArguments();
+  // The class has num_type_parameters type parameters.
+  const intptr_t num_type_parameters = type_class.NumTypeParameters();
+
+  // Initialize the type argument vector.
+  // Check the number of parsed type arguments, if any.
+  // Specifying no type arguments indicates a raw type, which is not an error.
+  // However, type parameter bounds are checked below, even for a raw type.
+  TypeArguments& arguments = TypeArguments::Handle(Z, type.arguments());
+  if (!arguments.IsNull() && (arguments.Length() != num_type_parameters)) {
+    // Wrong number of type arguments. The type is mapped to the raw type.
+    if (Isolate::Current()->flags().error_on_bad_type()) {
+      const String& type_class_name = String::Handle(Z, type_class.Name());
+      ReportError(cls, type.token_pos(),
+                  "wrong number of type arguments for class '%s'",
+                  type_class_name.ToCString());
+    }
+    // Make the type raw and continue without reporting any error.
+    // A static warning should have been reported.
+    arguments = TypeArguments::null();
+    type.set_arguments(arguments);
+  }
+
+  // Mark the type as being finalized in order to detect self reference and
+  // postpone bound checking until after all types in the graph of
+  // mutually recursive types are finalized.
+  type.SetIsBeingFinalized();
+  pending_types->Add(type);
+
+  // The full type argument vector consists of the type arguments of the
+  // super types of type_class, which are initialized from the parsed
+  // type arguments, followed by the parsed type arguments.
+  TypeArguments& full_arguments = TypeArguments::Handle(Z);
+  if (num_type_arguments > 0) {
+    // If no type arguments were parsed and if the super types do not prepend
+    // type arguments to the vector, we can leave the vector as null.
+    if (!arguments.IsNull() || (num_type_arguments > num_type_parameters)) {
+      full_arguments = TypeArguments::New(num_type_arguments);
+      // Copy the parsed type arguments at the correct offset in the full type
+      // argument vector.
+      const intptr_t offset = num_type_arguments - num_type_parameters;
+      AbstractType& type_arg =
+          AbstractType::Handle(Z, Type::DynamicType());
+      // Leave the temporary type arguments at indices [0..offset[ as null.
+      for (intptr_t i = 0; i < num_type_parameters; i++) {
+        // If no type parameters were provided, a raw type is desired, so we
+        // create a vector of dynamic.
+        if (!arguments.IsNull()) {
+          type_arg = arguments.TypeAt(i);
+          // The parsed type_arg may or may not be finalized.
+        }
+        full_arguments.SetTypeAt(offset + i, type_arg);
+      }
+      // Replace the compile-time argument vector (of length zero or
+      // num_type_parameters) of this type being finalized with the still
+      // unfinalized run-time argument vector (of length num_type_arguments).
+      // This type being finalized may be recursively reached via bounds
+      // checking or type arguments of its super type.
+      type.set_arguments(full_arguments);
+      // Finalize the current type arguments of the type, which are still the
+      // parsed type arguments.
+      if (!arguments.IsNull()) {
+        for (intptr_t i = 0; i < num_type_parameters; i++) {
+          type_arg = full_arguments.TypeAt(offset + i);
+          ASSERT(!type_arg.IsBeingFinalized());
+          type_arg = FinalizeType(cls, type_arg, kFinalize, pending_types);
+          if (type_arg.IsMalformed()) {
+            // Malformed type arguments are mapped to dynamic.
+            type_arg = Type::DynamicType();
+          }
+          full_arguments.SetTypeAt(offset + i, type_arg);
+        }
+      }
+      if (offset > 0) {
+        TrailPtr trail = new Trail(Z, 4);
+        Error& bound_error = Error::Handle();
+        FinalizeTypeArguments(type_class, full_arguments, offset,
+                              &bound_error, pending_types, trail);
+      }
+      if (full_arguments.IsRaw(0, num_type_arguments)) {
+        // The parameterized_type is raw. Set its argument vector to null, which
+        // is more efficient in type tests.
+        full_arguments = TypeArguments::null();
+      }
+      type.set_arguments(full_arguments);
+    } else {
+      ASSERT(full_arguments.IsNull());  // Use null vector for raw type.
+    }
+  }
+
+  // Self referencing types may get finalized indirectly.
+  if (!type.IsFinalized()) {
+    ASSERT(full_arguments.IsNull() ||
+           !full_arguments.IsRaw(0, num_type_arguments));
+    // Mark the type as finalized.
+    type.SetIsFinalized();
+    // Do not yet remove the type from the pending_types array.
+  }
+  return full_arguments.IsNull() ? 0 : full_arguments.Length();
+}
+
+
 // Finalize the type argument vector 'arguments' of the type defined by the
 // class 'cls' parameterized with the type arguments 'cls_args'.
 // The vector 'cls_args' is already initialized as a subvector at the correct
 // position in the passed in 'arguments' vector.
 // The subvector 'cls_args' has length cls.NumTypeParameters() and starts at
 // offset cls.NumTypeArguments() - cls.NumTypeParameters() of the 'arguments'
 // vector.
 // The type argument vector of cls may overlap the type argument vector of its
 // super class. In case of an overlap, the overlapped type arguments of the
 // super class are already initialized. The still uninitialized ones have an
@@ skipping 47 matching lines @@
     TypeArguments& super_type_args = TypeArguments::Handle(
         super_type.arguments());
     // Offset of super type's type parameters in cls' type argument vector.
     const intptr_t super_offset = num_super_type_args - num_super_type_params;
     AbstractType& super_type_arg = AbstractType::Handle(Type::DynamicType());
     for (intptr_t i = super_offset; i < num_uninitialized_arguments; i++) {
       if (!super_type_args.IsNull()) {
         super_type_arg = super_type_args.TypeAt(i);
         if (!super_type_arg.IsTypeRef()) {
           if (super_type_arg.IsBeingFinalized()) {
-            ASSERT(super_type_arg.IsType());
-            CheckRecursiveType(cls, Type::Cast(super_type_arg), pending_types);
+            ASSERT(super_type_arg.IsType() || super_type_arg.IsFunctionType());
+            CheckRecursiveType(cls, super_type_arg, pending_types);
             if (FLAG_trace_type_finalization) {
               THR_Print("Creating TypeRef '%s': '%s'\n",
                         String::Handle(super_type_arg.Name()).ToCString(),
                         super_type_arg.ToCString());
             }
             super_type_arg = TypeRef::New(super_type_arg);
             super_type_args.SetTypeAt(i, super_type_arg);
           } else {
             if (!super_type_arg.IsFinalized()) {
               super_type_arg ^= FinalizeType(
@@ skipping 28 matching lines @@
               *bound_error = error.raw();
             }
           }
           if (!super_type_arg.IsFinalized() &&
               !super_type_arg.IsBeingFinalized()) {
             // The super_type_arg was instantiated from a type being finalized.
             // We need to finish finalizing its type arguments.
             if (super_type_arg.IsTypeRef()) {
               super_type_arg = TypeRef::Cast(super_type_arg).type();
             }
-            Type::Cast(super_type_arg).set_is_being_finalized();
+            Type::Cast(super_type_arg).SetIsBeingFinalized();
             pending_types->Add(super_type_arg);
             const Class& cls = Class::Handle(super_type_arg.type_class());
             FinalizeTypeArguments(
                 cls,
                 TypeArguments::Handle(super_type_arg.arguments()),
                 cls.NumTypeArguments() - cls.NumTypeParameters(),
                 bound_error,
                 pending_types,
                 trail);
             Type::Cast(super_type_arg).SetIsFinalized();
@@ skipping 86 matching lines @@
       // Shortcut the special case where we check a type parameter against its
       // declared upper bound.
       if (error.IsNull() &&
           !(type_arg.Equals(type_param) &&
             instantiated_bound.Equals(declared_bound))) {
         // If type_arg is a type parameter, its declared bound may not be
         // resolved yet.
         if (type_arg.IsTypeParameter()) {
           const Class& type_arg_cls = Class::Handle(
               TypeParameter::Cast(type_arg).parameterized_class());
-          const AbstractType& bound = AbstractType::Handle(
+          AbstractType& bound = AbstractType::Handle(
               TypeParameter::Cast(type_arg).bound());
-          ResolveType(type_arg_cls, bound);
+          bound = ResolveType(type_arg_cls, bound);
+          TypeParameter::Cast(type_arg).set_bound(bound);
         }
         // This may be called only if type needs to be finalized, therefore
         // seems OK to allocate finalized types in old space.
         if (!type_param.CheckBound(type_arg, instantiated_bound,
                 &error, Heap::kOld) && error.IsNull()) {
           // The bound cannot be checked at compile time; postpone to run time.
           type_arg = BoundedType::New(type_arg, instantiated_bound, type_param);
           arguments.SetTypeAt(offset + i, type_arg);
         }
       }
       if (!error.IsNull() && bound_error->IsNull()) {
         *bound_error = error.raw();
       }
     }
   }
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     CheckTypeArgumentBounds(super_class, arguments, bound_error);
   }
 }
 
 
-void ClassFinalizer::CheckTypeBounds(const Class& cls, const Type& type) {
+void ClassFinalizer::CheckTypeBounds(const Class& cls,
+                                     const AbstractType& type) {
+  ASSERT(type.IsType() || type.IsFunctionType());
   ASSERT(type.IsFinalized());
   TypeArguments& arguments = TypeArguments::Handle(type.arguments());
   if (arguments.IsNull()) {
     return;
   }
-  Class& owner_class = Class::Handle();
-  Class& type_class = Class::Handle(type.type_class());
-  if (type_class.IsSignatureClass()) {
-    const Function& signature_fun =
-        Function::Handle(type_class.signature_function());
-    ASSERT(!signature_fun.is_static());
-    owner_class = signature_fun.Owner();
-  } else {
-    owner_class = type_class.raw();
-  }
+  const Class& type_class = Class::Handle(type.type_class());
   Error& bound_error = Error::Handle();
-  CheckTypeArgumentBounds(owner_class, arguments, &bound_error);
+  CheckTypeArgumentBounds(type_class, arguments, &bound_error);
   type.set_arguments(arguments);
   // If a bound error occurred, mark the type as malbounded.
   // The bound error will be ignored in production mode.
   if (!bound_error.IsNull()) {
     // No compile-time error during finalization.
     const String& type_name = String::Handle(type.UserVisibleName());
     FinalizeMalboundedType(bound_error,
                            Script::Handle(cls.script()),
                            type,
                            "type '%s' has an out of bound type argument",
@@ skipping 28 matching lines @@
   if (type.IsTypeRef()) {
     // The referenced type will be finalized later by the code that set the
     // is_being_finalized mark bit.
     return type.raw();
   }
 
   // Recursive types must be processed in FinalizeTypeArguments() and cannot be
   // encountered here.
   ASSERT(!type.IsBeingFinalized());
 
+  Zone* Z = Thread::Current()->zone();
+  const AbstractType& resolved_type =
+      AbstractType::Handle(Z, ResolveType(cls, type));
   // A malformed type gets mapped to a finalized type.
-  ResolveType(cls, type);
-  if (type.IsMalformed()) {
-    ASSERT(type.IsFinalized());
-    return type.raw();
+  if (resolved_type.IsMalformed()) {
+    ASSERT(resolved_type.IsFinalized());
+    return resolved_type.raw();
   }
 
-  Zone* Z = Thread::Current()->zone();
   if (FLAG_trace_type_finalization) {
     THR_Print("Finalizing type '%s' for class '%s'\n",
-              String::Handle(Z, type.Name()).ToCString(),
+              String::Handle(Z, resolved_type.Name()).ToCString(),
               cls.ToCString());
   }
 
-  if (type.IsTypeParameter()) {
-    const TypeParameter& type_parameter = TypeParameter::Cast(type);
+  if (resolved_type.IsTypeParameter()) {
+    const TypeParameter& type_parameter = TypeParameter::Cast(resolved_type);
     const Class& parameterized_class =
         Class::Handle(Z, type_parameter.parameterized_class());
     ASSERT(!parameterized_class.IsNull());
     // The index must reflect the position of this type parameter in the type
     // arguments vector of its parameterized class. The offset to add is the
     // number of type arguments in the super type, which is equal to the
     // difference in number of type arguments and type parameters of the
     // parameterized class.
     const intptr_t offset = parameterized_class.NumTypeArguments() -
                             parameterized_class.NumTypeParameters();
     // Calling NumTypeParameters() may finalize this type parameter if it
     // belongs to a mixin application class.
     if (!type_parameter.IsFinalized()) {
       type_parameter.set_index(type_parameter.index() + offset);
-      type_parameter.set_is_finalized();
+      type_parameter.SetIsFinalized();
     } else {
       ASSERT(cls.IsMixinApplication());
     }
 
     if (FLAG_trace_type_finalization) {
       THR_Print("Done finalizing type parameter '%s' with index %" Pd "\n",
                 String::Handle(Z, type_parameter.name()).ToCString(),
                 type_parameter.index());
     }
 
     // We do not canonicalize type parameters.
     return type_parameter.raw();
   }
 
-  // At this point, we can only have a parameterized_type.
-  const Type& parameterized_type = Type::Cast(type);
+  // At this point, we can only have a Type or a FunctionType.
+  ASSERT(resolved_type.IsType() || resolved_type.IsFunctionType());
 
   // This type is the root type of the type graph if no pending types queue is
   // allocated yet.
   const bool is_root_type = (pending_types == NULL);
   if (is_root_type) {
     pending_types = new PendingTypes(Z, 4);
   }
 
-  // The type class does not need to be finalized in order to finalize the type,
-  // however, it must at least be resolved (this was done as part of resolving
-  // the type itself, a precondition to calling FinalizeType).
-  // Also, the interfaces of the type class must be resolved and the type
-  // parameters of the type class must be finalized.
-  Class& type_class = Class::Handle(Z, parameterized_type.type_class());
-  if (!type_class.is_type_finalized()) {
-    FinalizeTypeParameters(type_class, pending_types);
-    ResolveUpperBounds(type_class);
-  }
-
-  // The finalized type argument vector needs num_type_arguments types.
-  const intptr_t num_type_arguments = type_class.NumTypeArguments();
-  // The type class has num_type_parameters type parameters.
-  const intptr_t num_type_parameters = type_class.NumTypeParameters();
-
-  // Initialize the type argument vector.
-  // Check the number of parsed type arguments, if any.
-  // Specifying no type arguments indicates a raw type, which is not an error.
-  // However, type parameter bounds are checked below, even for a raw type.
-  TypeArguments& arguments =
-      TypeArguments::Handle(Z, parameterized_type.arguments());
-  if (!arguments.IsNull() && (arguments.Length() != num_type_parameters)) {
-    // Wrong number of type arguments. The type is mapped to the raw type.
-    if (Isolate::Current()->flags().error_on_bad_type()) {
-      const String& type_class_name =
-          String::Handle(Z, type_class.Name());
-      ReportError(cls, parameterized_type.token_pos(),
-                  "wrong number of type arguments for class '%s'",
-                  type_class_name.ToCString());
-    }
-    // Make the type raw and continue without reporting any error.
-    // A static warning should have been reported.
-    arguments = TypeArguments::null();
-    parameterized_type.set_arguments(arguments);
-  }
-
-  // Mark the type as being finalized in order to detect self reference and
-  // postpone bound checking until after all types in the graph of
-  // mutually recursive types are finalized.
-  parameterized_type.set_is_being_finalized();
-  pending_types->Add(parameterized_type);
-
-  // The full type argument vector consists of the type arguments of the
-  // super types of type_class, which are initialized from the parsed
-  // type arguments, followed by the parsed type arguments.
-  TypeArguments& full_arguments = TypeArguments::Handle(Z);
-  Error& bound_error = Error::Handle(Z);
-  if (num_type_arguments > 0) {
-    // If no type arguments were parsed and if the super types do not prepend
-    // type arguments to the vector, we can leave the vector as null.
-    if (!arguments.IsNull() || (num_type_arguments > num_type_parameters)) {
-      full_arguments = TypeArguments::New(num_type_arguments);
-      // Copy the parsed type arguments at the correct offset in the full type
-      // argument vector.
-      const intptr_t offset = num_type_arguments - num_type_parameters;
-      AbstractType& type_arg =
-          AbstractType::Handle(Z, Type::DynamicType());
-      // Leave the temporary type arguments at indices [0..offset[ as null.
-      for (intptr_t i = 0; i < num_type_parameters; i++) {
-        // If no type parameters were provided, a raw type is desired, so we
-        // create a vector of dynamic.
-        if (!arguments.IsNull()) {
-          type_arg = arguments.TypeAt(i);
-          // The parsed type_arg may or may not be finalized.
-        }
-        full_arguments.SetTypeAt(offset + i, type_arg);
-      }
-      // Replace the compile-time argument vector (of length zero or
-      // num_type_parameters) of this type being finalized with the still
-      // unfinalized run-time argument vector (of length num_type_arguments).
-      // This type being finalized may be recursively reached via bounds
-      // checking or type arguments of its super type.
-      parameterized_type.set_arguments(full_arguments);
-      // Finalize the current type arguments of the type, which are still the
-      // parsed type arguments.
-      if (!arguments.IsNull()) {
-        for (intptr_t i = 0; i < num_type_parameters; i++) {
-          type_arg = full_arguments.TypeAt(offset + i);
-          ASSERT(!type_arg.IsBeingFinalized());
-          type_arg = FinalizeType(cls, type_arg, kFinalize, pending_types);
-          if (type_arg.IsMalformed()) {
-            // Malformed type arguments are mapped to dynamic.
-            type_arg = Type::DynamicType();
-          }
-          full_arguments.SetTypeAt(offset + i, type_arg);
-        }
-      }
-      // If the type class is a signature class, the full argument vector
-      // must include the argument vector of the super type.
-      // If the signature class is a function type alias, it is also the owner
-      // of its signature function and no super type is involved.
-      // If the signature class is canonical (not an alias), the owner of its
-      // signature function may either be an alias or the enclosing class of a
-      // local function, in which case the super type of the enclosing class is
-      // also considered when filling up the argument vector.
-      Class& owner_class = Class::Handle(Z);
-      if (type_class.IsSignatureClass()) {
-        const Function& signature_fun =
-            Function::Handle(Z, type_class.signature_function());
-        ASSERT(!signature_fun.is_static());
-        owner_class = signature_fun.Owner();
-      } else {
-        owner_class = type_class.raw();
-      }
-      if (offset > 0) {
-        TrailPtr trail = new Trail(Z, 4);
-        FinalizeTypeArguments(owner_class, full_arguments, offset,
-                              &bound_error, pending_types, trail);
-      }
-      if (full_arguments.IsRaw(0, num_type_arguments)) {
-        // The parameterized_type is raw. Set its argument vector to null, which
-        // is more efficient in type tests.
-        full_arguments = TypeArguments::null();
-      }
-      parameterized_type.set_arguments(full_arguments);
-    } else {
-      ASSERT(full_arguments.IsNull());  // Use null vector for raw type.
-    }
-  }
-
-  // Self referencing types may get finalized indirectly.
-  if (!parameterized_type.IsFinalized()) {
-    ASSERT(full_arguments.IsNull() ||
-           !full_arguments.IsRaw(0, num_type_arguments));
-    // Mark the type as finalized.
-    parameterized_type.SetIsFinalized();
-    // Do not yet remove the type from the pending_types array.
-  }
+  const intptr_t num_expanded_type_arguments =
+      ExpandAndFinalizeTypeArguments(cls, resolved_type, pending_types);
 
   // If we are done finalizing a graph of mutually recursive types, check their
   // bounds.
   if (is_root_type) {
     for (intptr_t i = pending_types->length() - 1; i >= 0; i--) {
-      CheckTypeBounds(cls, Type::Cast(pending_types->At(i)));
-      if (FLAG_trace_type_finalization && type.IsRecursive()) {
+      CheckTypeBounds(cls, pending_types->At(i));
+      if (FLAG_trace_type_finalization && resolved_type.IsRecursive()) {
         THR_Print("Done finalizing recursive type '%s': %s\n",
-                  String::Handle(Z, type.Name()).ToCString(),
-                  type.ToCString());
+                  String::Handle(Z, resolved_type.Name()).ToCString(),
+                  resolved_type.ToCString());
       }
     }
   }
 
-  // If the type class is a signature class, we are currently finalizing a
-  // signature type, i.e. finalizing the result type and parameter types of the
-  // signature function of this signature type.
+  // If the type is a FunctionType, we also need to finalize the types in its
+  // signature, i.e. finalize the result type and parameter types of the
+  // signature function of this function type.
   // We do this after marking this type as finalized in order to allow a
   // function type to refer to itself via its parameter types and result type.
-  if (type_class.IsSignatureClass()) {
-    // The class may be created while parsing a function body, after all
-    // pending classes have already been finalized.
-    FinalizeTypesInClass(type_class);
+  // Note that we do not instantiate these types according to the type
+  // arguments. This will happen on demand when executing a type test.
+  if (resolved_type.IsFunctionType()) {
+    const Function& signature =
+        Function::Handle(Z, FunctionType::Cast(resolved_type).signature());
+    FinalizeSignature(cls, signature);
   }
 
   if (FLAG_trace_type_finalization) {
     THR_Print("Done finalizing type '%s' with %" Pd " type args: %s\n",
-              String::Handle(Z, parameterized_type.Name()).ToCString(),
-              parameterized_type.arguments() == TypeArguments::null() ?
-                  0 : num_type_arguments,
-              parameterized_type.ToCString());
+              String::Handle(Z, resolved_type.Name()).ToCString(),
+              num_expanded_type_arguments,
+              resolved_type.ToCString());
   }
 
   if (finalization >= kCanonicalize) {
-    if (FLAG_trace_type_finalization && parameterized_type.IsRecursive()) {
-      AbstractType& type = Type::Handle(Z);
-      type = parameterized_type.Canonicalize();
+    if (FLAG_trace_type_finalization && resolved_type.IsRecursive()) {
+      AbstractType& recursive_type =
+          AbstractType::Handle(Z, resolved_type.Canonicalize());
       THR_Print("Done canonicalizing recursive type '%s': %s\n",
-                String::Handle(Z, type.Name()).ToCString(),
-                type.ToCString());
-      return type.raw();
+                String::Handle(Z, recursive_type.Name()).ToCString(),
+                recursive_type.ToCString());
+      return recursive_type.raw();
     }
-    return parameterized_type.Canonicalize();
+    return resolved_type.Canonicalize();
   } else {
-    return parameterized_type.raw();
+    return resolved_type.raw();
   }
 }
 
 
-void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
-                                                 const Function& function) {
+void ClassFinalizer::ResolveSignature(const Class& cls,
+                                      const Function& function) {
   // Resolve result type.
   AbstractType& type = AbstractType::Handle(function.result_type());
   // It is not a compile time error if this name does not resolve to a class or
   // interface.
+  AbstractType& resolved_type = AbstractType::Handle(ResolveType(cls, type));
+  if (resolved_type.raw() != type.raw()) {
+    function.set_result_type(resolved_type);
+  }
+  // Resolve formal parameter types.
+  const intptr_t num_parameters = function.NumParameters();
+  for (intptr_t i = 0; i < num_parameters; i++) {
+    type = function.ParameterTypeAt(i);
+    resolved_type = ResolveType(cls, type);
+    if (resolved_type.raw() != type.raw()) {
+      function.SetParameterTypeAt(i, resolved_type);
+    }
+  }
+}
+
+
+void ClassFinalizer::FinalizeSignature(const Class& cls,
+                                       const Function& function) {
+  // Finalize result type.
+  AbstractType& type = AbstractType::Handle(function.result_type());
+  // It is not a compile time error if this name does not resolve to a class or
+  // interface.
   AbstractType& finalized_type =
       AbstractType::Handle(FinalizeType(cls, type, kCanonicalize));
   // The result type may be malformed or malbounded.
-  if (type.raw() != finalized_type.raw()) {
+  if (finalized_type.raw() != type.raw()) {
     function.set_result_type(finalized_type);
   }
-  // Resolve formal parameter types.
+  // Finalize formal parameter types.
   const intptr_t num_parameters = function.NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
     finalized_type = FinalizeType(cls, type, kCanonicalize);
     // The parameter type may be malformed or malbounded.
     if (type.raw() != finalized_type.raw()) {
       function.SetParameterTypeAt(i, finalized_type);
     }
   }
 }
@@ skipping 53 matching lines @@
   AbstractType& bound = AbstractType::Handle();
   const TypeArguments& type_params =
       TypeArguments::Handle(cls.type_parameters());
   ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
          (type_params.Length() == num_type_params));
   // In a first pass, resolve all bounds. This guarantees that finalization
   // of mutually referencing bounds will not encounter an unresolved bound.
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_param ^= type_params.TypeAt(i);
     bound = type_param.bound();
-    ResolveType(cls, bound);
+    bound = ResolveType(cls, bound);
+    type_param.set_bound(bound);
   }
 }
 
 
 // Finalize the upper bounds of the type parameters of class cls.
 void ClassFinalizer::FinalizeUpperBounds(const Class& cls) {
   const intptr_t num_type_params = cls.NumTypeParameters();
   TypeParameter& type_param = TypeParameter::Handle();
   AbstractType& bound = AbstractType::Handle();
   const TypeArguments& type_params =
@@ skipping 169 matching lines @@
   }
   // Resolve function signatures and check for conflicts in super classes and
   // interfaces.
   array = cls.functions();
   Function& function = Function::Handle(Z);
   Function& overridden_function = Function::Handle(Z);
   const intptr_t num_functions = array.Length();
   Error& error = Error::Handle(Z);
   for (intptr_t i = 0; i < num_functions; i++) {
     function ^= array.At(i);
-    ResolveAndFinalizeSignature(cls, function);
+    FinalizeSignature(cls, function);
     name = function.name();
     // Report signature conflicts only.
     if (Isolate::Current()->flags().error_on_bad_override() &&
         !function.is_static() && !function.IsGenerativeConstructor()) {
       // A constructor cannot override anything.
       for (intptr_t i = 0; i < interfaces.length(); i++) {
         const Class* super_class = interfaces.At(i);
         // Finalize superclass since overrides check relies on all members
         // of the superclass to be finalized.
         FinalizeClass(*super_class);
@@ skipping 252 matching lines @@
           param ^= mixin_type_args.TypeAt(i);
           param_bound = param.bound();
           if (!param_bound.IsInstantiated()) {
             // Make sure the bound is finalized before instantiating it.
             if (!param_bound.IsFinalized() &&
                 !param_bound.IsBeingFinalized()) {
               param_bound =
                   FinalizeType(mixin_app_class, param_bound, kCanonicalize);
               param.set_bound(param_bound);  // In case part of recursive type.
             }
-            param_bound = param_bound.InstantiateFrom(instantiator,
-                                                      &bound_error);
+            param_bound = param_bound.InstantiateFrom(
+                instantiator, &bound_error, NULL, Heap::kOld);
             // The instantiator contains only TypeParameter objects and no
             // BoundedType objects, so no bound error may occur.
             ASSERT(!param_bound.IsBoundedType());
             ASSERT(bound_error.IsNull());
             ASSERT(!param_bound.IsInstantiated());
             param.set_bound(param_bound);
           }
         }
       }
 
@@ skipping 207 matching lines @@
     const intptr_t offset =
         mixin_class_super_type_args.Length() - num_aliased_mixin_type_params;
     for (intptr_t i = 0; i < num_aliased_mixin_type_params; i++) {
       type = mixin_class_super_type_args.TypeAt(offset + i);
       if (!type.IsInstantiated()) {
         // In the presence of bounds, the bounded type and the upper bound must
         // be instantiated separately. Instantiating a BoundedType would wrap
         // the BoundedType in another BoundedType.
         if (type.IsBoundedType()) {
           bounded_type = BoundedType::Cast(type).type();
-          bounded_type = bounded_type.InstantiateFrom(instantiator,
-                                                      &bound_error);
+          bounded_type = bounded_type.InstantiateFrom(
+              instantiator, &bound_error, NULL, Heap::kOld);
           // The instantiator contains only TypeParameter objects and no
           // BoundedType objects, so no bound error may occur.
           ASSERT(bound_error.IsNull());
           upper_bound = BoundedType::Cast(type).bound();
-          upper_bound = upper_bound.InstantiateFrom(instantiator, &bound_error);
+          upper_bound = upper_bound.InstantiateFrom(
+              instantiator, &bound_error, NULL, Heap::kOld);
           ASSERT(bound_error.IsNull());
           type_parameter = BoundedType::Cast(type).type_parameter();
           // The type parameter that declared the bound does not change.
           type = BoundedType::New(bounded_type, upper_bound, type_parameter);
         } else {
-          type = type.InstantiateFrom(instantiator, &bound_error);
+          type = type.InstantiateFrom(
+              instantiator, &bound_error, NULL, Heap::kOld);
           ASSERT(bound_error.IsNull());
         }
       }
       new_mixin_type_args.SetTypeAt(i, type);
     }
   }
   TypeArguments& new_super_type_args = TypeArguments::Handle(zone);
   if ((num_super_type_params + num_aliased_mixin_type_params) > 0) {
     new_super_type_args = TypeArguments::New(num_super_type_params +
                                              num_aliased_mixin_type_params);
@@ skipping 265 matching lines @@
   if (!super_class.IsNull()) {
     FinalizeTypesInClass(super_class);
   }
   // Finalize type parameters before finalizing the super type.
   FinalizeTypeParameters(cls);  // May change super type.
   super_class = cls.SuperClass();
   ASSERT(super_class.IsNull() || super_class.is_type_finalized());
   // Only resolving rather than finalizing the upper bounds here would result in
   // instantiated type parameters of the super type to temporarily have
   // unfinalized bounds. It is more efficient to finalize them early.
+  // Finalize bounds even if running in production mode, so that a snapshot
+  // contains them.
   FinalizeUpperBounds(cls);
   // Finalize super type.
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     // In case of a bound error in the super type in production mode, the
     // finalized super type will have a BoundedType as type argument for the
     // out of bound type argument.
     // It should not be a problem if the class is written to a snapshot and
     // later executed in checked mode. Note that the finalized type argument
     // vector of any type of the base class will contain a BoundedType for the
     // out of bound type argument.
     super_type = FinalizeType(cls, super_type, kCanonicalizeWellFormed);
     cls.set_super_type(super_type);
   }
   // Finalize mixin type.
   Type& mixin_type = Type::Handle(cls.mixin());
   if (!mixin_type.IsNull()) {
     mixin_type ^= FinalizeType(cls, mixin_type, kCanonicalizeWellFormed);
     cls.set_mixin(mixin_type);
   }
-  if (cls.IsSignatureClass()) {
+  if (cls.IsTypedefClass()) {
+    const Function& signature = Function::Handle(cls.signature_function());
+    FunctionType& type = FunctionType::Handle(signature.SignatureType());
+
     // Check for illegal self references.
     GrowableArray<intptr_t> visited_aliases;
-    if (!IsAliasCycleFree(cls, &visited_aliases)) {
+    if (!IsTypedefCycleFree(cls, type, &visited_aliases)) {
       const String& name = String::Handle(cls.Name());
       ReportError(cls, cls.token_pos(),
                   "typedef '%s' illegally refers to itself",
                   name.ToCString());
     }
     cls.set_is_type_finalized();
 
-    // The type parameters of signature classes may have bounds.
-    FinalizeUpperBounds(cls);
+    // Resolve and finalize the result and parameter types of the signature
+    // function of this typedef class.
+    FinalizeSignature(cls, signature);  // Does not modify signature type.
+    ASSERT(signature.SignatureType() == type.raw());
 
-    // Resolve and finalize the result and parameter types of the signature
-    // function of this signature class.
-    const Function& sig_function = Function::Handle(cls.signature_function());
-    ResolveAndFinalizeSignature(cls, sig_function);
+    // Resolve and finalize the signature type of this typedef.
+    type ^= FinalizeType(cls, type, kCanonicalizeWellFormed);
+    signature.SetSignatureType(type);
 
-    // Resolve and finalize the signature type of this signature class.
-    const Type& sig_type = Type::Handle(cls.SignatureType());
-    FinalizeType(cls, sig_type, kCanonicalizeWellFormed);
+    // Closure instances do not refer to this typedef as their class, so there
+    // is no need to add this typedef class to the subclasses of _Closure.
+    ASSERT(super_type.IsNull() || super_type.IsObjectType());
 
-    // Add this class to the subclasses of the superclass (_FunctionImpl).
-    if (!super_type.IsNull()) {
-      ASSERT(!super_type.IsObjectType());
-      ASSERT(!super_class.IsNull());
-      super_class.AddDirectSubclass(cls);
-    }
     return;
   }
+
   // Finalize interface types (but not necessarily interface classes).
   Array& interface_types = Array::Handle(cls.interfaces());
   AbstractType& interface_type = AbstractType::Handle();
   AbstractType& seen_interf = AbstractType::Handle();
   for (intptr_t i = 0; i < interface_types.Length(); i++) {
     interface_type ^= interface_types.At(i);
     interface_type = FinalizeType(cls, interface_type, kCanonicalizeWellFormed);
     interface_types.SetAt(i, interface_type);
 
     // Check whether the interface is duplicated. We need to wait with
@@ skipping 16 matching lines @@
                     "interface '%s' appears twice in "
                     "implements clause of class '%s'",
                     String::Handle(interface_type.Name()).ToCString(),
                     String::Handle(cls.Name()).ToCString());
       }
     }
   }
   // Mark as type finalized before resolving type parameter upper bounds
   // in order to break cycles.
   cls.set_is_type_finalized();
-  // Finalize bounds even if running in production mode, so that a snapshot
-  // contains them.
-  FinalizeUpperBounds(cls);
   // Add this class to the direct subclasses of the superclass, unless the
   // superclass is Object.
   if (!super_type.IsNull() && !super_type.IsObjectType()) {
     ASSERT(!super_class.IsNull());
     super_class.AddDirectSubclass(cls);
   }
   // A top level class is parsed eagerly so just finalize it.
   if (cls.IsTopLevel()) {
     FinalizeClass(cls);
   } else {
@@ skipping 46 matching lines @@
 
     const Class& mixin_app_class = Class::Handle(cls.SuperClass());
     const Type& mixin_type = Type::Handle(mixin_app_class.mixin());
     const Class& mixin_cls = Class::Handle(mixin_type.type_class());
 
     CreateForwardingConstructors(cls, mixin_cls, cloned_funcs);
     const Array& functions = Array::Handle(Array::MakeArray(cloned_funcs));
     cls.SetFunctions(functions);
   }
   // Every class should have at least a constructor, unless it is a top level
-  // class or a signature class.
+  // class or a typedef class.
   ASSERT(cls.IsTopLevel() ||
-         cls.IsSignatureClass() ||
+         cls.IsTypedefClass() ||
          (Array::Handle(cls.functions()).Length() > 0));
   // Resolve and finalize all member types.
   ResolveAndFinalizeMemberTypes(cls);
   // Run additional checks after all types are finalized.
   if (cls.is_const()) {
     CheckForLegalConstClass(cls);
   }
   if (FLAG_use_cha_deopt) {
     GrowableArray<intptr_t> cids;
     CollectFinalizedSuperClasses(cls, &cids);
@@ skipping 70 matching lines @@
     test2 = test2.SuperClass();
     if (!test2.IsNull()) {
       test2 = test2.SuperClass();
     }
   }
   // No cycles.
   return true;
 }
 
 
-// Helper function called by IsAliasCycleFree.
-bool ClassFinalizer::IsTypeCycleFree(
-    const Class& cls,
-    const AbstractType& type,
-    GrowableArray<intptr_t>* visited) {
+// Returns false if a function type alias illegally refers to itself.
+bool ClassFinalizer::IsTypedefCycleFree(const Class& cls,
+                                        const AbstractType& type,
+                                        GrowableArray<intptr_t>* visited) {
   ASSERT(visited != NULL);
-  ResolveType(cls, type);
-  if (type.IsType() && !type.IsMalformed()) {
-    const Class& type_class = Class::Handle(type.type_class());
-    if (!type_class.is_type_finalized() &&
-        type_class.IsSignatureClass() &&
-        !IsAliasCycleFree(type_class, visited)) {
-      return false;
-    }
-    const TypeArguments& type_args = TypeArguments::Handle(type.arguments());
-    if (!type_args.IsNull()) {
-      AbstractType& type_arg = AbstractType::Handle();
-      for (intptr_t i = 0; i < type_args.Length(); i++) {
-        type_arg = type_args.TypeAt(i);
-        if (!IsTypeCycleFree(cls, type_arg, visited)) {
+  AbstractType& resolved_type = AbstractType::Handle(ResolveType(cls, type));
+  bool checking_typedef = false;
+  if ((resolved_type.IsType() || resolved_type.IsFunctionType()) &&
+      !resolved_type.IsMalformed()) {
+    AbstractType& other_type = AbstractType::Handle();
+    if (resolved_type.IsFunctionType()) {
+      const Class& scope_class = Class::Handle(resolved_type.type_class());
+      if (!scope_class.is_type_finalized() && scope_class.IsTypedefClass()) {
+        checking_typedef = true;
+        const intptr_t scope_class_id = scope_class.id();
+        ASSERT(visited != NULL);
+        for (intptr_t i = 0; i < visited->length(); i++) {
+          if ((*visited)[i] == scope_class_id) {
+            // We have already visited alias 'scope_class'. We found a cycle.
+            return false;
+          }
+        }
+        visited->Add(scope_class_id);
+      }
+      // Check the bounds of this function type.
+      const intptr_t num_type_params = scope_class.NumTypeParameters();
+      TypeParameter& type_param = TypeParameter::Handle();
+      const TypeArguments& type_params =
+          TypeArguments::Handle(scope_class.type_parameters());
+      ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
+             (type_params.Length() == num_type_params));
+      for (intptr_t i = 0; i < num_type_params; i++) {
+        type_param ^= type_params.TypeAt(i);
+        other_type = type_param.bound();
+        if (!IsTypedefCycleFree(cls, other_type, visited)) {
           return false;
         }
       }
+      // Check the result type of the signature of this function type.
+      const Function& function =
+          Function::Handle(FunctionType::Cast(resolved_type).signature());
+      other_type = function.result_type();
+      if (!IsTypedefCycleFree(cls, other_type, visited)) {
+        return false;
+      }
+      // Check the parameter types of the signature of this function type.
+      const intptr_t num_parameters = function.NumParameters();
+      for (intptr_t i = 0; i < num_parameters; i++) {
+        other_type = function.ParameterTypeAt(i);
+        if (!IsTypedefCycleFree(cls, other_type, visited)) {
+          return false;
+        }
+      }
+    }
+    const TypeArguments& type_args =
+        TypeArguments::Handle(resolved_type.arguments());
+    if (!type_args.IsNull()) {
+      for (intptr_t i = 0; i < type_args.Length(); i++) {
+        other_type = type_args.TypeAt(i);
+        if (!IsTypedefCycleFree(cls, other_type, visited)) {
+          return false;
+        }
+      }
+    }
+    if (checking_typedef) {
+      visited->RemoveLast();
     }
   }
   return true;
 }
 
-
-// Returns false if the function type alias illegally refers to itself.
-bool ClassFinalizer::IsAliasCycleFree(const Class& cls,
-                                      GrowableArray<intptr_t>* visited) {
-  ASSERT(cls.IsSignatureClass());
-  ASSERT(!cls.is_type_finalized());
-  ASSERT(visited != NULL);
-  const intptr_t cls_index = cls.id();
-  for (intptr_t i = 0; i < visited->length(); i++) {
-    if ((*visited)[i] == cls_index) {
-      // We have already visited alias 'cls'. We found a cycle.
-      return false;
-    }
-  }
-
-  // Visit the bounds, result type, and parameter types of this signature type.
-  visited->Add(cls.id());
-  AbstractType& type = AbstractType::Handle();
-
-  // Check the bounds of this signature type.
-  const intptr_t num_type_params = cls.NumTypeParameters();
-  TypeParameter& type_param = TypeParameter::Handle();
-  const TypeArguments& type_params =
-      TypeArguments::Handle(cls.type_parameters());
-  ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
-         (type_params.Length() == num_type_params));
-  for (intptr_t i = 0; i < num_type_params; i++) {
-    type_param ^= type_params.TypeAt(i);
-    type = type_param.bound();
-    if (!IsTypeCycleFree(cls, type, visited)) {
-      return false;
-    }
-  }
-  // Check the result type of the function of this signature type.
-  const Function& function = Function::Handle(cls.signature_function());
-  type = function.result_type();
-  if (!IsTypeCycleFree(cls, type, visited)) {
-    return false;
-  }
-  // Check the formal parameter types of the function of this signature type.
-  const intptr_t num_parameters = function.NumParameters();
-  for (intptr_t i = 0; i < num_parameters; i++) {
-    type = function.ParameterTypeAt(i);
-    if (!IsTypeCycleFree(cls, type, visited)) {
-      return false;
-    }
-  }
-  visited->RemoveLast();
-  return true;
-}
-
 
 // Returns false if the mixin illegally refers to itself.
 bool ClassFinalizer::IsMixinCycleFree(const Class& cls,
                                       GrowableArray<intptr_t>* visited) {
   ASSERT(visited != NULL);
   const intptr_t cls_index = cls.id();
   for (intptr_t i = 0; i < visited->length(); i++) {
     if ((*visited)[i] == cls_index) {
       // We have already visited mixin 'cls'. We found a cycle.
       return false;
@@ skipping 64 matching lines @@
   // and resolve super type and mixin types.
   Zone* zone = Thread::Current()->zone();
   const Library& library = Library::Handle(zone, cls.library());
   ASSERT(!library.IsNull());
   const Script& script = Script::Handle(zone, cls.script());
   ASSERT(!script.IsNull());
   const GrowableObjectArray& type_args =
       GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
   AbstractType& mixin_super_type =
       AbstractType::Handle(zone, mixin_app_type.super_type());
-  ResolveType(cls, mixin_super_type);
+  mixin_super_type = ResolveType(cls, mixin_super_type);
   ASSERT(mixin_super_type.HasResolvedTypeClass());  // Even if malformed.
   if (mixin_super_type.IsMalformedOrMalbounded()) {
     ReportError(Error::Handle(zone, mixin_super_type.error()));
   }
   if (mixin_super_type.IsDynamicType()) {
     ReportError(cls, cls.token_pos(),
                 "class '%s' may not extend 'dynamic'",
                 String::Handle(zone, cls.Name()).ToCString());
   }
   // The super type may have a BoundedType as type argument, but cannot be
   // a BoundedType itself.
   CollectTypeArguments(cls, Type::Cast(mixin_super_type), type_args);
   AbstractType& mixin_type = AbstractType::Handle(zone);
   Class& mixin_type_class = Class::Handle(zone);
   Class& mixin_app_class = Class::Handle(zone);
   String& mixin_app_class_name = String::Handle(zone);
   String& mixin_type_class_name = String::Handle(zone);
   AbstractType& super_type_arg = AbstractType::Handle(zone);
   AbstractType& mixin_type_arg = AbstractType::Handle(zone);
   const intptr_t depth = mixin_app_type.Depth();
   for (intptr_t i = 0; i < depth; i++) {
     mixin_type = mixin_app_type.MixinTypeAt(i);
     ASSERT(!mixin_type.IsNull());
-    ResolveType(cls, mixin_type);
+    mixin_type = ResolveType(cls, mixin_type);
     ASSERT(mixin_type.HasResolvedTypeClass());  // Even if malformed.
     ASSERT(mixin_type.IsType());
     const intptr_t num_super_type_args = type_args.Length();
     CollectTypeArguments(cls, Type::Cast(mixin_type), type_args);
 
     // If the mixin type has identical type arguments as the super type, they
     // can share the same type parameters of the mixin application class,
     // thereby allowing for further optimizations, such as instantiator vector
     // reuse or sharing of type arguments with the super class.
     bool share_type_params = (num_super_type_args > 0) &&
@@ skipping 140 matching lines @@
   // If cls belongs to core lib, restrictions about allowed interfaces
   // are lifted.
   const bool cls_belongs_to_core_lib = cls.library() == Library::CoreLibrary();
 
   // Resolve and check the super type and interfaces of cls.
   visited->Add(cls_index);
   AbstractType& interface = AbstractType::Handle(zone);
   Class& interface_class = Class::Handle(zone);
 
   // Resolve super type. Failures lead to a longjmp.
-  ResolveType(cls, super_type);
+  super_type = ResolveType(cls, super_type);
   if (super_type.IsMalformedOrMalbounded()) {
     ReportError(Error::Handle(zone, super_type.error()));
   }
   if (super_type.IsDynamicType()) {
     ReportError(cls, cls.token_pos(),
                 "class '%s' may not extend 'dynamic'",
                 String::Handle(zone, cls.Name()).ToCString());
   }
   interface_class = super_type.type_class();
-  if (interface_class.IsSignatureClass()) {
+  if (interface_class.IsTypedefClass()) {
     ReportError(cls, cls.token_pos(),
                 "class '%s' may not extend function type alias '%s'",
                 String::Handle(zone, cls.Name()).ToCString(),
                 String::Handle(zone,
                                super_type.UserVisibleName()).ToCString());
   }
   if (interface_class.is_enum_class()) {
     ReportError(cls, cls.token_pos(),
                 "class '%s' may not extend enum '%s'",
                 String::Handle(zone, cls.Name()).ToCString(),
@@ skipping 49 matching lines @@
                   String::Handle(zone, cls.Name()).ToCString(),
                   interface_name.ToCString());
     }
   }
   // Now resolve the super interfaces of the super type.
   ResolveSuperTypeAndInterfaces(interface_class, visited);
 
   // Resolve interfaces. Failures lead to a longjmp.
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
-    ResolveType(cls, interface);
+    interface = ResolveType(cls, interface);
     ASSERT(!interface.IsTypeParameter());  // Should be detected by parser.
     // A malbounded interface is only reported when involved in a type test.
     if (interface.IsMalformed()) {
       ReportError(Error::Handle(zone, interface.error()));
     }
     if (interface.IsDynamicType()) {
       ReportError(cls, cls.token_pos(),
                   "'dynamic' may not be used as interface");
     }
     interface_class = interface.type_class();
-    if (interface_class.IsSignatureClass()) {
+    if (interface_class.IsTypedefClass()) {
       const String& interface_name = String::Handle(zone,
                                                     interface_class.Name());
       ReportError(cls, cls.token_pos(),
                   "function type alias '%s' may not be used as interface",
                   interface_name.ToCString());
     }
     if (interface_class.is_enum_class()) {
       const String& interface_name = String::Handle(zone,
                                                     interface_class.Name());
       ReportError(cls, cls.token_pos(),
@@ skipping 115 matching lines @@
   if (Isolate::Current()->flags().error_on_bad_type()) {
     ReportError(error);
   }
   type.set_error(error);
   // Make the type raw, since it may not be possible to
   // properly finalize its type arguments.
   type.set_type_class(Class::Handle(Object::dynamic_class()));
   type.set_arguments(Object::null_type_arguments());
   if (!type.IsFinalized()) {
     type.SetIsFinalized();
-    // Do not canonicalize malformed types, since they may not be resolved.
+    // Do not canonicalize malformed types, since they contain an error field.
   } else {
     // The only case where the malformed type was already finalized is when its
     // type arguments are not within bounds. In that case, we have a prev_error.
     ASSERT(!prev_error.IsNull());
   }
 }
 
 
 RawType* ClassFinalizer::NewFinalizedMalformedType(const Error& prev_error,
                                                    const Script& script,
@@ skipping 21 matching lines @@
                                            const char* format, ...) {
   va_list args;
   va_start(args, format);
   MarkTypeMalformed(prev_error, script, type, format, args);
   va_end(args);
 }
 
 
 void ClassFinalizer::FinalizeMalboundedType(const Error& prev_error,
                                             const Script& script,
-                                            const Type& type,
+                                            const AbstractType& type,
                                             const char* format, ...) {
   va_list args;
   va_start(args, format);
   LanguageError& error = LanguageError::Handle(
       LanguageError::NewFormattedV(
           prev_error, script, type.token_pos(), Report::AtLocation,
           Report::kMalboundedType, Heap::kOld,
           format, args));
   va_end(args);
   if (Isolate::Current()->flags().error_on_bad_type()) {
@@ skipping 107 matching lines @@
   ASSERT(fields_array.Length() == ByteBuffer::NumberOfFields());
   field ^= fields_array.At(0);
   ASSERT(field.Offset() == ByteBuffer::data_offset());
   name ^= field.name();
   expected_name ^= String::New("_data");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
 #endif
 }
 
 }  // namespace dart