Stop postponing instantiation of Type and remove InstantiatedType VM class.

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 44 matching lines @@
 RawInstance* Object::transition_sentinel_ =
     reinterpret_cast<RawInstance*>(RAW_NULL);
 RawClass* Object::class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::null_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::dynamic_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::void_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unresolved_class_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_parameter_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
-RawClass* Object::instantiated_type_class_ =
-    reinterpret_cast<RawClass*>(RAW_NULL);
-RawClass* Object::abstract_type_arguments_class_ =
-    reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instantiated_type_arguments_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::function_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::field_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::literal_token_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::token_stream_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::script_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_prefix_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ skipping 26 matching lines @@
   } else if (raw_class == dynamic_class()) {
     return kDynamicClass;
   } else if (raw_class == void_class()) {
     return kVoidClass;
   } else if (raw_class == unresolved_class_class()) {
     return kUnresolvedClassClass;
   } else if (raw_class == type_class()) {
     return kTypeClass;
   } else if (raw_class == type_parameter_class()) {
     return kTypeParameterClass;
-  } else if (raw_class == instantiated_type_class()) {
-    return kInstantiatedTypeClass;
-  } else if (raw_class == abstract_type_arguments_class()) {
-    return kAbstractTypeArgumentsClass;
   } else if (raw_class == type_arguments_class()) {
     return kTypeArgumentsClass;
   } else if (raw_class == instantiated_type_arguments_class()) {
     return kInstantiatedTypeArgumentsClass;
   } else if (raw_class == function_class()) {
     return kFunctionClass;
   } else if (raw_class == field_class()) {
     return kFieldClass;
   } else if (raw_class == literal_token_class()) {
     return kLiteralTokenClass;
@@ skipping 40 matching lines @@
 
 RawClass* Object::GetSingletonClass(int index) {
   switch (index) {
     case kClassClass: return class_class();
     case kNullClass: return null_class();
     case kDynamicClass: return dynamic_class();
     case kVoidClass: return void_class();
     case kUnresolvedClassClass: return unresolved_class_class();
     case kTypeClass: return type_class();
     case kTypeParameterClass: return type_parameter_class();
-    case kInstantiatedTypeClass: return instantiated_type_class();
-    case kAbstractTypeArgumentsClass: return abstract_type_arguments_class();
     case kTypeArgumentsClass: return type_arguments_class();
     case kInstantiatedTypeArgumentsClass:
         return instantiated_type_arguments_class();
     case kFunctionClass: return function_class();
     case kFieldClass: return field_class();
     case kLiteralTokenClass: return literal_token_class();
     case kTokenStreamClass: return token_stream_class();
     case kScriptClass: return script_class();
     case kLibraryClass: return library_class();
     case kLibraryPrefixClass: return library_prefix_class();
@@ skipping 20 matching lines @@
 
 const char* Object::GetSingletonClassName(int index) {
   switch (index) {
     case kClassClass: return "Class";
     case kNullClass: return "Null";
     case kDynamicClass: return "Dynamic";
     case kVoidClass: return "void";
     case kUnresolvedClassClass: return "UnresolvedClass";
     case kTypeClass: return "Type";
     case kTypeParameterClass: return "TypeParameter";
-    case kInstantiatedTypeClass: return "InstantiatedType";
-    case kAbstractTypeArgumentsClass: return "AbstractTypeArguments";
     case kTypeArgumentsClass: return "TypeArguments";
     case kInstantiatedTypeArgumentsClass: return "InstantiatedTypeArguments";
     case kFunctionClass: return "Function";
     case kFieldClass: return "Field";
     case kLiteralTokenClass: return "LiteralToken";
     case kTokenStreamClass: return "TokenStream";
     case kScriptClass: return "Script";
     case kLibraryClass: return "Library";
     case kLibraryPrefixClass: return "LibraryPrefix";
     case kCodeClass: return "Code";
@@ skipping 112 matching lines @@
   cls = Class::New<Instance>(kVoidClassIndex);
   cls.set_is_finalized();
   void_class_ = cls.raw();
 
   cls = Class::New<Type>();
   type_class_ = cls.raw();
 
   cls = Class::New<TypeParameter>();
   type_parameter_class_ = cls.raw();
 
-  cls = Class::New<InstantiatedType>();
-  instantiated_type_class_ = cls.raw();
-
-  cls = Class::New<AbstractTypeArguments>();
-  abstract_type_arguments_class_ = cls.raw();
-
   cls = Class::New<TypeArguments>();
   type_arguments_class_ = cls.raw();
 
   cls = Class::New<InstantiatedTypeArguments>();
   instantiated_type_arguments_class_ = cls.raw();
 
   cls = Class::New<Function>();
   function_class_ = cls.raw();
 
   cls = Class::New<Field>();
@@ skipping 2064 matching lines @@
 }
 
 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);
-}
-
-
 const char* AbstractType::ToCString() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return "AbstractType";
 }
 
 
 RawType* Type::NullType() {
   return Isolate::Current()->object_store()->null_type();
 }
@@ skipping 178 matching lines @@
   instantiated_type.set_is_finalized_instantiated();
   return instantiated_type.raw();
 }
 
 
 bool Type::Equals(const AbstractType& other) const {
   ASSERT(IsFinalized() && other.IsFinalized());
   if (raw() == other.raw()) {
     return true;
   }
-  if (IsMalformed() || other.IsMalformed() ||
-      (!other.IsType() && !other.IsInstantiatedType())) {
+  if (IsMalformed() || !other.IsType() || other.IsMalformed()) {
     return false;
   }
   if (type_class() != other.type_class()) {
     return false;
   }
   return AbstractTypeArguments::AreEqual(
       AbstractTypeArguments::Handle(arguments()),
       AbstractTypeArguments::Handle(other.arguments()));
 }
 
@@ skipping 266 matching lines @@
   const char* format = "TypeParameter: name %s; index: %d";
   const char* name_cstr = String::Handle(Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, name_cstr, Index()) + 1;
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, format, name_cstr, Index());
   return chars;
 }
 
 
-RawClass* InstantiatedType::type_class() const {
-  return AbstractType::Handle(uninstantiated_type()).type_class();
-}
-
-
-RawAbstractTypeArguments* InstantiatedType::arguments() const {
-  return InstantiatedTypeArguments::New(
-      AbstractTypeArguments::Handle(AbstractType::Handle(
-          uninstantiated_type()).arguments()),
-      AbstractTypeArguments::Handle(instantiator_type_arguments()));
-}
-
-
-intptr_t InstantiatedType::token_index() const {
-  return AbstractType::Handle(uninstantiated_type()).token_index();
-}
-
-
-void InstantiatedType::set_uninstantiated_type(
-    const AbstractType& value) const {
-  StorePointer(&raw_ptr()->uninstantiated_type_, value.raw());
-}
-
-
-void InstantiatedType::set_instantiator_type_arguments(
-    const AbstractTypeArguments& value) const {
-  StorePointer(&raw_ptr()->instantiator_type_arguments_, value.raw());
-}
-
-
-RawInstantiatedType* InstantiatedType::New() {
-  const Class& instantiated_type_class =
-      Class::Handle(Object::instantiated_type_class());
-  RawObject* raw = Object::Allocate(instantiated_type_class,
-                                    InstantiatedType::InstanceSize(),
-                                    Heap::kOld);
-  return reinterpret_cast<RawInstantiatedType*>(raw);
-}
-
-
-RawInstantiatedType* InstantiatedType::New(
-    const AbstractType& uninstantiated_type,
-    const AbstractTypeArguments& instantiator_type_arguments) {
-  const InstantiatedType& result =
-      InstantiatedType::Handle(InstantiatedType::New());
-  result.set_uninstantiated_type(uninstantiated_type);
-  result.set_instantiator_type_arguments(instantiator_type_arguments);
-  return result.raw();
-}
-
-
-bool InstantiatedType::Equals(const AbstractType& other) const {
-  ASSERT(IsFinalized() && other.IsFinalized());
-  if (raw() == other.raw()) {
-    return true;
-  }
-  if (IsMalformed() || other.IsMalformed() ||
-      (!other.IsType() && !other.IsInstantiatedType())) {
-    return false;
-  }
-  if (type_class() != other.type_class()) {
-    return false;
-  }
-  return AbstractTypeArguments::AreEqual(
-      AbstractTypeArguments::Handle(arguments()),
-      AbstractTypeArguments::Handle(other.arguments()));
-}
-
-
-const char* InstantiatedType::ToCString() const {
-  return "InstantiatedType";
-}
-
-
 intptr_t AbstractTypeArguments::Length() const  {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return -1;
 }
 
 
 RawAbstractType* AbstractTypeArguments::TypeAt(intptr_t index) const {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
@@ skipping 437 matching lines @@
 intptr_t InstantiatedTypeArguments::Length() const {
   return AbstractTypeArguments::Handle(
       uninstantiated_type_arguments()).Length();
 }
 
 
 RawAbstractType* InstantiatedTypeArguments::TypeAt(intptr_t index) const {
   const AbstractType& type = AbstractType::Handle(
       AbstractTypeArguments::Handle(
           uninstantiated_type_arguments()).TypeAt(index));
-  if (type.IsTypeParameter()) {
-    AbstractTypeArguments& instantiator =
+  if (!type.IsInstantiated()) {
+    const AbstractTypeArguments& instantiator_type_args =
         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.InstantiateFrom(instantiator_type_args);
   }
   return type.raw();
 }
 
 
 void InstantiatedTypeArguments::SetTypeAt(intptr_t index,
                                           const AbstractType& value) const {
   // We only replace individual argument types during resolution at compile
   // time, when no type parameters are instantiated yet.
   UNREACHABLE();
@@ skipping 6501 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