Java Code Examples for org.eclipse.jdt.core.compiler.IProblem#IllegalRedefinitionToNonNullParameter

The following examples show how to use org.eclipse.jdt.core.compiler.IProblem#IllegalRedefinitionToNonNullParameter . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source File: NullAnnotationsCleanUp.java    From Eclipse-Postfix-Code-Completion with Eclipse Public License 1.0 5 votes vote down vote up 
/**
 * {@inheritDoc}
 */
@Override
public String[] getStepDescriptions() {
	List<String> result= new ArrayList<String>();
	switch (this.handledProblemID) {
		case IProblem.NonNullLocalVariableComparisonYieldsFalse:
		case IProblem.RedundantNullCheckOnNonNullLocalVariable:
		case IProblem.RequiredNonNullButProvidedNull:
		case IProblem.RequiredNonNullButProvidedPotentialNull:
		case IProblem.RequiredNonNullButProvidedSpecdNullable:
		case IProblem.RequiredNonNullButProvidedUnknown:
		case IProblem.IllegalDefinitionToNonNullParameter:
		case IProblem.IllegalRedefinitionToNonNullParameter:
		case IProblem.ParameterLackingNullableAnnotation:
			result.add(MultiFixMessages.NullAnnotationsCleanUp_add_nullable_annotation);
			break;
		case IProblem.ParameterLackingNonNullAnnotation:
			result.add(MultiFixMessages.NullAnnotationsCleanUp_add_nonnull_annotation);
			break;
		case IProblem.RedundantNullAnnotation:
		case IProblem.RedundantNullDefaultAnnotationPackage:
		case IProblem.RedundantNullDefaultAnnotationType:
		case IProblem.RedundantNullDefaultAnnotationMethod:
			result.add(MultiFixMessages.NullAnnotationsCleanUp_remove_redundant_nullness_annotation);
			break;
	}
	return result.toArray(new String[result.size()]);
}
Example 2
Source File: NullAnnotationsFix.java    From Eclipse-Postfix-Code-Completion with Eclipse Public License 1.0 4 votes vote down vote up 
public static NullAnnotationsFix createNullAnnotationInSignatureFix(CompilationUnit compilationUnit, IProblemLocation problem, 
		ChangeKind changeKind, boolean isArgumentProblem) {
	String nullableAnnotationName= getNullableAnnotationName(compilationUnit.getJavaElement(), false);
	String nonNullAnnotationName= getNonNullAnnotationName(compilationUnit.getJavaElement(), false);
	String annotationToAdd= nullableAnnotationName;
	String annotationToRemove= nonNullAnnotationName;

	switch (problem.getProblemId()) {
		case IProblem.IllegalDefinitionToNonNullParameter:
		case IProblem.IllegalRedefinitionToNonNullParameter:
			// case ParameterLackingNullableAnnotation: // never proposed with modifyOverridden
			if (changeKind == ChangeKind.OVERRIDDEN) {
				annotationToAdd= nonNullAnnotationName;
				annotationToRemove= nullableAnnotationName;
			}
			break;
		case IProblem.ParameterLackingNonNullAnnotation:
		case IProblem.IllegalReturnNullityRedefinition:
			if (changeKind != ChangeKind.OVERRIDDEN) {
				annotationToAdd= nonNullAnnotationName;
				annotationToRemove= nullableAnnotationName;
			}
			break;
		case IProblem.RequiredNonNullButProvidedNull:
		case IProblem.RequiredNonNullButProvidedPotentialNull:
		case IProblem.RequiredNonNullButProvidedUnknown:
		case IProblem.RequiredNonNullButProvidedSpecdNullable:
			if (isArgumentProblem == (changeKind != ChangeKind.TARGET)) {
				annotationToAdd= nonNullAnnotationName;
				annotationToRemove= nullableAnnotationName;
			}
			break;
		case IProblem.ConflictingNullAnnotations:
		case IProblem.ConflictingInheritedNullAnnotations:
			if (changeKind == ChangeKind.INVERSE) {
				annotationToAdd= nonNullAnnotationName;
				annotationToRemove= nullableAnnotationName;
			}
		// all others propose to add @Nullable
	}

	// when performing one change at a time we can actually modify another CU than the current one:
	NullAnnotationsRewriteOperations.SignatureAnnotationRewriteOperation operation= NullAnnotationsRewriteOperations.createAddAnnotationOperation(compilationUnit, problem, annotationToAdd, annotationToRemove, null,
			false/*thisUnitOnly*/, true/*allowRemove*/, isArgumentProblem, changeKind);
	if (operation == null)
		return null;

	if (annotationToAdd == nonNullAnnotationName) {
		operation.fRemoveIfNonNullByDefault= true;
		operation.fNonNullByDefaultName= getNonNullByDefaultAnnotationName(compilationUnit.getJavaElement(), false);
	}
	return new NullAnnotationsFix(operation.getMessage(), operation.getCompilationUnit(), // note that this uses the findings from createAddAnnotationOperation(..)
			new NullAnnotationsRewriteOperations.SignatureAnnotationRewriteOperation[] { operation });
}
Example 3
Source File: NullAnnotationsFix.java    From Eclipse-Postfix-Code-Completion with Eclipse Public License 1.0 4 votes vote down vote up 
private static void createAddNullAnnotationOperations(CompilationUnit compilationUnit, IProblemLocation[] locations, List<CompilationUnitRewriteOperation> result) {
	String nullableAnnotationName= getNullableAnnotationName(compilationUnit.getJavaElement(), false);
	String nonNullAnnotationName= getNonNullAnnotationName(compilationUnit.getJavaElement(), false);
	Set<String> handledPositions= new HashSet<String>();
	for (int i= 0; i < locations.length; i++) {
		IProblemLocation problem= locations[i];
		if (problem == null)
			continue; // problem was filtered out by createCleanUp()
		boolean isArgumentProblem= isComplainingAboutArgument(problem.getCoveredNode(compilationUnit));
		String annotationToAdd= nullableAnnotationName;
		String annotationToRemove= nonNullAnnotationName;
		// cf. createNullAnnotationInSignatureFix() but changeKind is constantly LOCAL
		switch (problem.getProblemId()) {
			case IProblem.IllegalDefinitionToNonNullParameter:
			case IProblem.IllegalRedefinitionToNonNullParameter:
				break;
			case IProblem.ParameterLackingNonNullAnnotation:
			case IProblem.IllegalReturnNullityRedefinition:
				annotationToAdd= nonNullAnnotationName;
				annotationToRemove= nullableAnnotationName;
				break;
			case IProblem.RequiredNonNullButProvidedNull:
			case IProblem.RequiredNonNullButProvidedPotentialNull:
			case IProblem.RequiredNonNullButProvidedUnknown:
			case IProblem.RequiredNonNullButProvidedSpecdNullable:
				if (isArgumentProblem) {
					annotationToAdd= nonNullAnnotationName;
					annotationToRemove= nullableAnnotationName;
				}
				break;
			// all others propose to add @Nullable
		}
		// when performing multiple changes we can only modify the one CU that the CleanUp infrastructure provides to the operation.
		SignatureAnnotationRewriteOperation fix= NullAnnotationsRewriteOperations.createAddAnnotationOperation(compilationUnit, problem, annotationToAdd, annotationToRemove, handledPositions,
				true/*thisUnitOnly*/, false/*allowRemove*/, isArgumentProblem, ChangeKind.LOCAL);
		if (fix != null) {
			if (annotationToAdd == nonNullAnnotationName) {
				fix.fRemoveIfNonNullByDefault= true;
				fix.fNonNullByDefaultName= getNonNullByDefaultAnnotationName(compilationUnit.getJavaElement(), false);
			}
			result.add(fix);
		}
	}
}
Example 4
Source File: NullAnnotationsRewriteOperations.java    From Eclipse-Postfix-Code-Completion with Eclipse Public License 1.0 4 votes vote down vote up 
private static SignatureAnnotationRewriteOperation createAddAnnotationToOverriddenOperation(CompilationUnit compilationUnit, IProblemLocation problem, String annotationToAdd,
		String annotationToRemove, boolean allowRemove) {
	ICompilationUnit cu= (ICompilationUnit) compilationUnit.getJavaElement();
	if (!JavaModelUtil.is50OrHigher(cu.getJavaProject()))
		return null;

	ASTNode selectedNode= problem.getCoveringNode(compilationUnit);
	if (selectedNode == null)
		return null;

	ASTNode declaringNode= getDeclaringNode(selectedNode);
	switch (problem.getProblemId()) {
		case IProblem.IllegalDefinitionToNonNullParameter:
		case IProblem.IllegalRedefinitionToNonNullParameter:
			break;
		case IProblem.IllegalReturnNullityRedefinition:
			if (declaringNode == null)
				declaringNode= selectedNode;
			break;
		default:
			return null;
	}

	String annotationNameLabel= annotationToAdd;
	int lastDot= annotationToAdd.lastIndexOf('.');
	if (lastDot != -1)
		annotationNameLabel= annotationToAdd.substring(lastDot + 1);
	annotationNameLabel= BasicElementLabels.getJavaElementName(annotationNameLabel);

	if (declaringNode instanceof MethodDeclaration) {
		// complaint is in signature of this method
		MethodDeclaration declaration= (MethodDeclaration) declaringNode;
		switch (problem.getProblemId()) {
			case IProblem.IllegalDefinitionToNonNullParameter:
			case IProblem.IllegalRedefinitionToNonNullParameter:
				return createChangeOverriddenParameterOperation(compilationUnit, cu, declaration, selectedNode, allowRemove, annotationToAdd, annotationToRemove, annotationNameLabel);
			case IProblem.IllegalReturnNullityRedefinition:
				if (hasNullAnnotation(declaration)) { // don't adjust super if local has no explicit annotation (?)
					return createChangeOverriddenReturnOperation(compilationUnit, cu, declaration, allowRemove, annotationToAdd, annotationToRemove, annotationNameLabel);
				}
		}
	}
	return null;
}