Hide names of internal classes from the user by mapping them to the documented

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 310 matching lines @@
 
   static int GetSingletonClassIndex(const RawClass* raw_class);
   static RawClass* GetSingletonClass(int index);
   static const char* GetSingletonClassName(int index);
 
   static RawClass* CreateAndRegisterInterface(const char* cname,
                                               const Script& script,
                                               const Library& lib);
   static void RegisterClass(const Class& cls,
                             const char* cname,
+                            const char* user_visible_cname,
                             const Script& script,
                             const Library& lib);
 
   static void RegisterPrivateClass(const Class& cls,
                                    const char* cname,
+                                   const char* user_visible_cname,
                                    const Script& script,
                                    const Library& lib);
 
   static RawError* Init(Isolate* isolate);
   static void InitFromSnapshot(Isolate* isolate);
   static void InitOnce();
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawObject));
   }
 
   static const ObjectKind kInstanceKind = kObject;
 
   // Different kinds of type tests.
   enum TypeTestKind {
     kIsSubtypeOf = 0,
     kIsMoreSpecificThan
   };
 
+  // Different kinds of name visibility.
+  enum NameVisibility {
+    kInternalName = 0,
+    kUserVisibleName
+  };
+
  protected:
   // Used for extracting the C++ vtable during bringup.
   Object() : raw_(null_) {}
 
   uword raw_value() const {
     return reinterpret_cast<uword>(raw());
   }
 
   inline void SetRaw(RawObject* value);
 
@@ skipping 116 matching lines @@
     raw_ptr()->instance_kind_ = value;
   }
 
   intptr_t id() const { return raw_ptr()->id_; }
   void set_id(intptr_t value) const {
     raw_ptr()->id_ = value;
   }
 
   RawString* Name() const;
 
+  RawString* UserVisibleName() const;
+
   RawScript* script() const { return raw_ptr()->script_; }
 
   intptr_t token_pos() const { return raw_ptr()->token_pos_; }
 
   // This class represents the signature class of a closure function if
   // signature_function() is not null.
   // The associated function may be a closure function (with code) or a
   // signature function (without code) solely describing the result type and
   // parameter types of the signature.
   RawFunction* signature_function() const {
@@ skipping 233 matching lines @@
                                      const Function& signature_function,
                                      const Script& script);
 
   // Return a class object corresponding to the specified kind. If
   // a canonicalized version of it exists then that object is returned
   // otherwise a new object is allocated and returned.
   static RawClass* GetClass(ObjectKind kind);
 
  private:
   void set_name(const String& value) const;
+  void set_user_visible_name(const String& value) const;
   void set_script(const Script& value) const;
   void set_token_pos(intptr_t value) const;
   void set_signature_function(const Function& value) const;
   void set_signature_type(const AbstractType& value) const;
   void set_class_state(int8_t state) const;
 
   void set_constants(const Array& value) const;
 
   void set_canonical_types(const Array& value) const;
   RawArray* canonical_types() const;
@@ skipping 14 matching lines @@
                                                      intptr_t token_pos);
 
   // Check the subtype or 'more specific' relationship.
   bool TypeTest(TypeTestKind test_kind,
                 const AbstractTypeArguments& type_arguments,
                 const Class& other,
                 const AbstractTypeArguments& other_type_arguments,
                 Error* malformed_error) const;
 
   HEAP_OBJECT_IMPLEMENTATION(Class, Object);
+  friend class AbstractType;
+  friend class Instance;
   friend class Object;
-  friend class Instance;
-  friend class AbstractType;
   friend class Type;
 };
 
 
 // Unresolved class is used for storing unresolved names which will be resolved
 // to a class after all classes have been loaded and finalized.
 class UnresolvedClass : public Object {
  public:
   RawLibraryPrefix* library_prefix() const {
     return raw_ptr()->library_prefix_;
@@ skipping 49 matching lines @@
 
   // Instantiate this type using the given type argument vector.
   // Return a new type, or return 'this' if it is already instantiated.
   virtual RawAbstractType* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments) const;
 
   // Return the canonical version of this type.
   virtual RawAbstractType* Canonicalize() const;
 
   // The name of this type, including the names of its type arguments, if any.
-  virtual RawString* Name() const;
+  virtual RawString* Name() const {
+    return BuildName(kInternalName);
+  }
+
+  // The name of this type, including the names of its type arguments, if any.
+  // Names of internal classes are mapped to their public interfaces.
+  virtual RawString* UserVisibleName() const {
+    return BuildName(kUserVisibleName);
+  }
 
   // The name of this type's class, i.e. without the type argument names of this
   // type.
   RawString* ClassName() const;
 
   // Check if this type represents the 'Dynamic' type.
   bool IsDynamicType() const {
     return HasResolvedTypeClass() && (type_class() == Object::dynamic_class());
   }
 
@@ skipping 52 matching lines @@
                           Error* malformed_error) const {
     return TypeTest(kIsMoreSpecificThan, other, malformed_error);
   }
 
  private:
   // Check the subtype or 'more specific' relationship.
   bool TypeTest(TypeTestKind test_kind,
                 const AbstractType& other,
                 Error* malformed_error) const;
 
+  // Return the internal or public name of this type, including the names of its
+  // type arguments, if any.
+  RawString* BuildName(NameVisibility visibility) const;
+
  protected:
   HEAP_OBJECT_IMPLEMENTATION(AbstractType, Object);
+  friend class AbstractTypeArguments;
   friend class Class;
-  friend class AbstractTypeArguments;
+  friend class Function;
 };
 
 
 // A Type consists of a class, possibly parameterized with type
 // arguments. Example: C<T1, T2>.
 // An unresolved class is a String specifying the class name.
 //
 // Caution: 'RawType*' denotes a 'raw' pointer to a VM object of class Type, as
 // opposed to 'Type' denoting a 'handle' to the same object. 'RawType' does not
 // relate to a 'raw type', as opposed to a 'cooked type' or 'rare type'.
@@ skipping 106 matching lines @@
     return raw_ptr()->type_state_ == RawTypeParameter::kFinalizedUninstantiated;
   }
   void set_is_finalized() const;
   virtual bool IsBeingFinalized() const { return false; }
   virtual bool IsMalformed() const { return false; }
   virtual bool IsResolved() const { return true; }
   virtual bool HasResolvedTypeClass() const { return false; }
   RawClass* parameterized_class() const {
       return raw_ptr()->parameterized_class_;
   }
-  virtual RawString* Name() const { return raw_ptr()->name_; }
+  RawString* name() const { return raw_ptr()->name_; }
   intptr_t index() const { return raw_ptr()->index_; }
   void set_index(intptr_t value) const;
   RawAbstractType* bound() const { return raw_ptr()->bound_; }
   void set_bound(const AbstractType& value) const;
   virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; }
   virtual bool IsInstantiated() const { return false; }
   virtual bool Equals(const AbstractType& other) const;
   virtual bool IsIdentical(const AbstractType& other,
                            bool check_type_parameter_bound) const;
   virtual RawAbstractType* InstantiateFrom(
@@ skipping 40 matching lines @@
   // Return 'this' if this type argument vector is instantiated, i.e. if it does
   // not refer to type parameters. Otherwise, return a new type argument vector
   // where each reference to a type parameter is replaced with the corresponding
   // type of the instantiator type argument vector.
   virtual RawAbstractTypeArguments* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments) const;
 
   // Do not canonicalize InstantiatedTypeArguments or NULL objects
   virtual RawAbstractTypeArguments* Canonicalize() const { return this->raw(); }
 
-  // The name of this type argument vector, e.g. "<T, Dynamic, List<T>, int>".
+  // The name of this type argument vector, e.g. "<T, Dynamic, List<T>, Smi>".
   virtual RawString* Name() const {
-    return SubvectorName(0, Length());
+    return SubvectorName(0, Length(), kInternalName);
   }
 
-  // The name of a subvector of this type argument vector, e.g. "<T, Dynamic>".
-  virtual RawString* SubvectorName(intptr_t from_index, intptr_t len) const;
+  // The name of this type argument vector, e.g. "<T, Dynamic, List<T>, int>".
+  // Names of internal classes are mapped to their public interfaces.
+  virtual RawString* UserVisibleName() const {
+    return SubvectorName(0, Length(), kUserVisibleName);
+  }
 
   // Check if this type argument vector consists solely of DynamicType,
   // considering only a prefix of length 'len'.
   bool IsRaw(intptr_t len) const {
     return IsDynamicTypes(false, len);
   }
 
   // Check if this type argument vector would consist solely of DynamicType if
   // it was instantiated from a raw (null) instantiator, i.e. consider each type
   // parameter as it would be first instantiated from a vector of dynamic types.
@@ skipping 40 matching lines @@
   // instantiated from a vector of dynamic types.
   bool IsDynamicTypes(bool raw_instantiated, intptr_t len) const;
 
   // Check the subtype or 'more specific' relationship, considering only a
   // prefix of length 'len'.
   bool TypeTest(TypeTestKind test_kind,
                 const AbstractTypeArguments& other,
                 intptr_t len,
                 Error* malformed_error) const;
 
+  // Return the internal or public name of a subvector of this type argument
+  // vector, e.g. "<T, Dynamic, List<T>, int>".
+  RawString* SubvectorName(intptr_t from_index,
+                           intptr_t len,
+                           NameVisibility name_visibility) const;
+
  protected:
   HEAP_OBJECT_IMPLEMENTATION(AbstractTypeArguments, Object);
+  friend class AbstractType;
   friend class Class;
 };
 
 
 // A TypeArguments is an array of AbstractType.
 class TypeArguments : public AbstractTypeArguments {
  public:
   virtual intptr_t Length() const;
   virtual RawAbstractType* TypeAt(intptr_t index) const;
   static intptr_t type_at_offset(intptr_t index) {
@@ skipping 90 matching lines @@
   HEAP_OBJECT_IMPLEMENTATION(InstantiatedTypeArguments, AbstractTypeArguments);
   friend class Class;
 };
 
 
 class Function : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
 
   // Build a string of the form '<T, R>(T, [b: B, c: C]) => R' representing the
-  // signature of the given function.
+  // internal signature of the given function.
   RawString* Signature() const {
-    return BuildSignature(false, TypeArguments::Handle());
+    const bool instantiate = false;
+    return BuildSignature(instantiate, kInternalName, TypeArguments::Handle());
   }
 
   // Build a string of the form '(A, [b: B, c: C]) => D' representing the
   // signature of the given function, where all generic types (e.g. '<T, R>' in
   // '<T, R>(T, [b: B, c: C]) => R') are instantiated using the given
   // instantiator type argument vector (e.g. '<A, D>').
   RawString* InstantiatedSignatureFrom(
-      const AbstractTypeArguments& instantiator) const {
-    return BuildSignature(true, instantiator);
+      const AbstractTypeArguments& instantiator,
+      NameVisibility name_visibility) const {
+    const bool instantiate = true;
+    return BuildSignature(instantiate, name_visibility, instantiator);
   }
 
   // Returns true if the signature of this function is instantiated, i.e. if it
   // does not involve generic parameter types or generic result type.
   bool HasInstantiatedSignature() const;
 
   RawClass* owner() const { return raw_ptr()->owner_; }
   void set_owner(const Class& value) const;
 
   RawAbstractType* result_type() const { return raw_ptr()->result_type_; }
@@ skipping 260 matching lines @@
   void set_name(const String& value) const;
   void set_kind(RawFunction::Kind value) const;
   void set_is_static(bool is_static) const;
   void set_is_const(bool is_const) const;
   void set_parent_function(const Function& value) const;
   void set_token_pos(intptr_t value) const;
   void set_implicit_closure_function(const Function& value) const;
   static RawFunction* New();
 
   RawString* BuildSignature(bool instantiate,
+                            NameVisibility name_visibility,
                             const AbstractTypeArguments& instantiator) const;
 
   // Check the subtype or 'more specific' relationship.
   bool TypeTest(TypeTestKind test_kind,
                 const AbstractTypeArguments& type_arguments,
                 const Function& other,
                 const AbstractTypeArguments& other_type_arguments,
                 Error* malformed_error) const;
 
   // Checks the type of the formal parameter at the given position for
@@ skipping 399 matching lines @@
   static RawLibrary* NewLibraryHelper(const String& url,
                                       bool import_core_lib);
   void AddImportedInto(const Library& library) const;
   RawObject* LookupObjectFiltered(const String& name,
                                   const Library& filter_lib) const;
   RawLibrary* LookupObjectInImporter(const String& name) const;
   RawString* FindDuplicateDefinition() const;
 
   HEAP_OBJECT_IMPLEMENTATION(Library, Object);
   friend class Class;
+  friend class Debugger;
   friend class DictionaryIterator;
-  friend class Debugger;
   friend class Isolate;
 };
 
 
 class LibraryPrefix : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
   RawArray* libraries() const { return raw_ptr()->libraries_; }
   intptr_t num_libs() const { return raw_ptr()->num_libs_; }
 
@@ skipping 64 matching lines @@
     raw_ptr()->code_ = code;
   }
 
   // New is a private method as RawInstruction and RawCode objects should
   // only be created using the Code::FinalizeCode method. This method creates
   // the RawInstruction and RawCode objects, sets up the pointer offsets
   // and links the two in a GC safe manner.
   static RawInstructions* New(intptr_t size);
 
   HEAP_OBJECT_IMPLEMENTATION(Instructions, Object);
+  friend class Class;
   friend class Code;
-  friend class Class;
 };
 
 
 class LocalVarDescriptors : public Object {
  public:
   intptr_t Length() const;
 
   RawString* GetName(intptr_t var_index) const;
 
   void SetVar(intptr_t var_index,
@@ skipping 146 matching lines @@
   }
 
   bool InRange(intptr_t offset) const { return offset < SizeInBits(); }
 
   bool GetBit(intptr_t bit_offset) const;
   void SetBit(intptr_t bit_offset, bool value) const;
 
   void set_bitmap_size_in_bytes(intptr_t value) const;
 
   HEAP_OBJECT_IMPLEMENTATION(Stackmap, Object);
+  friend class BitmapBuilder;
   friend class Class;
-  friend class BitmapBuilder;
 };
 
 
 class ExceptionHandlers : public Object {
  public:
   intptr_t Length() const;
 
   intptr_t TryIndex(intptr_t index) const;
   intptr_t HandlerPC(intptr_t index) const;
 
@@ skipping 668 matching lines @@
   static RawInteger* New(const String& str, Heap::Space space = Heap::kNew);
   static RawInteger* New(int64_t value, Heap::Space space = Heap::kNew);
 
   virtual double AsDoubleValue() const;
   virtual int64_t AsInt64Value() const;
 
   // Returns 0, -1 or 1.
   virtual int CompareWith(const Integer& other) const;
 
   OBJECT_IMPLEMENTATION(Integer, Number);
+  friend class Class;
 };
 
 
 class Smi : public Integer {
  public:
   // Smi value range is from -(2^N) to (2^N)-1.
   // N=30 (32-bit build) or N=62 (64-bit build).
   static const intptr_t kBits = kBitsPerWord - 2;
   static const intptr_t kMaxValue = (static_cast<intptr_t>(1) << kBits) - 1;
   static const intptr_t kMinValue =  -(static_cast<intptr_t>(1) << kBits);
@@ skipping 35 matching lines @@
 
   static bool IsValid(intptr_t value) {
     return (value >= kMinValue) && (value <= kMaxValue);
   }
 
   static bool IsValid64(int64_t value) {
     return (value >= kMinValue) && (value <= kMaxValue);
   }
 
  private:
-  friend class Api;  // For ValueFromRaw
-
   static intptr_t ValueFromRaw(uword raw_value) {
     intptr_t value = raw_value;
     ASSERT((value & kSmiTagMask) == kSmiTag);
     return (value >> kSmiTagShift);
   }
   static cpp_vtable handle_vtable_;
 
   OBJECT_IMPLEMENTATION(Smi, Integer);
+  friend class Api;  // For ValueFromRaw
+  friend class Class;
   friend class Object;
-  friend class Class;
 };
 
 
 class Mint : public Integer {
  public:
   static const intptr_t kBits = 63;  // 64-th bit is sign.
   static const int64_t kMaxValue =
       static_cast<int64_t>(DART_2PART_UINT64_C(0x7FFFFFFF, FFFFFFFF));
   static const int64_t kMinValue =
       static_cast<int64_t>(DART_2PART_UINT64_C(0x80000000, 00000000));
@@ skipping 93 matching lines @@
   Chunk* ChunkAddr(intptr_t index) const {
     ASSERT(0 <= index);
     ASSERT(index < Length());
     uword digits_start = reinterpret_cast<uword>(raw_ptr()) + sizeof(RawBigint);
     return &(reinterpret_cast<Chunk*>(digits_start)[index]);
   }
 
   static RawBigint* Allocate(intptr_t length, Heap::Space space = Heap::kNew);
 
   HEAP_OBJECT_IMPLEMENTATION(Bigint, Integer);
+  friend class BigintOperations;
   friend class Class;
-  friend class BigintOperations;
 };
 
 
 class Double : public Number {
  public:
   double value() const {
     return raw_ptr()->value_;
   }
 
   bool EqualsToDouble(double value) const;
@@ skipping 509 matching lines @@
     return value ? Bool::True() : Bool::False();
   }
 
  private:
   void set_value(bool value) const { raw_ptr()->value_ = value; }
 
   // New should only be called to initialize the two legal bool values.
   static RawBool* New(bool value);
 
   HEAP_OBJECT_IMPLEMENTATION(Bool, Instance);
+  friend class Class;
   friend class Object;  // To initialize the true and false values.
-  friend class Class;
 };
 
 
 class Array : public Instance {
  public:
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
   }
   static intptr_t length_offset() { return OFFSET_OF(RawArray, length_); }
@@ skipping 172 matching lines @@
  private:
   RawArray* DataArray() const { return data()->ptr(); }
   RawObject** ObjectAddr(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
     return &(DataArray()->data()[index]);
   }
 
   static const int kDefaultInitialCapacity = 4;
 
   HEAP_OBJECT_IMPLEMENTATION(GrowableObjectArray, Instance);
+  friend class Array;
   friend class Class;
-  friend class Array;
 };
 
 
 class ByteArray : public Instance {
  public:
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
   }
 
@@ skipping 1303 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_