Issue 23389. Report error in the renamed element be invisible after rename.

pkg/analysis_server/lib/src/services/refactoring/rename_class_member.dart

 // Copyright (c) 2014, 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.
 
 library services.src.refactoring.rename_class_member;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol_server.dart'
     hide Element, ElementKind;
 import 'package:analysis_server/src/services/correction/status.dart';
 import 'package:analysis_server/src/services/correction/util.dart';
 import 'package:analysis_server/src/services/refactoring/naming_conventions.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring_internal.dart';
 import 'package:analysis_server/src/services/refactoring/rename.dart';
 import 'package:analysis_server/src/services/search/hierarchy.dart';
 import 'package:analysis_server/src/services/search/search_engine.dart';
+import 'package:analyzer/src/generated/ast.dart' show Identifier;
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 
 /**
  * Checks if creating a method with the given [name] in [classElement] will
  * cause any conflicts.
  */
 Future<RefactoringStatus> validateCreateMethod(
     SearchEngine searchEngine, ClassElement classElement, String name) {
   return new _ClassMemberValidator.forCreate(searchEngine, classElement, name)
@@ skipping 87 matching lines @@
     potentialEditIds.add(id);
     return id;
   }
 }
 
 /**
  * Helper to check if the created or renamed [Element] will cause any conflicts.
  */
 class _ClassMemberValidator {
   final SearchEngine searchEngine;
+  final LibraryElement library;
   final Element element;
   final ClassElement elementClass;
   final ElementKind elementKind;
   final String name;
   final bool isRename;
 
+  final RefactoringStatus result = new RefactoringStatus();
   Set<Element> elements = new Set<Element>();
   List<SearchMatch> references = <SearchMatch>[];
 
   _ClassMemberValidator.forCreate(
       this.searchEngine, this.elementClass, this.name)
       : isRename = false,
+        library = null,
         element = null,
         elementKind = ElementKind.METHOD;
 
   _ClassMemberValidator.forRename(this.searchEngine, Element element, this.name)
       : isRename = true,
+        library = element.library,
         element = element,
         elementClass = element.enclosingElement,
         elementKind = element.kind;
 
   Future<RefactoringStatus> validate() async {
-    RefactoringStatus result = new RefactoringStatus();
     // check if there is a member with "newName" in the same ClassElement
     for (Element newNameMember in getChildren(elementClass, name)) {
       result.addError(format(
           "Class '{0}' already declares {1} with name '{2}'.",
           elementClass.displayName, getElementKindName(newNameMember),
           name), newLocation_fromElement(newNameMember));
     }
     // do chained computations
     Set<ClassElement> superClasses = getSuperClasses(elementClass);
     await _prepareReferences();
@@ skipping 32 matching lines @@
             if (isReferenceInLocalRange(localElement, reference)) {
               result.addError(format(
                   "Usage of renamed {0} will be shadowed by {1} '{2}'.",
                   elementKind.displayName, getElementKindName(localElement),
                   localElement.displayName), newLocation_fromMatch(reference));
             }
           }
         }
       }
     }
+    // visibility
+    if (isRename) {
+      _validateWillBeInvisible();
+    }
     // done
     return result;
   }
 
   /**
    * Fills [elements] with [Element]s to rename.
    */
   Future _prepareElements() async {
     if (element is ClassMemberElement) {
       elements = await getHierarchyMembers(searchEngine, element);
     } else {
       elements = new Set.from([element]);
     }
   }
 
   /**
    * Fills [references] with all references to [elements].
    */
   Future _prepareReferences() async {
     if (!isRename) {
       return new Future.value();
     }
     await _prepareElements();
     await Future.forEach(elements, (Element element) async {
       List<SearchMatch> elementReferences =
           await searchEngine.searchReferences(element);
       references.addAll(elementReferences);
     });
   }
+
+  /**
+   * Validates if any usage of [element] renamed to [name] will be invisible.
+   */
+  Future _validateWillBeInvisible() async {
+    if (!Identifier.isPrivateName(name)) {
+      return;
+    }
+    for (SearchMatch reference in references) {
+      Element refElement = reference.element;
+      LibraryElement refLibrary = refElement.library;
+      if (refLibrary != library) {
+        String message = format("Renamed {0} will be invisible in '{1}'.",
+            getElementKindName(element), getElementQualifiedName(refLibrary));
+        result.addError(message, newLocation_fromMatch(reference));
+      }
+    }
+  }
 }