plugins/InspectionGadgets/src/com/siyeh/ig/imports/RedundantImportInspection.java

   1 /*
   2  * Copyright 2003-2009 Dave Griffith, Bas Leijdekkers
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.siyeh.ig.imports;
  17
  18 import com.intellij.psi.*;
  19 import com.intellij.psi.util.PsiUtil;
  20 import com.siyeh.InspectionGadgetsBundle;
  21 import com.siyeh.ig.BaseInspection;
  22 import com.siyeh.ig.BaseInspectionVisitor;
  23 import com.siyeh.ig.InspectionGadgetsFix;
  24 import com.siyeh.ig.fixes.DeleteImportFix;
  25 import com.siyeh.ig.psiutils.ImportUtils;
  26 import org.jetbrains.annotations.NotNull;
  27
  28 import java.util.HashSet;
  29 import java.util.Set;
  30
  31 public class RedundantImportInspection extends BaseInspection {
  32
  33     @Override
  34     @NotNull
  35     public String getDisplayName() {
  36         return InspectionGadgetsBundle.message(
  37                 "redundant.import.display.name");
  38     }
  39
  40     @Override
  41     @NotNull
  42     public String buildErrorString(Object... infos) {
  43         return InspectionGadgetsBundle.message(
  44                 "redundant.import.problem.descriptor");
  45     }
  46
  47     @Override
  48     public InspectionGadgetsFix buildFix(Object... infos) {
  49         return new DeleteImportFix();
  50     }
  51
  52     @Override
  53     public BaseInspectionVisitor buildVisitor() {
  54         return new RedundantImportVisitor();
  55     }
  56
  57     private static class RedundantImportVisitor extends BaseInspectionVisitor {
  58
  59         @Override public void visitFile(PsiFile file) {
  60             super.visitFile(file);
  61             if (!(file instanceof PsiJavaFile)) {
  62                 return;
  63             }
  64             final PsiJavaFile javaFile = (PsiJavaFile)file;
  65             if (PsiUtil.isInJspFile(file)) {
  66                 return;
  67             }
  68             final PsiImportList importList = javaFile.getImportList();
  69             if (importList == null) {
  70                 return;
  71             }
  72             checkNonStaticImports(importList, javaFile);
  73             checkStaticImports(importList, javaFile);
  74         }
  75
  76         private void checkStaticImports(PsiImportList importList,
  77                                         PsiJavaFile javaFile) {
  78             final PsiImportStaticStatement[] importStaticStatements =
  79                     importList.getImportStaticStatements();
  80             final Set<String> staticImports =
  81                     new HashSet<String>(importStaticStatements.length);
  82             for (PsiImportStaticStatement importStaticStatement :
  83                     importStaticStatements) {
  84                 final String referenceName =
  85                         importStaticStatement.getReferenceName();
  86                 final PsiClass targetClass =
  87                         importStaticStatement.resolveTargetClass();
  88                 if (targetClass == null) {
  89                     continue;
  90                 }
  91                 final String qualifiedName = targetClass.getQualifiedName();
  92                 if (referenceName == null) {
  93                     if (staticImports.contains(qualifiedName)) {
  94                         registerError(importStaticStatement);
  95                         continue;
  96                     }
  97                     staticImports.add(qualifiedName);
  98                 } else {
  99                     final String qualifiedReferenceName =
 100                             qualifiedName + '.' + referenceName;
 101                     if (staticImports.contains(qualifiedReferenceName)) {
 102                         registerError(importStaticStatement);
 103                         continue;
 104                     }
 105                     if (staticImports.contains(qualifiedName)) {
 106                         if (!ImportUtils.hasOnDemandImportConflict(
 107                                 qualifiedReferenceName, javaFile)) {
 108                             registerError(importStaticStatement);
 109                         }
 110                     }
 111                     staticImports.add(qualifiedReferenceName);
 112                 }
 113             }
 114         }
 115
 116         private void checkNonStaticImports(PsiImportList importList,
 117                                            PsiJavaFile javaFile) {
 118             final PsiImportStatement[] importStatements =
 119                     importList.getImportStatements();
 120             final Set<String> onDemandImports = new HashSet();
 121             final Set<String> singleClassImports = new HashSet();
 122             for(final PsiImportStatement importStatement : importStatements) {
 123                 final String qualifiedName = importStatement.getQualifiedName();
 124                 if(qualifiedName == null) {
 125                     continue;
 126                 }
 127                 if (importStatement.isOnDemand()) {
 128                     if (onDemandImports.contains(qualifiedName)) {
 129                         registerError(importStatement);
 130                     }
 131                     onDemandImports.add(qualifiedName);
 132                 } else {
 133                     if (singleClassImports.contains(qualifiedName)) {
 134                         registerError(importStatement);
 135                         continue;
 136                     }
 137                     final PsiElement element = importStatement.resolve();
 138                     if (!(element instanceof PsiClass)) {
 139                         continue;
 140                     }
 141                         final PsiElement context = element.getContext();
 142                     if (context == null) {
 143                         continue;
 144                     }
 145                     final String contextName;
 146                     if (context instanceof PsiJavaFile) {
 147                             final PsiJavaFile file = (PsiJavaFile)context;
 148                             contextName = file.getPackageName();
 149                     } else if (context instanceof PsiClass) {
 150                         final PsiClass aClass = (PsiClass)context;
 151                         contextName = aClass.getQualifiedName();
 152                     } else {
 153                         continue;
 154                     }
 155                     if (onDemandImports.contains(contextName) &&
 156                             !ImportUtils.hasOnDemandImportConflict(qualifiedName,
 157                                     javaFile) &&
 158                             !ImportUtils.hasDefaultImportConflict(qualifiedName,
 159                                     javaFile)) {
 160                         registerError(importStatement);
 161                     }
 162                     singleClassImports.add(qualifiedName);
 163                 }
 164             }
 165         }
 166     }
 167 }