runtime/vm/object.cc - Issue 10800002: Hide names of internal classes from the user by mapping them to the documented

Unified Diff: runtime/vm/object.cc

Issue 10800002: Hide names of internal classes from the user by mapping them to the documented (Closed) Base URL: http://dart.googlecode.com/svn/branches/bleeding_edge/dart/

Patch Set: Created 8 years, 5 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: runtime/vm/object.cc

===================================================================

--- runtime/vm/object.cc (revision 9728)

+++ runtime/vm/object.cc (working copy)

@@ -430,10 +430,14 @@

void Object::RegisterClass(const Class& cls,

const char* cname,

+ const char* user_visible_cname,

const Script& script,

const Library& lib) {

const String& name = String::Handle(String::NewSymbol(cname));

cls.set_name(name);

+ const String& user_visible_name =

+ String::Handle(String::NewSymbol(user_visible_cname));

+ cls.set_user_visible_name(user_visible_name);

cls.set_script(script);

lib.AddClass(cls);

}

@@ -441,12 +445,16 @@

void Object::RegisterPrivateClass(const Class& cls,

const char* public_class_name,

+ const char* user_visible_cname,

const Script& script,

const Library& lib) {

String& str = String::Handle();

str = String::NewSymbol(public_class_name);

str = lib.PrivateName(str);

cls.set_name(str);

+ const String& user_visible_name =

+ String::Handle(String::NewSymbol(user_visible_cname));

+ cls.set_user_visible_name(user_visible_name);

cls.set_script(script);

lib.AddClass(cls);

}

@@ -525,84 +533,94 @@

// remaining classes and register them by name in the dictionaries.

const Script& impl_script = Script::Handle(Bootstrap::LoadImplScript());

+ cls = Class::New<Integer>();

+ object_store->set_integer_implementation_class(cls);

+ RegisterClass(cls, "IntegerImplementation", "int",

+ impl_script, core_impl_lib);

+ pending_classes.Add(cls, Heap::kOld);

cls = Class::New<Smi>();

object_store->set_smi_class(cls);

- RegisterClass(cls, "Smi", impl_script, core_impl_lib);

+ RegisterClass(cls, "Smi", "int", impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

cls = Class::New<Mint>();

object_store->set_mint_class(cls);

- RegisterClass(cls, "Mint", impl_script, core_impl_lib);

+ RegisterClass(cls, "Mint", "int", impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

cls = Class::New<Bigint>();

object_store->set_bigint_class(cls);

- RegisterClass(cls, "Bigint", impl_script, core_impl_lib);

+ RegisterClass(cls, "Bigint", "int", impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

cls = Class::New<Double>();

object_store->set_double_class(cls);

- RegisterClass(cls, "Double", impl_script, core_impl_lib);

+ RegisterClass(cls, "Double", "double", impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

cls = Class::New<Bool>();

object_store->set_bool_class(cls);

- RegisterClass(cls, "Bool", impl_script, core_impl_lib);

+ RegisterClass(cls, "Bool", "bool", impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

cls = object_store->array_class(); // Was allocated above.

- RegisterClass(cls, "ObjectArray", impl_script, core_impl_lib);

+ RegisterClass(cls, "ObjectArray", "List", impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

cls = object_store->growable_object_array_class(); // Was allocated above.

- RegisterClass(cls, "GrowableObjectArray", impl_script, core_impl_lib);

+ RegisterClass(cls, "GrowableObjectArray", "List", impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

cls = Class::New<ImmutableArray>();

object_store->set_immutable_array_class(cls);

cls.set_type_arguments_instance_field_offset(Array::type_arguments_offset());

ASSERT(object_store->immutable_array_class() != object_store->array_class());

- RegisterClass(cls, "ImmutableArray", impl_script, core_impl_lib);

+ RegisterClass(cls, "ImmutableArray", "List", impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

cls = object_store->one_byte_string_class(); // Was allocated above.

- RegisterClass(cls, "OneByteString", impl_script, core_impl_lib);

+ RegisterClass(cls, "OneByteString", "String", impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

cls = Class::New<TwoByteString>();

object_store->set_two_byte_string_class(cls);

- RegisterClass(cls, "TwoByteString", impl_script, core_impl_lib);

+ RegisterClass(cls, "TwoByteString", "String", impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

cls = Class::New<FourByteString>();

object_store->set_four_byte_string_class(cls);

- RegisterClass(cls, "FourByteString", impl_script, core_impl_lib);

+ RegisterClass(cls, "FourByteString", "String", impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

cls = Class::New<ExternalOneByteString>();

object_store->set_external_one_byte_string_class(cls);

- RegisterClass(cls, "ExternalOneByteString", impl_script, core_impl_lib);

+ RegisterClass(cls, "ExternalOneByteString", "String",

+ impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

cls = Class::New<ExternalTwoByteString>();

object_store->set_external_two_byte_string_class(cls);

- RegisterClass(cls, "ExternalTwoByteString", impl_script, core_impl_lib);

+ RegisterClass(cls, "ExternalTwoByteString", "String",

+ impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

cls = Class::New<ExternalFourByteString>();

object_store->set_external_four_byte_string_class(cls);

- RegisterClass(cls, "ExternalFourByteString", impl_script, core_impl_lib);

+ RegisterClass(cls, "ExternalFourByteString", "String",

+ impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

cls = Class::New<Stacktrace>();

object_store->set_stacktrace_class(cls);

- RegisterClass(cls, "Stacktrace", impl_script, core_impl_lib);

+ RegisterClass(cls, "Stacktrace", "Stacktrace", impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

// Super type set below, after Object is allocated.

cls = Class::New<JSRegExp>();

object_store->set_jsregexp_class(cls);

- RegisterClass(cls, "JSSyntaxRegExp", impl_script, core_impl_lib);

+ RegisterClass(cls, "JSSyntaxRegExp", "JSSyntaxRegExp",

+ impl_script, core_impl_lib);

pending_classes.Add(cls, Heap::kOld);

// Initialize the base interfaces used by the core VM classes.

@@ -614,6 +632,7 @@

cls = Class::New<Instance>();

object_store->set_object_class(cls);

cls.set_name(String::Handle(String::NewSymbol("Object")));

+ cls.set_user_visible_name(String::Handle(String::NewSymbol("Object")));

cls.set_script(script);

cls.set_is_prefinalized();

core_lib.AddClass(cls);

@@ -623,83 +642,92 @@

cls = Class::New<Int8Array>();

object_store->set_int8_array_class(cls);

- RegisterPrivateClass(cls, "_Int8Array", script, core_lib);

+ RegisterPrivateClass(cls, "_Int8Array", "Int8List", script, core_lib);

cls = Class::New<Uint8Array>();

object_store->set_uint8_array_class(cls);

- RegisterPrivateClass(cls, "_Uint8Array", script, core_lib);

+ RegisterPrivateClass(cls, "_Uint8Array", "Uint8List", script, core_lib);

cls = Class::New<Int16Array>();

object_store->set_int16_array_class(cls);

- RegisterPrivateClass(cls, "_Int16Array", script, core_lib);

+ RegisterPrivateClass(cls, "_Int16Array", "Int16List", script, core_lib);

cls = Class::New<Uint16Array>();

object_store->set_uint16_array_class(cls);

- RegisterPrivateClass(cls, "_Uint16Array", script, core_lib);

+ RegisterPrivateClass(cls, "_Uint16Array", "Uint16List", script, core_lib);

cls = Class::New<Int32Array>();

object_store->set_int32_array_class(cls);

- RegisterPrivateClass(cls, "_Int32Array", script, core_lib);

+ RegisterPrivateClass(cls, "_Int32Array", "Int32List", script, core_lib);

cls = Class::New<Uint32Array>();

object_store->set_uint32_array_class(cls);

- RegisterPrivateClass(cls, "_Uint32Array", script, core_lib);

+ RegisterPrivateClass(cls, "_Uint32Array", "Uint32List", script, core_lib);

cls = Class::New<Int64Array>();

object_store->set_int64_array_class(cls);

- RegisterPrivateClass(cls, "_Int64Array", script, core_lib);

+ RegisterPrivateClass(cls, "_Int64Array", "Int64List", script, core_lib);

cls = Class::New<Uint64Array>();

object_store->set_uint64_array_class(cls);

- RegisterPrivateClass(cls, "_Uint64Array", script, core_lib);

+ RegisterPrivateClass(cls, "_Uint64Array", "Uint64List", script, core_lib);

cls = Class::New<Float32Array>();

object_store->set_float32_array_class(cls);

- RegisterPrivateClass(cls, "_Float32Array", script, core_lib);

+ RegisterPrivateClass(cls, "_Float32Array", "Float32List", script, core_lib);

cls = Class::New<Float64Array>();

object_store->set_float64_array_class(cls);

- RegisterPrivateClass(cls, "_Float64Array", script, core_lib);

+ RegisterPrivateClass(cls, "_Float64Array", "Float64List", script, core_lib);

cls = Class::New<ExternalInt8Array>();

object_store->set_external_int8_array_class(cls);

- RegisterPrivateClass(cls, "_ExternalInt8Array", script, core_lib);

+ RegisterPrivateClass(cls, "_ExternalInt8Array", "Int8List", script, core_lib);

cls = Class::New<ExternalUint8Array>();

object_store->set_external_uint8_array_class(cls);

- RegisterPrivateClass(cls, "_ExternalUint8Array", script, core_lib);

+ RegisterPrivateClass(cls, "_ExternalUint8Array", "Uint8List",

+ script, core_lib);

cls = Class::New<ExternalInt16Array>();

object_store->set_external_int16_array_class(cls);

- RegisterPrivateClass(cls, "_ExternalInt16Array", script, core_lib);

+ RegisterPrivateClass(cls, "_ExternalInt16Array", "Int16List",

+ script, core_lib);

cls = Class::New<ExternalUint16Array>();

object_store->set_external_uint16_array_class(cls);

- RegisterPrivateClass(cls, "_ExternalUint16Array", script, core_lib);

+ RegisterPrivateClass(cls, "_ExternalUint16Array", "Uint16List",

+ script, core_lib);

cls = Class::New<ExternalInt32Array>();

object_store->set_external_int32_array_class(cls);

- RegisterPrivateClass(cls, "_ExternalInt32Array", script, core_lib);

+ RegisterPrivateClass(cls, "_ExternalInt32Array", "Int32List",

+ script, core_lib);

cls = Class::New<ExternalUint32Array>();

object_store->set_external_uint32_array_class(cls);

- RegisterPrivateClass(cls, "_ExternalUint32Array", script, core_lib);

+ RegisterPrivateClass(cls, "_ExternalUint32Array", "Uint32List",

+ script, core_lib);

cls = Class::New<ExternalInt64Array>();

object_store->set_external_int64_array_class(cls);

- RegisterPrivateClass(cls, "_ExternalInt64Array", script, core_lib);

+ RegisterPrivateClass(cls, "_ExternalInt64Array", "Int64List",

+ script, core_lib);

cls = Class::New<ExternalUint64Array>();

object_store->set_external_uint64_array_class(cls);

- RegisterPrivateClass(cls, "_ExternalUint64Array", script, core_lib);

+ RegisterPrivateClass(cls, "_ExternalUint64Array", "Uint64List",

+ script, core_lib);

cls = Class::New<ExternalFloat32Array>();

object_store->set_external_float32_array_class(cls);

- RegisterPrivateClass(cls, "_ExternalFloat32Array", script, core_lib);

+ RegisterPrivateClass(cls, "_ExternalFloat32Array", "Float32List",

+ script, core_lib);

cls = Class::New<ExternalFloat64Array>();

object_store->set_external_float64_array_class(cls);

- RegisterPrivateClass(cls, "_ExternalFloat64Array", script, core_lib);

+ RegisterPrivateClass(cls, "_ExternalFloat64Array", "Float64List",

+ script, core_lib);

// Set the super type of class Stacktrace to Object type so that the

// 'toString' method is implemented.

@@ -908,6 +936,9 @@

cls = Class::New<ExternalFloat64Array>();

object_store->set_external_float64_array_class(cls);

+ cls = Class::New<Integer>();

+ object_store->set_integer_implementation_class(cls);

cls = Class::New<Smi>();

object_store->set_smi_class(cls);

@@ -1046,6 +1077,14 @@

}

+RawString* Class::UserVisibleName() const {

+ if (raw_ptr()->user_visible_name_ != String::null()) {

+ return raw_ptr()->user_visible_name_;

+ }

+ return Name();

RawType* Class::SignatureType() const {

ASSERT(IsSignatureClass());

const Function& function = Function::Handle(signature_function());

@@ -1327,7 +1366,7 @@

AbstractType& bound = AbstractType::Handle();

for (intptr_t i = 0; i < num_type_params; i++) {

type_param ^= type_params.TypeAt(i);

- type_param_name = type_param.Name();

+ type_param_name = type_param.name();

if (type_param_name.Equals(type_name)) {

intptr_t index = type_param.index();

bound = type_param.bound();

@@ -1453,6 +1492,7 @@

intptr_t token_pos) {

Class& result = Class::Handle(New<FakeInstance>(kIllegalObjectKind));

result.set_name(name);

+ result.set_user_visible_name(name);

result.set_script(script);

result.set_token_pos(token_pos);

return result.raw();

@@ -1536,6 +1576,9 @@

RawClass* Class::GetClass(ObjectKind kind) {

ObjectStore* object_store = Isolate::Current()->object_store();

switch (kind) {

+ case kInteger:

+ ASSERT(object_store->integer_implementation_class() != Class::null());

+ return object_store->integer_implementation_class();

case kSmi:

ASSERT(object_store->smi_class() != Class::null());

return object_store->smi_class();

@@ -1686,6 +1729,12 @@

}

+void Class::set_user_visible_name(const String& value) const {

+ ASSERT(value.IsSymbol());

+ StorePointer(&raw_ptr()->user_visible_name_, value.raw());

void Class::set_script(const Script& value) const {

StorePointer(&raw_ptr()->script_, value.raw());

}

@@ -2310,13 +2359,12 @@

}

-// TODO(regis): Investigate if we can safely map internal integer types (Smi,

-// Mint, and Bigint) to 'int' and internal String types (OneByteString, etc...)

-// to 'String' here. It may be too early. Also consider the upcoming type()

-// method.

-RawString* AbstractType::Name() const {

+RawString* AbstractType::BuildName(NameVisibility name_visibility) const {

+ if (IsTypeParameter()) {

+ return TypeParameter::Cast(*this).name();

+ }

// If the type is still being finalized, we may be reporting an error about

- // an illformed type, so proceed with caution.

+ // a malformed type, so proceed with caution.

const AbstractTypeArguments& args =

AbstractTypeArguments::Handle(arguments());

const intptr_t num_args = args.IsNull() ? 0 : args.Length();

@@ -2325,12 +2373,18 @@

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 (name_visibility == kInternalName) {

+ class_name = cls.Name();

+ } else {

+ ASSERT(name_visibility == kUserVisibleName);

+ // Map internal types to their corresponding public interfaces.

+ class_name = cls.UserVisibleName();

+ }

if (num_type_params > num_args) {

first_type_param_index = 0;

if (!IsFinalized() || IsBeingFinalized() || IsMalformed()) {

- // Most probably an illformed type. Do not fill up with "Dynamic",

+ // Most probably a malformed type. Do not fill up with "Dynamic",

// but use actual vector.

num_type_params = num_args;

} else {

@@ -2342,17 +2396,20 @@

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

+ // We may be reporting an error about a malformed function type. In that

// case, avoid instantiating the signature, since it may lead to cycles.

if (!IsFinalized() || IsBeingFinalized() || IsMalformed()) {

return class_name.raw();

}

- if (num_type_params > 0) {

+ // In order to avoid cycles, print the name of a typedef (non-canonical

+ // signature class) as a regular, possibly parameterized, class.

+ if (cls.IsCanonicalSignatureClass()) {

const Function& signature_function = Function::Handle(

- cls.signature_function());

+ cls.signature_function());

// Signature classes have no super type.

ASSERT(first_type_param_index == 0);

- return signature_function.InstantiatedSignatureFrom(args);

+ return signature_function.InstantiatedSignatureFrom(args,

+ name_visibility);

}

} else {

@@ -2366,7 +2423,9 @@

type_name = class_name.raw();

} else {

const String& args_name = String::Handle(

- args.SubvectorName(first_type_param_index, num_type_params));

+ args.SubvectorName(first_type_param_index,

+ num_type_params,

+ name_visibility));

type_name = String::Concat(class_name, args_name);

}

// The name is only used for type checking and debugging purposes.

@@ -2874,9 +2933,9 @@

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);

+ const String& type_param_name = String::Handle(name());

+ const String& other_type_param_name = String::Handle(other_type_param.name());

+ return type_param_name.Equals(other_type_param_name);

}

@@ -2894,9 +2953,9 @@

// Therefore, both type parameters may have different parameterized classes

// and different indices. Compare the type parameter names only, and their

// bounds if requested.

- String& name = String::Handle(Name());

- String& other_name = String::Handle(other_type_param.Name());

- if (!name.Equals(other_name)) {

+ String& type_param_name = String::Handle(name());

+ String& other_type_param_name = String::Handle(other_type_param.name());

+ if (!type_param_name.Equals(other_type_param_name)) {

return false;

}

if (check_type_parameter_bound) {

@@ -3037,8 +3096,10 @@

}

-RawString* AbstractTypeArguments::SubvectorName(intptr_t from_index,

- intptr_t len) const {

+RawString* AbstractTypeArguments::SubvectorName(

+ intptr_t from_index,

+ intptr_t len,

+ NameVisibility name_visibility) const {

ASSERT(from_index + len <= Length());

String& name = String::Handle();

const intptr_t num_strings = 2*len + 1; // "<""T"", ""T"">".

@@ -3049,7 +3110,7 @@

AbstractType& type = AbstractType::Handle();

for (intptr_t i = 0; i < len; i++) {

type = TypeAt(from_index + i);

- name = type.Name();

+ name = type.BuildName(name_visibility);

strings.SetAt(s++, name);

if (i < len - 1) {

strings.SetAt(s++, kCommaSpace);

@@ -3215,9 +3276,10 @@

// Ignore this bound error if another malformed error was already

// reported for this type test.

if (malformed_error->IsNull()) {

- const String& type_arg_name = String::Handle(this_type_arg.Name());

+ const String& type_arg_name =

+ String::Handle(this_type_arg.UserVisibleName());

const String& class_name = String::Handle(cls.Name());

- const String& bound_name = String::Handle(bound.Name());

+ const String& bound_name = String::Handle(bound.UserVisibleName());

const Script& script = Script::Handle(cls.script());

// Since the bound was canonicalized, its token index was lost,

// therefore, use the token index of the corresponding type parameter.

@@ -4124,6 +4186,7 @@

RawString* Function::BuildSignature(

bool instantiate,

+ NameVisibility name_visibility,

const AbstractTypeArguments& instantiator) const {

const GrowableObjectArray& pieces =

GrowableObjectArray::Handle(GrowableObjectArray::New());

@@ -4135,6 +4198,8 @@

const String& kRBracket = String::Handle(String::NewSymbol("]"));

String& name = String::Handle();

if (!instantiate && !is_static()) {

+ // Prefix the signature with its type parameters, if any (e.g. "<K, V>").

+ // The signature of static functions cannot be type parameterized.

const String& kSpaceExtendsSpace =

String::Handle(String::NewSymbol(" extends "));

const String& kLAngleBracket = String::Handle(String::NewSymbol("<"));

@@ -4150,12 +4215,12 @@

AbstractType& bound = AbstractType::Handle();

for (intptr_t i = 0; i < num_type_parameters; i++) {

type_parameter ^= type_parameters.TypeAt(i);

- name = type_parameter.Name();

+ name = type_parameter.name();

pieces.Add(name);

bound = type_parameter.bound();

if (!bound.IsNull() && !bound.IsDynamicType()) {

pieces.Add(kSpaceExtendsSpace);

- name = bound.Name();

+ name = bound.BuildName(name_visibility);

pieces.Add(name);

}

if (i < num_type_parameters - 1) {

@@ -4177,7 +4242,7 @@

if (instantiate && !param_type.IsInstantiated()) {

param_type = param_type.InstantiateFrom(instantiator);

}

- name = param_type.Name();

+ name = param_type.BuildName(name_visibility);

pieces.Add(name);

if (i != (num_params - 1)) {

pieces.Add(kCommaSpace);

@@ -4194,7 +4259,7 @@

param_type = param_type.InstantiateFrom(instantiator);

}

ASSERT(!param_type.IsNull());

- name = param_type.Name();

+ name = param_type.BuildName(name_visibility);

pieces.Add(name);

if (i != (num_params - 1)) {

pieces.Add(kCommaSpace);

@@ -4207,7 +4272,7 @@

if (instantiate && !res_type.IsInstantiated()) {

res_type = res_type.InstantiateFrom(instantiator);

}

- name = res_type.Name();

+ name = res_type.BuildName(name_visibility);

pieces.Add(name);

const Array& strings = Array::Handle(Array::MakeArray(pieces));

return String::NewSymbol(String::Handle(String::ConcatAll(strings)));

« no previous file with comments | « runtime/vm/object.h ('k') | runtime/vm/object_store.h » ('j') | runtime/vm/raw_object.h » ('J')