Gentle start with removing explicit interfaces

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 734 matching lines @@
   cls = Class::New<ExternalFloat64Array>();
   object_store->set_external_float64_array_class(cls);
   name = Symbols::_ExternalFloat64Array();
   RegisterPrivateClass(cls, name, core_lib);
 
   // Set the super type of class Stacktrace to Object type so that the
   // 'toString' method is implemented.
   cls = object_store->stacktrace_class();
   cls.set_super_type(type);
 
-  cls = CreateAndRegisterInterface("Function", script, core_lib);
+  name = Symbols::Function();
+  cls = Class::New(name, script, Scanner::kDummyTokenIndex);
+  core_lib.AddClass(cls);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
-  object_store->set_function_interface(type);
+  object_store->set_function_type(type);
 
-  cls = CreateAndRegisterInterface("num", script, core_lib);
+  name = Symbols::New("num");

[siva, 2012/08/21 21:22:06]

why not make "num" also a predefined symbol in the vm isolate.

This is going to generate a new class id for num, don't you want to use
kNumberCid for this?

[hausner, 2012/08/23 00:25:06]

Done.

+  cls = Class::New(name, script, Scanner::kDummyTokenIndex);
+  core_lib.AddClass(cls);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
-  object_store->set_number_interface(type);
+  object_store->set_number_type(type);
 
   cls = CreateAndRegisterInterface("int", script, core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_int_interface(type);
 
   cls = CreateAndRegisterInterface("double", script, core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_double_interface(type);
@@ skipping 956 matching lines @@
   const Array& empty_array = Array::Handle(Object::empty_array());
   ASSERT(!super_type.IsNull());
   result.set_super_type(super_type);
   result.set_signature_function(signature_function);
   result.set_type_parameters(type_parameters);
   result.SetFields(empty_array);
   result.SetFunctions(empty_array);
   result.set_type_arguments_instance_field_offset(
       Closure::type_arguments_offset());
   // Implements interface "Function".
-  const Type& function_interface = Type::Handle(Type::FunctionInterface());
+  const Type& function_type = Type::Handle(Type::Function());
   const Array& interfaces = Array::Handle(Array::New(1, Heap::kOld));
-  interfaces.SetAt(0, function_interface);
+  interfaces.SetAt(0, function_type);
   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.
   if (signature_function.signature_class() == Object::null()) {
     signature_function.set_signature_class(result);
     result.set_is_finalized();
   } else {
     // This new signature class is an alias.
     ASSERT(!result.IsCanonicalSignatureClass());
@@ skipping 809 matching lines @@
       (type_class() == Type::Handle(Type::IntInterface()).type_class());
 }
 
 
 bool AbstractType::IsDoubleInterface() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::DoubleInterface()).type_class());
 }
 
 
-bool AbstractType::IsNumberInterface() const {
+bool AbstractType::IsNumber() const {
   return HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::NumberInterface()).type_class());
+      (type_class() == Type::Handle(Type::Number()).type_class());
 }
 
 
 bool AbstractType::IsStringInterface() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::StringInterface()).type_class());
 }
 
 
-bool AbstractType::IsFunctionInterface() const {
+bool AbstractType::IsFunction() const {
   return HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::FunctionInterface()).type_class());
+      (type_class() == Type::Handle(Type::Function()).type_class());
 }
 
 
 bool AbstractType::IsListInterface() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::ListInterface()).type_class());
 }
 
 
 bool AbstractType::TypeTest(TypeTestKind test_kind,
@@ skipping 95 matching lines @@
 RawType* Type::IntInterface() {
   return Isolate::Current()->object_store()->int_interface();
 }
 
 
 RawType* Type::DoubleInterface() {
   return Isolate::Current()->object_store()->double_interface();
 }
 
 
-RawType* Type::NumberInterface() {
-  return Isolate::Current()->object_store()->number_interface();
+RawType* Type::Number() {
+  return Isolate::Current()->object_store()->number_type();
 }
 
 
 RawType* Type::StringInterface() {
   return Isolate::Current()->object_store()->string_interface();
 }
 
 
-RawType* Type::FunctionInterface() {
-  return Isolate::Current()->object_store()->function_interface();
+RawType* Type::Function() {
+  return Isolate::Current()->object_store()->function_type();
 }
 
 
 RawType* Type::ListInterface() {
   return Isolate::Current()->object_store()->list_interface();
 }
 
 
 RawType* Type::NewNonParameterizedType(
     const Class& type_class) {
@@ skipping 8417 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "WeakProperty";
 }
 
 }  // namespace dart