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

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 2856 matching lines @@
   Type& super_type = Type::Handle();
   if (CurrentToken() == Token::kEXTENDS) {
     ConsumeToken();
     const intptr_t type_pos = TokenPos();
     const AbstractType& type = AbstractType::Handle(
         ParseType(ClassFinalizer::kTryResolve));
     if (type.IsTypeParameter()) {
       ErrorMsg(type_pos,
                "class '%s' may not extend type parameter '%s'",
                class_name.ToCString(),
-               String::Handle(type.Name()).ToCString());
+               String::Handle(type.UserVisibleName()).ToCString());
     }
     super_type ^= type.raw();
     if (super_type.IsInterfaceType()) {
       ErrorMsg(type_pos,
                "class '%s' may implement, but cannot extend interface '%s'",
                class_name.ToCString(),
-               String::Handle(super_type.Name()).ToCString());
+               String::Handle(super_type.UserVisibleName()).ToCString());
     }
   } else {
     // No extends clause: Implicitly extend Object.
     super_type = Type::ObjectType();
   }
   ASSERT(!super_type.IsNull());
   cls.set_super_type(super_type);
 
   if (CurrentToken() == Token::kIMPLEMENTS) {
     Array& interfaces = Array::Handle();
@@ skipping 382 matching lines @@
     do {
       ConsumeToken();
       if (CurrentToken() != Token::kIDENT) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
       const intptr_t type_parameter_pos = TokenPos();
       // Check for duplicate type parameters.
       for (intptr_t i = 0; i < index; i++) {
         existing_type_parameter ^= type_parameters_array.At(i);
-        existing_type_parameter_name = existing_type_parameter.Name();
+        existing_type_parameter_name = existing_type_parameter.name();
         if (existing_type_parameter_name.Equals(type_parameter_name)) {
           ErrorMsg("duplicate type parameter '%s'",
                    type_parameter_name.ToCString());
         }
       }
       ConsumeToken();
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
         // A bound may refer to the owner of the type parameter it applies to,
         // i.e. to the class or interface currently being parsed.
@@ skipping 77 matching lines @@
   ASSERT((CurrentToken() == Token::kIMPLEMENTS) ||
          (CurrentToken() == Token::kEXTENDS));
   const GrowableObjectArray& interfaces =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   String& interface_name = String::Handle();
   AbstractType& interface = AbstractType::Handle();
   String& other_name = String::Handle();
   AbstractType& other_interface = AbstractType::Handle();
   do {
     ConsumeToken();
-    intptr_t supertype_pos = TokenPos();
+    intptr_t interface_pos = TokenPos();
     interface = ParseType(ClassFinalizer::kTryResolve);
-    interface_name = interface.Name();
+    interface_name = interface.UserVisibleName();
     for (int i = 0; i < interfaces.Length(); i++) {
       other_interface ^= interfaces.At(i);
-      other_name = other_interface.Name();
+      other_name = other_interface.UserVisibleName();
       if (interface_name.Equals(other_name)) {
-        ErrorMsg(supertype_pos, "Duplicate supertype '%s'",
+        ErrorMsg(interface_pos, "duplicate interface '%s'",
                  interface_name.ToCString());
       }
     }
     interfaces.Add(interface);
   } while (CurrentToken() == Token::kCOMMA);
   return Array::MakeArray(interfaces);
 }
 
 
 void Parser::AddInterfaces(intptr_t interfaces_pos,
@@ skipping 11 matching lines @@
   // Now add the new interfaces.
   AbstractType& conflicting = AbstractType::Handle();
   for (intptr_t i = 0; i < interfaces.Length(); i++) {
     AbstractType& interface = AbstractType::ZoneHandle();
     interface ^= interfaces.At(i);
     if (interface.IsTypeParameter()) {
       if (cls.is_interface()) {
         ErrorMsg(interfaces_pos,
                  "interface '%s' may not extend type parameter '%s'",
                  String::Handle(cls.Name()).ToCString(),
-                 String::Handle(interface.Name()).ToCString());
+                 String::Handle(interface.UserVisibleName()).ToCString());
       } else {
         ErrorMsg(interfaces_pos,
                  "class '%s' may not implement type parameter '%s'",
                  String::Handle(cls.Name()).ToCString(),
-                 String::Handle(interface.Name()).ToCString());
+                 String::Handle(interface.UserVisibleName()).ToCString());
       }
     }
     if (!ClassFinalizer::AddInterfaceIfUnique(all_interfaces,
                                               interface,
                                               &conflicting)) {
       ASSERT(!conflicting.IsNull());
       ErrorMsg(interfaces_pos,
                "interface '%s' conflicts with interface '%s'",
-               String::Handle(interface.Name()).ToCString(),
-               String::Handle(conflicting.Name()).ToCString());
+               String::Handle(interface.UserVisibleName()).ToCString(),
+               String::Handle(conflicting.UserVisibleName()).ToCString());
     }
   }
   cls_interfaces = Array::MakeArray(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level) {
   TRACE_PARSER("ParseTopLevelVariable");
   const bool is_final = (CurrentToken() == Token::kFINAL);
@@ skipping 3409 matching lines @@
         // First check if the type is a type parameter of the given scope class.
         const TypeParameter& type_parameter = TypeParameter::Handle(
             scope_class.LookupTypeParameter(unresolved_class_name,
                                             type->token_pos()));
         if (!type_parameter.IsNull()) {
           // A type parameter cannot be parameterized, so report an error if
           // type arguments have previously been parsed.
           if (!AbstractTypeArguments::Handle(type->arguments()).IsNull()) {
             ErrorMsg(type_parameter.token_pos(),
                      "type parameter '%s' cannot be parameterized",
-                     String::Handle(type_parameter.Name()).ToCString());
+                     String::Handle(type_parameter.name()).ToCString());
           }
           *type = type_parameter.raw();
           return;
         }
       }
       // Global lookup in current library.
       resolved_type_class = library_.LookupClass(unresolved_class_name);
     } else {
       LibraryPrefix& lib_prefix =
           LibraryPrefix::Handle(unresolved_class.library_prefix());
       // Local lookup in library prefix scope.
       resolved_type_class = lib_prefix.LookupLocalClass(unresolved_class_name);
     }
     // At this point, we can only have a parameterized_type.
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type->raw();
     if (!resolved_type_class.IsNull()) {
       // Replace unresolved class with resolved type class.
       parameterized_type.set_type_class(resolved_type_class);
     } else if (finalization >= ClassFinalizer::kCanonicalize) {
       // The type is malformed.
       ClassFinalizer::FinalizeMalformedType(
           Error::Handle(),  // No previous error.
           current_class(), parameterized_type, finalization,
           "type '%s' is not loaded",
-          String::Handle(parameterized_type.Name()).ToCString());
+          String::Handle(parameterized_type.UserVisibleName()).ToCString());
     }
   }
   // Resolve type arguments, if any.
   const AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(type->arguments());
   if (!arguments.IsNull()) {
     const intptr_t num_arguments = arguments.Length();
     for (intptr_t i = 0; i < num_arguments; i++) {
       AbstractType& type_argument = AbstractType::Handle(arguments.TypeAt(i));
       ResolveTypeFromClass(scope_class, finalization, &type_argument);
@@ skipping 409 matching lines @@
   AstNode* resolved = NULL;
   ResolveIdentInLocalScope(ident_pos, ident, &resolved);
   if (resolved == NULL) {
     // Check whether the identifier is a type parameter. Type parameters
     // can never be used in primary expressions.
     const Class& scope_class = Class::Handle(TypeParametersScopeClass());
     if (!scope_class.IsNull()) {
       TypeParameter& type_param = TypeParameter::Handle(
           scope_class.LookupTypeParameter(ident, ident_pos));
       if (!type_param.IsNull()) {
-        String& type_param_name = String::Handle(type_param.Name());
+        String& type_param_name = String::Handle(type_param.name());
         ErrorMsg(ident_pos, "illegal use of type parameter %s",
                  type_param_name.ToCString());
       }
     }
     // Not found in the local scope, and the name is not a type parameter.
     // Try finding the variable in the library scope (current library
     // and all libraries imported by it).
     QualIdent qual_ident;
     qual_ident.lib_prefix = NULL;
     qual_ident.ident_pos = ident_pos;
@@ skipping 217 matching lines @@
            !elem->AsLiteralNode()->literal().IsInstanceOf(
                element_type, TypeArguments::Handle(), &malformed_error))) {
         // If the failure is due to a malformed type error, display it instead.
         if (!malformed_error.IsNull()) {
           ErrorMsg(malformed_error);
         } else {
           ErrorMsg(elem->AsLiteralNode()->token_pos(),
                    "list literal element at index %d must be "
                    "a constant of type '%s'",
                    i,
-                   String::Handle(element_type.Name()).ToCString());
+                   String::Handle(element_type.UserVisibleName()).ToCString());
         }
       }
       const_list.SetAt(i, elem->AsLiteralNode()->literal());
     }
     const_list ^= const_list.Canonicalize();
     const_list.MakeImmutable();
     return new LiteralNode(literal_pos, const_list);
   } else {
     // Factory call at runtime.
     String& list_literal_factory_class_name = String::Handle(
@@ skipping 178 matching lines @@
            !arg->AsLiteralNode()->literal().IsInstanceOf(
                value_type, TypeArguments::Handle(), &malformed_error))) {
         // If the failure is due to a malformed type error, display it instead.
         if (!malformed_error.IsNull()) {
           ErrorMsg(malformed_error);
         } else {
           ErrorMsg(arg->AsLiteralNode()->token_pos(),
                    "map literal value at index %d must be "
                    "a constant of type '%s'",
                    i >> 1,
-                   String::Handle(value_type.Name()).ToCString());
+                   String::Handle(value_type.UserVisibleName()).ToCString());
         }
       }
       key_value_array.SetAt(i, arg->AsLiteralNode()->literal());
     }
     key_value_array ^= key_value_array.Canonicalize();
     key_value_array.MakeImmutable();
 
     // Construct the map object.
     const String& immutable_map_class_name =
         String::Handle(String::NewSymbol(kImmutableMapName));
@@ skipping 105 matching lines @@
   intptr_t type_pos = TokenPos();
   const AbstractType& type = AbstractType::Handle(
       ParseType(ClassFinalizer::kCanonicalizeWellFormed));
   // Malformed bounds never result in a compile time error, therefore, the
   // parsed type may be malformed although we requested kCanonicalizeWellFormed.
   // In that case, we throw a dynamic type error instead of calling the
   // constructor.
   if (type.IsTypeParameter()) {
     ErrorMsg(type_pos,
              "type parameter '%s' cannot be instantiated",
-             String::Handle(type.Name()).ToCString());
+             String::Handle(type.UserVisibleName()).ToCString());
   }
   if (type.IsDynamicType()) {
     ErrorMsg(type_pos, "Dynamic cannot be instantiated");
   }
   Class& type_class = Class::Handle(type.type_class());
   String& type_class_name = String::Handle(type_class.Name());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::ZoneHandle(type.arguments());
 
   // The constructor class and its name are those of the parsed type, unless the
@@ skipping 377 matching lines @@
                                     *qual_ident.ident,
                                     &primary)) {
         // Check whether the identifier is a type parameter. Type parameters
         // can never be used as part of primary expressions.
         const Class& scope_class = Class::Handle(TypeParametersScopeClass());
         if (!scope_class.IsNull()) {
           TypeParameter& type_param = TypeParameter::ZoneHandle(
               scope_class.LookupTypeParameter(*(qual_ident.ident),
                                               TokenPos()));
           if (!type_param.IsNull()) {
-            String& type_param_name = String::Handle(type_param.Name());
+            const String& type_param_name = String::Handle(type_param.name());
             ErrorMsg(qual_ident.ident_pos,
                      "illegal use of type parameter %s",
                      type_param_name.ToCString());
           }
         }
         // This is a non-local unqualified identifier so resolve the
         // identifier locally in the main app library and all libraries
         // imported by it.
         primary = ResolveIdentInLibraryScope(library_,
                                              qual_ident,
@@ skipping 362 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart