case-study/jdt-after/ui/org/eclipse/jdt/internal/ui/fix/UnnecessaryCodeCleanUp.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2011 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package org.eclipse.jdt.internal.ui.fix;
  12
  13 import java.util.ArrayList;
  14 import java.util.Hashtable;
  15 import java.util.List;
  16 import java.util.Map;
  17
  18 import org.eclipse.core.runtime.CoreException;
  19
  20 import org.eclipse.jdt.core.ICompilationUnit;
  21 import org.eclipse.jdt.core.JavaCore;
  22 import org.eclipse.jdt.core.compiler.IProblem;
  23 import org.eclipse.jdt.core.dom.CompilationUnit;
  24
  25 import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
  26 import org.eclipse.jdt.internal.corext.fix.UnusedCodeFix;
  27
  28 import org.eclipse.jdt.ui.cleanup.CleanUpRequirements;
  29 import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
  30 import org.eclipse.jdt.ui.text.java.IProblemLocation;
  31
  32 public class UnnecessaryCodeCleanUp extends AbstractMultiFix {
  33
  34         public UnnecessaryCodeCleanUp(Map<String, String> options) {
  35                 super(options);
  36         }
  37
  38         public UnnecessaryCodeCleanUp() {
  39                 super();
  40         }
  41
  42         /**
  43          * {@inheritDoc}
  44          */
  45         @Override
  46         public CleanUpRequirements getRequirements() {
  47                 boolean requireAST= isEnabled(CleanUpConstants.REMOVE_UNNECESSARY_CASTS);
  48                 Map<String, String> requiredOptions= requireAST ? getRequiredOptions() : null;
  49                 return new CleanUpRequirements(requireAST, false, false, requiredOptions);
  50         }
  51
  52         /**
  53          * {@inheritDoc}
  54          */
  55         @Override
  56         protected ICleanUpFix createFix(CompilationUnit compilationUnit) throws CoreException {
  57                 return UnusedCodeFix.createCleanUp(compilationUnit,
  58                                 false,
  59                                 false,
  60                                 false,
  61                                 false,
  62                                 false,
  63                                 false,
  64                                 isEnabled(CleanUpConstants.REMOVE_UNNECESSARY_CASTS));
  65         }
  66
  67         /**
  68          * {@inheritDoc}
  69          */
  70         @Override
  71         protected ICleanUpFix createFix(CompilationUnit compilationUnit, IProblemLocation[] problems) throws CoreException {
  72                 return UnusedCodeFix.createCleanUp(compilationUnit, problems,
  73                                 false,
  74                                 false,
  75                                 false,
  76                                 false,
  77                                 false,
  78                                 false,
  79                                 isEnabled(CleanUpConstants.REMOVE_UNNECESSARY_CASTS));
  80         }
  81
  82         private Map<String, String> getRequiredOptions() {
  83                 Map<String, String> result= new Hashtable<String, String>();
  84
  85                 if (isEnabled(CleanUpConstants.REMOVE_UNNECESSARY_CASTS))
  86                         result.put(JavaCore.COMPILER_PB_UNNECESSARY_TYPE_CHECK, JavaCore.WARNING);
  87
  88                 return result;
  89         }
  90
  91         /**
  92          * {@inheritDoc}
  93          */
  94         @Override
  95         public String[] getStepDescriptions() {
  96                 List<String> result= new ArrayList<String>();
  97                 if (isEnabled(CleanUpConstants.REMOVE_UNNECESSARY_CASTS))
  98                         result.add(MultiFixMessages.UnusedCodeCleanUp_RemoveUnusedCasts_description);
  99                 return result.toArray(new String[result.size()]);
 100         }
 101
 102         /**
 103          * {@inheritDoc}
 104          */
 105         @Override
 106         public String getPreview() {
 107                 StringBuffer buf= new StringBuffer();
 108
 109                 if (isEnabled(CleanUpConstants.REMOVE_UNNECESSARY_CASTS)) {
 110                         buf.append("Boolean b= Boolean.TRUE;\n"); //$NON-NLS-1$
 111                 } else {
 112                         buf.append("Boolean b= (Boolean) Boolean.TRUE;\n"); //$NON-NLS-1$
 113                 }
 114
 115                 return buf.toString();
 116         }
 117
 118         /**
 119          * {@inheritDoc}
 120          */
 121         public boolean canFix(ICompilationUnit compilationUnit, IProblemLocation problem) {
 122                 if (problem.getProblemId() == IProblem.UnnecessaryCast)
 123                         return isEnabled(CleanUpConstants.REMOVE_UNNECESSARY_CASTS);
 124
 125                 return false;
 126         }
 127
 128         /**
 129          * {@inheritDoc}
 130          */
 131         @Override
 132         public int computeNumberOfFixes(CompilationUnit compilationUnit) {
 133                 int result= 0;
 134                 IProblem[] problems= compilationUnit.getProblems();
 135                 if (isEnabled(CleanUpConstants.REMOVE_UNNECESSARY_CASTS))
 136                         result+= getNumberOfProblems(problems, IProblem.UnnecessaryCast);
 137                 return result;
 138         }
 139 }