Java RefactoringStatus.addError方法代码示例

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
/**
 * Checks if the parameter names are valid.
 *
 * @return validation status
 */
public RefactoringStatus checkParameterNames() {
	RefactoringStatus result = new RefactoringStatus();
	for (Iterator<ParameterInfo> iter = fParameterInfos.iterator(); iter.hasNext();) {
		ParameterInfo parameter = iter.next();
		result.merge(Checks.checkIdentifier(parameter.getNewName(), fCUnit));
		for (Iterator<ParameterInfo> others = fParameterInfos.iterator(); others.hasNext();) {
			ParameterInfo other = others.next();
			if (parameter != other && other.getNewName().equals(parameter.getNewName())) {
				result.addError(Messages.format(RefactoringCoreMessages.ExtractMethodRefactoring_error_sameParameter, BasicElementLabels.getJavaElementName(other.getNewName())));
				return result;
			}
		}
		if (parameter.isRenamed() && fUsedNames.contains(parameter.getNewName())) {
			result.addError(Messages.format(RefactoringCoreMessages.ExtractMethodRefactoring_error_nameInUse, BasicElementLabels.getJavaElementName(parameter.getNewName())));
			return result;
		}
	}
	return result;
}
 

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
@Override
public RefactoringStatus checkFinalConditions(IProgressMonitor pm, CheckConditionsContext context)
		throws CoreException, OperationCanceledException {
	RefactoringStatus status = new RefactoringStatus();
	// Consume "rename" tsserver command.
	try {
		rename = tsFile.rename(offset, isFindInComments(), isFindInStrings()).get(1000, TimeUnit.MILLISECONDS);
		RenameInfo info = rename.getInfo();
		if (!info.isCanRename()) {
			// Refactoring cannot be done.
			status.addError(info.getLocalizedErrorMessage());
		}
	} catch (Exception e) {
		status.addError(e.getMessage());
	}
	return status;
}
 

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
private RefactoringStatus checkParameterNamesInRippleMethods() throws JavaModelException {
  RefactoringStatus result = new RefactoringStatus();
  Set<String> newParameterNames = getNewParameterNamesList();
  for (int i = 0; i < fRippleMethods.length; i++) {
    String[] paramNames = fRippleMethods[i].getParameterNames();
    for (int j = 0; j < paramNames.length; j++) {
      if (newParameterNames.contains(paramNames[j])) {
        String[] args =
            new String[] {
              JavaElementUtil.createMethodSignature(fRippleMethods[i]),
              BasicElementLabels.getJavaElementName(paramNames[j])
            };
        String msg =
            Messages.format(RefactoringCoreMessages.ChangeSignatureRefactoring_already_has, args);
        RefactoringStatusContext context =
            JavaStatusContext.create(
                fRippleMethods[i].getCompilationUnit(), fRippleMethods[i].getNameRange());
        result.addError(msg, context);
      }
    }
  }
  return result;
}
 

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
@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;
}
 

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
private RefactoringStatus checkTypesInCompilationUnit() {
  RefactoringStatus result = new RefactoringStatus();
  if (!Checks.isTopLevel(fType)) { // the other case checked in checkTypesInPackage
    IType siblingType = fType.getDeclaringType().getType(getNewElementName());
    if (siblingType.exists()) {
      String msg =
          Messages.format(
              RefactoringCoreMessages.RenameTypeRefactoring_member_type_exists,
              new String[] {
                getNewElementLabel(),
                BasicElementLabels.getJavaElementName(
                    fType.getDeclaringType().getFullyQualifiedName('.'))
              });
      result.addError(msg, JavaStatusContext.create(siblingType));
    }
  }
  return result;
}
 

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
private static void addReferenceShadowedError(
    ICompilationUnit cu, SearchMatch newMatch, String newElementName, RefactoringStatus result) {
  // Found a new match with no corresponding old match.
  // -> The new match is a reference which was pointing to another element,
  // but that other element has been shadowed

  // TODO: should not have to filter declarations:
  if (newMatch instanceof MethodDeclarationMatch || newMatch instanceof FieldDeclarationMatch)
    return;
  ISourceRange range = getOldSourceRange(newMatch);
  RefactoringStatusContext context = JavaStatusContext.create(cu, range);
  String message =
      Messages.format(
          RefactoringCoreMessages.RenameAnalyzeUtil_reference_shadowed,
          new String[] {
            BasicElementLabels.getFileName(cu),
            BasicElementLabels.getJavaElementName(newElementName)
          });
  result.addError(message, context);
}
 

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
private RefactoringStatus checkTypeNameConflicts(
    ICompilationUnit iCompilationUnit, Set<String> topLevelTypeNames) throws CoreException {
  RefactoringStatus result = new RefactoringStatus();
  IType[] types = iCompilationUnit.getTypes();

  for (int i = 0; i < types.length; i++) {
    String name = types[i].getElementName();
    if (topLevelTypeNames.contains(name)) {
      String[] keys = {getElementLabel(iCompilationUnit.getParent()), getElementLabel(types[i])};
      String msg =
          Messages.format(RefactoringCoreMessages.RenamePackageRefactoring_contains_type, keys);
      RefactoringStatusContext context = JavaStatusContext.create(types[i]);
      result.addError(msg, context);
    }
  }
  return result;
}
 

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
/**
 * Checks if the new method is already used in the given type.
 *
 * @param type
 * @param methodName
 * @param parameters
 * @return the status
 */
public static RefactoringStatus checkMethodInType(
    ITypeBinding type, String methodName, ITypeBinding[] parameters) {
  RefactoringStatus result = new RefactoringStatus();
  IMethodBinding method =
      org.eclipse.jdt.internal.corext.dom.Bindings.findMethodInType(type, methodName, parameters);
  if (method != null) {
    if (method.isConstructor()) {
      result.addWarning(
          Messages.format(
              RefactoringCoreMessages.Checks_methodName_constructor,
              new Object[] {BasicElementLabels.getJavaElementName(type.getName())}));
    } else {
      result.addError(
          Messages.format(
              RefactoringCoreMessages.Checks_methodName_exists,
              new Object[] {
                BasicElementLabels.getJavaElementName(methodName),
                BasicElementLabels.getJavaElementName(type.getName())
              }),
          JavaStatusContext.create(method));
    }
  }
  return result;
}
 

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
/**
 * Checks if the new method is already used in the given type.
 *
 * @param type
 * @param methodName
 * @param parameters
 * @return the status
 */
public static RefactoringStatus checkMethodInType(ITypeBinding type, String methodName, ITypeBinding[] parameters) {
	RefactoringStatus result = new RefactoringStatus();
	IMethodBinding method = org.eclipse.jdt.internal.corext.dom.Bindings.findMethodInType(type, methodName, parameters);
	if (method != null) {
		if (method.isConstructor()) {
			result.addWarning(Messages.format(RefactoringCoreMessages.Checks_methodName_constructor, new Object[] { BasicElementLabels.getJavaElementName(type.getName()) }));
		} else {
			result.addError(Messages.format(RefactoringCoreMessages.Checks_methodName_exists, new Object[] { BasicElementLabels.getJavaElementName(methodName), BasicElementLabels.getJavaElementName(type.getName()) }),
					JavaStatusContext.create(method));
		}
	}
	return result;
}
 

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
/**
 * Checks if the new method somehow conflicts with an already existing
 * method in the hierarchy. The following checks are done:
 * <ul>
 * <li>if the new method overrides a method defined in the given type or in
 * one of its super classes.</li>
 * </ul>
 *
 * @param type
 * @param methodName
 * @param returnType
 * @param parameters
 * @return the status
 */
public static RefactoringStatus checkMethodInHierarchy(ITypeBinding type, String methodName, ITypeBinding returnType, ITypeBinding[] parameters) {
	RefactoringStatus result = new RefactoringStatus();
	IMethodBinding method = Bindings.findMethodInHierarchy(type, methodName, parameters);
	if (method != null) {
		boolean returnTypeClash = false;
		ITypeBinding methodReturnType = method.getReturnType();
		if (returnType != null && methodReturnType != null) {
			String returnTypeKey = returnType.getKey();
			String methodReturnTypeKey = methodReturnType.getKey();
			if (returnTypeKey == null && methodReturnTypeKey == null) {
				returnTypeClash = returnType != methodReturnType;
			} else if (returnTypeKey != null && methodReturnTypeKey != null) {
				returnTypeClash = !returnTypeKey.equals(methodReturnTypeKey);
			}
		}
		ITypeBinding dc = method.getDeclaringClass();
		if (returnTypeClash) {
			result.addError(Messages.format(RefactoringCoreMessages.Checks_methodName_returnTypeClash, new Object[] { BasicElementLabels.getJavaElementName(methodName), BasicElementLabels.getJavaElementName(dc.getName()) }),
					JavaStatusContext.create(method));
		} else {
			if (method.isConstructor()) {
				result.addWarning(Messages.format(RefactoringCoreMessages.Checks_methodName_constructor, new Object[] { BasicElementLabels.getJavaElementName(dc.getName()) }));
			} else {
				result.addError(Messages.format(RefactoringCoreMessages.Checks_methodName_overrides, new Object[] { BasicElementLabels.getJavaElementName(methodName), BasicElementLabels.getJavaElementName(dc.getName()) }),
						JavaStatusContext.create(method));
			}
		}
	}
	return result;
}
 

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
private RefactoringStatus analyzeSelection(RefactoringStatus status) {
	fInputFlowContext = new FlowContext(0, fMaxVariableId + 1);
	fInputFlowContext.setConsiderAccessMode(true);
	fInputFlowContext.setComputeMode(FlowContext.ARGUMENTS);

	InOutFlowAnalyzer flowAnalyzer = new InOutFlowAnalyzer(fInputFlowContext);
	fInputFlowInfo = flowAnalyzer.perform(getSelectedNodes());

	if (fInputFlowInfo.branches()) {
		String canHandleBranchesProblem = canHandleBranches();
		if (canHandleBranchesProblem != null) {
			status.addFatalError(canHandleBranchesProblem, JavaStatusContext.create(fCUnit, getSelection()));
			fReturnKind = ERROR;
			return status;
		}
	}
	if (fInputFlowInfo.isValueReturn()) {
		fReturnKind = RETURN_STATEMENT_VALUE;
	} else if (fInputFlowInfo.isVoidReturn() || (fInputFlowInfo.isPartialReturn() && isVoidMethod() && isLastStatementSelected())) {
		fReturnKind = RETURN_STATEMENT_VOID;
	} else if (fInputFlowInfo.isNoReturn() || fInputFlowInfo.isThrow() || fInputFlowInfo.isUndefined()) {
		fReturnKind = NO;
	}

	if (fReturnKind == UNDEFINED) {
		status.addError(RefactoringCoreMessages.FlowAnalyzer_execution_flow, JavaStatusContext.create(fCUnit, getSelection()));
		fReturnKind = NO;
	}
	computeInput();
	computeExceptions();
	computeOutput(status);
	if (status.hasFatalError()) {
		return status;
	}

	adjustArgumentsAndMethodLocals();
	compressArrays();
	return status;
}
 

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
private void checkTypes(
    RefactoringStatus result, IMethod method, IType[] types, String key, IProgressMonitor pm) {
  pm.beginTask("", types.length); // $NON-NLS-1$
  for (int i = 0; i < types.length; i++) {
    pm.worked(1);
    IMethod[] overridden = types[i].findMethods(method);
    if (overridden != null && overridden.length > 0) {
      result.addError(
          Messages.format(key, BasicElementLabels.getJavaElementName(types[i].getElementName())),
          JavaStatusContext.create(overridden[0]));
    }
  }
}
 

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
private void checkTypes(
    RefactoringStatus result, IMethod method, IType[] types, String key, IProgressMonitor pm) {
  pm.beginTask("", types.length); // $NON-NLS-1$
  for (int i = 0; i < types.length; i++) {
    pm.worked(1);
    IMethod[] overridden = types[i].findMethods(method);
    if (overridden != null && overridden.length > 0) {
      result.addError(
          Messages.format(
              key, JavaElementLabels.getElementLabel(types[i], JavaElementLabels.ALL_DEFAULT)),
          JavaStatusContext.create(overridden[0]));
    }
  }
}
 

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
private void logMalfunctioningParticipant(
    RefactoringStatus status, ParticipantDescriptor descriptor, Throwable e) {
  status.addError(
      Messages.format(
          RefactoringCoreMessages.ParticipantExtensionPoint_participant_removed,
          descriptor.getName()));
  RefactoringCorePlugin.logRemovedParticipant(descriptor, e);
}
 

import org.eclipse.ltk.core.refactoring.RefactoringStatus; //导入方法依赖的package包/类
public static RefactoringStatus reportProblemNodes(
    String modifiedWorkingCopySource, SimpleName[] problemNodes) {
  RefactoringStatus result = new RefactoringStatus();
  for (int i = 0; i < problemNodes.length; i++) {
    RefactoringStatusContext context =
        new JavaStringStatusContext(
            modifiedWorkingCopySource, SourceRangeFactory.create(problemNodes[i]));
    result.addError(
        Messages.format(
            RefactoringCoreMessages.RefactoringAnalyzeUtil_name_collision,
            BasicElementLabels.getJavaElementName(problemNodes[i].getIdentifier())),
        context);
  }
  return result;
}