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

Example 31 with RefactoringStatus

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

the class ResourceChangeChecker method createFrom.

private static RefactoringStatus createFrom(IStatus status) {
    if (status.isOK())
        return new RefactoringStatus();
    if (!status.isMultiStatus()) {
        switch(status.getSeverity()) {
            case IStatus.OK:
                return new RefactoringStatus();
            case IStatus.INFO:
                return RefactoringStatus.createInfoStatus(status.getMessage());
            case IStatus.WARNING:
                return RefactoringStatus.createWarningStatus(status.getMessage());
            case IStatus.ERROR:
                return RefactoringStatus.createErrorStatus(status.getMessage());
            case IStatus.CANCEL:
                return RefactoringStatus.createFatalErrorStatus(status.getMessage());
            default:
                return RefactoringStatus.createFatalErrorStatus(status.getMessage());
        }
    } else {
        IStatus[] children = status.getChildren();
        RefactoringStatus result = new RefactoringStatus();
        for (int i = 0; i < children.length; i++) {
            result.merge(createFrom(children[i]));
        }
        return result;
    }
}

Example 32 with RefactoringStatus

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

the class InferTypeArgumentsRefactoring method checkInitialConditions.

/*
	 * @see org.eclipse.ltk.core.refactoring.Refactoring#checkInitialConditions(org.eclipse.core.runtime.IProgressMonitor)
	 */
@Override
public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException, OperationCanceledException {
    RefactoringStatus result = check15();
    pm.done();
    return result;
}

Example 33 with RefactoringStatus

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

the class InferTypeArgumentsRefactoring method checkFinalConditions.

/*
	 * @see org.eclipse.ltk.core.refactoring.Refactoring#checkFinalConditions(org.eclipse.core.runtime.IProgressMonitor)
	 */
@Override
public RefactoringStatus checkFinalConditions(final IProgressMonitor pm) throws CoreException, OperationCanceledException {
    HashMap<IJavaProject, ArrayList<IJavaElement>> projectsToElements = getJavaElementsPerProject(fElements);
    //$NON-NLS-1$
    pm.beginTask("", projectsToElements.size() + 2);
    final RefactoringStatus result = new RefactoringStatus();
    try {
        fTCModel = new InferTypeArgumentsTCModel();
        final InferTypeArgumentsConstraintCreator unitCollector = new InferTypeArgumentsConstraintCreator(fTCModel, fAssumeCloneReturnsSameType);
        for (Iterator<Entry<IJavaProject, ArrayList<IJavaElement>>> iter = projectsToElements.entrySet().iterator(); iter.hasNext(); ) {
            Entry<IJavaProject, ArrayList<IJavaElement>> entry = iter.next();
            IJavaProject project = entry.getKey();
            ArrayList<IJavaElement> javaElementsList = entry.getValue();
            IJavaElement[] javaElements = javaElementsList.toArray(new IJavaElement[javaElementsList.size()]);
            List<ICompilationUnit> cus = Arrays.asList(JavaModelUtil.getAllCompilationUnits(javaElements));
            int batchSize = 150;
            int batches = ((cus.size() - 1) / batchSize) + 1;
            SubProgressMonitor projectMonitor = new SubProgressMonitor(pm, 1);
            //$NON-NLS-1$
            projectMonitor.beginTask("", batches);
            projectMonitor.setTaskName(RefactoringCoreMessages.InferTypeArgumentsRefactoring_building);
            for (int i = 0; i < batches; i++) {
                List<ICompilationUnit> batch = cus.subList(i * batchSize, Math.min(cus.size(), (i + 1) * batchSize));
                ICompilationUnit[] batchCus = batch.toArray(new ICompilationUnit[batch.size()]);
                final SubProgressMonitor batchMonitor = new SubProgressMonitor(projectMonitor, 1);
                batchMonitor.subTask(RefactoringCoreMessages.InferTypeArgumentsRefactoring_calculating_dependencies);
                ASTParser parser = ASTParser.newParser(ASTProvider.SHARED_AST_LEVEL);
                parser.setProject(project);
                parser.setCompilerOptions(RefactoringASTParser.getCompilerOptions(project));
                parser.setResolveBindings(true);
                parser.createASTs(batchCus, new String[0], new ASTRequestor() {

                    @Override
                    public void acceptAST(final ICompilationUnit source, final CompilationUnit ast) {
                        batchMonitor.subTask(BasicElementLabels.getFileName(source));
                        SafeRunner.run(new ISafeRunnable() {

                            public void run() throws Exception {
                                IProblem[] problems = ast.getProblems();
                                for (int p = 0; p < problems.length; p++) {
                                    if (problems[p].isError()) {
                                        String cuName = JavaElementLabels.getElementLabel(source, JavaElementLabels.CU_QUALIFIED);
                                        String msg = Messages.format(RefactoringCoreMessages.InferTypeArgumentsRefactoring_error_in_cu_skipped, new Object[] { cuName });
                                        result.addError(msg, JavaStatusContext.create(source, SourceRangeFactory.create(problems[p])));
                                        return;
                                    }
                                }
                                ast.accept(unitCollector);
                            }

                            public void handleException(Throwable exception) {
                                String cuName = JavaElementLabels.getElementLabel(source, JavaElementLabels.CU_QUALIFIED);
                                String msg = Messages.format(RefactoringCoreMessages.InferTypeArgumentsRefactoring_internal_error, new Object[] { cuName });
                                JavaPlugin.log(new Status(IStatus.ERROR, JavaPlugin.getPluginId(), IJavaStatusConstants.INTERNAL_ERROR, msg, null));
                                String msg2 = Messages.format(RefactoringCoreMessages.InferTypeArgumentsRefactoring_error_skipped, new Object[] { cuName });
                                result.addError(msg2, JavaStatusContext.create(source));
                            }
                        });
                        fTCModel.newCu();
                    }

                    @Override
                    public void acceptBinding(String bindingKey, IBinding binding) {
                    //do nothing
                    }
                }, batchMonitor);
            }
            projectMonitor.done();
            fTCModel.newCu();
        }
        //			Display.getDefault().syncExec(new Runnable() {
        //				public void run() {
        //					MessageDialog.openInformation(Display.getCurrent().getActiveShell(), "Debugging...", "after constraint gen");
        //				}
        //			});
        pm.setTaskName(RefactoringCoreMessages.InferTypeArgumentsRefactoring_solving);
        InferTypeArgumentsConstraintsSolver solver = new InferTypeArgumentsConstraintsSolver(fTCModel);
        InferTypeArgumentsUpdate updates = solver.solveConstraints(new SubProgressMonitor(pm, 1));
        //free caches
        solver = null;
        fChangeManager = new TextChangeManager();
        rewriteDeclarations(updates, new SubProgressMonitor(pm, 1));
        IFile[] filesToModify = ResourceUtil.getFiles(fChangeManager.getAllCompilationUnits());
        result.merge(Checks.validateModifiesFiles(filesToModify, getValidationContext()));
        return result;
    } finally {
        pm.done();
        clearGlobalState();
    }
}

Example 34 with RefactoringStatus

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

the class InferTypeArgumentsRefactoring method initialize.

private RefactoringStatus initialize(JavaRefactoringArguments arguments) {
    final String clone = arguments.getAttribute(ATTRIBUTE_CLONE);
    if (clone != null) {
        fAssumeCloneReturnsSameType = Boolean.valueOf(clone).booleanValue();
    } else
        return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_CLONE));
    final String leave = arguments.getAttribute(ATTRIBUTE_LEAVE);
    if (leave != null) {
        fLeaveUnconstrainedRaw = Boolean.valueOf(leave).booleanValue();
    } else
        return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_LEAVE));
    int count = 1;
    final List<IJavaElement> elements = new ArrayList<IJavaElement>();
    String handle = null;
    String attribute = JavaRefactoringDescriptorUtil.ATTRIBUTE_ELEMENT + count;
    final RefactoringStatus status = new RefactoringStatus();
    while ((handle = arguments.getAttribute(attribute)) != null) {
        final IJavaElement element = JavaRefactoringDescriptorUtil.handleToElement(arguments.getProject(), handle, false);
        if (element == null || !element.exists())
            return JavaRefactoringDescriptorUtil.createInputFatalStatus(element, getName(), IJavaRefactorings.INFER_TYPE_ARGUMENTS);
        else
            elements.add(element);
        count++;
        attribute = JavaRefactoringDescriptorUtil.ATTRIBUTE_ELEMENT + count;
    }
    fElements = elements.toArray(new IJavaElement[elements.size()]);
    if (elements.isEmpty())
        return JavaRefactoringDescriptorUtil.createInputFatalStatus(null, getName(), IJavaRefactorings.INFER_TYPE_ARGUMENTS);
    if (!status.isOK())
        return status;
    return new RefactoringStatus();
}

Example 35 with RefactoringStatus

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

the class SourceAnalyzer method checkActivation.

public RefactoringStatus checkActivation() throws JavaModelException {
    RefactoringStatus result = new RefactoringStatus();
    if (!fTypeRoot.isStructureKnown()) {
        result.addFatalError(RefactoringCoreMessages.InlineMethodRefactoring_SourceAnalyzer_syntax_errors, JavaStatusContext.create(fTypeRoot));
        return result;
    }
    IProblem[] problems = ASTNodes.getProblems(fDeclaration, ASTNodes.NODE_ONLY, ASTNodes.ERROR);
    if (problems.length > 0) {
        result.addFatalError(RefactoringCoreMessages.InlineMethodRefactoring_SourceAnalyzer_declaration_has_errors, JavaStatusContext.create(fTypeRoot, fDeclaration));
        return result;
    }
    final IMethodBinding declarationBinding = fDeclaration.resolveBinding();
    if (declarationBinding != null) {
        final int modifiers = declarationBinding.getModifiers();
        if (Modifier.isAbstract(modifiers)) {
            result.addFatalError(RefactoringCoreMessages.InlineMethodRefactoring_SourceAnalyzer_abstract_methods, JavaStatusContext.create(fTypeRoot, fDeclaration));
            return result;
        } else if (Modifier.isNative(modifiers)) {
            result.addFatalError(RefactoringCoreMessages.InlineMethodRefactoring_SourceAnalyzer_native_methods, JavaStatusContext.create(fTypeRoot, fDeclaration));
            return result;
        }
    } else {
        result.addFatalError(RefactoringCoreMessages.InlineMethodRefactoring_SourceAnalyzer_methoddeclaration_has_errors, JavaStatusContext.create(fTypeRoot));
        return result;
    }
    ActivationAnalyzer analyzer = new ActivationAnalyzer();
    fDeclaration.accept(analyzer);
    result.merge(analyzer.status);
    if (!result.hasFatalError()) {
        List<SingleVariableDeclaration> parameters = fDeclaration.parameters();
        fParameters = new HashMap<IVariableBinding, ParameterData>(parameters.size() * 2);
        for (Iterator<SingleVariableDeclaration> iter = parameters.iterator(); iter.hasNext(); ) {
            SingleVariableDeclaration element = iter.next();
            IVariableBinding binding = element.resolveBinding();
            if (binding == null) {
                result.addFatalError(RefactoringCoreMessages.InlineMethodRefactoring_SourceAnalyzer_declaration_has_errors, JavaStatusContext.create(fTypeRoot, fDeclaration));
                return result;
            }
            fParameters.put(binding, (ParameterData) element.getProperty(ParameterData.PROPERTY));
        }
        fNames = new HashMap<IBinding, NameData>();
        fImplicitReceivers = new ArrayList<Expression>(2);
        fTypeParameterReferences = new ArrayList<NameData>(0);
        fTypeParameterMapping = new HashMap<ITypeBinding, NameData>();
        ITypeBinding declaringType = declarationBinding.getDeclaringClass();
        if (declaringType == null) {
            result.addFatalError(RefactoringCoreMessages.InlineMethodRefactoring_SourceAnalyzer_typedeclaration_has_errors, JavaStatusContext.create(fTypeRoot));
            return result;
        }
        ITypeBinding[] typeParameters = declaringType.getTypeParameters();
        for (int i = 0; i < typeParameters.length; i++) {
            NameData data = new NameData(typeParameters[i].getName());
            fTypeParameterReferences.add(data);
            fTypeParameterMapping.put(typeParameters[i], data);
        }
        fMethodTypeParameterReferences = new ArrayList<NameData>(0);
        fMethodTypeParameterMapping = new HashMap<ITypeBinding, NameData>();
        IMethodBinding method = declarationBinding;
        typeParameters = method.getTypeParameters();
        for (int i = 0; i < typeParameters.length; i++) {
            NameData data = new NameData(typeParameters[i].getName());
            fMethodTypeParameterReferences.add(data);
            fMethodTypeParameterMapping.put(typeParameters[i], data);
        }
    }
    if (fDeclaration.isVarargs()) {
        List<SingleVariableDeclaration> parameters = fDeclaration.parameters();
        VarargAnalyzer vAnalyzer = new VarargAnalyzer(parameters.get(parameters.size() - 1).getName().resolveBinding());
        fDeclaration.getBody().accept(vAnalyzer);
    }
    return result;
}