use of org.eclipse.jdt.core.IJavaElement in project che by eclipse.
the class RenameTypeProcessor method initializeSimilarElementsRenameProcessors.
// --------- Similar names
/**
* Creates and initializes the refactoring processors for similarly named elements
* @param progressMonitor progress monitor
* @param context context
* @return status
* @throws CoreException should not happen
*/
private RefactoringStatus initializeSimilarElementsRenameProcessors(IProgressMonitor progressMonitor, CheckConditionsContext context) throws CoreException {
Assert.isNotNull(fPreloadedElementToName);
Assert.isNotNull(fPreloadedElementToSelection);
final RefactoringStatus status = new RefactoringStatus();
final Set<IMethod> handledTopLevelMethods = new HashSet<IMethod>();
final Set<Warning> warnings = new HashSet<Warning>();
final List<RefactoringProcessor> processors = new ArrayList<RefactoringProcessor>();
fFinalSimilarElementToName = new HashMap<IJavaElement, String>();
CompilationUnit currentResolvedCU = null;
ICompilationUnit currentCU = null;
int current = 0;
final int max = fPreloadedElementToName.size();
//$NON-NLS-1$
progressMonitor.beginTask("", max * 3);
progressMonitor.setTaskName(RefactoringCoreMessages.RenameTypeProcessor_checking_similarly_named_declarations_refactoring_conditions);
for (Iterator<IJavaElement> iter = fPreloadedElementToName.keySet().iterator(); iter.hasNext(); ) {
final IJavaElement element = iter.next();
current++;
progressMonitor.worked(3);
// not selected? -> skip
if (!(fPreloadedElementToSelection.get(element)).booleanValue())
continue;
// already registered? (may happen with overridden methods) -> skip
if (fFinalSimilarElementToName.containsKey(element))
continue;
// CompilationUnit changed? (note: fPreloadedElementToName is sorted by CompilationUnit)
ICompilationUnit newCU = (ICompilationUnit) element.getAncestor(IJavaElement.COMPILATION_UNIT);
if (!newCU.equals(currentCU)) {
checkCUCompleteConditions(status, currentResolvedCU, currentCU, processors);
if (status.hasFatalError())
return status;
// reset values
currentResolvedCU = null;
currentCU = newCU;
processors.clear();
}
final String newName = fPreloadedElementToName.get(element);
RefactoringProcessor processor = null;
if (element instanceof ILocalVariable) {
final ILocalVariable currentLocal = (ILocalVariable) element;
if (currentResolvedCU == null)
currentResolvedCU = new RefactoringASTParser(ASTProvider.SHARED_AST_LEVEL).parse(currentCU, true);
processor = createLocalRenameProcessor(currentLocal, newName, currentResolvedCU);
if (status.hasFatalError())
return status;
fFinalSimilarElementToName.put(currentLocal, newName);
}
if (element instanceof IField) {
final IField currentField = (IField) element;
processor = createFieldRenameProcessor(currentField, newName);
status.merge(checkForConflictingRename(currentField, newName));
if (status.hasFatalError())
return status;
fFinalSimilarElementToName.put(currentField, newName);
}
if (element instanceof IMethod) {
IMethod currentMethod = (IMethod) element;
if (MethodChecks.isVirtual(currentMethod)) {
final IType declaringType = currentMethod.getDeclaringType();
ITypeHierarchy hierarchy = null;
if (!declaringType.isInterface())
hierarchy = declaringType.newTypeHierarchy(new NullProgressMonitor());
final IMethod topmost = MethodChecks.getTopmostMethod(currentMethod, hierarchy, new NullProgressMonitor());
if (topmost != null)
currentMethod = topmost;
if (handledTopLevelMethods.contains(currentMethod))
continue;
handledTopLevelMethods.add(currentMethod);
final IMethod[] ripples = RippleMethodFinder2.getRelatedMethods(currentMethod, new NullProgressMonitor(), null);
if (checkForWarnings(warnings, newName, ripples))
continue;
status.merge(checkForConflictingRename(ripples, newName));
if (status.hasFatalError())
return status;
processor = createVirtualMethodRenameProcessor(currentMethod, newName, ripples, hierarchy);
fFinalSimilarElementToName.put(currentMethod, newName);
for (int i = 0; i < ripples.length; i++) {
fFinalSimilarElementToName.put(ripples[i], newName);
}
} else {
status.merge(checkForConflictingRename(new IMethod[] { currentMethod }, newName));
if (status.hasFatalError())
break;
fFinalSimilarElementToName.put(currentMethod, newName);
processor = createNonVirtualMethodRenameProcessor(currentMethod, newName);
}
}
progressMonitor.subTask(Messages.format(RefactoringCoreMessages.RenameTypeProcessor_progress_current_total, new Object[] { String.valueOf(current), String.valueOf(max) }));
status.merge(processor.checkInitialConditions(new NoOverrideProgressMonitor(progressMonitor, 1)));
if (status.hasFatalError())
return status;
status.merge(processor.checkFinalConditions(new NoOverrideProgressMonitor(progressMonitor, 1), context));
if (status.hasFatalError())
return status;
processors.add(processor);
progressMonitor.worked(1);
if (progressMonitor.isCanceled())
throw new OperationCanceledException();
}
// check last CU
checkCUCompleteConditions(status, currentResolvedCU, currentCU, processors);
status.merge(addWarnings(warnings));
progressMonitor.done();
return status;
}
use of org.eclipse.jdt.core.IJavaElement in project che by eclipse.
the class RenameTypeProcessor method resetSelectedSimilarElements.
/**
* Resets the element maps back to the original status. This affects the
* maps returned in {@link #getSimilarElementsToNewNames() } and
* {@link #getSimilarElementsToSelection() }. All new names are reset to
* the calculated ones and every element gets selected.
*/
public void resetSelectedSimilarElements() {
Assert.isNotNull(fPreloadedElementToName);
for (Iterator<IJavaElement> iter = fPreloadedElementToNameDefault.keySet().iterator(); iter.hasNext(); ) {
final IJavaElement element = iter.next();
fPreloadedElementToName.put(element, fPreloadedElementToNameDefault.get(element));
fPreloadedElementToSelection.put(element, Boolean.TRUE);
}
}
use of org.eclipse.jdt.core.IJavaElement in project che by eclipse.
the class RenameTypeProcessor method checkTypesImportedInCu.
private RefactoringStatus checkTypesImportedInCu() throws CoreException {
IImportDeclaration imp = getImportedType(fType.getCompilationUnit(), getNewElementName());
if (imp == null)
return null;
String msg = Messages.format(RefactoringCoreMessages.RenameTypeRefactoring_imported, new Object[] { getNewElementLabel(), BasicElementLabels.getPathLabel(fType.getCompilationUnit().getResource().getFullPath(), false) });
IJavaElement grandParent = imp.getParent().getParent();
if (grandParent instanceof ICompilationUnit)
return RefactoringStatus.createErrorStatus(msg, JavaStatusContext.create(imp));
return null;
}
use of org.eclipse.jdt.core.IJavaElement in project che by eclipse.
the class RenameTypeProcessor method addSimilarElementsTextualUpdates.
// ----------- Edit creation -----------
/**
* Updates textual matches for fields.
*
* Strategy for matching text matches: Match and replace all fully qualified
* field names, but non-qualified field names only iff there are no fields
* which have the same original, but a different new name. Don't add java
* references; duplicate edits may be created but do not matter.
* @param manager text change manager
* @param monitor progress monitor
* @throws CoreException if updating failed
*/
private void addSimilarElementsTextualUpdates(TextChangeManager manager, IProgressMonitor monitor) throws CoreException {
final Map<String, String> simpleNames = new HashMap<String, String>();
final List<String> forbiddenSimpleNames = new ArrayList<String>();
for (Iterator<IJavaElement> iter = fFinalSimilarElementToName.keySet().iterator(); iter.hasNext(); ) {
final IJavaElement element = iter.next();
if (element instanceof IField) {
if (forbiddenSimpleNames.contains(element.getElementName()))
continue;
final String registeredNewName = simpleNames.get(element.getElementName());
final String newNameToCheck = fFinalSimilarElementToName.get(element);
if (registeredNewName == null)
simpleNames.put(element.getElementName(), newNameToCheck);
else if (!registeredNewName.equals(newNameToCheck))
forbiddenSimpleNames.add(element.getElementName());
}
}
for (Iterator<IJavaElement> iter = fFinalSimilarElementToName.keySet().iterator(); iter.hasNext(); ) {
final IJavaElement element = iter.next();
if (element instanceof IField) {
final IField field = (IField) element;
final String newName = fFinalSimilarElementToName.get(field);
TextMatchUpdater.perform(monitor, RefactoringScopeFactory.create(field), field.getElementName(), field.getDeclaringType().getFullyQualifiedName(), newName, manager, new SearchResultGroup[0], forbiddenSimpleNames.contains(field.getElementName()));
}
}
}
use of org.eclipse.jdt.core.IJavaElement in project che by eclipse.
the class RenameTypeProcessor method initializeReferences.
/**
* Initializes the references to the type and the similarly named elements. This
* method creates both the fReferences and the fPreloadedElementToName
* fields.
*
* May be called from the UI.
* @param monitor progress monitor
* @return initialization status
* @throws JavaModelException some fundamental error with the underlying model
* @throws OperationCanceledException if user canceled the task
*
*/
public RefactoringStatus initializeReferences(IProgressMonitor monitor) throws JavaModelException, OperationCanceledException {
Assert.isNotNull(fType);
Assert.isNotNull(getNewElementName());
if (fReferences != null && (getNewElementName().equals(fCachedNewName)) && (fCachedRenameSimilarElements == getUpdateSimilarDeclarations()) && (fCachedRenamingStrategy == fRenamingStrategy))
return fCachedRefactoringStatus;
fCachedNewName = getNewElementName();
fCachedRenameSimilarElements = fUpdateSimilarElements;
fCachedRenamingStrategy = fRenamingStrategy;
fCachedRefactoringStatus = new RefactoringStatus();
try {
SearchPattern pattern = SearchPattern.createPattern(fType, IJavaSearchConstants.REFERENCES, SearchUtils.GENERICS_AGNOSTIC_MATCH_RULE);
String binaryRefsDescription = Messages.format(RefactoringCoreMessages.ReferencesInBinaryContext_ref_in_binaries_description, BasicElementLabels.getJavaElementName(fType.getElementName()));
ReferencesInBinaryContext binaryRefs = new ReferencesInBinaryContext(binaryRefsDescription);
fReferences = RefactoringSearchEngine.search(pattern, RefactoringScopeFactory.create(fType, true, false), new TypeOccurrenceCollector(fType, binaryRefs), monitor, fCachedRefactoringStatus);
binaryRefs.addErrorIfNecessary(fCachedRefactoringStatus);
fReferences = Checks.excludeCompilationUnits(fReferences, fCachedRefactoringStatus);
fPreloadedElementToName = new LinkedHashMap<IJavaElement, String>();
fPreloadedElementToSelection = new HashMap<IJavaElement, Boolean>();
final String unQualifiedTypeName = fType.getElementName();
//$NON-NLS-1$
monitor.beginTask("", fReferences.length);
if (getUpdateSimilarDeclarations()) {
RenamingNameSuggestor sugg = new RenamingNameSuggestor(fRenamingStrategy);
for (int i = 0; i < fReferences.length; i++) {
final ICompilationUnit cu = fReferences[i].getCompilationUnit();
if (cu == null)
continue;
final SearchMatch[] results = fReferences[i].getSearchResults();
for (int j = 0; j < results.length; j++) {
if (!(results[j] instanceof TypeReferenceMatch))
continue;
final TypeReferenceMatch match = (TypeReferenceMatch) results[j];
final List<IJavaElement> matches = new ArrayList<IJavaElement>();
if (match.getLocalElement() != null) {
if (match.getLocalElement() instanceof ILocalVariable) {
matches.add(match.getLocalElement());
}
// else don't update (e.g. match in type parameter, annotation, ...)
} else {
matches.add((IJavaElement) match.getElement());
}
final IJavaElement[] others = match.getOtherElements();
if (others != null)
matches.addAll(Arrays.asList(others));
for (Iterator<IJavaElement> iter = matches.iterator(); iter.hasNext(); ) {
final IJavaElement element = iter.next();
if (!(element instanceof IMethod) && !(element instanceof IField) && !(element instanceof ILocalVariable))
continue;
if (!isInDeclaredType(match.getOffset(), element))
continue;
if (element instanceof IField) {
final IField currentField = (IField) element;
final String newFieldName = sugg.suggestNewFieldName(currentField.getJavaProject(), currentField.getElementName(), Flags.isStatic(currentField.getFlags()), unQualifiedTypeName, getNewElementName());
if (newFieldName != null)
fPreloadedElementToName.put(currentField, newFieldName);
} else if (element instanceof IMethod) {
final IMethod currentMethod = (IMethod) element;
addMethodRename(unQualifiedTypeName, sugg, currentMethod);
} else if (element instanceof ILocalVariable) {
final ILocalVariable currentLocal = (ILocalVariable) element;
final boolean isParameter;
if (currentLocal.isParameter()) {
addMethodRename(unQualifiedTypeName, sugg, (IMethod) currentLocal.getParent());
isParameter = true;
} else
isParameter = false;
final String newLocalName = sugg.suggestNewLocalName(currentLocal.getJavaProject(), currentLocal.getElementName(), isParameter, unQualifiedTypeName, getNewElementName());
if (newLocalName != null)
fPreloadedElementToName.put(currentLocal, newLocalName);
}
}
}
if (monitor.isCanceled())
throw new OperationCanceledException();
}
}
for (Iterator<IJavaElement> iter = fPreloadedElementToName.keySet().iterator(); iter.hasNext(); ) {
IJavaElement element = iter.next();
fPreloadedElementToSelection.put(element, Boolean.TRUE);
}
fPreloadedElementToNameDefault = new LinkedHashMap<IJavaElement, String>(fPreloadedElementToName);
} catch (OperationCanceledException e) {
fReferences = null;
fPreloadedElementToName = null;
throw new OperationCanceledException();
}
return fCachedRefactoringStatus;
}
Aggregations