blob: d085e784b67af21f8d9f1383b7e78ba69bd8e6b7 [file] [log] [blame]
// 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.
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/dart/ast/ast.dart';
import 'package:analyzer/dart/ast/visitor.dart';
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/src/dart/element/ast_provider.dart';
import 'package:analyzer/src/generated/java_core.dart';
import 'package:analyzer/src/generated/source.dart';
/**
* Checks if creating a method with the given [name] in [classElement] will
* cause any conflicts.
*/
Future<RefactoringStatus> validateCreateMethod(SearchEngine searchEngine,
AstProvider astProvider, ClassElement classElement, String name) {
return new _ClassMemberValidator.forCreate(
searchEngine, astProvider, classElement, name)
.validate();
}
/**
* A [Refactoring] for renaming class member [Element]s.
*/
class RenameClassMemberRefactoringImpl extends RenameRefactoringImpl {
final AstProvider astProvider;
_ClassMemberValidator _validator;
RenameClassMemberRefactoringImpl(
RefactoringWorkspace workspace, this.astProvider, Element element)
: super(workspace, element);
@override
String get refactoringName {
if (element is TypeParameterElement) {
return "Rename Type Parameter";
}
if (element is FieldElement) {
return "Rename Field";
}
return "Rename Method";
}
@override
Future<RefactoringStatus> checkFinalConditions() {
_validator = new _ClassMemberValidator.forRename(
searchEngine, astProvider, element, newName);
return _validator.validate();
}
@override
Future<RefactoringStatus> checkInitialConditions() async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
RefactoringStatus result = await super.checkInitialConditions();
if (element is MethodElement && (element as MethodElement).isOperator) {
result.addFatalError('Cannot rename operator.');
}
return new Future<RefactoringStatus>.value(result);
}
@override
RefactoringStatus checkNewName() {
RefactoringStatus result = super.checkNewName();
if (element is FieldElement) {
result.addStatus(validateFieldName(newName));
}
if (element is MethodElement) {
result.addStatus(validateMethodName(newName));
}
return result;
}
@override
Future<void> fillChange() async {
var processor = new RenameProcessor(searchEngine, change, newName);
// update declarations
for (Element renameElement in _validator.elements) {
if (renameElement.isSynthetic && renameElement is FieldElement) {
processor.addDeclarationEdit(renameElement.getter);
processor.addDeclarationEdit(renameElement.setter);
} else {
processor.addDeclarationEdit(renameElement);
}
}
// update references
processor.addReferenceEdits(_validator.references);
// potential matches
List<SearchMatch> nameMatches =
await searchEngine.searchMemberReferences(oldName);
List<SourceReference> nameRefs = getSourceReferences(nameMatches);
for (SourceReference reference in nameRefs) {
// ignore references from SDK and pub cache
if (!workspace.containsFile(reference.element.source.fullName)) {
continue;
}
// check the element being renamed is accessible
{
LibraryElement whereLibrary = reference.element.library;
if (!element.isAccessibleIn(whereLibrary)) {
continue;
}
}
// add edit
reference.addEdit(change, newName, id: _newPotentialId());
}
}
String _newPotentialId() {
String id = potentialEditIds.length.toString();
potentialEditIds.add(id);
return id;
}
}
/**
* Helper to check if the created or renamed [Element] will cause any conflicts.
*/
class _ClassMemberValidator {
final SearchEngine searchEngine;
final ResolvedUnitCache unitCache;
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, AstProvider astProvider, this.elementClass, this.name)
: unitCache = new ResolvedUnitCache(astProvider),
isRename = false,
library = null,
element = null,
elementKind = ElementKind.METHOD;
_ClassMemberValidator.forRename(
this.searchEngine, AstProvider astProvider, Element element, this.name)
: unitCache = new ResolvedUnitCache(astProvider),
isRename = true,
library = element.library,
element = element,
elementClass = element.enclosingElement,
elementKind = element.kind;
Future<RefactoringStatus> validate() async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
// 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();
Set<ClassElement> subClasses =
await searchEngine.searchAllSubtypes(elementClass);
// check shadowing of class names
if (element != null) {
for (Element element in elements) {
ClassElement clazz = element.enclosingElement;
if (clazz.name == name) {
result.addError(
format(
"Renamed {0} has the same name as the declaring class '{1}'.",
elementKind.displayName,
name),
newLocation_fromElement(element));
}
}
} else {
if (elementClass.name == name) {
result.addError(
format(
"Created {0} has the same name as the declaring class '{1}'.",
elementKind.displayName,
name),
newLocation_fromElement(elementClass));
}
}
// usage of the renamed Element is shadowed by a local element
{
_MatchShadowedByLocal conflict = await _getShadowingLocalElement();
if (conflict != null) {
LocalElement localElement = conflict.localElement;
result.addError(
format(
"Usage of renamed {0} will be shadowed by {1} '{2}'.",
elementKind.displayName,
getElementKindName(localElement),
localElement.displayName),
newLocation_fromMatch(conflict.match));
}
}
// check shadowing in the hierarchy
List<SearchMatch> declarations =
await searchEngine.searchMemberDeclarations(name);
for (SearchMatch declaration in declarations) {
Element nameElement = getSyntheticAccessorVariable(declaration.element);
Element nameClass = nameElement.enclosingElement;
// the renamed Element shadows a member of a superclass
if (superClasses.contains(nameClass)) {
result.addError(
format(
isRename
? "Renamed {0} will shadow {1} '{2}'."
: "Created {0} will shadow {1} '{2}'.",
elementKind.displayName,
getElementKindName(nameElement),
getElementQualifiedName(nameElement)),
newLocation_fromElement(nameElement));
}
// the renamed Element is shadowed by a member of a subclass
if (isRename && subClasses.contains(nameClass)) {
result.addError(
format(
"Renamed {0} will be shadowed by {1} '{2}'.",
elementKind.displayName,
getElementKindName(nameElement),
getElementQualifiedName(nameElement)),
newLocation_fromElement(nameElement));
}
}
// visibility
if (isRename) {
_validateWillBeInvisible();
}
// done
return result;
}
Future<_MatchShadowedByLocal> _getShadowingLocalElement() async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
var localElementMap = <CompilationUnitElement, List<LocalElement>>{};
Future<List<LocalElement>> getLocalElements(Element element) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
var unitElement = unitCache.getUnitElement(element);
var localElements = localElementMap[unitElement];
if (localElements == null) {
var unit = await unitCache.getUnit(unitElement);
var collector = new _LocalElementsCollector(name);
unit.accept(collector);
localElements = collector.elements;
localElementMap[unitElement] = localElements;
}
return localElements;
}
for (SearchMatch match in references) {
// Qualified reference cannot be shadowed by local elements.
if (match.isQualified) {
continue;
}
// Check local elements that might shadow the reference.
var localElements = await getLocalElements(match.element);
for (LocalElement localElement in localElements) {
SourceRange elementRange = localElement.visibleRange;
if (elementRange != null &&
elementRange.intersects(match.sourceRange)) {
return new _MatchShadowedByLocal(match, localElement);
}
}
}
return null;
}
/**
* Fills [elements] with [Element]s to rename.
*/
Future _prepareElements() async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
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 {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
if (!isRename) {
return new Future.value();
}
await _prepareElements();
await Future.forEach(elements, (Element element) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
List<SearchMatch> elementReferences =
await searchEngine.searchReferences(element);
references.addAll(elementReferences);
});
}
/**
* Validates if any usage of [element] renamed to [name] will be invisible.
*/
void _validateWillBeInvisible() {
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));
}
}
}
}
class _LocalElementsCollector extends GeneralizingAstVisitor<void> {
final String name;
final List<LocalElement> elements = [];
_LocalElementsCollector(this.name);
visitSimpleIdentifier(SimpleIdentifier node) {
Element element = node.staticElement;
if (element is LocalElement && element.name == name) {
elements.add(element);
}
}
}
class _MatchShadowedByLocal {
final SearchMatch match;
final LocalElement localElement;
_MatchShadowedByLocal(this.match, this.localElement);
}