private SearchResultGroup[] getNewReferences(
IProgressMonitor pm,
RefactoringStatus status,
WorkingCopyOwner owner,
ICompilationUnit[] newWorkingCopies)
throws CoreException {
pm.beginTask("", 2); // $NON-NLS-1$
ICompilationUnit declaringCuWorkingCopy =
RenameAnalyzeUtil.findWorkingCopyForCu(newWorkingCopies, fField.getCompilationUnit());
if (declaringCuWorkingCopy == null) return new SearchResultGroup[0];
IField field = getFieldInWorkingCopy(declaringCuWorkingCopy, getNewElementName());
if (field == null || !field.exists()) return new SearchResultGroup[0];
CollectingSearchRequestor requestor = null;
if (fDelegateUpdating
&& RefactoringAvailabilityTester.isDelegateCreationAvailable(getField())) {
// There will be two new matches inside the delegate (the invocation
// and the javadoc) which are OK and must not be reported.
final IField oldField =
getFieldInWorkingCopy(declaringCuWorkingCopy, getCurrentElementName());
requestor =
new CollectingSearchRequestor() {
public void acceptSearchMatch(SearchMatch match) throws CoreException {
if (!oldField.equals(match.getElement())) super.acceptSearchMatch(match);
}
};
} else requestor = new CollectingSearchRequestor();
SearchPattern newPattern = SearchPattern.createPattern(field, IJavaSearchConstants.REFERENCES);
IJavaSearchScope scope = RefactoringScopeFactory.create(fField, true, true);
return RefactoringSearchEngine.search(
newPattern, owner, scope, requestor, new SubProgressMonitor(pm, 1), status);
}
private RefactoringStatus checkAccessorDeclarations(IProgressMonitor pm, IMethod existingAccessor)
throws CoreException {
RefactoringStatus result = new RefactoringStatus();
SearchPattern pattern =
SearchPattern.createPattern(
existingAccessor,
IJavaSearchConstants.DECLARATIONS,
SearchUtils.GENERICS_AGNOSTIC_MATCH_RULE);
IJavaSearchScope scope = SearchEngine.createHierarchyScope(fField.getDeclaringType());
SearchResultGroup[] groupDeclarations =
RefactoringSearchEngine.search(pattern, scope, pm, result);
Assert.isTrue(groupDeclarations.length > 0);
if (groupDeclarations.length != 1) {
String message =
Messages.format(
RefactoringCoreMessages.RenameFieldRefactoring_overridden,
JavaElementUtil.createMethodSignature(existingAccessor));
result.addError(message);
} else {
SearchResultGroup group = groupDeclarations[0];
Assert.isTrue(group.getSearchResults().length > 0);
if (group.getSearchResults().length != 1) {
String message =
Messages.format(
RefactoringCoreMessages.RenameFieldRefactoring_overridden_or_overrides,
JavaElementUtil.createMethodSignature(existingAccessor));
result.addError(message);
}
}
return result;
}
private void addAccessorOccurrences(
IProgressMonitor pm,
IMethod accessor,
String editName,
String newAccessorName,
RefactoringStatus status)
throws CoreException {
Assert.isTrue(accessor.exists());
IJavaSearchScope scope = RefactoringScopeFactory.create(accessor);
SearchPattern pattern =
SearchPattern.createPattern(
accessor,
IJavaSearchConstants.ALL_OCCURRENCES,
SearchUtils.GENERICS_AGNOSTIC_MATCH_RULE);
SearchResultGroup[] groupedResults =
RefactoringSearchEngine.search(
pattern, scope, new MethodOccurenceCollector(accessor.getElementName()), pm, status);
for (int i = 0; i < groupedResults.length; i++) {
ICompilationUnit cu = groupedResults[i].getCompilationUnit();
if (cu == null) continue;
SearchMatch[] results = groupedResults[i].getSearchResults();
for (int j = 0; j < results.length; j++) {
SearchMatch searchResult = results[j];
TextEdit edit =
new ReplaceEdit(searchResult.getOffset(), searchResult.getLength(), newAccessorName);
addTextEdit(fChangeManager.get(cu), editName, edit);
}
}
}
private SearchResultGroup[] getOccurrences(
IProgressMonitor pm, RefactoringStatus status, ReferencesInBinaryContext binaryRefs)
throws CoreException {
SearchPattern pattern = createOccurrenceSearchPattern();
return RefactoringSearchEngine.search(
pattern,
createRefactoringScope(),
new MethodOccurenceCollector(getMethod().getElementName(), binaryRefs),
pm,
status);
}
private SearchResultGroup[] getReferences(IProgressMonitor pm, RefactoringStatus status)
throws CoreException {
String binaryRefsDescription =
Messages.format(
RefactoringCoreMessages.ReferencesInBinaryContext_ref_in_binaries_description,
BasicElementLabels.getJavaElementName(getCurrentElementName()));
ReferencesInBinaryContext binaryRefs = new ReferencesInBinaryContext(binaryRefsDescription);
SearchResultGroup[] result =
RefactoringSearchEngine.search(
createSearchPattern(),
createRefactoringScope(),
new CuCollectingSearchRequestor(binaryRefs),
pm,
status);
binaryRefs.addErrorIfNecessary(status);
return result;
}
private IType[] searchForOuterTypesOfReferences(IMethod[] newNameMethods, IProgressMonitor pm)
throws CoreException {
final Set<IType> outerTypesOfReferences = new HashSet<>();
SearchPattern pattern =
RefactoringSearchEngine.createOrPattern(newNameMethods, IJavaSearchConstants.REFERENCES);
IJavaSearchScope scope = createRefactoringScope(getMethod());
SearchRequestor requestor =
new SearchRequestor() {
@Override
public void acceptSearchMatch(SearchMatch match) throws CoreException {
Object element = match.getElement();
if (!(element instanceof IMember))
return; // e.g. an IImportDeclaration for a static method import
IMember member = (IMember) element;
IType declaring = member.getDeclaringType();
if (declaring == null) return;
IType outer = declaring.getDeclaringType();
if (outer != null) outerTypesOfReferences.add(declaring);
}
};
new SearchEngine()
.search(pattern, SearchUtils.getDefaultSearchParticipants(), scope, requestor, pm);
return outerTypesOfReferences.toArray(new IType[outerTypesOfReferences.size()]);
}
@SuppressWarnings({"unchecked"})
@Override
public RefactoringStatus checkFinalConditions(IProgressMonitor pm)
throws CoreException, OperationCanceledException {
RefactoringStatus result = new RefactoringStatus();
fChangeManager.clear();
pm.beginTask("", 12);
pm.setTaskName("Convert to AtomicInteger checking preconditions");
pm.worked(1);
if (result.hasFatalError()) return result;
pm.setTaskName("ConvertToAtomicInteger searching for cunits");
final SubProgressMonitor subPm = new SubProgressMonitor(pm, 5);
ICompilationUnit[] affectedCUs =
RefactoringSearchEngine.findAffectedCompilationUnits(
SearchPattern.createPattern(targetClass, IJavaSearchConstants.ALL_OCCURRENCES),
RefactoringScopeFactory.create(targetClass, true),
subPm,
result,
true);
if (result.hasFatalError()) return result;
pm.setTaskName("Analyzing the field");
IProgressMonitor sub = new SubProgressMonitor(pm, 5);
sub.beginTask("", affectedCUs.length);
List ownerDescriptions = new ArrayList();
ICompilationUnit owner = targetClass.getCompilationUnit();
for (int i = 0; i < affectedCUs.length; i++) {
ICompilationUnit unit = affectedCUs[i];
sub.subTask(unit.getElementName());
CompilationUnit root = null;
ASTRewrite rewriter = null;
List descriptions;
if (owner.equals(unit)) {
root = fRoot;
rewriter = fRewriter;
descriptions = ownerDescriptions;
} else {
root = new RefactoringASTParser(AST.JLS3).parse(unit, true);
rewriter = ASTRewrite.create(root.getAST());
descriptions = new ArrayList();
}
checkCompileErrors(result, root, unit);
// We will perform a different set of analysis and rewrites for the compilation unit
// containing the
// target class and other compilation units
if (owner.equals(unit)) {
// Analysis passes
ClassMutatorAnalysis mutatorAnalysis = new ClassMutatorAnalysis(targetClass, pm);
mutatorAnalysis.findMutators();
ClassConstructorAnalysis constructorAnalysis =
new ClassConstructorAnalysis(targetClassDeclaration);
targetClassDeclaration.accept(constructorAnalysis);
// Rewrite pass
MakeClassImmutableRewriter immutableRewriter =
new MakeClassImmutableRewriter(this, unit, rewriter);
immutableRewriter.rewrite(targetClassDeclaration, mutatorAnalysis, constructorAnalysis);
result.merge(immutableRewriter.getStatus());
if (result.hasFatalError()) {
fChangeManager.clear();
return result;
}
} else {
// descriptions.addAll(immutableRewriter.getGroupDescriptions());
createEdits(unit, rewriter, descriptions);
}
sub.worked(1);
if (pm.isCanceled()) throw new OperationCanceledException();
}
createEdits(owner, fRewriter, ownerDescriptions);
sub.done();
IFile[] filesToBeModified = ResourceUtil.getFiles(fChangeManager.getAllCompilationUnits());
result.merge(Checks.validateModifiesFiles(filesToBeModified, getValidationContext()));
if (result.hasFatalError()) return result;
ResourceChangeChecker.checkFilesToBeChanged(filesToBeModified, new SubProgressMonitor(pm, 1));
return result;
}
private SearchResultGroup[] batchFindNewOccurrences(
IMethod[] wcNewMethods,
final IMethod[] wcOldMethods,
ICompilationUnit[] newDeclarationWCs,
IProgressMonitor pm,
RefactoringStatus status)
throws CoreException {
pm.beginTask("", 2); // $NON-NLS-1$
SearchPattern refsPattern =
RefactoringSearchEngine.createOrPattern(wcNewMethods, IJavaSearchConstants.REFERENCES);
SearchParticipant[] searchParticipants = SearchUtils.getDefaultSearchParticipants();
IJavaSearchScope scope = RefactoringScopeFactory.create(wcNewMethods);
MethodOccurenceCollector requestor;
if (getDelegateUpdating()) {
// There will be two new matches inside the delegate(s) (the invocation
// and the javadoc) which are OK and must not be reported.
// Note that except these ocurrences, the delegate bodies are empty
// (as they were created this way).
requestor =
new MethodOccurenceCollector(getNewElementName()) {
@Override
public void acceptSearchMatch(ICompilationUnit unit, SearchMatch match)
throws CoreException {
for (int i = 0; i < wcOldMethods.length; i++)
if (wcOldMethods[i].equals(match.getElement())) return;
super.acceptSearchMatch(unit, match);
}
};
} else requestor = new MethodOccurenceCollector(getNewElementName());
SearchEngine searchEngine = new SearchEngine(fWorkingCopyOwner);
ArrayList<ICompilationUnit> needWCs = new ArrayList<>();
HashSet<ICompilationUnit> declaringCUs = new HashSet<>(newDeclarationWCs.length);
for (int i = 0; i < newDeclarationWCs.length; i++)
declaringCUs.add(newDeclarationWCs[i].getPrimary());
for (int i = 0; i < fOccurrences.length; i++) {
ICompilationUnit cu = fOccurrences[i].getCompilationUnit();
if (!declaringCUs.contains(cu)) needWCs.add(cu);
}
ICompilationUnit[] otherWCs = null;
try {
otherWCs =
RenameAnalyzeUtil.createNewWorkingCopies(
needWCs.toArray(new ICompilationUnit[needWCs.size()]),
fChangeManager,
fWorkingCopyOwner,
new SubProgressMonitor(pm, 1));
searchEngine.search(
refsPattern, searchParticipants, scope, requestor, new SubProgressMonitor(pm, 1));
} finally {
pm.done();
if (otherWCs != null) {
for (int i = 0; i < otherWCs.length; i++) {
otherWCs[i].discardWorkingCopy();
}
}
}
SearchResultGroup[] newResults =
RefactoringSearchEngine.groupByCu(requestor.getResults(), status);
return newResults;
}
private SearchPattern createOccurrenceSearchPattern() {
HashSet<IMethod> methods = new HashSet<>(fMethodsToRename);
methods.add(fMethod);
IMethod[] ms = methods.toArray(new IMethod[methods.size()]);
return RefactoringSearchEngine.createOrPattern(ms, IJavaSearchConstants.ALL_OCCURRENCES);
}
