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

runtime/vm/object.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_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 998 matching lines @@
 
   // The type argument vector is flattened and includes the type arguments of
   // the super class.
   intptr_t NumTypeArguments() const;
 
   // Return the number of type arguments that are specific to this class, i.e.
   // not overlapping with the type arguments of the super class of this class.
   intptr_t NumOwnTypeArguments() const;
 
   // Return true if this class declares type parameters.
-  bool IsGeneric() const;
+  bool IsGeneric() const { return NumTypeParameters(Thread::Current()) > 0; }
 
   // If this class is parameterized, each instance has a type_arguments field.
   static const intptr_t kNoTypeArguments = -1;
   intptr_t type_arguments_field_offset() const {
     ASSERT(is_type_finalized() || is_prefinalized());
     if (raw_ptr()->type_arguments_field_offset_in_words_ == kNoTypeArguments) {
       return kNoTypeArguments;
     }
     return raw_ptr()->type_arguments_field_offset_in_words_ * kWordSize;
   }
@@ skipping 1259 matching lines @@
   RawArray* parameter_names() const { return raw_ptr()->parameter_names_; }
   void set_parameter_names(const Array& value) const;
 
   // The type parameters (and their bounds) are specified as an array of
   // TypeParameter.
   RawTypeArguments* type_parameters() const {
       return raw_ptr()->type_parameters_;
   }
   void set_type_parameters(const TypeArguments& value) const;
   intptr_t NumTypeParameters(Thread* thread) const;
-  intptr_t NumTypeParameters() const {
-    return NumTypeParameters(Thread::Current());
-  }
 
   // Return a TypeParameter if the type_name is a type parameter of this
   // function or of one of its parent functions.
   // Unless NULL, adjust function_level accordingly (in and out parameter).
   // Return null otherwise.
   RawTypeParameter* LookupTypeParameter(const String& type_name,
                                         intptr_t* function_level) const;
 
   // Return true if this function declares type parameters.
-  bool IsGeneric() const { return NumTypeParameters() > 0; }
+  bool IsGeneric() const { return NumTypeParameters(Thread::Current()) > 0; }
 
   // Not thread-safe; must be called in the main thread.
   // Sets function's code and code's function.
   void InstallOptimizedCode(const Code& code, bool is_osr) const;
   void AttachCode(const Code& value) const;
   void SetInstructions(const Code& value) const;
   void ClearCode() const;
 
   // Disables optimized code and switches to unoptimized code.
   void SwitchToUnoptimizedCode() const;
@@ skipping 3810 matching lines @@
   }
   bool IsClassTypeParameter() const {
     return parameterized_class_id() != kIllegalCid;
   }
   bool IsFunctionTypeParameter() const {
     return parameterized_function() != Function::null();
   }
   RawString* name() const { return raw_ptr()->name_; }
   intptr_t index() const { return raw_ptr()->index_; }
   void set_index(intptr_t value) const;
+  intptr_t parent_level() const { return raw_ptr()->parent_level_; }
   RawAbstractType* bound() const { return raw_ptr()->bound_; }
   void set_bound(const AbstractType& value) const;
   // Returns true if bounded_type is below upper_bound, otherwise return false
   // and set bound_error if both bounded_type and upper_bound are instantiated.
   // If one or both are not instantiated, returning false only means that the
   // bound cannot be checked yet and this is not an error.
   bool CheckBound(const AbstractType& bounded_type,
                   const AbstractType& upper_bound,
                   Error* bound_error,
                   TrailPtr bound_trail,
@@ skipping 39 matching lines @@
                                TokenPosition token_pos);
 
  private:
   intptr_t ComputeHash() const;
   void SetHash(intptr_t value) const;
 
   void set_parameterized_class(const Class& value) const;
   void set_parameterized_function(const Function& value) const;
   void set_name(const String& value) const;
   void set_token_pos(TokenPosition token_pos) const;
+  void set_parent_level(uint8_t value) const;
   void set_type_state(int8_t state) const;
 
   static RawTypeParameter* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeParameter, AbstractType);
   friend class Class;
 };
 
 
 // A BoundedType represents a type instantiated at compile time from a type
@@ skipping 2771 matching lines @@
 
 inline void TypeArguments::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_