Generic/UselessOverridingMethod: bail if not checking a class method

The UselessOverridingMethod is triggered when the T_FUNCTION token is
found. This token is used for regular functions and also methods.

The sniff should run only for class and trait methods (including abstract and
anonymous classes). Those are the only methods that can have a parent.
So this commit changes the sniff to bail early when dealing with a
regular function, nested function or enum method.

Author: rodrigoprimo

src/Standards/Generic/Sniffs/CodeAnalysis/UselessOverridingMethodSniff.php

@@ -60,6 +60,14 @@ public function process(File $phpcsFile, $stackPtr)
             return;
         }
 
+        $conditions    = $token['conditions'];
+        $lastCondition = end($conditions);
+
+        // Skip functions that are not a method part of a class, anon class or trait.
+        if (in_array($lastCondition, [T_CLASS, T_ANON_CLASS, T_TRAIT]) === false) {
+            return;
+        }
+
         // Get function name.
         $methodName = $phpcsFile->getDeclarationName($stackPtr);
 

src/Standards/Generic/Tests/CodeAnalysis/UselessOverridingMethodUnitTest.1.inc

@@ -68,6 +68,13 @@ class Bar {
     public function differentCase() {
         return parent::DIFFERENTcase();
     }
+
+    public function nestedFunctionShouldBailEarly() {
+        function nestedFunctionShouldBailEarly() {
+            // Invalid code needed to ensure an error is NOT triggered and the sniff bails early when handling nested function.
+            parent::nestedFunctionShouldBailEarly();
+        }
+    }
 }
 
 abstract class AbstractFoo {
@@ -80,4 +87,56 @@ interface InterfaceFoo {
 
 trait TraitFoo {
     abstract public function sniffShouldBailEarly();
+
+    public function usefulMethodInTrait() {
+        parent::usefulMethodInTrait();
+
+        return 1;
+    }
+
+    public function uselessMethodInTrait() {
+        return parent::uselessMethodInTrait();
+    }
+}
+
+abstract class AbstractBar extends AbstractFoo {
+    public function uselessMethodInAbstractClass() {
+        parent::uselessMethodInAbstractClass();
+    }
+
+    public function usefulMethodInAbstractClass() {
+        $a = 1;
+        parent::usefulMethodInAbstractClass($a);
+    }
+}
+
+enum EnumFoo {
+    public function sniffShouldBailEarly() {
+        // Invalid code needed to ensure an error is NOT triggered and the sniff bails early when handling an enum method.
+        parent::sniffShouldBailEarly();
+    }
+}
+
+function shouldBailEarly() {
+    // Invalid code needed to ensure an error is NOT triggered and the sniff bails early when handling a regular function.
+    parent::shouldBailEarly();
+}
+
+new class extends ParentClass {
+    public function uselessOverridingMethod() {
+        parent::uselessOverridingMethod();
+    }
+
+    public function usefulOverridingMethod() {
+        $a = 10;
+        parent::usefulOverridingMethod($a);
+    }
+};
+
+function foo() {
+    new class extends ParentClass {
+        public function uselessOverridingMethod() {
+            parent::uselessOverridingMethod();
+        }
+    };
 }

src/Standards/Generic/Tests/CodeAnalysis/UselessOverridingMethodUnitTest.php

@@ -50,11 +50,15 @@ public function getWarningList($testFile='')
         switch ($testFile) {
         case 'UselessOverridingMethodUnitTest.1.inc':
             return [
-                4  => 1,
-                16 => 1,
-                38 => 1,
-                56 => 1,
-                68 => 1,
+                4   => 1,
+                16  => 1,
+                38  => 1,
+                56  => 1,
+                68  => 1,
+                97  => 1,
+                103 => 1,
+                126 => 1,
+                138 => 1,
             ];
         default:
             return [];