| /* |
| * Copyright 2009-2011 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.javadoc; |
| |
| import com.intellij.codeInspection.ProblemDescriptor; |
| import com.intellij.codeInspection.ui.SingleCheckboxOptionsPanel; |
| import com.intellij.openapi.project.Project; |
| import com.intellij.openapi.util.text.StringUtil; |
| import com.intellij.psi.*; |
| import com.intellij.psi.javadoc.*; |
| import com.intellij.psi.tree.IElementType; |
| import com.intellij.psi.util.MethodSignature; |
| import com.intellij.psi.util.MethodSignatureUtil; |
| import com.intellij.psi.util.PsiTreeUtil; |
| import com.intellij.psi.util.TypeConversionUtil; |
| import com.intellij.util.IncorrectOperationException; |
| import com.siyeh.InspectionGadgetsBundle; |
| import com.siyeh.ig.BaseInspection; |
| import com.siyeh.ig.BaseInspectionVisitor; |
| import com.siyeh.ig.InspectionGadgetsFix; |
| import org.jetbrains.annotations.Nls; |
| import org.jetbrains.annotations.NonNls; |
| import org.jetbrains.annotations.NotNull; |
| |
| import javax.swing.*; |
| |
| public class UnnecessaryJavaDocLinkInspection extends BaseInspection { |
| |
| private static final int THIS_METHOD = 1; |
| private static final int THIS_CLASS = 2; |
| private static final int SUPER_METHOD = 3; |
| |
| @SuppressWarnings({"PublicField"}) |
| public boolean ignoreInlineLinkToSuper = false; |
| |
| @Nls |
| @NotNull |
| @Override |
| public String getDisplayName() { |
| return InspectionGadgetsBundle.message( |
| "unnecessary.javadoc.link.display.name"); |
| } |
| |
| @NotNull |
| @Override |
| protected String buildErrorString(Object... infos) { |
| final int n = ((Integer)infos[1]).intValue(); |
| if (n == THIS_METHOD) { |
| return InspectionGadgetsBundle.message( |
| "unnecessary.javadoc.link.this.method.problem.descriptor"); |
| } |
| if (n == THIS_CLASS) { |
| return InspectionGadgetsBundle.message( |
| "unnecessary.javadoc.link.this.class.problem.descriptor"); |
| } |
| return InspectionGadgetsBundle.message( |
| "unnecessary.javadoc.link.super.method.problem.descriptor"); |
| } |
| |
| @Override |
| public JComponent createOptionsPanel() { |
| return new SingleCheckboxOptionsPanel( |
| InspectionGadgetsBundle.message( |
| "unnecessary.javadoc.link.option"), |
| this, "ignoreInlineLinkToSuper"); |
| } |
| |
| @Override |
| protected InspectionGadgetsFix buildFix(Object... infos) { |
| return new UnnecessaryJavaDocLinkFix((String)infos[0]); |
| } |
| |
| private static class UnnecessaryJavaDocLinkFix |
| extends InspectionGadgetsFix { |
| |
| private final String tagName; |
| |
| public UnnecessaryJavaDocLinkFix(String tagName) { |
| this.tagName = tagName; |
| } |
| |
| @Override |
| @NotNull |
| public String getName() { |
| return InspectionGadgetsBundle.message( |
| "unnecessary.javadoc.link.quickfix", tagName); |
| } |
| |
| @NotNull |
| @Override |
| public String getFamilyName() { |
| return "Remove redundant tag"; |
| } |
| |
| @Override |
| protected void doFix(Project project, ProblemDescriptor descriptor) |
| throws IncorrectOperationException { |
| final PsiElement element = descriptor.getPsiElement(); |
| final PsiElement parent = element.getParent(); |
| if (!(parent instanceof PsiDocTag)) { |
| return; |
| } |
| final PsiDocTag docTag = (PsiDocTag)parent; |
| final PsiDocComment docComment = docTag.getContainingComment(); |
| if (docComment != null) { |
| if (shouldDeleteEntireComment(docComment)) { |
| docComment.delete(); |
| return; |
| } |
| } |
| docTag.delete(); |
| } |
| |
| private static boolean shouldDeleteEntireComment( |
| PsiDocComment docComment) { |
| final PsiDocToken[] docTokens = PsiTreeUtil.getChildrenOfType( |
| docComment, PsiDocToken.class); |
| if (docTokens == null) { |
| return false; |
| } |
| for (PsiDocToken docToken : docTokens) { |
| final IElementType tokenType = docToken.getTokenType(); |
| if (!JavaDocTokenType.DOC_COMMENT_DATA.equals(tokenType)) { |
| continue; |
| } |
| if (!StringUtil.isEmptyOrSpaces(docToken.getText())) { |
| return false; |
| } |
| } |
| return true; |
| } |
| } |
| |
| @Override |
| public BaseInspectionVisitor buildVisitor() { |
| return new UnnecessaryJavaDocLinkVisitor(); |
| } |
| |
| private class UnnecessaryJavaDocLinkVisitor |
| extends BaseInspectionVisitor { |
| |
| @Override |
| public void visitDocTag(PsiDocTag tag) { |
| super.visitDocTag(tag); |
| @NonNls final String name = tag.getName(); |
| if ("link".equals(name) || "linkplain".equals(name)) { |
| if (!(tag instanceof PsiInlineDocTag)) { |
| return; |
| } |
| } |
| else if ("see".equals(name)) { |
| if (tag instanceof PsiInlineDocTag) { |
| return; |
| } |
| } |
| final PsiReference reference = extractReference(tag); |
| if (reference == null) { |
| return; |
| } |
| final PsiElement target = reference.resolve(); |
| if (target == null) { |
| return; |
| } |
| final PsiMethod containingMethod = |
| PsiTreeUtil.getParentOfType(tag, PsiMethod.class); |
| if (containingMethod == null) { |
| return; |
| } |
| if (target.equals(containingMethod)) { |
| registerError(tag.getNameElement(), '@' + name, |
| Integer.valueOf(THIS_METHOD)); |
| return; |
| } |
| final PsiClass containingClass = |
| PsiTreeUtil.getParentOfType(tag, PsiClass.class); |
| if (target.equals(containingClass)) { |
| registerError(tag.getNameElement(), '@' + name, |
| Integer.valueOf(THIS_CLASS)); |
| return; |
| } |
| if (!(target instanceof PsiMethod)) { |
| return; |
| } |
| final PsiMethod method = (PsiMethod)target; |
| if (!isSuperMethod(method, containingMethod)) { |
| return; |
| } |
| if (ignoreInlineLinkToSuper && tag instanceof PsiInlineDocTag) { |
| return; |
| } |
| registerError(tag.getNameElement(), '@' + name, |
| Integer.valueOf(SUPER_METHOD)); |
| } |
| |
| private PsiReference extractReference(PsiDocTag tag) { |
| final PsiDocTagValue valueElement = tag.getValueElement(); |
| if (valueElement != null) { |
| return valueElement.getReference(); |
| } |
| // hack around the fact that a reference to a class is apparently |
| // not a PsiDocTagValue |
| final PsiElement[] dataElements = tag.getDataElements(); |
| if (dataElements.length == 0) { |
| return null; |
| } |
| PsiElement salientElement = null; |
| for (PsiElement dataElement : dataElements) { |
| if (!(dataElement instanceof PsiWhiteSpace)) { |
| salientElement = dataElement; |
| break; |
| } |
| } |
| if (salientElement == null) { |
| return null; |
| } |
| final PsiElement child = salientElement.getFirstChild(); |
| if (!(child instanceof PsiReference)) { |
| return null; |
| } |
| return (PsiReference)child; |
| } |
| |
| public boolean isSuperMethod(PsiMethod superMethodCandidate, |
| PsiMethod derivedMethod) { |
| final PsiClass superClassCandidate = |
| superMethodCandidate.getContainingClass(); |
| final PsiClass derivedClass = derivedMethod.getContainingClass(); |
| if (derivedClass == null || superClassCandidate == null) { |
| return false; |
| } |
| if (!derivedClass.isInheritor(superClassCandidate, false)) { |
| return false; |
| } |
| final PsiSubstitutor superSubstitutor = |
| TypeConversionUtil.getSuperClassSubstitutor( |
| superClassCandidate, derivedClass, |
| PsiSubstitutor.EMPTY); |
| final MethodSignature superSignature = |
| superMethodCandidate.getSignature(superSubstitutor); |
| final MethodSignature derivedSignature = |
| derivedMethod.getSignature(PsiSubstitutor.EMPTY); |
| return MethodSignatureUtil.isSubsignature(superSignature, |
| derivedSignature); |
| } |
| } |
| } |
