Generic/FunctionCallArgumentSpacing: efficiency fix - skip over arrow functions

PHP 7.4 introduced arrow functions.

While arrow functions being passed as an argument in a function call will not lead to false positives for this sniff - at least, I haven't been able to come up with a code sample in which it would [^1] -, skipping over them is still beneficial as it prevents unnecessary token walking.

Mind: the `scope_closer` of the arrow function _may_ be the comma separating the arrow function argument from the next function call argument, so we need to step one token back to prevent false negatives on those comma's.

Either way, this is now handled.

Includes unit tests.

[^1]: comma's in arrow functions will always be nested within parentheses, within a short array or within a nested closure or anonymous class, all of which the sniff already ignores.

Author: jrfnl

src/Standards/Generic/Sniffs/Functions/FunctionCallArgumentSpacingSniff.php

@@ -109,6 +109,7 @@ public function checkSpacing(File $phpcsFile, $stackPtr, $openBracket)
         $find = [
             T_COMMA,
             T_CLOSURE,
+            T_FN,
             T_ANON_CLASS,
             T_OPEN_SHORT_ARRAY,
         ];
@@ -120,6 +121,11 @@ public function checkSpacing(File $phpcsFile, $stackPtr, $openBracket)
                 // Skip closures.
                 $nextSeparator = $tokens[$nextSeparator]['scope_closer'];
                 continue;
+            } else if ($tokens[$nextSeparator]['code'] === T_FN) {
+                // Skip arrow functions, but don't skip the arrow function closer as it is likely to
+                // be the comma separating it from the next function call argument (or the parenthesis closer).
+                $nextSeparator = ($tokens[$nextSeparator]['scope_closer'] - 1);
+                continue;
             } else if ($tokens[$nextSeparator]['code'] === T_OPEN_SHORT_ARRAY) {
                 // Skips arrays using short notation.
                 $nextSeparator = $tokens[$nextSeparator]['bracket_closer'];

src/Standards/Generic/Tests/Functions/FunctionCallArgumentSpacingUnitTest.1.inc

@@ -177,3 +177,15 @@ $foo = new MyClass(
 #[AttributeName(1,2)]
 
 $callable = myCallable(...);
+
+// Skip over PHP 7.4 arrow functions.
+// While any commas belonging to the code within the arrow function would always need to be within parentheses
+// or within a short array, so there aren't any false positives, the sniff also does not need to examine these,
+// so will be more efficient skipping over arrow functions.
+$foobar = functionCallFnParamA(
+    fn ($foo,$bar) => [1,2,3],
+    $args,
+);
+
+$foobar = functionCallFnParamB(fn ($foo,$bar) => [1,2,3]  ,$args);
+$foobar = functionCallFnParamC($args, fn ($foo,$bar) => [1,2,3]  ,  );

src/Standards/Generic/Tests/Functions/FunctionCallArgumentSpacingUnitTest.1.inc.fixed

@@ -177,3 +177,15 @@ $foo = new MyClass(
 #[AttributeName(1, 2)]
 
 $callable = myCallable(...);
+
+// Skip over PHP 7.4 arrow functions.
+// While any commas belonging to the code within the arrow function would always need to be within parentheses
+// or within a short array, so there aren't any false positives, the sniff also does not need to examine these,
+// so will be more efficient skipping over arrow functions.
+$foobar = functionCallFnParamA(
+    fn ($foo,$bar) => [1,2,3],
+    $args,
+);
+
+$foobar = functionCallFnParamB(fn ($foo,$bar) => [1,2,3], $args);
+$foobar = functionCallFnParamC($args, fn ($foo,$bar) => [1,2,3], );

src/Standards/Generic/Tests/Functions/FunctionCallArgumentSpacingUnitTest.php

@@ -66,6 +66,8 @@ public function getErrorList($testFile='')
                 162 => 2,
                 170 => 1,
                 177 => 1,
+                190 => 2,
+                191 => 2,
             ];
 
         default: