Merge pull request #1877 from Haehnchen/feature/constants-routing

#1705 support constants for route name and path via first level self owning

Author: Haehnchen

src/main/java/fr/adrienbrault/idea/symfony2plugin/util/PhpPsiAttributesUtil.java

@@ -7,10 +7,7 @@
 import com.intellij.psi.util.PsiTreeUtil;
 import com.jetbrains.php.lang.lexer.PhpTokenTypes;
 import com.jetbrains.php.lang.psi.PhpPsiUtil;
-import com.jetbrains.php.lang.psi.elements.ArrayCreationExpression;
-import com.jetbrains.php.lang.psi.elements.ParameterList;
-import com.jetbrains.php.lang.psi.elements.PhpAttribute;
-import com.jetbrains.php.lang.psi.elements.StringLiteralExpression;
+import com.jetbrains.php.lang.psi.elements.*;
 import com.jetbrains.php.lang.psi.stubs.indexes.expectedArguments.PhpExpectedFunctionArgument;
 import org.apache.commons.lang.StringUtils;
 import org.jetbrains.annotations.NotNull;
@@ -34,6 +31,8 @@ public static String getAttributeValueByNameAsString(@NotNull PhpAttribute attri
             if (StringUtils.isNotBlank(contents)) {
                 return contents;
             }
+        } else if(nextSibling instanceof ClassConstantReference) {
+            return resolveLocalValue(attribute, (ClassConstantReference) nextSibling);
         }
 
         return null;
@@ -64,9 +63,45 @@ public static String getAttributeValueByNameAsStringWithDefaultParameterFallback
         for (PhpAttribute.PhpAttributeArgument argument : attribute.getArguments()) {
             PhpExpectedFunctionArgument argument1 = argument.getArgument();
             if (argument1.getArgumentIndex() == 0) {
-                String value = PsiElementUtils.trimQuote(argument1.getValue());
-                if (StringUtils.isNotBlank(value)) {
-                    return value;
+
+                // hint: reference is a complete fake object lazily created; it is not reflect the real element :(
+                // PhpPsiElementFactory.createPhpPsiFromText => com.jetbrains.php.lang.psi.stubs.indexes.expectedArguments.PhpExpectedFunctionClassConstantArgument.createReference
+                @NotNull PsiElement namedElement = argument1.createReference(attribute.getProject());
+
+                if (namedElement instanceof StringLiteralExpression) {
+                    // we can trust the string representation here, looks to be right implemented
+                    String contents = ((StringLiteralExpression) namedElement).getContents();
+                    if (StringUtils.isNotBlank(contents)) {
+                        return contents;
+                    }
+                } else if(namedElement instanceof ClassConstantReference) {
+                    // not working: we are in a dummy and temporary out-of-scope object
+                    // resolveLocalValue(attribute, (ClassConstantReference) nextSibling);
+                    PhpExpression classReference = ((ClassConstantReference) namedElement).getClassReference();
+                    if (classReference instanceof ClassReference) {
+                        PsiElement phpAttributesList = attribute.getParent();
+                        if (phpAttributesList instanceof PhpAttributesList) {
+                            PsiElement method = phpAttributesList.getParent();
+                            if (method instanceof Method) {
+                                PsiElement phpClass = method.getParent();
+                                // instead of normal "$this", "self", ... we are getting here the class name :(
+                                // so to check the owning scope compare it via the class name
+                                if (phpClass instanceof PhpClass && ((PhpClass) phpClass).getFQN().equals(((ClassReference) classReference).getFQN())) {
+                                    String fieldName = ((ClassConstantReference) namedElement).getName();
+                                    Field ownFieldByName = ((PhpClass) phpClass).findOwnFieldByName(fieldName, true);
+                                    if (ownFieldByName != null) {
+                                        PsiElement defaultValue = ownFieldByName.getDefaultValue();
+                                        if (defaultValue instanceof StringLiteralExpression) {
+                                            String contents = ((StringLiteralExpression) defaultValue).getContents();
+                                            if (StringUtils.isNotBlank(contents)) {
+                                                return contents;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -104,4 +139,36 @@ private static PsiElementPattern.Capture<PsiElement> getAttributeColonPattern(St
             PhpTokenTypes.opCOLON
         ).afterLeaf(PlatformPatterns.psiElement().withElementType(PhpTokenTypes.IDENTIFIER).withText(name));
     }
+
+    @Nullable
+    private static String resolveLocalValue(@NotNull PhpAttribute attribute, @NotNull ClassConstantReference nextSibling) {
+        PhpExpression classReference = nextSibling.getClassReference();
+        if (classReference != null) {
+            String name = classReference.getName();
+            if (name != null && (name.equals("self") || name.equals("static"))) {
+                PsiElement phpAttributesList = attribute.getParent();
+                if (phpAttributesList instanceof PhpAttributesList) {
+                    PsiElement method = phpAttributesList.getParent();
+                    if (method instanceof Method) {
+                        PsiElement phpClass = method.getParent();
+                        if (phpClass instanceof PhpClass) {
+                            String fieldName = nextSibling.getName();
+                            Field ownFieldByName = ((PhpClass) phpClass).findOwnFieldByName(fieldName, true);
+                            if (ownFieldByName != null) {
+                                PsiElement defaultValue = ownFieldByName.getDefaultValue();
+                                if (defaultValue instanceof StringLiteralExpression) {
+                                    String contents = ((StringLiteralExpression) defaultValue).getContents();
+                                    if (StringUtils.isNotBlank(contents)) {
+                                        return contents;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
 }

src/test/java/fr/adrienbrault/idea/symfony2plugin/tests/stubs/indexes/RoutesStubIndexTest.java

@@ -178,6 +178,15 @@ public void testThatPhp8AttributesMethodsAreInIndex() {
 
         RouteInterface route5 = getFirstValue("prefix_home_default_parameter");
         assertEquals("/foo-attributes-default/edit/{id}", route5.getPath());
+
+        RouteInterface route6 = getFirstValue("attributes-names-foobar-const");
+        assertEquals("/attributes-path-foobar", route6.getPath());
+
+        RouteInterface route7 = getFirstValue("attributes-default-as-const");
+        assertEquals("/attributes-path-foobar", route7.getPath());
+
+        RouteInterface route8 = getFirstValue("attributesWithoutNameWithConstantsInMethods");
+        assertEquals(0, route8.getMethods().size());
     }
 
     @NotNull

src/test/java/fr/adrienbrault/idea/symfony2plugin/tests/stubs/indexes/fixtures/RoutesStubIndex.php

@@ -159,10 +159,15 @@ public function fooAction()
 
 namespace AppBundle\My\Controller
 {
+
+    use Symfony\Component\HttpFoundation\Request;
     use Symfony\Component\Routing\Annotation\Route;
 
     class DefaultController
     {
+        private const FOOBAR = 'attributes-names-foobar-const';
+        private const FOOBAR_URL = '/attributes-path-foobar';
+
         /**
          * @Route("/", name="framework_extra_bundle_route")
          */
@@ -180,10 +185,25 @@ public function attributesWithoutName()
         {
         }
 
+        #[Route('/attributesWithoutNameWithConstantsInMethods', name: 'attributesWithoutNameWithConstantsInMethods', methods: [Request::METHOD_GET])]
+        public function attributesWithoutNameWithConstantsInMethods()
+        {
+        }
+
         #[Route(path: '/attributes-path', name: 'attributes-names')]
         public function attributesPath()
         {
         }
+
+        #[Route(path: self::FOOBAR_URL, name: self::FOOBAR)]
+        public function attributesPathFoo1()
+        {
+        }
+
+        #[Route(self::FOOBAR_URL, name: "attributes-default-as-const")]
+        public function attributesPathFoo2()
+        {
+        }
     }
 }
 
@@ -234,4 +254,13 @@ public function __construct(
         ) {
         }
     }
-}
+}
+
+namespace Symfony\Component\HttpFoundation
+{
+    class Request
+    {
+        public const METHOD_GET = 'GET';
+    }
+}
+