Merge pull request #1902 from Haehnchen/feature/1366-subscriber

#1366 mark public method callbacks inside getSubscribedEvents as used code

Author: Haehnchen

src/main/java/fr/adrienbrault/idea/symfony2plugin/codeInsight/SymfonyImplicitUsageProvider.java

@@ -2,15 +2,15 @@
 
 import com.intellij.codeInsight.daemon.ImplicitUsageProvider;
 import com.intellij.psi.PsiElement;
-import com.jetbrains.php.lang.psi.elements.Method;
-import com.jetbrains.php.lang.psi.elements.PhpAttribute;
-import com.jetbrains.php.lang.psi.elements.PhpClass;
-import com.jetbrains.php.lang.psi.elements.PhpModifier;
+import com.intellij.psi.util.PsiTreeUtil;
+import com.jetbrains.php.lang.parser.PhpElementTypes;
+import com.jetbrains.php.lang.psi.elements.*;
 import de.espend.idea.php.annotation.dict.PhpDocCommentAnnotation;
 import de.espend.idea.php.annotation.util.AnnotationUtil;
 import fr.adrienbrault.idea.symfony2plugin.routing.RouteHelper;
 import fr.adrienbrault.idea.symfony2plugin.util.PhpElementsUtil;
 import fr.adrienbrault.idea.symfony2plugin.util.dict.ServiceUtil;
+import org.apache.commons.lang.StringUtils;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Collection;
@@ -27,10 +27,12 @@ public class SymfonyImplicitUsageProvider implements ImplicitUsageProvider {
     @Override
     public boolean isImplicitUsage(@NotNull PsiElement element) {
         if (element instanceof Method && ((Method) element).getAccess() == PhpModifier.Access.PUBLIC) {
-            return isMethodARoute((Method) element);
+            return isMethodARoute((Method) element)
+                || isSubscribedEvent((Method) element);
         } else if (element instanceof PhpClass) {
             return isRouteClass((PhpClass) element)
-                || isCommandAndService((PhpClass) element);
+                || isCommandAndService((PhpClass) element)
+                || isSubscribedEvent((PhpClass) element);
         }
 
         return false;
@@ -73,4 +75,45 @@ private boolean isMethodARoute(@NotNull Method method) {
 
         return RouteHelper.isRouteExistingForMethod(method);
     }
+
+    private boolean isSubscribedEvent(@NotNull PhpClass phpClass) {
+        return phpClass.getMethods()
+            .stream()
+            .filter(method -> method.getAccess() == PhpModifier.Access.PUBLIC)
+            .anyMatch(this::isSubscribedEvent);
+    }
+
+    private boolean isSubscribedEvent(@NotNull Method method) {
+        PhpClass containingClass = method.getContainingClass();
+        if (containingClass == null || !PhpElementsUtil.isInstanceOf(containingClass, "\\Symfony\\Component\\EventDispatcher\\EventSubscriberInterface")) {
+            return false;
+        }
+
+        Method subscribedEvents = containingClass.findMethodByName("getSubscribedEvents");
+        if (subscribedEvents == null) {
+            return false;
+        }
+
+        for (PhpReturn aReturn : PsiTreeUtil.collectElementsOfType(subscribedEvents, PhpReturn.class)) {
+            PsiElement[] psiElements = PsiTreeUtil.collectElements(aReturn, element -> {
+                if (!(element instanceof StringLiteralExpression)) {
+                    return false;
+                }
+
+                PsiElement parent = element.getParent();
+                return parent != null && parent.getNode().getElementType() == PhpElementTypes.ARRAY_VALUE && parent.getChildren().length == 1;
+            });
+
+            for (PsiElement psiElement : psiElements) {
+                if (psiElement instanceof StringLiteralExpression) {
+                    String contents = ((StringLiteralExpression) psiElement).getContents();
+                    if (StringUtils.isNotBlank(contents) && contents.equalsIgnoreCase(method.getName())) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
 }

src/test/java/fr/adrienbrault/idea/symfony2plugin/tests/codeInsight/SymfonyImplicitUsageProviderTest.java

@@ -137,6 +137,50 @@ public void testCommandRegisteredNotAsServiceIsUntouched() {
         assertFalse(new SymfonyImplicitUsageProvider().isImplicitUsage(firstClassFromFile));
     }
 
+    public void testEventSubscriberGetSubscribedEventsArray() {
+        PsiFile psiFile = myFixture.configureByText(PhpFileType.INSTANCE, "<?php\n" +
+            "<?php\n" +
+            "\n" +
+            "namespace App\\EventSubscriber;\n" +
+            "\n" +
+            "use Symfony\\Component\\EventDispatcher\\EventSubscriberInterface;\n" +
+            "use Symfony\\Component\\HttpKernel\\KernelEvents;\n" +
+            "\n" +
+            "class ExceptionSubscriber implements EventSubscriberInterface\n" +
+            "{\n" +
+            "    public static function getSubscribedEvents()\n" +
+            "    {\n" +
+            "        return [\n" +
+            "            KernelEvents::EXCEPTION => [\n" +
+            "                ['processException', 10],\n" +
+            "                ['notifyException', -10],\n" +
+            "            ],\n" +
+            "        ];\n" +
+            "        return [\n" +
+            "            'keyString' => 'logException'\n" +
+            "        ];" +
+            "    }\n" +
+            "\n" +
+            "    public function processException() {}\n" +
+            "    public function logException() {}\n" +
+            "    public function notifyException() {}\n" +
+            "    public function notifyExceptionUnknown() {}\n" +
+            "    public function keyString() {}\n" +
+            "}"
+        );
+
+        PhpClass phpClass = PhpElementsUtil.getFirstClassFromFile((PhpFile) psiFile.getContainingFile());
+
+        assertTrue(new SymfonyImplicitUsageProvider().isImplicitUsage(phpClass.findOwnMethodByName("processException")));
+        assertTrue(new SymfonyImplicitUsageProvider().isImplicitUsage(phpClass.findOwnMethodByName("logException")));
+        assertTrue(new SymfonyImplicitUsageProvider().isImplicitUsage(phpClass.findOwnMethodByName("notifyException")));
+
+        assertFalse(new SymfonyImplicitUsageProvider().isImplicitUsage(phpClass.findOwnMethodByName("notifyExceptionUnknown")));
+        assertFalse(new SymfonyImplicitUsageProvider().isImplicitUsage(phpClass.findOwnMethodByName("keyString")));
+
+        assertTrue(new SymfonyImplicitUsageProvider().isImplicitUsage(phpClass));
+    }
+
     private PhpClass createPhpControllerClassWithRouteContent(@NotNull String content) {
         return createPhpControllerClassWithRouteContent("\\App\\Controller\\FooController", content);
     }

src/test/java/fr/adrienbrault/idea/symfony2plugin/tests/codeInsight/fixtures/classes.php

@@ -13,4 +13,12 @@ class Route {}
     class Command
     {
     }
+}
+
+namespace Symfony\Component\EventDispatcher
+{
+    interface EventSubscriberInterface
+    {
+        public static function getSubscribedEvents();
+    }
 }