Make sure unresolved function type parameter bounds do not end up in snapshot.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 2406 matching lines @@
       set_num_own_type_arguments(num_type_params - num_overlapping_type_args);
       return num_type_params - num_overlapping_type_args;
     }
   }
   // No overlap found.
   set_num_own_type_arguments(num_type_params);
   return num_type_params;
 }
 
 
-bool Class::IsGeneric() const {
-  return NumTypeParameters() != 0;
-}
-
-
 intptr_t Class::NumTypeArguments() const {
   // Return cached value if already calculated.
   if (num_type_arguments() != kUnknownNumTypeArguments) {
     return num_type_arguments();
   }
   // To work properly, this call requires the super class of this class to be
   // resolved, which is checked by the type_class() call on the super type.
   // Note that calling type_class() on a MixinAppType fails.
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
@@ skipping 3442 matching lines @@
 }
 
 
 RawTypeParameter* Function::LookupTypeParameter(
     const String& type_name, intptr_t* function_level) const {
   ASSERT(!type_name.IsNull());
   Thread* thread = Thread::Current();
   REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(thread);
   REUSABLE_TYPE_PARAMETER_HANDLESCOPE(thread);
   REUSABLE_STRING_HANDLESCOPE(thread);
+  REUSABLE_FUNCTION_HANDLESCOPE(thread);
   TypeArguments& type_params = thread->TypeArgumentsHandle();
   TypeParameter&  type_param = thread->TypeParameterHandle();
   String& type_param_name = thread->StringHandle();
   Function& function = thread->FunctionHandle();
 
   function ^= this->raw();
   intptr_t parent_level = -1;
   while (!function.IsNull()) {
     type_params ^= function.type_parameters();
     if (!type_params.IsNull()) {
@@ skipping 12067 matching lines @@
   return result.raw();
 }
 
 
 void TypeParameter::set_token_pos(TokenPosition token_pos) const {
   ASSERT(!token_pos.IsClassifying());
   StoreNonPointer(&raw_ptr()->token_pos_, token_pos);
 }
 
 
+void TypeParameter::set_parent_level(uint8_t value) const {
+  StoreNonPointer(&raw_ptr()->parent_level_, value);
+}
+
+
 void TypeParameter::set_type_state(int8_t state) const {
   ASSERT((state == RawTypeParameter::kAllocated) ||
          (state == RawTypeParameter::kBeingFinalized) ||
          (state == RawTypeParameter::kFinalizedUninstantiated));
   StoreNonPointer(&raw_ptr()->type_state_, state);
 }
 
 
 const char* TypeParameter::ToCString() const {
-  const char* format =
-      "TypeParameter: name %s; index: %d; class: %s; bound: %s";
   const char* name_cstr = String::Handle(Name()).ToCString();
-  const Class& cls = Class::Handle(parameterized_class());
-  const char* cls_cstr =
-      cls.IsNull() ? " null" : String::Handle(cls.Name()).ToCString();
   const AbstractType& upper_bound = AbstractType::Handle(bound());
   const char* bound_cstr = String::Handle(upper_bound.Name()).ToCString();
-  intptr_t len = OS::SNPrint(
-      NULL, 0, format, name_cstr, index(), cls_cstr, bound_cstr) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, format, name_cstr, index(), cls_cstr, bound_cstr);
-  return chars;
+  if (IsFunctionTypeParameter()) {
+    const char* format = "TypeParameter: name %s; index: %d; parent_level: %d, "
+        "function: %s; bound: %s";
+    const Function& function = Function::Handle(parameterized_function());
+    const char* fun_cstr = String::Handle(function.name()).ToCString();
+    intptr_t len = OS::SNPrint(NULL, 0, format, name_cstr, index(),
+                               parent_level(), fun_cstr, bound_cstr) + 1;
+    char* chars = Thread::Current()->zone()->Alloc<char>(len);
+    OS::SNPrint(chars, len, format, name_cstr, index(), parent_level(),
+                fun_cstr, bound_cstr);
+    return chars;
+  } else {
+    const char* format =
+        "TypeParameter: name %s; index: %d; class: %s; bound: %s";
+    const Class& cls = Class::Handle(parameterized_class());
+    const char* cls_cstr =
+        cls.IsNull() ? " null" : String::Handle(cls.Name()).ToCString();
+    intptr_t len = OS::SNPrint(
+        NULL, 0, format, name_cstr, index(), cls_cstr, bound_cstr) + 1;
+    char* chars = Thread::Current()->zone()->Alloc<char>(len);
+    OS::SNPrint(chars, len, format, name_cstr, index(), cls_cstr, bound_cstr);
+    return chars;
+  }
 }
 
 
 bool BoundedType::IsMalformed() const {
   return AbstractType::Handle(type()).IsMalformed();
 }
 
 
 bool BoundedType::IsMalbounded() const {
   return AbstractType::Handle(type()).IsMalbounded();
@@ skipping 4934 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart