Java IProblemLocation类代码示例

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
@Override
public IJavaCompletionProposal[] getCorrections(IInvocationContext context,
    IProblemLocation[] locations) throws CoreException {
  for (final IProblemLocation problem : locations) {
    if ((problem.getProblemId() == IProblem.UnresolvedVariable
        || problem.getProblemId() == IProblem.UndefinedType)
        && Utils.isAPGAS(problem.getProblemArguments()[0])) {
      if (!apgasInBuildPath(context.getCompilationUnit().getJavaProject())) {
        return getAddAPGASToBuildPathProposals(context);
      }
    } else if (problem.getProblemId() == IProblem.UndefinedMethod
        && Utils.isAPGAS(problem.getProblemArguments()[1])) {
      if (!apgasInBuildPath(context.getCompilationUnit().getJavaProject())) {
        return getAddAPGASToBuildPathProposals(context);
      } else {
        return getImportStaticConstructsProposal(context);
      }
    }
  }
  return null;
}
 

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
public static ICleanUpFix createCleanUp(
    CompilationUnit compilationUnit, IProblemLocation[] locations, int problemID) {
  ICompilationUnit cu = (ICompilationUnit) compilationUnit.getJavaElement();
  if (!JavaModelUtil.is50OrHigher(cu.getJavaProject())) return null;

  List<CompilationUnitRewriteOperation> operations =
      new ArrayList<CompilationUnitRewriteOperation>();
  if (locations == null) {
    org.eclipse.jdt.core.compiler.IProblem[] problems = compilationUnit.getProblems();
    locations = new IProblemLocation[problems.length];
    for (int i = 0; i < problems.length; i++) {
      if (problems[i].getID() == problemID) locations[i] = new ProblemLocation(problems[i]);
    }
  }

  createAddNullAnnotationOperations(compilationUnit, locations, operations);
  createRemoveRedundantNullAnnotationsOperations(compilationUnit, locations, operations);
  if (operations.size() == 0) return null;
  CompilationUnitRewriteOperation[] operationsArray =
      operations.toArray(new CompilationUnitRewriteOperation[operations.size()]);
  return new NullAnnotationsFix(
      FixMessages.NullAnnotationsFix_add_annotation_change_name,
      compilationUnit,
      operationsArray);
}
 

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
private static void createRemoveRedundantNullAnnotationsOperations(
    CompilationUnit compilationUnit,
    IProblemLocation[] locations,
    List<CompilationUnitRewriteOperation> result) {
  for (int i = 0; i < locations.length; i++) {
    IProblemLocation problem = locations[i];
    if (problem == null) continue; // problem was filtered out by createCleanUp()

    int problemId = problem.getProblemId();
    if (problemId == IProblem.RedundantNullAnnotation
        || problemId == IProblem.RedundantNullDefaultAnnotationPackage
        || problemId == IProblem.RedundantNullDefaultAnnotationType
        || problemId == IProblem.RedundantNullDefaultAnnotationMethod) {
      RemoveRedundantAnnotationRewriteOperation operation =
          new RemoveRedundantAnnotationRewriteOperation(compilationUnit, problem);
      result.add(operation);
    }
  }
}
 

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
protected ICleanUpFix createFix(CompilationUnit unit) throws CoreException {
  IProblemLocation[] problemLocations = convertProblems(unit.getProblems());
  problemLocations =
      filter(
          problemLocations,
          new int[] {
            IProblem.AbstractMethodMustBeImplemented,
            IProblem.EnumConstantMustImplementAbstractMethod
          });

  return UnimplementedCodeFix.createCleanUp(
      unit,
      isEnabled(CleanUpConstants.ADD_MISSING_METHODES),
      isEnabled(MAKE_TYPE_ABSTRACT),
      problemLocations);
}
 

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
public static CompilationUnitRewriteOperationsFix createIndirectAccessToStaticFix(
    CompilationUnit compilationUnit, IProblemLocation problem) {
  if (!isIndirectStaticAccess(problem)) return null;

  ToStaticAccessOperation operations[] =
      createToStaticAccessOperations(
          compilationUnit, new HashMap<ASTNode, Block>(), problem, false);
  if (operations == null) return null;

  String label =
      Messages.format(
          FixMessages.CodeStyleFix_ChangeStaticAccess_description,
          operations[0].getAccessorName());
  return new CodeStyleFix(
      label, compilationUnit, new CompilationUnitRewriteOperation[] {operations[0]});
}
 

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
public static ASTNode getSelectedTypeNode(CompilationUnit root, IProblemLocation problem) {
  ASTNode selectedNode = problem.getCoveringNode(root);
  if (selectedNode == null) return null;

  if (selectedNode.getNodeType() == ASTNode.ANONYMOUS_CLASS_DECLARATION) { // bug 200016
    selectedNode = selectedNode.getParent();
  }

  if (selectedNode.getLocationInParent() == EnumConstantDeclaration.NAME_PROPERTY) {
    selectedNode = selectedNode.getParent();
  }
  if (selectedNode.getNodeType() == ASTNode.SIMPLE_NAME
      && selectedNode.getParent() instanceof AbstractTypeDeclaration) {
    return selectedNode.getParent();
  } else if (selectedNode.getNodeType() == ASTNode.CLASS_INSTANCE_CREATION) {
    return ((ClassInstanceCreation) selectedNode).getAnonymousClassDeclaration();
  } else if (selectedNode.getNodeType() == ASTNode.ENUM_CONSTANT_DECLARATION) {
    EnumConstantDeclaration enumConst = (EnumConstantDeclaration) selectedNode;
    if (enumConst.getAnonymousClassDeclaration() != null)
      return enumConst.getAnonymousClassDeclaration();
    return enumConst;
  } else {
    return null;
  }
}
 

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
private static Java50Fix createFix(
    CompilationUnit compilationUnit, IProblemLocation problem, String annotation, String label) {
  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);
  if (!(declaringNode instanceof BodyDeclaration)) return null;

  BodyDeclaration declaration = (BodyDeclaration) declaringNode;

  AnnotationRewriteOperation operation = new AnnotationRewriteOperation(declaration, annotation);

  return new Java50Fix(label, compilationUnit, new CompilationUnitRewriteOperation[] {operation});
}
 

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
public static Java50Fix createRawTypeReferenceFix(
    CompilationUnit compilationUnit, IProblemLocation problem) {
  List<CompilationUnitRewriteOperation> operations =
      new ArrayList<CompilationUnitRewriteOperation>();
  SimpleType node =
      createRawTypeReferenceOperations(
          compilationUnit, new IProblemLocation[] {problem}, operations);
  if (operations.size() == 0) return null;

  return new Java50Fix(
      Messages.format(
          FixMessages.Java50Fix_AddTypeArguments_description,
          BasicElementLabels.getJavaElementName(node.getName().getFullyQualifiedName())),
      compilationUnit,
      operations.toArray(new CompilationUnitRewriteOperation[operations.size()]));
}
 

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
public static void getRemoveJavadocTagProposals(
    IInvocationContext context, IProblemLocation problem, Collection<ICommandAccess> proposals) {
  ASTNode node = problem.getCoveringNode(context.getASTRoot());
  while (node != null && !(node instanceof TagElement)) {
    node = node.getParent();
  }
  if (node == null) {
    return;
  }
  ASTRewrite rewrite = ASTRewrite.create(node.getAST());
  rewrite.remove(node, null);

  String label = CorrectionMessages.JavadocTagsSubProcessor_removetag_description;
  Image image =
      JavaPluginImages.get(
          JavaPluginImages
              .IMG_TOOL_DELETE); // JavaPlugin.getDefault().getWorkbench().getSharedImages().getImage(ISharedImages.IMG_TOOL_DELETE);
  proposals.add(
      new ASTRewriteCorrectionProposal(
          label, context.getCompilationUnit(), rewrite, IProposalRelevance.REMOVE_TAG, image));
}
 

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
private static void createAddDeprecatedAnnotationOperations(
    CompilationUnit compilationUnit,
    IProblemLocation[] locations,
    List<CompilationUnitRewriteOperation> result) {
  for (int i = 0; i < locations.length; i++) {
    IProblemLocation problem = locations[i];

    if (isMissingDeprecationProblem(problem.getProblemId())) {
      ASTNode selectedNode = problem.getCoveringNode(compilationUnit);
      if (selectedNode != null) {

        ASTNode declaringNode = getDeclaringNode(selectedNode);
        if (declaringNode instanceof BodyDeclaration) {
          BodyDeclaration declaration = (BodyDeclaration) declaringNode;
          AnnotationRewriteOperation operation =
              new AnnotationRewriteOperation(declaration, DEPRECATED);
          result.add(operation);
        }
      }
    }
  }
}
 

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
public static UnusedCodeFix createRemoveUnusedCastFix(
    CompilationUnit compilationUnit, IProblemLocation problem) {
  if (problem.getProblemId() != IProblem.UnnecessaryCast) return null;

  ASTNode selectedNode = problem.getCoveringNode(compilationUnit);

  ASTNode curr = selectedNode;
  while (curr instanceof ParenthesizedExpression) {
    curr = ((ParenthesizedExpression) curr).getExpression();
  }

  if (!(curr instanceof CastExpression)) return null;

  return new UnusedCodeFix(
      FixMessages.UnusedCodeFix_RemoveCast_description,
      compilationUnit,
      new CompilationUnitRewriteOperation[] {new RemoveCastOperation((CastExpression) curr)});
}
 

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
public static void addUnusedMemberProposal(
    IInvocationContext context, IProblemLocation problem, Collection<ICommandAccess> proposals) {
  int problemId = problem.getProblemId();
  UnusedCodeFix fix = UnusedCodeFix.createUnusedMemberFix(context.getASTRoot(), problem, false);
  if (fix != null) {
    addProposal(context, proposals, fix);
  }

  if (problemId == IProblem.LocalVariableIsNeverUsed) {
    fix = UnusedCodeFix.createUnusedMemberFix(context.getASTRoot(), problem, true);
    addProposal(context, proposals, fix);
  }

  if (problemId == IProblem.ArgumentIsNeverUsed) {
    JavadocTagsSubProcessor.getUnusedAndUndocumentedParameterOrExceptionProposals(
        context, problem, proposals);
  }

  if (problemId == IProblem.UnusedPrivateField) {
    GetterSetterCorrectionSubProcessor.addGetterSetterProposal(
        context, problem, proposals, IProposalRelevance.GETTER_SETTER_UNUSED_PRIVATE_FIELD);
  }
}
 

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
public static void addRedundantSuperInterfaceProposal(
    IInvocationContext context, IProblemLocation problem, Collection<ICommandAccess> proposals) {
  ASTNode selectedNode = problem.getCoveringNode(context.getASTRoot());
  if (!(selectedNode instanceof Name)) {
    return;
  }
  ASTNode node = ASTNodes.getNormalizedNode(selectedNode);

  ASTRewrite rewrite = ASTRewrite.create(node.getAST());
  rewrite.remove(node, null);

  String label = CorrectionMessages.LocalCorrectionsSubProcessor_remove_redundant_superinterface;
  Image image =
      JavaPluginImages.get(
          JavaPluginImages
              .IMG_TOOL_DELETE); // JavaPlugin.getDefault().getWorkbench().getSharedImages().getImage(ISharedImages.IMG_TOOL_DELETE);

  ASTRewriteCorrectionProposal proposal =
      new ASTRewriteCorrectionProposal(
          label,
          context.getCompilationUnit(),
          rewrite,
          IProposalRelevance.REMOVE_REDUNDANT_SUPER_INTERFACE,
          image);
  proposals.add(proposal);
}
 

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
public static void addUnnecessaryCastProposal(
    IInvocationContext context, IProblemLocation problem, Collection<ICommandAccess> proposals) {
  IProposableFix fix = UnusedCodeFix.createRemoveUnusedCastFix(context.getASTRoot(), problem);
  if (fix != null) {
    Image image = JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
    Map<String, String> options = new Hashtable<String, String>();
    options.put(CleanUpConstants.REMOVE_UNNECESSARY_CASTS, CleanUpOptions.TRUE);
    FixCorrectionProposal proposal =
        new FixCorrectionProposal(
            fix,
            new UnnecessaryCodeCleanUp(options),
            IProposalRelevance.REMOVE_UNUSED_CAST,
            image,
            context);
    proposals.add(proposal);
  }
}
 

import org.eclipse.jdt.ui.text.java.IProblemLocation; //导入依赖的package包/类
public static void addMethodWithConstrNameProposals(
    IInvocationContext context, IProblemLocation problem, Collection<ICommandAccess> proposals) {
  ICompilationUnit cu = context.getCompilationUnit();

  ASTNode selectedNode = problem.getCoveringNode(context.getASTRoot());
  if (selectedNode instanceof MethodDeclaration) {
    MethodDeclaration declaration = (MethodDeclaration) selectedNode;

    ASTRewrite rewrite = ASTRewrite.create(declaration.getAST());
    rewrite.set(declaration, MethodDeclaration.CONSTRUCTOR_PROPERTY, Boolean.TRUE, null);

    String label = CorrectionMessages.ReturnTypeSubProcessor_constrnamemethod_description;
    Image image = JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
    ASTRewriteCorrectionProposal proposal =
        new ASTRewriteCorrectionProposal(
            label, cu, rewrite, IProposalRelevance.CHANGE_TO_CONSTRUCTOR, image);
    proposals.add(proposal);
  }
}