Merge remote-tracking branch 'origin/master'

plugins/devkit/resources/META-INF/plugin.xml

@@ -91,7 +91,7 @@
                      implementationClass="org.jetbrains.idea.devkit.inspections.ExtensionPointBeanClassInspection"/>
 
     <moduleConfigurationEditorProvider implementation="org.jetbrains.idea.devkit.module.PluginModuleEditorsProvider"/>
-    <implicitUsageProvider implementation="org.jetbrains.idea.devkit.inspections.DevKitEntryPoints"/>
+    <implicitUsageProvider implementation="org.jetbrains.idea.devkit.inspections.DevKitImplicitUsageProvider"/>
     <psi.referenceContributor implementation="org.jetbrains.idea.devkit.dom.impl.InspectionsPropertiesReferenceProviderContributor"/>
     <psi.referenceContributor implementation="org.jetbrains.idea.devkit.references.IconsReferencesContributor"/>
     <referencesSearch implementation="org.jetbrains.idea.devkit.references.IconsReferencesContributor"/>

plugins/devkit/src/inspections/DevKitEntryPoints.java

@@ -1,54 +0,0 @@
-/*
- * Copyright 2000-2013 JetBrains s.r.o.
- *
- * 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 org.jetbrains.idea.devkit.inspections;
-
-import com.intellij.codeInsight.daemon.ImplicitUsageProvider;
-import com.intellij.psi.*;
-
-/**
- * User: anna
- */
-public class DevKitEntryPoints implements ImplicitUsageProvider {
-
-  @Override
-  public boolean isImplicitUsage(PsiElement element) {
-    if (element instanceof PsiClass) {
-      final PsiClass psiClass = (PsiClass)element;
-      if (psiClass.isEnum() ||
-          psiClass.isAnnotationType() ||
-          psiClass.hasModifierProperty(PsiModifier.PRIVATE)) {
-        return false;
-      }
-
-      final PsiClass domClass =
-        JavaPsiFacade.getInstance(element.getProject()).findClass("com.intellij.util.xml.DomElement", element.getResolveScope());
-      if (domClass != null && psiClass.isInheritor(domClass, true)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  @Override
-  public boolean isImplicitRead(PsiElement element) {
-    return false;
-  }
-
-  @Override
-  public boolean isImplicitWrite(PsiElement element) {
-    return false;
-  }
-}

plugins/devkit/src/inspections/DevKitImplicitUsageProvider.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2000-2013 JetBrains s.r.o.
+ *
+ * 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 org.jetbrains.idea.devkit.inspections;
+
+import com.intellij.codeInsight.daemon.ImplicitUsageProvider;
+import com.intellij.psi.*;
+import com.intellij.psi.util.InheritanceUtil;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * @author anna
+ */
+public class DevKitImplicitUsageProvider implements ImplicitUsageProvider {
+
+  @Override
+  public boolean isImplicitUsage(PsiElement element) {
+    if (element instanceof PsiClass) {
+      final PsiClass psiClass = (PsiClass)element;
+      return isDomElementClass(psiClass);
+    }
+
+    if (element instanceof PsiMethod) {
+      PsiMethod psiMethod = (PsiMethod)element;
+      return isDomElementMethod(psiMethod);
+    }
+
+    return false;
+  }
+
+  @Override
+  public boolean isImplicitRead(PsiElement element) {
+    return false;
+  }
+
+  @Override
+  public boolean isImplicitWrite(PsiElement element) {
+    return false;
+  }
+
+  private static boolean isDomElementClass(PsiClass psiClass) {
+    if (psiClass.isEnum() ||
+        psiClass.isAnnotationType() ||
+        psiClass.hasModifierProperty(PsiModifier.PRIVATE)) {
+      return false;
+    }
+
+    return isDomElementInheritor(psiClass);
+  }
+
+  private static boolean isDomElementMethod(PsiMethod psiMethod) {
+    if (!psiMethod.hasModifierProperty(PsiModifier.PUBLIC) ||
+        psiMethod.hasModifierProperty(PsiModifier.STATIC) ||
+        psiMethod.isConstructor() ||
+        psiMethod.getParameterList().getParametersCount() > 1) {
+      return false;
+    }
+
+    final PsiClass containingClass = psiMethod.getContainingClass();
+    if (containingClass == null) {
+      return false;
+    }
+
+    if (!isDomElementClass(containingClass)) {
+      return isDomElementVisitorMethod(psiMethod, containingClass);
+    }
+
+    final PsiType returnType = psiMethod.getReturnType();
+    if (!(returnType instanceof PsiClassType)) {
+      return false;
+    }
+
+    PsiClassType returnClassType = (PsiClassType)returnType;
+
+    // Dom getDom(), GenericAttributeValue<X> getAttr(), ...
+    final PsiClass returnResolved = returnClassType.resolve();
+    if (isDomElementInheritor(returnResolved)) {
+      return true;
+    }
+
+    // List<Dom> getDoms()
+    if (returnClassType.getParameterCount() == 1 &&
+        InheritanceUtil.isInheritor(returnResolved, CommonClassNames.JAVA_UTIL_LIST)) {
+      final PsiType listType = returnClassType.getParameters()[0];
+      return isDomElementInheritor(listType);
+    }
+
+    return false;
+  }
+
+  private static boolean isDomElementVisitorMethod(PsiMethod method,
+                                                   PsiClass containingClass) {
+    if (method.getReturnType() != PsiType.VOID ||
+        !method.getName().startsWith("visit") ||
+        method.getParameterList().getParametersCount() != 1 ||
+        !InheritanceUtil.isInheritor(containingClass, "com.intellij.util.xml.DomElementVisitor")) {
+      return false;
+    }
+
+    final PsiType psiType = method.getParameterList().getParameters()[0].getType();
+    return isDomElementInheritor(psiType);
+  }
+
+  private static boolean isDomElementInheritor(@Nullable PsiType psiType) {
+    return InheritanceUtil.isInheritor(psiType, "com.intellij.util.xml.DomElement");
+  }
+
+  private static boolean isDomElementInheritor(@Nullable PsiClass psiClass) {
+    return InheritanceUtil.isInheritor(psiClass, "com.intellij.util.xml.DomElement");
+  }
+}

plugins/devkit/testData/codeInsight/ImplicitUsagesDomElement.java

@@ -0,0 +1,32 @@
+import java.util.List;
+import com.intellij.util.xml.DomElement;
+import com.intellij.util.xml.GenericAttributeValue;
+
+public abstract class ImplicitUsagesDomElement implements DomElement {
+
+  public abstract GenericAttributeValue<String> getStringAttribute();
+  public abstract ImplicitUsagesDomElement getDomElement();
+
+  public abstract List<ImplicitUsagesDomElement> getDoms();
+
+  public abstract ImplicitUsagesDomElement addDom();
+  public abstract ImplicitUsagesDomElement addDomIndexed(int index);
+
+
+  // invalid ===========
+
+  private GenericAttributeValue<String> <warning descr="Private method 'getStringAttributePrivate()' is never used">getStringAttributePrivate</warning>() { return null; };
+  public static GenericAttributeValue<String> <warning descr="Method 'getStringAttributeStatic()' is never used">getStringAttributeStatic</warning>() { return null; };
+
+  public String <warning descr="Method 'getNonDomString()' is never used">getNonDomString</warning>() { return null; };
+  public int <warning descr="Method 'getNonDomPrimitiveType()' is never used">getNonDomPrimitiveType</warning>() { return 0; }
+
+  private int <warning descr="Private method 'normalPrivateMethod()' is never used">normalPrivateMethod</warning>() { return 0; }
+
+  public List<String> <warning descr="Method 'getNonDomList()' is never used">getNonDomList</warning>() { return null; }
+
+
+  public abstract ImplicitUsagesDomElement <warning descr="Method 'addDomMoreThanOneParam(int, int)' is never used">addDomMoreThanOneParam</warning>(int i, int j);
+  public String <warning descr="Method 'addNonDom()' is never used">addNonDom</warning>() { return null; }
+
+}

plugins/devkit/testData/codeInsight/ImplicitUsagesDomElementVisitor.java

@@ -0,0 +1,30 @@
+import com.intellij.util.xml.DomElement;
+import com.intellij.util.xml.DomElementVisitor;
+
+public class ImplicitUsagesDomElementVisitor implements DomElementVisitor {
+
+  public static void main(String[] args) {} // suppress class unused
+
+  interface MyDom extends DomElement {}
+
+  public void visitMyDom(MyDom myDom) { myDom = null; }
+  public void visit(MyDom myDom) { myDom = null; }
+
+  // invalid ===========
+  public String <warning descr="Method 'nonVoidReturnTypeMethod(ImplicitUsagesDomElementVisitor.MyDom)' is never used">nonVoidReturnTypeMethod</warning>(MyDom myDom) { myDom = null; return null; }
+  public void <warning descr="Method 'doesNotStartWithVisit(ImplicitUsagesDomElementVisitor.MyDom)' is never used">doesNotStartWithVisit</warning>(MyDom myDom) { myDom = null; }
+  public void <warning descr="Method 'nonDomParameter(int)' is never used">nonDomParameter</warning>(int i) { i = 0; }
+  private void <warning descr="Private method 'visitMyDomMoreThanOneParam(ImplicitUsagesDomElementVisitor.MyDom, int)' is never used">visitMyDomMoreThanOneParam</warning>(MyDom myDom, int index) { myDom = null; index = 0; }
+  private void <warning descr="Private method 'visitMyDomPrivate(ImplicitUsagesDomElementVisitor.MyDom)' is never used">visitMyDomPrivate</warning>(MyDom myDom) { myDom = null; }
+  public static void <warning descr="Method 'visitMyDomStatic(ImplicitUsagesDomElementVisitor.MyDom)' is never used">visitMyDomStatic</warning>(MyDom myDom) { myDom = null; }
+
+
+  public static class NonDomElementVisitorClass {
+
+    public static void main(String[] args) {} // suppress class unused
+
+    public void <warning descr="Method 'visitMyDom(ImplicitUsagesDomElementVisitor.MyDom)' is never used">visitMyDom</warning>(MyDom myDom) { myDom = null; }
+
+  }
+
+}

plugins/devkit/testSources/codeInsight/PluginXmlFunctionalTest.groovy

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,6 +17,8 @@ package org.jetbrains.idea.devkit.codeInsight
 import com.intellij.codeInsight.TargetElementUtilBase
 import com.intellij.codeInsight.completion.CompletionType
 import com.intellij.codeInspection.LocalInspectionTool
+import com.intellij.codeInspection.deadCode.UnusedDeclarationInspection
+import com.intellij.codeInspection.unusedSymbol.UnusedSymbolLocalInspection
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.PluginPathManager
 import com.intellij.psi.ElementDescriptionUtil
@@ -196,6 +198,24 @@ public class PluginXmlFunctionalTest extends JavaCodeInsightFixtureTestCase {
     myFixture.testHighlighting(true, true, true);
   }
 
+  public void testImplicitUsagesDomElement() {
+    myFixture.addClass("package com.intellij.util.xml; public interface DomElement {}")
+    myFixture.addClass("package com.intellij.util.xml; public interface GenericAttributeValue<T> extends DomElement {}")
+
+    myFixture.enableInspections(new UnusedSymbolLocalInspection(), new UnusedDeclarationInspection())
+    myFixture.configureByFile("ImplicitUsagesDomElement.java")
+    myFixture.testHighlighting()
+  }
+
+  public void testImplicitUsagesDomElementVisitor() {
+    myFixture.addClass("package com.intellij.util.xml; public interface DomElement {}")
+    myFixture.addClass("package com.intellij.util.xml; public interface DomElementVisitor {}")
+
+    myFixture.enableInspections(new UnusedSymbolLocalInspection(), new UnusedDeclarationInspection())
+    myFixture.configureByFile("ImplicitUsagesDomElementVisitor.java")
+    myFixture.testHighlighting()
+  }
+
   static Collection<Class<? extends LocalInspectionTool>> getInspectionClasses() {
     return Arrays.asList(
       //RegistrationProblemsInspection.class,