Convert String and List to abstract classes.

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/bigint_operations.h"
@@ skipping 830 matching lines @@
   type = Type::NewNonParameterizedType(cls);
   object_store->set_int_type(type);
 
   name = Symbols::New("double");
   cls = Class::New<Instance>(name, script, Scanner::kDummyTokenIndex);
   RegisterClass(cls, name, core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_double_type(type);
 
-  cls = CreateAndRegisterInterface("String", script, core_lib);
+  name = Symbols::New("String");
+  cls = Class::New<Instance>(name, script, Scanner::kDummyTokenIndex);
+  RegisterClass(cls, name, core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
-  object_store->set_string_interface(type);
+  object_store->set_string_type(type);
 
-  cls = CreateAndRegisterInterface("List", script, core_lib);
+  name = Symbols::New("List");
+  cls = Class::New<Instance>(name, script, Scanner::kDummyTokenIndex);
+  RegisterClass(cls, name, core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
-  object_store->set_list_interface(type);
+  object_store->set_list_type(type);
 
   cls = CreateAndRegisterInterface("ByteArray", script, core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_byte_array_interface(type);
 
   cls = object_store->bool_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_bool_type(type);
 
@@ skipping 7472 matching lines @@
       (type_class() == Type::Handle(Type::Double()).type_class());
 }
 
 
 bool AbstractType::IsNumberType() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::Number()).type_class());
 }
 
 
-bool AbstractType::IsStringInterface() const {
+bool AbstractType::IsStringType() const {
   return HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::StringInterface()).type_class());
+      (type_class() == Type::Handle(Type::StringType()).type_class());
 }
 
 
 bool AbstractType::IsFunctionType() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::Function()).type_class());
 }
 
 
-bool AbstractType::IsListInterface() const {
+bool AbstractType::IsListType() const {
   return HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::ListInterface()).type_class());
+      (type_class() == Type::Handle(Type::ListType()).type_class());
 }
 
 
 bool AbstractType::TypeTest(TypeTestKind test_kind,
                             const AbstractType& other,
                             Error* malformed_error) const {
   ASSERT(IsFinalized());
   ASSERT(other.IsFinalized());
   // In case the type checked in a type test is malformed, the code generator
   // may compile a throw instead of a run time call performing the type check.
@@ skipping 104 matching lines @@
 RawType* Type::Double() {
   return Isolate::Current()->object_store()->double_type();
 }
 
 
 RawType* Type::Number() {
   return Isolate::Current()->object_store()->number_type();
 }
 
 
-RawType* Type::StringInterface() {
-  return Isolate::Current()->object_store()->string_interface();
+RawType* Type::StringType() {
+  return Isolate::Current()->object_store()->string_type();
 }
 
 
 RawType* Type::Function() {
   return Isolate::Current()->object_store()->function_type();
 }
 
 
-RawType* Type::ListInterface() {
-  return Isolate::Current()->object_store()->list_interface();
+RawType* Type::ListType() {
+  return Isolate::Current()->object_store()->list_type();
 }
 
 
 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);
@@ skipping 3642 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart