Examples with RefactoringStatus org.eclipse.ltk.core.refactoring.RefactoringStatus used on opensource projects

Example 1 with RefactoringStatus

use of org.eclipse.ltk.core.refactoring.RefactoringStatus in project che by eclipse.

the class RenameMethodProcessor method analyzeCompilationUnits.

private RefactoringStatus analyzeCompilationUnits() throws CoreException {
    if (fOccurrences.length == 0)
        return null;
    RefactoringStatus result = new RefactoringStatus();
    fOccurrences = Checks.excludeCompilationUnits(fOccurrences, result);
    if (result.hasFatalError())
        return result;
    result.merge(Checks.checkCompileErrorsInAffectedFiles(fOccurrences));
    return result;
}

Example 2 with RefactoringStatus

use of org.eclipse.ltk.core.refactoring.RefactoringStatus in project che by eclipse.

the class RenameMethodProcessor method doCheckFinalConditions.

@Override
protected RefactoringStatus doCheckFinalConditions(IProgressMonitor pm, CheckConditionsContext context) throws CoreException {
    try {
        RefactoringStatus result = new RefactoringStatus();
        //$NON-NLS-1$
        pm.beginTask("", 9);
        // TODO workaround for https://bugs.eclipse.org/bugs/show_bug.cgi?id=40367
        if (!Checks.isAvailable(fMethod)) {
            result.addFatalError(RefactoringCoreMessages.RenameMethodProcessor_is_binary, JavaStatusContext.create(fMethod));
            return result;
        }
        result.merge(Checks.checkIfCuBroken(fMethod));
        if (result.hasFatalError())
            return result;
        pm.setTaskName(RefactoringCoreMessages.RenameMethodRefactoring_taskName_checkingPreconditions);
        result.merge(checkNewElementName(getNewElementName()));
        if (result.hasFatalError())
            return result;
        boolean mustAnalyzeShadowing;
        IMethod[] newNameMethods = searchForDeclarationsOfClashingMethods(new SubProgressMonitor(pm, 1));
        if (newNameMethods.length == 0) {
            mustAnalyzeShadowing = false;
            pm.worked(1);
        } else {
            IType[] outerTypes = searchForOuterTypesOfReferences(newNameMethods, new SubProgressMonitor(pm, 1));
            if (outerTypes.length > 0) {
                //There exists a reference to a clashing method, where the reference is in a nested type.
                //That nested type could be a type in a ripple method's hierarchy, which could
                //cause the reference to bind to the new ripple method instead of to
                //its old binding (a method of an enclosing scope).
                //-> Getting *more* references than before -> Semantics not preserved.
                //Examples: RenameVirtualMethodInClassTests#testFail39() and #testFail41()
                //TODO: could pass declaringTypes to the RippleMethodFinder and check whether
                //a hierarchy contains one of outerTypes (or an outer type of an outerType, recursively).
                mustAnalyzeShadowing = true;
            } else {
                boolean hasOldRefsInInnerTypes = true;
                //(recursively), whether they declare a rippleMethod
                if (hasOldRefsInInnerTypes) {
                    //There exists a reference to a ripple method in a nested type
                    //of a type in the hierarchy of any ripple method.
                    //When that reference is renamed, and one of the supertypes of the
                    //nested type declared a method matching the new name, then
                    //the renamed reference will bind to the method in its supertype,
                    //since inherited methods bind stronger than methods from enclosing scopes.
                    //Getting *less* references than before -> Semantics not preserved.
                    //Examples: RenamePrivateMethodTests#testFail2(), RenamePrivateMethodTests#testFail5()
                    mustAnalyzeShadowing = true;
                } else {
                    mustAnalyzeShadowing = false;
                }
            }
        }
        String binaryRefsDescription = Messages.format(RefactoringCoreMessages.ReferencesInBinaryContext_ref_in_binaries_description, BasicElementLabels.getJavaElementName(getCurrentElementName()));
        ReferencesInBinaryContext binaryRefs = new ReferencesInBinaryContext(binaryRefsDescription);
        initializeMethodsToRename(new SubProgressMonitor(pm, 1), binaryRefs);
        pm.setTaskName(RefactoringCoreMessages.RenameMethodRefactoring_taskName_searchingForReferences);
        fOccurrences = getOccurrences(new SubProgressMonitor(pm, 3), result, binaryRefs);
        binaryRefs.addErrorIfNecessary(result);
        pm.setTaskName(RefactoringCoreMessages.RenameMethodRefactoring_taskName_checkingPreconditions);
        if (fUpdateReferences)
            result.merge(checkRelatedMethods());
        //removes CUs with syntax errors
        result.merge(analyzeCompilationUnits());
        pm.worked(1);
        if (result.hasFatalError())
            return result;
        createChanges(new SubProgressMonitor(pm, 1), result);
        if (fUpdateReferences & mustAnalyzeShadowing)
            result.merge(analyzeRenameChanges(new SubProgressMonitor(pm, 1)));
        else
            pm.worked(1);
        return result;
    } finally {
        pm.done();
    }
}

Example 3 with RefactoringStatus

use of org.eclipse.ltk.core.refactoring.RefactoringStatus in project che by eclipse.

the class RenameMethodProcessor method checkRelatedMethods.

private RefactoringStatus checkRelatedMethods() throws CoreException {
    RefactoringStatus result = new RefactoringStatus();
    for (Iterator<IMethod> iter = fMethodsToRename.iterator(); iter.hasNext(); ) {
        IMethod method = iter.next();
        result.merge(Checks.checkIfConstructorName(method, getNewElementName(), method.getDeclaringType().getElementName()));
        String[] msgData = new String[] { BasicElementLabels.getJavaElementName(method.getElementName()), BasicElementLabels.getJavaElementName(method.getDeclaringType().getFullyQualifiedName('.')) };
        if (!method.exists()) {
            result.addFatalError(Messages.format(RefactoringCoreMessages.RenameMethodRefactoring_not_in_model, msgData));
            continue;
        }
        if (method.isBinary())
            result.addFatalError(Messages.format(RefactoringCoreMessages.RenameMethodRefactoring_no_binary, msgData));
        if (method.isReadOnly())
            result.addFatalError(Messages.format(RefactoringCoreMessages.RenameMethodRefactoring_no_read_only, msgData));
        if (JdtFlags.isNative(method))
            result.addError(Messages.format(RefactoringCoreMessages.RenameMethodRefactoring_no_native_1, msgData));
    }
    return result;
}

Example 4 with RefactoringStatus

use of org.eclipse.ltk.core.refactoring.RefactoringStatus in project che by eclipse.

the class RenameMethodProcessor method checkInitialConditions.

//----------- preconditions ------------------
@Override
public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException {
    if (!fMethod.exists()) {
        String message = Messages.format(RefactoringCoreMessages.RenameMethodRefactoring_deleted, BasicElementLabels.getFileName(fMethod.getCompilationUnit()));
        return RefactoringStatus.createFatalErrorStatus(message);
    }
    RefactoringStatus result = Checks.checkAvailability(fMethod);
    if (result.hasFatalError())
        return result;
    result.merge(Checks.checkIfCuBroken(fMethod));
    if (JdtFlags.isNative(fMethod))
        result.addError(RefactoringCoreMessages.RenameMethodRefactoring_no_native);
    return result;
}

Example 5 with RefactoringStatus

use of org.eclipse.ltk.core.refactoring.RefactoringStatus 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;
}