Represent declared type parameters of a class as an array of TypeParameter

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 792 matching lines @@
   // Return the first canonical signature type if already computed.
   const Array& signature_types = Array::Handle(canonical_types());
   if (signature_types.Length() > 0) {
     Type& signature_type = Type::Handle();
     signature_type ^= signature_types.At(0);
     if (!signature_type.IsNull()) {
       return signature_type.raw();
     }
   }
   ASSERT(IsSignatureClass());
-  TypeArguments& signature_type_arguments = TypeArguments::Handle();
-  const intptr_t num_type_params = NumTypeParameters();
   // A signature class extends class Instance and is parameterized in the same
   // way as the owner class of its non-static signature function.
   // It is not type parameterized if its signature function is static.
   // See Class::NewSignatureClass() for the setup of its type parameters.
   // During type finalization, the type arguments of the super class of the
   // owner class of its signature function will be prepended to the type
   // argument vector. Therefore, we only need to set the type arguments
   // matching the type parameters here.
-  if (num_type_params > 0) {
-    const Array& type_params = Array::Handle(type_parameters());
-    // TODO(regis): Simply use the type parameters as type arguments, once type
-    // parameters are stored as an array of TypeParameter, rather than String.
-    signature_type_arguments = TypeArguments::New(num_type_params);
-    String& type_param_name = String::Handle();
-    AbstractType& type_param = AbstractType::Handle();
-    for (int i = 0; i < num_type_params; i++) {
-      type_param_name ^= type_params.At(i);
-      // TODO(regis): Use dummy token index 1 for now; see TODO above.
-      type_param = AbstractType::NewTypeParameter(i, type_param_name, 1);
-      signature_type_arguments.SetTypeAt(i, type_param);
-    }
-  }
+  const TypeArguments& signature_type_arguments =
+      TypeArguments::Handle(type_parameters());
   const Type& signature_type = Type::Handle(
       Type::New(*this, signature_type_arguments, token_index()));
 
   // Return the still unfinalized signature type.
   ASSERT(!signature_type.IsFinalized());
   return signature_type.raw();
 }
 
 
 template <class FakeObject>
@@ skipping 73 matching lines @@
          state == RawClass::kFinalized);
   raw_ptr()->class_state_ = state;
 }
 
 
 void Class::set_library(const Library& value) const {
   StorePointer(&raw_ptr()->library_, value.raw());
 }
 
 
-void Class::set_type_parameters(const Array& value) const {
+void Class::set_type_parameters(const TypeArguments& value) const {
   StorePointer(&raw_ptr()->type_parameters_, value.raw());
 }
 
 
-void Class::set_type_parameter_extends(const TypeArguments& value) const {
-  StorePointer(&raw_ptr()->type_parameter_extends_, value.raw());
+void Class::set_type_parameter_bounds(const TypeArguments& value) const {
+  StorePointer(&raw_ptr()->type_parameter_bounds_, value.raw());
 }
 
 
 intptr_t Class::NumTypeParameters() const {
-  const Array& type_params = Array::Handle(type_parameters());
+  const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
   if (type_params.IsNull()) {
     return 0;
   } else {
     return type_params.Length();
   }
 }
 
 
 intptr_t Class::NumTypeArguments() const {
   // To work properly, this call requires the super class of this class to be
@@ skipping 73 matching lines @@
 void Class::set_factory_class(const Object& value) const {
   StorePointer(&raw_ptr()->factory_class_, value.raw());
 }
 
 
 // Return a TypeParameter if the type_name is a type parameter of this class.
 // Return null otherwise.
 RawTypeParameter* Class::LookupTypeParameter(const String& type_name,
                                              intptr_t token_index) const {
   ASSERT(!type_name.IsNull());
-  const Array& type_params = Array::Handle(type_parameters());
+  const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
   if (!type_params.IsNull()) {
     intptr_t num_type_params = type_params.Length();
-    String& type_param = String::Handle();
+    TypeParameter& type_param = TypeParameter::Handle();
+    String& type_param_name = String::Handle();
     for (intptr_t i = 0; i < num_type_params; i++) {
-      type_param ^= type_params.At(i);
-      if (type_param.Equals(type_name)) {
+      type_param ^= type_params.TypeAt(i);
+      type_param_name = type_param.Name();
+      if (type_param_name.Equals(type_name)) {
+        ASSERT(type_param.IsFinalized() || (type_param.Index() == i));
+        // Create a new TypeParameter with the given token_index.
         return TypeParameter::New(i, type_name, token_index);
       }
     }
   }
   return TypeParameter::null();
 }
 
 
 void Class::CalculateFieldOffsets() const {
   Array& flds = Array::Handle(fields());
   const Class& super = Class::Handle(SuperClass());
   intptr_t offset = 0;
   intptr_t type_args_field_offset = kNoTypeArguments;
   if (super.IsNull()) {
     offset = sizeof(RawObject);
   } else {
     type_args_field_offset = super.type_arguments_instance_field_offset();
     offset = super.next_field_offset();
     ASSERT(offset > 0);
     // We should never call CalculateFieldOffsets for native wrapper
     // classes, assert this.
     ASSERT(num_native_fields() == 0);
     set_num_native_fields(super.num_native_fields());
   }
   // If the super class is parameterized, use the same type_arguments field.
   if (type_args_field_offset == kNoTypeArguments) {
-    const Array& type_params = Array::Handle(type_parameters());
+    const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
     if (!type_params.IsNull()) {
       ASSERT(type_params.Length() > 0);
       // The instance needs a type_arguments field.
       type_args_field_offset = offset;
       offset += kWordSize;
     }
   }
   set_type_arguments_instance_field_offset(type_args_field_offset);
   ASSERT(offset != 0);
   Field& field = Field::Handle();
@@ skipping 89 matching lines @@
   return result.raw();
 }
 
 
 RawClass* Class::NewSignatureClass(const String& name,
                                    const Function& signature_function,
                                    const Script& script) {
   ASSERT(!signature_function.IsNull());
   const Class& owner_class = Class::Handle(signature_function.owner());
   ASSERT(!owner_class.IsNull());
-  Array& type_parameters = Array::Handle();
-  TypeArguments& type_parameter_extends = TypeArguments::Handle();
+  TypeArguments& type_parameters = TypeArguments::Handle();
+  TypeArguments& type_parameter_bounds = TypeArguments::Handle();
   // A signature class extends class Instance and is parameterized in the same
   // way as the owner class of its non-static signature function.
   // It is not type parameterized if its signature function is static.
   if (!signature_function.is_static()) {
     if ((owner_class.NumTypeParameters() > 0) &&
         !signature_function.HasInstantiatedSignature()) {
       type_parameters = owner_class.type_parameters();
-      type_parameter_extends = owner_class.type_parameter_extends();
+      type_parameter_bounds = owner_class.type_parameter_bounds();
     }
   }
   const intptr_t token_index = signature_function.token_index();
   Class& result = Class::Handle(New<Closure>(name, script, token_index));
   const Type& super_type = Type::Handle(Type::ObjectType());
   ASSERT(!super_type.IsNull());
   result.set_super_type(super_type);
   result.set_signature_function(signature_function);
   result.set_type_parameters(type_parameters);
-  result.set_type_parameter_extends(type_parameter_extends);
+  result.set_type_parameter_bounds(type_parameter_bounds);
   result.SetFields(Array::Handle(Array::Empty()));
   result.SetFunctions(Array::Handle(Array::Empty()));
   // Implements interface "Function".
   const Type& function_interface = Type::Handle(Type::FunctionInterface());
   const Array& interfaces = Array::Handle(Array::New(1, Heap::kOld));
   interfaces.SetAt(0, function_interface);
   result.set_interfaces(interfaces);
   // Unless the signature function already has a signature class, create a
   // canonical signature class by having the signature function point back to
   // the signature class.
@@ skipping 243 matching lines @@
           // interface cannot be instantiated and we must check against a raw
           // interface.
           interface_args = TypeArguments::null();
         } else {
           // The type arguments of this type that are referred to by the type
           // parameters of the interface are at the end of the type vector,
           // after the type arguments of the super type of this type.
           // The index of the type parameters is adjusted upon finalization.
           ASSERT(interface.IsFinalized());
           interface_args = interface_args.InstantiateFrom(type_arguments);
-          // TODO(regis): Check the subtyping constraints if any, i.e. if
-          // interface.type_parameter_extends() is not an array of DynamicType.
-          // Should we pass the constraints to InstantiateFrom and it would
-          // return null on failure?
+          // TODO(regis): Do we have to consider the bounds of the type
+          // parameters of the interface?
         }
       }
       if (interface_class.IsMoreSpecificThan(interface_args,
                                              other,
                                              other_type_arguments)) {
         return true;
       }
     }
   }
   // Check the interface case.
@@ skipping 693 matching lines @@
 RawType* Type::FunctionInterface() {
   return Isolate::Current()->object_store()->function_interface();
 }
 
 
 RawType* Type::ListInterface() {
   return Isolate::Current()->object_store()->list_interface();
 }
 
 
-RawType* Type::NewRawType(const Class& type_class, intptr_t token_index) {
-  const AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::Handle(type_class.type_parameter_extends());
-  return New(Object::Handle(type_class.raw()), type_arguments, token_index);
-}
-
-
 RawType* Type::NewNonParameterizedType(
     const Class& type_class) {
   ASSERT(!type_class.HasTypeArguments());
   const TypeArguments& no_type_arguments = TypeArguments::Handle();
   Type& type = Type::Handle();
   type ^= Type::New(Object::Handle(type_class.raw()),
                     no_type_arguments,
                     Scanner::kDummyTokenIndex);
   type.set_is_finalized();
   type ^= type.Canonicalize();
@@ skipping 229 matching lines @@
 }
 
 
 bool TypeParameter::Equals(const AbstractType& other) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsTypeParameter()) {
     return false;
   }
-  TypeParameter& other_type_parameter = TypeParameter::Handle();
-  other_type_parameter ^= other.raw();
-  return Index() == other_type_parameter.Index();
+  TypeParameter& other_type_param = TypeParameter::Handle();
+  other_type_param ^= other.raw();
+  if (Index() != other_type_param.Index()) {
+    return false;
+  }
+  const String& name = String::Handle(Name());
+  const String& other_type_param_name = String::Handle(other_type_param.Name());
+  return name.Equals(other_type_param_name);
 }
 
 
 void TypeParameter::set_index(intptr_t value) const {
   ASSERT(value >= 0);
   raw_ptr()->index_ = value;
 }
 
 
 void TypeParameter::set_name(const String& value) const {
@@ skipping 150 matching lines @@
 
 
 bool AbstractTypeArguments::IsUninstantiatedIdentity() const {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
 bool AbstractTypeArguments::Equals(const AbstractTypeArguments& other) const {
+  ASSERT(!IsNull());  // Use AbstractTypeArguments::AreEqual().
   if (this->raw() == other.raw()) {
     return true;
   }
+  if (other.IsNull()) {
+    return false;
+  }
   intptr_t num_types = Length();
   if (num_types != other.Length()) {
     return false;
   }
   AbstractType& type = AbstractType::Handle();
   AbstractType& other_type = AbstractType::Handle();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     other_type = other.TypeAt(i);
     if (!type.Equals(other_type)) {
@@ skipping 867 matching lines @@
   const String& kRParen = String::Handle(String::NewSymbol(") => "));
   const String& kLBracket = String::Handle(String::NewSymbol("["));
   const String& kRBracket = String::Handle(String::NewSymbol("]"));
   if (!instantiate && !is_static()) {
     const String& kSpaceExtendsSpace =
         String::Handle(String::NewSymbol(" extends "));
     const String& kLAngleBracket = String::Handle(String::NewSymbol("<"));
     const String& kRAngleBracket = String::Handle(String::NewSymbol(">"));
     const Class& function_class = Class::Handle(owner());
     ASSERT(!function_class.IsNull());
-    const Array& type_parameters = Array::Handle(
+    const TypeArguments& type_parameters = TypeArguments::Handle(
         function_class.type_parameters());
     if (!type_parameters.IsNull()) {
       intptr_t num_type_parameters = type_parameters.Length();
       pieces.Add(&kLAngleBracket);
-      const TypeArguments& type_parameter_extends = TypeArguments::Handle(
-          function_class.type_parameter_extends());
-      AbstractType& parameter_extends = AbstractType::Handle();
+      const TypeArguments& bounds = TypeArguments::Handle(
+          function_class.type_parameter_bounds());
+      AbstractType& type_parameter = AbstractType::Handle();
+      AbstractType& bound = AbstractType::Handle();
       for (intptr_t i = 0; i < num_type_parameters; i++) {
-        String& type_parameter = String::ZoneHandle();
-        type_parameter ^= type_parameters.At(i);
-        pieces.Add(&type_parameter);
-        parameter_extends = type_parameter_extends.TypeAt(i);
-        if (!parameter_extends.IsNull() && !parameter_extends.IsDynamicType()) {
+        type_parameter ^= type_parameters.TypeAt(i);
+        pieces.Add(&String::ZoneHandle(type_parameter.Name()));
+        bound = bounds.TypeAt(i);
+        if (!bound.IsNull() && !bound.IsDynamicType()) {
           pieces.Add(&kSpaceExtendsSpace);
-          pieces.Add(&String::ZoneHandle(parameter_extends.Name()));
+          pieces.Add(&String::ZoneHandle(bound.Name()));
         }
         if (i < num_type_parameters - 1) {
           pieces.Add(&kCommaSpace);
         }
       }
       pieces.Add(&kRAngleBracket);
     }
   }
   AbstractType& param_type = AbstractType::Handle();
   const intptr_t num_params = NumberOfParameters();
@@ skipping 4463 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart