Java IProblem.IllegalReturnNullityRedefinition方法代碼示例

import org.eclipse.jdt.core.compiler.IProblem; //導入方法依賴的package包/類
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});
}
 

import org.eclipse.jdt.core.compiler.IProblem; //導入方法依賴的package包/類
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);
    }
  }
}
 

import org.eclipse.jdt.core.compiler.IProblem; //導入方法依賴的package包/類
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;
}