Private names are not exported, not even if the library imports itself

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 "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 1504 matching lines @@
   }
 
   // At this point, we must see an identifier for the parameter name.
   parameter.name_pos = TokenPos();
   parameter.name = ExpectIdentifier("parameter name expected");
   if (parameter.is_field_initializer) {
     params->has_field_initializer = true;
   }
 
   if (params->has_optional_named_parameters &&
-      (parameter.name->CharAt(0) == '_')) {
+      (parameter.name->CharAt(0) == Library::kPrivateIdentifierStart)) {
     ReportError(parameter.name_pos, "named parameter must not be private");
   }
 
   // Check for duplicate formal parameters.
   const intptr_t num_existing_parameters =
       params->num_fixed_parameters + params->num_optional_parameters;
   for (intptr_t i = 0; i < num_existing_parameters; i++) {
     ParamDesc& existing_parameter = (*params->parameters)[i];
     if (existing_parameter.name->Equals(*parameter.name)) {
       ReportError(parameter.name_pos, "duplicate formal parameter '%s'",
@@ skipping 8010 matching lines @@
 
 
 // Do a lookup for the identifier in the scope of the specified
 // library prefix. This means trying to resolve it locally in all of the
 // libraries present in the library prefix.
 AstNode* Parser::ResolveIdentInPrefixScope(intptr_t ident_pos,
                                            const LibraryPrefix& prefix,
                                            const String& ident) {
   TRACE_PARSER("ResolveIdentInPrefixScope");
   HANDLESCOPE(I);
+  if (ident.CharAt(0) == Library::kPrivateIdentifierStart) {
+    // Private names are not exported by libraries. The name mangling
+    // of private names with a library-specific suffix usually ensures
+    // that _x in library A is not found when looked up from library B.
+    // In the pathological case where a library includes itself with
+    // a prefix, the name mangling would not help in hiding the private
+    // name, so we need to explicitly reject private names here.
+    return NULL;
+  }
   Object& obj = Object::Handle(I);
   if (prefix.is_loaded()) {
     obj = prefix.LookupObject(ident);
   } else {
     // Remember that this function depends on an import prefix of an
     // unloaded deferred library. Note that parsed_function() can be
     // NULL when parsing expressions outside the scope of a function.
     if (parsed_function() != NULL) {
       parsed_function()->AddDeferredPrefix(prefix);
     }
@@ skipping 1691 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart