com.siyeh.ig.style.UnnecessaryInterfaceModifierInspection Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of java-analysis-impl Show documentation
A packaging of the IntelliJ Community Edition java-analysis-impl library. This is release number 1 of trunk branch 142.
The newest version!
/*
 * Copyright 2003-2014 Dave Griffith, Bas Leijdekkers
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.siyeh.ig.style;

import com.intellij.codeInspection.CleanupLocalInspectionTool;
import com.intellij.codeInspection.ProblemDescriptor;
import com.intellij.codeInspection.ProblemHighlightType;
import com.intellij.openapi.project.Project;
import com.intellij.psi.*;
import com.intellij.psi.util.PsiUtil;
import com.siyeh.InspectionGadgetsBundle;
import com.siyeh.ig.BaseInspection;
import com.siyeh.ig.BaseInspectionVisitor;
import com.siyeh.ig.InspectionGadgetsFix;
import com.siyeh.ig.psiutils.ClassUtils;
import org.jetbrains.annotations.NotNull;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class UnnecessaryInterfaceModifierInspection extends BaseInspection implements CleanupLocalInspectionTool{

  private static final Set INTERFACE_REDUNDANT_MODIFIERS =
    new HashSet(Arrays.asList(PsiModifier.ABSTRACT, PsiModifier.STATIC));
  private static final Set INNER_CLASS_REDUNDANT_MODIFIERS =
    new HashSet(Arrays.asList(PsiModifier.PUBLIC, PsiModifier.STATIC));
  private static final Set INNER_INTERFACE_REDUNDANT_MODIFIERS =
    new HashSet(Arrays.asList(PsiModifier.PUBLIC, PsiModifier.ABSTRACT, PsiModifier.STATIC));
  private static final Set FIELD_REDUNDANT_MODIFIERS =
    new HashSet(Arrays.asList(PsiModifier.PUBLIC, PsiModifier.STATIC, PsiModifier.FINAL));
  private static final Set METHOD_REDUNDANT_MODIFIERS =
    new HashSet(Arrays.asList(PsiModifier.PUBLIC, PsiModifier.ABSTRACT));

  @Override
  @NotNull
  public String getDisplayName() {
    return InspectionGadgetsBundle.message("unnecessary.interface.modifier.display.name");
  }

  @Override
  public boolean isEnabledByDefault() {
    return true;
  }

  @Override
  @NotNull
  public String buildErrorString(Object... infos) {
    final PsiModifierList modifierList = (PsiModifierList)infos[1];
    final PsiElement parent = modifierList.getParent();
    if (parent instanceof PsiClass) {
      final PsiClass aClass = (PsiClass)parent;
      final PsiClass containingClass = aClass.getContainingClass();
      if (containingClass != null) {
        if (aClass.isInterface()) {
          return InspectionGadgetsBundle.message("unnecessary.interface.modifier.inner.interface.of.interface.problem.descriptor");
        }
        else {
          return InspectionGadgetsBundle.message("unnecessary.interface.modifier.problem.descriptor3");
        }
      }
      else {
        return InspectionGadgetsBundle.message("unnecessary.interface.modifier.problem.descriptor");
      }
    }
    else if (parent instanceof PsiMethod) {
      return InspectionGadgetsBundle.message("unnecessary.interface.modifier.problem.descriptor2");
    }
    else {
      return InspectionGadgetsBundle.message("unnecessary.interface.modifier.problem.descriptor4");
    }
  }

  @Override
  public BaseInspectionVisitor buildVisitor() {
    return new UnnecessaryInterfaceModifierVisitor();
  }

  @Override
  public InspectionGadgetsFix buildFix(Object... infos) {
    return new UnnecessaryInterfaceModifiersFix((String)infos[0]);
  }

  private static class UnnecessaryInterfaceModifiersFix extends InspectionGadgetsFix {

    private final String modifiersText;

    private UnnecessaryInterfaceModifiersFix(String modifiersText) {
      this.modifiersText = modifiersText;
    }

    @Override
    @NotNull
    public String getName() {
      return InspectionGadgetsBundle.message("smth.unnecessary.remove.quickfix", modifiersText);
    }

    @NotNull
    @Override
    public String getFamilyName() {
      return "Remove unnecessary modifiers";
    }

    @Override
    public void doFix(Project project, ProblemDescriptor descriptor) {
      final PsiElement element = descriptor.getPsiElement();
      final PsiModifierList modifierList;
      if (element instanceof PsiModifierList) {
        modifierList = (PsiModifierList)element;
      }
      else {
        final PsiElement parent = element.getParent();
        if (!(parent instanceof PsiModifierList)) {
          return;
        }
        modifierList = (PsiModifierList)parent;
      }
      final PsiElement modifierOwner = modifierList.getParent();
      if (!(modifierOwner instanceof PsiMethod && PsiUtil.isLanguageLevel8OrHigher(modifierList))) {
        modifierList.setModifierProperty(PsiModifier.STATIC, false);
      }
      assert modifierOwner != null;
      if (modifierOwner instanceof PsiClass) {
        final PsiClass aClass = (PsiClass)modifierOwner;
        if (aClass.isInterface()) {
          modifierList.setModifierProperty(PsiModifier.ABSTRACT, false);
        }
        final PsiClass containingClass = ClassUtils.getContainingClass(modifierOwner);
        if (containingClass != null && containingClass.isInterface()) {
          // do the inner classes
          modifierList.setModifierProperty(PsiModifier.PUBLIC, false);
        }
      }
      else if (modifierOwner instanceof PsiMethod) {
        modifierList.setModifierProperty(PsiModifier.ABSTRACT, false);
        modifierList.setModifierProperty(PsiModifier.PUBLIC, false);
      }
      else {
        modifierList.setModifierProperty(PsiModifier.PUBLIC, false);
        modifierList.setModifierProperty(PsiModifier.FINAL, false);
      }
    }
  }

  private static class UnnecessaryInterfaceModifierVisitor extends BaseInspectionVisitor {

    @Override
    public void visitClass(@NotNull PsiClass aClass) {
      final PsiClass parent = ClassUtils.getContainingClass(aClass);
      if (parent != null && parent.isInterface()) {
        final PsiModifierList modifiers = aClass.getModifierList();
        if (aClass.isInterface()) {
          checkForRedundantModifiers(modifiers, INNER_INTERFACE_REDUNDANT_MODIFIERS);
        }
        else {
          checkForRedundantModifiers(modifiers, INNER_CLASS_REDUNDANT_MODIFIERS);
        }
      }
      else if (aClass.isInterface()) {
        final PsiModifierList modifiers = aClass.getModifierList();
        checkForRedundantModifiers(modifiers, INTERFACE_REDUNDANT_MODIFIERS);
      }
    }

    @Override
    public void visitField(@NotNull PsiField field) {
      // don't call super, to keep this from drilling in
      final PsiClass containingClass = field.getContainingClass();
      if (containingClass == null) {
        return;
      }
      if (!containingClass.isInterface()) {
        return;
      }
      final PsiModifierList modifiers = field.getModifierList();
      checkForRedundantModifiers(modifiers, FIELD_REDUNDANT_MODIFIERS);
    }

    @Override
    public void visitMethod(@NotNull PsiMethod method) {
      // don't call super, to keep this from drilling in
      final PsiClass aClass = method.getContainingClass();
      if (aClass == null) {
        return;
      }
      if (!aClass.isInterface()) {
        return;
      }
      final PsiModifierList modifiers = method.getModifierList();
      checkForRedundantModifiers(modifiers, METHOD_REDUNDANT_MODIFIERS);
    }

    public void checkForRedundantModifiers(PsiModifierList list, Set modifiers) {
      if (list == null) {
        return;
      }
      final PsiElement[] children = list.getChildren();
      final StringBuilder redundantModifiers = new StringBuilder();
      for (PsiElement child : children) {
        final String modifierText = child.getText();
        if (modifiers.contains(modifierText)) {
          if (redundantModifiers.length() > 0) {
            redundantModifiers.append(' ');
          }
          redundantModifiers.append(modifierText);
        }
      }
      for (PsiElement child : children) {
        if (modifiers.contains(child.getText())) {
          registerError(child, ProblemHighlightType.LIKE_UNUSED_SYMBOL, redundantModifiers.toString(), list);
        }
      }
    }
  }
}