Java IProblem.RequiredNonNullButProvidedPotentialNull方法代碼示例

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

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);
    }
  }
}