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 or a interface or enum method.

Author: rodrigoprimo

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

@@ -60,6 +60,13 @@ public function process(File $phpcsFile, $stackPtr)
             return;
         }
 
+        // Skip functions (including nested functions) and also interface and enum methods.
+        if ($phpcsFile->hasCondition($stackPtr, [T_CLASS, T_ANON_CLASS, T_TRAIT]) === false
+            || $phpcsFile->hasCondition($stackPtr, [T_FUNCTION]) === true
+        ) {
+            return;
+        }
+
         // Get function name.
         $methodName = $phpcsFile->getDeclarationName($stackPtr);
 

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

@@ -68,6 +68,12 @@ class Bar {
     public function differentCase() {
         return parent::DIFFERENTcase();
     }
+
+    public function nestedFunctionShouldBailEarly() {
+        function nestedFunctionShouldBailEarly() {
+            return 1;
+        }
+    }
 }
 
 abstract class AbstractFoo {
@@ -80,4 +86,42 @@ 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() {}
+}
+
+new class extends ParentClass {
+    public function __construct() {
+        parent::__construct();
+    }
+};
+
+new class extends ParentClass {
+    public function __construct() {
+        $a = 10;
+        parent::__construct($a);
+    }
+};

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

@@ -0,0 +1,8 @@
+<?php
+
+// Intentional fatal error (calling parent inside a function).
+// Testing that the sniff is *not* triggered in this case.
+
+function __construct() {
+    parent::__construct();
+}

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

@@ -50,11 +50,14 @@ 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,
+                96  => 1,
+                102 => 1,
+                117 => 1,
             ];
         default:
             return [];