Use null type argument vector instead of vector of Dynamic for a generic raw

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 1100 matching lines @@
   ASSERT(!type_name.IsNull());
   const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
   if (!type_params.IsNull()) {
     intptr_t num_type_params = type_params.Length();
     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.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);
+        intptr_t index = type_param.Index();
+        // Create a non-finalized new TypeParameter with the given token_index.
+        if (type_param.IsFinalized()) {
+          // The index was adjusted during finalization. Revert.
+          index -= NumTypeArguments() - num_type_params;
+        } else {
+          ASSERT(type_param.Index() == i);
+        }
+        return TypeParameter::New(*this, index, type_name, token_index);
       }
     }
   }
   return TypeParameter::null();
 }
 
 
 void Class::CalculateFieldOffsets() const {
   Array& flds = Array::Handle(fields());
   const Class& super = Class::Handle(SuperClass());
@@ skipping 362 matching lines @@
   if (raw() == other.raw()) {
     const intptr_t len = NumTypeArguments();
     if (len == 0) {
       return true;
     }
     // Since we do not truncate the type argument vector of a subclass (see
     // below), we only check a prefix of the proper length.
     // Check for covariance.
     if (type_arguments.IsNull() ||
         other_type_arguments.IsNull() ||
-        type_arguments.IsDynamicTypes(len) ||
-        other_type_arguments.IsDynamicTypes(len)) {
+        type_arguments.IsRawInstantiatedRaw(len) ||
+        other_type_arguments.IsRawInstantiatedRaw(len)) {
       return true;
     }
     return type_arguments.IsSubtypeOf(other_type_arguments,
                                       len,
                                       malformed_error);
   }
   // Check for two function types.
   if (IsSignatureClass() && other.IsSignatureClass()) {
     const Function& fun = Function::Handle(signature_function());
     const Function& other_fun = Function::Handle(other.signature_function());
@@ skipping 504 matching lines @@
   String& class_name = String::Handle();
   intptr_t first_type_param_index;
   intptr_t num_type_params;  // Number of type parameters to print.
   if (HasResolvedTypeClass()) {
     const Class& cls = Class::Handle(type_class());
     class_name = cls.Name();
     num_type_params = cls.NumTypeParameters();  // Do not print the full vector.
     if (num_type_params > num_args) {
       first_type_param_index = 0;
       if (!IsFinalized() || IsBeingFinalized()) {
-        // Most probably an illformed type. Do not fill up with "Dynamic".
+        // Most probably an illformed type. Do not fill up with "Dynamic",
+        // but use actual vector.
         num_type_params = num_args;
       } else {
         ASSERT(num_args == 0);  // Type is raw.
-        // We fill up with "Dynamic".
+        // No need to fill up with "Dynamic".
+        num_type_params = 0;
       }
     } else {
       first_type_param_index = num_args - num_type_params;
     }
     if (cls.IsSignatureClass()) {
       // We may be reporting an error about an illformed function type. In that
       // case, avoid instantiating the signature, since it may lead to cycles.
       if (!IsFinalized() || IsBeingFinalized()) {
         return class_name.raw();
       }
       const Function& signature_function = Function::Handle(
           cls.signature_function());
       // Signature classes have no super type.
       ASSERT(first_type_param_index == 0);
       return signature_function.InstantiatedSignatureFrom(args);
     }
   } else {
     const UnresolvedClass& cls = UnresolvedClass::Handle(unresolved_class());
     class_name = cls.Name();
     num_type_params = num_args;
     first_type_param_index = 0;
   }
   String& type_name = String::Handle();
   if (num_type_params == 0) {
     type_name = class_name.raw();
   } else {
-    const intptr_t num_strings = 2*num_type_params + 2;  // "C""<""T"", ""T"">".
-    const Array& strings = Array::Handle(Array::New(num_strings));
-    intptr_t s = 0;
-    strings.SetAt(s++, class_name);
-    strings.SetAt(s++, String::Handle(String::NewSymbol("<")));
-    const String& kCommaSpace = String::Handle(String::NewSymbol(", "));
-    AbstractType& type = AbstractType::Handle();
-    for (intptr_t i = 0; i < num_type_params; i++) {
-      if (first_type_param_index + i >= num_args) {
-        type = Type::DynamicType();
-      } else {
-        type = args.TypeAt(first_type_param_index + i);
-      }
-      type_name = type.Name();
-      strings.SetAt(s++, type_name);
-      if (i < num_type_params - 1) {
-        strings.SetAt(s++, kCommaSpace);
-      }
-    }
-    strings.SetAt(s++, String::Handle(String::NewSymbol(">")));
-    ASSERT(s == num_strings);
-    type_name = String::ConcatAll(strings);
+    const String& args_name = String::Handle(
+        args.SubvectorName(first_type_param_index, num_type_params));
+    type_name = String::Concat(class_name, args_name);
   }
   // The name is only used for type checking and debugging purposes.
   // Unless profiling data shows otherwise, it is not worth caching the name in
   // the type.
   return String::NewSymbol(type_name);
 }
 
 
 intptr_t AbstractType::Index() const {
   // AbstractType is an abstract class.
@@ skipping 52 matching lines @@
       (type_class() == Type::Handle(Type::ListInterface()).type_class());
 }
 
 
 bool AbstractType::IsSubtypeOf(const AbstractType& other,
                                Error* malformed_error) const {
   ASSERT(IsFinalized());
   ASSERT(other.IsFinalized());
   // AbstractType parameters cannot be handled by Class::IsSubtypeOf().
   if (IsTypeParameter() || other.IsTypeParameter()) {
-    return IsTypeParameter() && other.IsTypeParameter() &&
-        (Index() == other.Index());
+    // An uninstantiated type parameter is equivalent to Dynamic.
+    return true;
   }
   const Class& cls = Class::Handle(type_class());
   return cls.IsSubtypeOf(AbstractTypeArguments::Handle(arguments()),
                          Class::Handle(other.type_class()),
                          AbstractTypeArguments::Handle(other.arguments()),
                          malformed_error);
 }
 
-RawAbstractType* AbstractType::NewTypeParameter(
-    intptr_t index, const String& name, intptr_t token_index) {
-  return TypeParameter::New(index, name, token_index);
+RawAbstractType* AbstractType::NewTypeParameter(const Class& clazz,
+                                                intptr_t index,
+                                                const String& name,
+                                                intptr_t token_index) {
+  return TypeParameter::New(clazz, index, name, token_index);
 }
 
 
 RawAbstractType* AbstractType::NewInstantiatedType(
     const AbstractType& uninstantiated_type,
     const AbstractTypeArguments& instantiator_type_arguments) {
   return InstantiatedType::New(uninstantiated_type,
                                instantiator_type_arguments);
 }
 
@@ skipping 308 matching lines @@
     }
   } else {
     return "Unresolved Type";
   }
 }
 
 
 void TypeParameter::set_is_finalized() const {
   ASSERT(!IsFinalized());
   set_type_state(RawTypeParameter::kFinalized);
+  // Field parameterized_class_ is not needed after finalization anymore.
+  set_parameterized_class(Class::Handle());
 }
 
 
 bool TypeParameter::Equals(const AbstractType& other) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsTypeParameter()) {
     return false;
   }
   TypeParameter& other_type_param = TypeParameter::Handle();
   other_type_param ^= other.raw();
+  if (IsFinalized() != other_type_param.IsFinalized()) {
+    return false;
+  }
+  if (parameterized_class() != other_type_param.parameterized_class()) {
+    return false;
+  }
   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_parameterized_class(const Class& value) const {
+  // Set value may be null.
+  StorePointer(&raw_ptr()->parameterized_class_, value.raw());
+}
+
+
 void TypeParameter::set_index(intptr_t value) const {
   ASSERT(value >= 0);
   raw_ptr()->index_ = value;
 }
 
 
 void TypeParameter::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
@@ skipping 12 matching lines @@
 RawTypeParameter* TypeParameter::New() {
   const Class& type_parameter_class =
       Class::Handle(Object::type_parameter_class());
   RawObject* raw = Object::Allocate(type_parameter_class,
                                     TypeParameter::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawTypeParameter*>(raw);
 }
 
 
-RawTypeParameter* TypeParameter::New(
-    intptr_t index, const String& name, intptr_t token_index) {
+RawTypeParameter* TypeParameter::New(const Class& parameterized_class,
+                                     intptr_t index,
+                                     const String& name,
+                                     intptr_t token_index) {
   const TypeParameter& result = TypeParameter::Handle(TypeParameter::New());
+  result.set_parameterized_class(parameterized_class);
   result.set_index(index);
   result.set_name(name);
   result.set_token_index(token_index);
   result.raw_ptr()->type_state_ = RawTypeParameter::kAllocated;
   return result.raw();
 }
 
 
 void TypeParameter::set_token_index(intptr_t token_index) const {
   ASSERT(token_index >= 0);
@@ skipping 111 matching lines @@
 }
 
 
 bool AbstractTypeArguments::IsUninstantiatedIdentity() const {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
+RawString* AbstractTypeArguments::SubvectorName(intptr_t from_index,
+                                                intptr_t len) const {
+  ASSERT(from_index + len <= Length());
+  String& name = String::Handle();
+  const intptr_t num_strings = 2*len + 1;  // "<""T"", ""T"">".
+  const Array& strings = Array::Handle(Array::New(num_strings));
+  intptr_t s = 0;
+  strings.SetAt(s++, String::Handle(String::NewSymbol("<")));
+  const String& kCommaSpace = String::Handle(String::NewSymbol(", "));
+  AbstractType& type = AbstractType::Handle();
+  for (intptr_t i = 0; i < len; i++) {
+    type = TypeAt(from_index + i);
+    name = type.Name();
+    strings.SetAt(s++, name);
+    if (i < len - 1) {
+      strings.SetAt(s++, kCommaSpace);
+    }
+  }
+  strings.SetAt(s++, String::Handle(String::NewSymbol(">")));
+  ASSERT(s == num_strings);
+  name = String::ConcatAll(strings);
+  return String::NewSymbol(name);
+}
+
+
 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()) {
@@ skipping 12 matching lines @@
 }
 
 
 bool AbstractTypeArguments::AreEqual(
     const AbstractTypeArguments& arguments,
     const AbstractTypeArguments& other_arguments) {
   if (arguments.raw() == other_arguments.raw()) {
     return true;
   }
   if (arguments.IsNull()) {
-    return other_arguments.IsDynamicTypes(other_arguments.Length());
+    return other_arguments.IsDynamicTypes(false, other_arguments.Length());
   }
   if (other_arguments.IsNull()) {
-    return arguments.IsDynamicTypes(arguments.Length());
+    return arguments.IsDynamicTypes(false, arguments.Length());
   }
   return arguments.Equals(other_arguments);
 }
 
 
 RawAbstractTypeArguments* AbstractTypeArguments::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments) const {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
-bool AbstractTypeArguments::IsDynamicTypes(intptr_t len) const {
+bool AbstractTypeArguments::IsDynamicTypes(bool raw_instantiated,
+                                           intptr_t len) const {
   ASSERT(Length() >= len);
   AbstractType& type = AbstractType::Handle();
   Class& type_class = Class::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(i);
     ASSERT(!type.IsNull());
     if (!type.HasResolvedTypeClass()) {
-      ASSERT(type.IsTypeParameter() || type.IsMalformed());
+      if (raw_instantiated && type.IsTypeParameter()) {
+        // An uninstantiated type parameter is equivalent to Dynamic.
+        continue;
+      }
+      ASSERT((!raw_instantiated && type.IsTypeParameter()) ||
+             type.IsMalformed());
       return false;
     }
     type_class = type.type_class();
     if (!type_class.IsDynamicClass()) {
       return false;
     }
   }
   return true;
 }
 
@@ skipping 57 matching lines @@
                                           "type argument '%s' does not "
                                           "extend bound '%s' of '%s'\n",
                                           type_argument_name.ToCString(),
                                           bound_name.ToCString(),
                                           class_name.ToCString());
         }
         return false;
       }
     }
   }
-  const Type& super_type = Type::Handle(cls.super_type());
-  if (!super_type.IsNull()) {
-    ASSERT(super_type.IsFinalized());
-    const Class& super_class = Class::Handle(super_type.type_class());
-    if (!IsWithinBoundsOf(super_class, bounds_instantiator, malformed_error)) {
-      return false;
-    }
+  const Class& super_class = Class::Handle(cls.SuperClass());
+  if (!super_class.IsNull() &&
+      !IsWithinBoundsOf(super_class, bounds_instantiator, malformed_error)) {
+    return false;
   }
   return true;
 }
 
 
 bool AbstractTypeArguments::IsSubtypeOf(
     const AbstractTypeArguments& other,
     intptr_t len,
     Error* malformed_error) const {
   ASSERT(Length() >= len);
@@ skipping 100 matching lines @@
     type = TypeAt(i);
     if (!type.IsInstantiated()) {
       type = type.InstantiateFrom(instantiator_type_arguments);
     }
     instantiated_array.SetTypeAt(i, type);
   }
   return instantiated_array.raw();
 }
 
 
+bool TypeArguments::AreIdenticalTypeParameters(
+    const TypeArguments& arguments,
+    const TypeArguments& other_arguments) {
+  if (arguments.raw() == other_arguments.raw()) {
+    return true;
+  }
+  if (arguments.IsNull() || other_arguments.IsNull()) {
+    return false;
+  }
+  intptr_t num_types = arguments.Length();
+  if (num_types != other_arguments.Length()) {
+    return false;
+  }
+  TypeParameter& type = TypeParameter::Handle();
+  TypeParameter& other_type = TypeParameter::Handle();
+  String& name = String::Handle();
+  String& other_name = String::Handle();
+  for (intptr_t i = 0; i < num_types; i++) {
+    type ^= arguments.TypeAt(i);
+    other_type ^= other_arguments.TypeAt(i);
+    if (type.raw() == other_type.raw()) {
+      continue;
+    }
+    // Both type parameters may have different type_class and their index may be
+    // different after finalization, which is OK. Do not check.
+    name = type.Name();
+    other_name = other_type.Name();
+    if (!name.Equals(other_name)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+
 RawTypeArguments* TypeArguments::New(intptr_t len) {
   if ((len < 0) || (len > kMaxTypes)) {
     // TODO(iposva): Should we throw an illegal parameter exception?
     UNIMPLEMENTED();
     return null();
   }
 
   const Class& type_arguments_class =
       Class::Handle(Object::type_arguments_class());
   TypeArguments& result = TypeArguments::Handle();
@@ skipping 79 matching lines @@
 }
 
 
 RawAbstractType* InstantiatedTypeArguments::TypeAt(intptr_t index) const {
   const AbstractType& type = AbstractType::Handle(
       AbstractTypeArguments::Handle(
           uninstantiated_type_arguments()).TypeAt(index));
   if (type.IsTypeParameter()) {
     AbstractTypeArguments& instantiator =
         AbstractTypeArguments::Handle(instantiator_type_arguments());
+    if (instantiator.IsNull()) {
+      return Type::DynamicType();
+    }
     return instantiator.TypeAt(type.Index());
   }
   if (!type.IsInstantiated()) {
     return InstantiatedType::New(
         type, AbstractTypeArguments::Handle(instantiator_type_arguments()));
   }
   return type.raw();
 }
 
 
@@ skipping 3332 matching lines @@
            (type_arguments.Length() == num_type_arguments) ||
            (cls.IsSignatureClass() &&
             (type_arguments.Length() > num_type_arguments)));
   }
   Class& other_class = Class::Handle();
   AbstractTypeArguments& other_type_arguments = AbstractTypeArguments::Handle();
   // In case 'other' is not instantiated, we could simply call
   // other.InstantiateFrom(other_instantiator), however, we can save the
   // allocation of a new AbstractType by inlining the code.
   if (other.IsTypeParameter()) {
-    AbstractType& instantiated_other = AbstractType::Handle();
-    if (!other_instantiator.IsNull()) {
-      instantiated_other = other_instantiator.TypeAt(other.Index());
-      ASSERT(instantiated_other.IsInstantiated());
-    } else {
-      instantiated_other = Type::DynamicType();
+    if (other_instantiator.IsNull()) {
+      // An uninstantiated type parameter is equivalent to Dynamic.
+      return true;
+    }
+    AbstractType& instantiated_other = AbstractType::Handle(
+        other_instantiator.TypeAt(other.Index()));
+    if (instantiated_other.IsDynamicType() ||
+        instantiated_other.IsTypeParameter()) {
+      return true;
     }
     other_class = instantiated_other.type_class();
     other_type_arguments = instantiated_other.arguments();
   } else {
     other_class = other.type_class();
     other_type_arguments = other.arguments();
     if (!other_type_arguments.IsNull() &&
         !other_type_arguments.IsInstantiated()) {
       other_type_arguments =
           other_type_arguments.InstantiateFrom(other_instantiator);
@@ skipping 2555 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