✘
This tool is currently proof-of-concept. Your feedback and evaluation is valuable in helping to improve it and ensure its reports are meaninful.
Please click here to complete a short survey to tell us what you think. It should take less than 5 minutes and help further this research project!
Symfony\Component\Routing\RouteCompiler

Detected issues

Issue	Method	Line number
Use of static methods	Route	50
Use of static methods	bool	106
Use of static methods	string	254
Use of static methods	string	272
Use of static methods	string	298
Use of static methods	string	328
Code

Click highlighted lines for details
<?php/* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */namespace Symfony\Component\Routing;/** * RouteCompiler compiles Route instances to CompiledRoute instances. * * @author Fabien Potencier <fabien@symfony.com> * @author Tobias Schultze <http://tobion.de> */class RouteCompiler implements RouteCompilerInterface{    /**     * @deprecated since Symfony 5.1, to be removed in 6.0     */    public const REGEX_DELIMITER = '#';    /**     * This string defines the characters that are automatically considered separators in front of     * optional placeholders (with default and no static text following). Such a single separator     * can be left out together with the optional placeholder from matching and generating URLs.     */    public const SEPARATORS = '/,;.:-_~+*=@|';    /**     * The maximum supported length of a PCRE subpattern name     * http://pcre.org/current/doc/html/pcre2pattern.html#SEC16.     *     * @internal     */    public const VARIABLE_MAXIMUM_LENGTH = 32;    /**     * {@inheritdoc}     *     * @throws \InvalidArgumentException if a path variable is named _fragment     * @throws \LogicException           if a variable is referenced more than once     * @throws \DomainException          if a variable name starts with a digit or if it is too long to be successfully used as     *                                   a PCRE subpattern     */    public static function compile(Route $route)
			Why this impedes flexibility
Static methods
Summary of issues
Tight Coupling
Hidden dependencies
Global state (if also using static variables)
Tight Coupling
Use of static methods always reduces flexibility by introducing tight coupling[1]. A static method tightly couples the calling code to the specific class the method exists in.

 
function totalAbs(double value, double value2) {
    return abs(value) + abs(value2);
}

Here, the method totalAbs has a dependency on the Math class and the .abs() method will always be called. Although for testing purposes this may not be a problem, the coupling reduces flexibility because the total method can only work with doubles/integers, as that's all the Math.abs() function can use. Although type coercion will allow the use of any primitive numeric type, these types have limitations. It's impossible to use another class such as BigInteger or a class for dealing with greater precision decimals or even alternative numbering systems such as Roman numerals.
The totalAbs function takes two doubles and converts them to their absolute values before adding them. This is inflexible because it only works with doubles. It's tied to doubles because that's what the Math.abs() static method requires. If, instead, using OOP an interface was created to handle any number that had this method:

 interface Numeric {
    public function abs(): Numeric;
}

It would then be possible to rewrite the totalAbs method to work with any kind of number:

 function totalAbs(Numeric value, Numeric value): Numeric {
    return value.abs() + value2.abs();
}


By removing the static method and using an instance method in its place the totalAbs method is now agnostic about the type of number it is dealing with. It could be called with any of the following (assuming they implement the Numeric interface)

 
totalAbs(new Integer(4), new Integer(-53));

totalAbs(new Double(34.4), new Integer(-2));

totalAbs(new BigInteger('123445454564765739878989343225778'), new Integer(2343));

totalAbs(new RomanNumeral('VII'), new RomanNumeral('CXV'));


Making the method reusable in a way that it wasn't when static methods were being used. By changing the static methods to instance methods, flexibility has been enhanced as the method can be used with any numeric type, not just numeric types that are supported by the Math.abs() method.
Broken encapsulation
Static methods also break encapsulation. Encapsulation is defined by Rogers[2] as:
the bundling of data with the methods that operate on that data
By passing the numeric value into the abs method, the data being operated on is being separated from the methods that operate on it, breaking encapsulation. Instead using num.abs() the data is encapsulated in the num instance and its type is not visible or relevant to the outside world. abs() will work on the data and work regardless of num's type, providing it implements the abs method.
This is a simple example, but applies to all static methods. Use of polymorphic instance methods that work on encapsulated data will always be more flexible than static method calls which can only ever deal with specific pre-defined types.
Further reading
What is tight coupling?
Why Static is Bad and How to Avoid It
Static Methods Will Shock You
Flaw: Brittle Global State & Singletons
Static Methods are Death to Testability
Exceptions
The only exception to this rule is when a static method is used for object creation in place of the new keyword[3]. This is because the new keyword is already a static call. However, even here a non-static factory is often preferable for testing purposes[4][5].
References
Popov, N. (2014) Don't be STUPID: GRASP SOLID!  [online]. Available from: https://nikic.github.io/2011/12/27/Dont-be-STUPID-GRASP-SOLID.html 
Rogers, P. (2001) Encapsulation is not information hiding [online]. Available from: http://www.javaworld.com/article/2075271/core-java/encapsulation-is-not-information-hiding.html 
Sonmez, J. (2010)  Static Methods Will Shock You  [online]. Available from: http://simpleprogrammer.com/2010/01/29/static-methods-will-shock-you/ 
Hevery, M. (2008) Static Methods are Death to Testability [online]. Available from: http://misko.hevery.com/2008/12/15/static-methods-are-death-to-testability/ 
Butler, T. (2013) Are Static Methods/Variables bad practice? [online]. Available from: https://r.je/static-methods-bad-practice.html 
    {        $hostVariables = [];        $variables = [];        $hostRegex = null;        $hostTokens = [];        if ('' !== $host = $route->getHost()) {            $result = self::compilePattern($route, $host, true);            $hostVariables = $result['variables'];            $variables = $hostVariables;            $hostTokens = $result['tokens'];            $hostRegex = $result['regex'];        }        $locale = $route->getDefault('_locale');        if (null !== $locale && null !== $route->getDefault('_canonical_route') && preg_quote($locale) === $route->getRequirement('_locale')) {            $requirements = $route->getRequirements();            unset($requirements['_locale']);            $route->setRequirements($requirements);            $route->setPath(str_replace('{_locale}', $locale, $route->getPath()));        }        $path = $route->getPath();        $result = self::compilePattern($route, $path, false);        $staticPrefix = $result['staticPrefix'];        $pathVariables = $result['variables'];        foreach ($pathVariables as $pathParam) {            if ('_fragment' === $pathParam) {                throw new \InvalidArgumentException(sprintf('Route pattern "%s" cannot contain "_fragment" as a path parameter.', $route->getPath()));            }        }        $variables = array_merge($variables, $pathVariables);        $tokens = $result['tokens'];        $regex = $result['regex'];        return new CompiledRoute(            $staticPrefix,            $regex,            $tokens,            $pathVariables,            $hostRegex,            $hostTokens,            $hostVariables,            array_unique($variables)        );    }    private static function compilePattern(Route $route, string $pattern, bool $isHost): array
			Why this impedes flexibility
Static methods
Summary of issues
Tight Coupling
Hidden dependencies
Global state (if also using static variables)
Tight Coupling
Use of static methods always reduces flexibility by introducing tight coupling[1]. A static method tightly couples the calling code to the specific class the method exists in.

 
function totalAbs(double value, double value2) {
    return abs(value) + abs(value2);
}

Here, the method totalAbs has a dependency on the Math class and the .abs() method will always be called. Although for testing purposes this may not be a problem, the coupling reduces flexibility because the total method can only work with doubles/integers, as that's all the Math.abs() function can use. Although type coercion will allow the use of any primitive numeric type, these types have limitations. It's impossible to use another class such as BigInteger or a class for dealing with greater precision decimals or even alternative numbering systems such as Roman numerals.
The totalAbs function takes two doubles and converts them to their absolute values before adding them. This is inflexible because it only works with doubles. It's tied to doubles because that's what the Math.abs() static method requires. If, instead, using OOP an interface was created to handle any number that had this method:

 interface Numeric {
    public function abs(): Numeric;
}

It would then be possible to rewrite the totalAbs method to work with any kind of number:

 function totalAbs(Numeric value, Numeric value): Numeric {
    return value.abs() + value2.abs();
}


By removing the static method and using an instance method in its place the totalAbs method is now agnostic about the type of number it is dealing with. It could be called with any of the following (assuming they implement the Numeric interface)

 
totalAbs(new Integer(4), new Integer(-53));

totalAbs(new Double(34.4), new Integer(-2));

totalAbs(new BigInteger('123445454564765739878989343225778'), new Integer(2343));

totalAbs(new RomanNumeral('VII'), new RomanNumeral('CXV'));


Making the method reusable in a way that it wasn't when static methods were being used. By changing the static methods to instance methods, flexibility has been enhanced as the method can be used with any numeric type, not just numeric types that are supported by the Math.abs() method.
Broken encapsulation
Static methods also break encapsulation. Encapsulation is defined by Rogers[2] as:
the bundling of data with the methods that operate on that data
By passing the numeric value into the abs method, the data being operated on is being separated from the methods that operate on it, breaking encapsulation. Instead using num.abs() the data is encapsulated in the num instance and its type is not visible or relevant to the outside world. abs() will work on the data and work regardless of num's type, providing it implements the abs method.
This is a simple example, but applies to all static methods. Use of polymorphic instance methods that work on encapsulated data will always be more flexible than static method calls which can only ever deal with specific pre-defined types.
Further reading
What is tight coupling?
Why Static is Bad and How to Avoid It
Static Methods Will Shock You
Flaw: Brittle Global State & Singletons
Static Methods are Death to Testability
Exceptions
The only exception to this rule is when a static method is used for object creation in place of the new keyword[3]. This is because the new keyword is already a static call. However, even here a non-static factory is often preferable for testing purposes[4][5].
References
Popov, N. (2014) Don't be STUPID: GRASP SOLID!  [online]. Available from: https://nikic.github.io/2011/12/27/Dont-be-STUPID-GRASP-SOLID.html 
Rogers, P. (2001) Encapsulation is not information hiding [online]. Available from: http://www.javaworld.com/article/2075271/core-java/encapsulation-is-not-information-hiding.html 
Sonmez, J. (2010)  Static Methods Will Shock You  [online]. Available from: http://simpleprogrammer.com/2010/01/29/static-methods-will-shock-you/ 
Hevery, M. (2008) Static Methods are Death to Testability [online]. Available from: http://misko.hevery.com/2008/12/15/static-methods-are-death-to-testability/ 
Butler, T. (2013) Are Static Methods/Variables bad practice? [online]. Available from: https://r.je/static-methods-bad-practice.html 
    {        $tokens = [];        $variables = [];        $matches = [];        $pos = 0;        $defaultSeparator = $isHost ? '.' : '/';        $useUtf8 = preg_match('//u', $pattern);        $needsUtf8 = $route->getOption('utf8');        if (!$needsUtf8 && $useUtf8 && preg_match('/[\x80-\xFF]/', $pattern)) {            throw new \LogicException(sprintf('Cannot use UTF-8 route patterns without setting the "utf8" option for route "%s".', $route->getPath()));        }        if (!$useUtf8 && $needsUtf8) {            throw new \LogicException(sprintf('Cannot mix UTF-8 requirements with non-UTF-8 pattern "%s".', $pattern));        }        // Match all variables enclosed in "{}" and iterate over them. But we only want to match the innermost variable        // in case of nested "{}", e.g. {foo{bar}}. This in ensured because \w does not match "{" or "}" itself.        preg_match_all('#\{(!)?(\w+)\}#', $pattern, $matches, \PREG_OFFSET_CAPTURE | \PREG_SET_ORDER);        foreach ($matches as $match) {            $important = $match[1][1] >= 0;            $varName = $match[2][0];            // get all static text preceding the current variable            $precedingText = substr($pattern, $pos, $match[0][1] - $pos);            $pos = $match[0][1] + \strlen($match[0][0]);            if (!\strlen($precedingText)) {                $precedingChar = '';            } elseif ($useUtf8) {                preg_match('/.$/u', $precedingText, $precedingChar);                $precedingChar = $precedingChar[0];            } else {                $precedingChar = substr($precedingText, -1);            }            $isSeparator = '' !== $precedingChar && str_contains(static::SEPARATORS, $precedingChar);            // A PCRE subpattern name must start with a non-digit. Also a PHP variable cannot start with a digit so the            // variable would not be usable as a Controller action argument.            if (preg_match('/^\d/', $varName)) {                throw new \DomainException(sprintf('Variable name "%s" cannot start with a digit in route pattern "%s". Please use a different name.', $varName, $pattern));            }            if (\in_array($varName, $variables)) {                throw new \LogicException(sprintf('Route pattern "%s" cannot reference variable name "%s" more than once.', $pattern, $varName));            }            if (\strlen($varName) > self::VARIABLE_MAXIMUM_LENGTH) {                throw new \DomainException(sprintf('Variable name "%s" cannot be longer than %d characters in route pattern "%s". Please use a shorter name.', $varName, self::VARIABLE_MAXIMUM_LENGTH, $pattern));            }            if ($isSeparator && $precedingText !== $precedingChar) {                $tokens[] = ['text', substr($precedingText, 0, -\strlen($precedingChar))];            } elseif (!$isSeparator && \strlen($precedingText) > 0) {                $tokens[] = ['text', $precedingText];            }            $regexp = $route->getRequirement($varName);            if (null === $regexp) {                $followingPattern = (string) substr($pattern, $pos);                // Find the next static character after the variable that functions as a separator. By default, this separator and '/'                // are disallowed for the variable. This default requirement makes sure that optional variables can be matched at all                // and that the generating-matching-combination of URLs unambiguous, i.e. the params used for generating the URL are                // the same that will be matched. Example: new Route('/{page}.{_format}', ['_format' => 'html'])                // If {page} would also match the separating dot, {_format} would never match as {page} will eagerly consume everything.                // Also even if {_format} was not optional the requirement prevents that {page} matches something that was originally                // part of {_format} when generating the URL, e.g. _format = 'mobile.html'.                $nextSeparator = self::findNextSeparator($followingPattern, $useUtf8);                $regexp = sprintf(                    '[^%s%s]+',                    preg_quote($defaultSeparator),                    $defaultSeparator !== $nextSeparator && '' !== $nextSeparator ? preg_quote($nextSeparator) : ''                );                if (('' !== $nextSeparator && !preg_match('#^\{\w+\}#', $followingPattern)) || '' === $followingPattern) {                    // When we have a separator, which is disallowed for the variable, we can optimize the regex with a possessive                    // quantifier. This prevents useless backtracking of PCRE and improves performance by 20% for matching those patterns.                    // Given the above example, there is no point in backtracking into {page} (that forbids the dot) when a dot must follow                    // after it. This optimization cannot be applied when the next char is no real separator or when the next variable is                    // directly adjacent, e.g. '/{x}{y}'.                    $regexp .= '+';                }            } else {                if (!preg_match('//u', $regexp)) {                    $useUtf8 = false;                } elseif (!$needsUtf8 && preg_match('/[\x80-\xFF]|(?<!\\\\)\\\\(?:\\\\\\\\)*+(?-i:X|[pP][\{CLMNPSZ]|x\{[A-Fa-f0-9]{3})/', $regexp)) {                    throw new \LogicException(sprintf('Cannot use UTF-8 route requirements without setting the "utf8" option for variable "%s" in pattern "%s".', $varName, $pattern));                }                if (!$useUtf8 && $needsUtf8) {                    throw new \LogicException(sprintf('Cannot mix UTF-8 requirement with non-UTF-8 charset for variable "%s" in pattern "%s".', $varName, $pattern));                }                $regexp = self::transformCapturingGroupsToNonCapturings($regexp);            }            if ($important) {                $token = ['variable', $isSeparator ? $precedingChar : '', $regexp, $varName, false, true];            } else {                $token = ['variable', $isSeparator ? $precedingChar : '', $regexp, $varName];            }            $tokens[] = $token;            $variables[] = $varName;        }        if ($pos < \strlen($pattern)) {            $tokens[] = ['text', substr($pattern, $pos)];        }        // find the first optional token        $firstOptional = \PHP_INT_MAX;        if (!$isHost) {            for ($i = \count($tokens) - 1; $i >= 0; --$i) {                $token = $tokens[$i];                // variable is optional when it is not important and has a default value                if ('variable' === $token[0] && !($token[5] ?? false) && $route->hasDefault($token[3])) {                    $firstOptional = $i;                } else {                    break;                }            }        }        // compute the matching regexp        $regexp = '';        for ($i = 0, $nbToken = \count($tokens); $i < $nbToken; ++$i) {            $regexp .= self::computeRegexp($tokens, $i, $firstOptional);        }        $regexp = '{^'.$regexp.'$}sD'.($isHost ? 'i' : '');        // enable Utf8 matching if really required        if ($needsUtf8) {            $regexp .= 'u';            for ($i = 0, $nbToken = \count($tokens); $i < $nbToken; ++$i) {                if ('variable' === $tokens[$i][0]) {                    $tokens[$i][4] = true;                }            }        }        return [            'staticPrefix' => self::determineStaticPrefix($route, $tokens),            'regex' => $regexp,            'tokens' => array_reverse($tokens),            'variables' => $variables,        ];    }    /**     * Determines the longest static prefix possible for a route.     */    private static function determineStaticPrefix(Route $route, array $tokens): string
			Why this impedes flexibility
Static methods
Summary of issues
Tight Coupling
Hidden dependencies
Global state (if also using static variables)
Tight Coupling
Use of static methods always reduces flexibility by introducing tight coupling[1]. A static method tightly couples the calling code to the specific class the method exists in.

 
function totalAbs(double value, double value2) {
    return abs(value) + abs(value2);
}

Here, the method totalAbs has a dependency on the Math class and the .abs() method will always be called. Although for testing purposes this may not be a problem, the coupling reduces flexibility because the total method can only work with doubles/integers, as that's all the Math.abs() function can use. Although type coercion will allow the use of any primitive numeric type, these types have limitations. It's impossible to use another class such as BigInteger or a class for dealing with greater precision decimals or even alternative numbering systems such as Roman numerals.
The totalAbs function takes two doubles and converts them to their absolute values before adding them. This is inflexible because it only works with doubles. It's tied to doubles because that's what the Math.abs() static method requires. If, instead, using OOP an interface was created to handle any number that had this method:

 interface Numeric {
    public function abs(): Numeric;
}

It would then be possible to rewrite the totalAbs method to work with any kind of number:

 function totalAbs(Numeric value, Numeric value): Numeric {
    return value.abs() + value2.abs();
}


By removing the static method and using an instance method in its place the totalAbs method is now agnostic about the type of number it is dealing with. It could be called with any of the following (assuming they implement the Numeric interface)

 
totalAbs(new Integer(4), new Integer(-53));

totalAbs(new Double(34.4), new Integer(-2));

totalAbs(new BigInteger('123445454564765739878989343225778'), new Integer(2343));

totalAbs(new RomanNumeral('VII'), new RomanNumeral('CXV'));


Making the method reusable in a way that it wasn't when static methods were being used. By changing the static methods to instance methods, flexibility has been enhanced as the method can be used with any numeric type, not just numeric types that are supported by the Math.abs() method.
Broken encapsulation
Static methods also break encapsulation. Encapsulation is defined by Rogers[2] as:
the bundling of data with the methods that operate on that data
By passing the numeric value into the abs method, the data being operated on is being separated from the methods that operate on it, breaking encapsulation. Instead using num.abs() the data is encapsulated in the num instance and its type is not visible or relevant to the outside world. abs() will work on the data and work regardless of num's type, providing it implements the abs method.
This is a simple example, but applies to all static methods. Use of polymorphic instance methods that work on encapsulated data will always be more flexible than static method calls which can only ever deal with specific pre-defined types.
Further reading
What is tight coupling?
Why Static is Bad and How to Avoid It
Static Methods Will Shock You
Flaw: Brittle Global State & Singletons
Static Methods are Death to Testability
Exceptions
The only exception to this rule is when a static method is used for object creation in place of the new keyword[3]. This is because the new keyword is already a static call. However, even here a non-static factory is often preferable for testing purposes[4][5].
References
Popov, N. (2014) Don't be STUPID: GRASP SOLID!  [online]. Available from: https://nikic.github.io/2011/12/27/Dont-be-STUPID-GRASP-SOLID.html 
Rogers, P. (2001) Encapsulation is not information hiding [online]. Available from: http://www.javaworld.com/article/2075271/core-java/encapsulation-is-not-information-hiding.html 
Sonmez, J. (2010)  Static Methods Will Shock You  [online]. Available from: http://simpleprogrammer.com/2010/01/29/static-methods-will-shock-you/ 
Hevery, M. (2008) Static Methods are Death to Testability [online]. Available from: http://misko.hevery.com/2008/12/15/static-methods-are-death-to-testability/ 
Butler, T. (2013) Are Static Methods/Variables bad practice? [online]. Available from: https://r.je/static-methods-bad-practice.html 
    {        if ('text' !== $tokens[0][0]) {            return ($route->hasDefault($tokens[0][3]) || '/' === $tokens[0][1]) ? '' : $tokens[0][1];        }        $prefix = $tokens[0][1];        if (isset($tokens[1][1]) && '/' !== $tokens[1][1] && false === $route->hasDefault($tokens[1][3])) {            $prefix .= $tokens[1][1];        }        return $prefix;    }    /**     * Returns the next static character in the Route pattern that will serve as a separator (or the empty string when none available).     */    private static function findNextSeparator(string $pattern, bool $useUtf8): string
			Why this impedes flexibility
Static methods
Summary of issues
Tight Coupling
Hidden dependencies
Global state (if also using static variables)
Tight Coupling
Use of static methods always reduces flexibility by introducing tight coupling[1]. A static method tightly couples the calling code to the specific class the method exists in.

 
function totalAbs(double value, double value2) {
    return abs(value) + abs(value2);
}

Here, the method totalAbs has a dependency on the Math class and the .abs() method will always be called. Although for testing purposes this may not be a problem, the coupling reduces flexibility because the total method can only work with doubles/integers, as that's all the Math.abs() function can use. Although type coercion will allow the use of any primitive numeric type, these types have limitations. It's impossible to use another class such as BigInteger or a class for dealing with greater precision decimals or even alternative numbering systems such as Roman numerals.
The totalAbs function takes two doubles and converts them to their absolute values before adding them. This is inflexible because it only works with doubles. It's tied to doubles because that's what the Math.abs() static method requires. If, instead, using OOP an interface was created to handle any number that had this method:

 interface Numeric {
    public function abs(): Numeric;
}

It would then be possible to rewrite the totalAbs method to work with any kind of number:

 function totalAbs(Numeric value, Numeric value): Numeric {
    return value.abs() + value2.abs();
}


By removing the static method and using an instance method in its place the totalAbs method is now agnostic about the type of number it is dealing with. It could be called with any of the following (assuming they implement the Numeric interface)

 
totalAbs(new Integer(4), new Integer(-53));

totalAbs(new Double(34.4), new Integer(-2));

totalAbs(new BigInteger('123445454564765739878989343225778'), new Integer(2343));

totalAbs(new RomanNumeral('VII'), new RomanNumeral('CXV'));


Making the method reusable in a way that it wasn't when static methods were being used. By changing the static methods to instance methods, flexibility has been enhanced as the method can be used with any numeric type, not just numeric types that are supported by the Math.abs() method.
Broken encapsulation
Static methods also break encapsulation. Encapsulation is defined by Rogers[2] as:
the bundling of data with the methods that operate on that data
By passing the numeric value into the abs method, the data being operated on is being separated from the methods that operate on it, breaking encapsulation. Instead using num.abs() the data is encapsulated in the num instance and its type is not visible or relevant to the outside world. abs() will work on the data and work regardless of num's type, providing it implements the abs method.
This is a simple example, but applies to all static methods. Use of polymorphic instance methods that work on encapsulated data will always be more flexible than static method calls which can only ever deal with specific pre-defined types.
Further reading
What is tight coupling?
Why Static is Bad and How to Avoid It
Static Methods Will Shock You
Flaw: Brittle Global State & Singletons
Static Methods are Death to Testability
Exceptions
The only exception to this rule is when a static method is used for object creation in place of the new keyword[3]. This is because the new keyword is already a static call. However, even here a non-static factory is often preferable for testing purposes[4][5].
References
Popov, N. (2014) Don't be STUPID: GRASP SOLID!  [online]. Available from: https://nikic.github.io/2011/12/27/Dont-be-STUPID-GRASP-SOLID.html 
Rogers, P. (2001) Encapsulation is not information hiding [online]. Available from: http://www.javaworld.com/article/2075271/core-java/encapsulation-is-not-information-hiding.html 
Sonmez, J. (2010)  Static Methods Will Shock You  [online]. Available from: http://simpleprogrammer.com/2010/01/29/static-methods-will-shock-you/ 
Hevery, M. (2008) Static Methods are Death to Testability [online]. Available from: http://misko.hevery.com/2008/12/15/static-methods-are-death-to-testability/ 
Butler, T. (2013) Are Static Methods/Variables bad practice? [online]. Available from: https://r.je/static-methods-bad-practice.html 
    {        if ('' == $pattern) {            // return empty string if pattern is empty or false (false which can be returned by substr)            return '';        }        // first remove all placeholders from the pattern so we can find the next real static character        if ('' === $pattern = preg_replace('#\{\w+\}#', '', $pattern)) {            return '';        }        if ($useUtf8) {            preg_match('/^./u', $pattern, $pattern);        }        return str_contains(static::SEPARATORS, $pattern[0]) ? $pattern[0] : '';    }    /**     * Computes the regexp used to match a specific token. It can be static text or a subpattern.     *     * @param array $tokens        The route tokens     * @param int   $index         The index of the current token     * @param int   $firstOptional The index of the first optional token     *     * @return string The regexp pattern for a single token     */    private static function computeRegexp(array $tokens, int $index, int $firstOptional): string
			Why this impedes flexibility
Static methods
Summary of issues
Tight Coupling
Hidden dependencies
Global state (if also using static variables)
Tight Coupling
Use of static methods always reduces flexibility by introducing tight coupling[1]. A static method tightly couples the calling code to the specific class the method exists in.

 
function totalAbs(double value, double value2) {
    return abs(value) + abs(value2);
}

Here, the method totalAbs has a dependency on the Math class and the .abs() method will always be called. Although for testing purposes this may not be a problem, the coupling reduces flexibility because the total method can only work with doubles/integers, as that's all the Math.abs() function can use. Although type coercion will allow the use of any primitive numeric type, these types have limitations. It's impossible to use another class such as BigInteger or a class for dealing with greater precision decimals or even alternative numbering systems such as Roman numerals.
The totalAbs function takes two doubles and converts them to their absolute values before adding them. This is inflexible because it only works with doubles. It's tied to doubles because that's what the Math.abs() static method requires. If, instead, using OOP an interface was created to handle any number that had this method:

 interface Numeric {
    public function abs(): Numeric;
}

It would then be possible to rewrite the totalAbs method to work with any kind of number:

 function totalAbs(Numeric value, Numeric value): Numeric {
    return value.abs() + value2.abs();
}


By removing the static method and using an instance method in its place the totalAbs method is now agnostic about the type of number it is dealing with. It could be called with any of the following (assuming they implement the Numeric interface)

 
totalAbs(new Integer(4), new Integer(-53));

totalAbs(new Double(34.4), new Integer(-2));

totalAbs(new BigInteger('123445454564765739878989343225778'), new Integer(2343));

totalAbs(new RomanNumeral('VII'), new RomanNumeral('CXV'));


Making the method reusable in a way that it wasn't when static methods were being used. By changing the static methods to instance methods, flexibility has been enhanced as the method can be used with any numeric type, not just numeric types that are supported by the Math.abs() method.
Broken encapsulation
Static methods also break encapsulation. Encapsulation is defined by Rogers[2] as:
the bundling of data with the methods that operate on that data
By passing the numeric value into the abs method, the data being operated on is being separated from the methods that operate on it, breaking encapsulation. Instead using num.abs() the data is encapsulated in the num instance and its type is not visible or relevant to the outside world. abs() will work on the data and work regardless of num's type, providing it implements the abs method.
This is a simple example, but applies to all static methods. Use of polymorphic instance methods that work on encapsulated data will always be more flexible than static method calls which can only ever deal with specific pre-defined types.
Further reading
What is tight coupling?
Why Static is Bad and How to Avoid It
Static Methods Will Shock You
Flaw: Brittle Global State & Singletons
Static Methods are Death to Testability
Exceptions
The only exception to this rule is when a static method is used for object creation in place of the new keyword[3]. This is because the new keyword is already a static call. However, even here a non-static factory is often preferable for testing purposes[4][5].
References
Popov, N. (2014) Don't be STUPID: GRASP SOLID!  [online]. Available from: https://nikic.github.io/2011/12/27/Dont-be-STUPID-GRASP-SOLID.html 
Rogers, P. (2001) Encapsulation is not information hiding [online]. Available from: http://www.javaworld.com/article/2075271/core-java/encapsulation-is-not-information-hiding.html 
Sonmez, J. (2010)  Static Methods Will Shock You  [online]. Available from: http://simpleprogrammer.com/2010/01/29/static-methods-will-shock-you/ 
Hevery, M. (2008) Static Methods are Death to Testability [online]. Available from: http://misko.hevery.com/2008/12/15/static-methods-are-death-to-testability/ 
Butler, T. (2013) Are Static Methods/Variables bad practice? [online]. Available from: https://r.je/static-methods-bad-practice.html 
    {        $token = $tokens[$index];        if ('text' === $token[0]) {            // Text tokens            return preg_quote($token[1]);        } else {            // Variable tokens            if (0 === $index && 0 === $firstOptional) {                // When the only token is an optional variable token, the separator is required                return sprintf('%s(?P<%s>%s)?', preg_quote($token[1]), $token[3], $token[2]);            } else {                $regexp = sprintf('%s(?P<%s>%s)', preg_quote($token[1]), $token[3], $token[2]);                if ($index >= $firstOptional) {                    // Enclose each optional token in a subpattern to make it optional.                    // "?:" means it is non-capturing, i.e. the portion of the subject string that                    // matched the optional subpattern is not passed back.                    $regexp = "(?:$regexp";                    $nbTokens = \count($tokens);                    if ($nbTokens - 1 == $index) {                        // Close the optional subpatterns                        $regexp .= str_repeat(')?', $nbTokens - $firstOptional - (0 === $firstOptional ? 1 : 0));                    }                }                return $regexp;            }        }    }    private static function transformCapturingGroupsToNonCapturings(string $regexp): string
			Why this impedes flexibility
Static methods
Summary of issues
Tight Coupling
Hidden dependencies
Global state (if also using static variables)
Tight Coupling
Use of static methods always reduces flexibility by introducing tight coupling[1]. A static method tightly couples the calling code to the specific class the method exists in.

 
function totalAbs(double value, double value2) {
    return abs(value) + abs(value2);
}

Here, the method totalAbs has a dependency on the Math class and the .abs() method will always be called. Although for testing purposes this may not be a problem, the coupling reduces flexibility because the total method can only work with doubles/integers, as that's all the Math.abs() function can use. Although type coercion will allow the use of any primitive numeric type, these types have limitations. It's impossible to use another class such as BigInteger or a class for dealing with greater precision decimals or even alternative numbering systems such as Roman numerals.
The totalAbs function takes two doubles and converts them to their absolute values before adding them. This is inflexible because it only works with doubles. It's tied to doubles because that's what the Math.abs() static method requires. If, instead, using OOP an interface was created to handle any number that had this method:

 interface Numeric {
    public function abs(): Numeric;
}

It would then be possible to rewrite the totalAbs method to work with any kind of number:

 function totalAbs(Numeric value, Numeric value): Numeric {
    return value.abs() + value2.abs();
}


By removing the static method and using an instance method in its place the totalAbs method is now agnostic about the type of number it is dealing with. It could be called with any of the following (assuming they implement the Numeric interface)

 
totalAbs(new Integer(4), new Integer(-53));

totalAbs(new Double(34.4), new Integer(-2));

totalAbs(new BigInteger('123445454564765739878989343225778'), new Integer(2343));

totalAbs(new RomanNumeral('VII'), new RomanNumeral('CXV'));


Making the method reusable in a way that it wasn't when static methods were being used. By changing the static methods to instance methods, flexibility has been enhanced as the method can be used with any numeric type, not just numeric types that are supported by the Math.abs() method.
Broken encapsulation
Static methods also break encapsulation. Encapsulation is defined by Rogers[2] as:
the bundling of data with the methods that operate on that data
By passing the numeric value into the abs method, the data being operated on is being separated from the methods that operate on it, breaking encapsulation. Instead using num.abs() the data is encapsulated in the num instance and its type is not visible or relevant to the outside world. abs() will work on the data and work regardless of num's type, providing it implements the abs method.
This is a simple example, but applies to all static methods. Use of polymorphic instance methods that work on encapsulated data will always be more flexible than static method calls which can only ever deal with specific pre-defined types.
Further reading
What is tight coupling?
Why Static is Bad and How to Avoid It
Static Methods Will Shock You
Flaw: Brittle Global State & Singletons
Static Methods are Death to Testability
Exceptions
The only exception to this rule is when a static method is used for object creation in place of the new keyword[3]. This is because the new keyword is already a static call. However, even here a non-static factory is often preferable for testing purposes[4][5].
References
Popov, N. (2014) Don't be STUPID: GRASP SOLID!  [online]. Available from: https://nikic.github.io/2011/12/27/Dont-be-STUPID-GRASP-SOLID.html 
Rogers, P. (2001) Encapsulation is not information hiding [online]. Available from: http://www.javaworld.com/article/2075271/core-java/encapsulation-is-not-information-hiding.html 
Sonmez, J. (2010)  Static Methods Will Shock You  [online]. Available from: http://simpleprogrammer.com/2010/01/29/static-methods-will-shock-you/ 
Hevery, M. (2008) Static Methods are Death to Testability [online]. Available from: http://misko.hevery.com/2008/12/15/static-methods-are-death-to-testability/ 
Butler, T. (2013) Are Static Methods/Variables bad practice? [online]. Available from: https://r.je/static-methods-bad-practice.html 
    {        for ($i = 0; $i < \strlen($regexp); ++$i) {            if ('\\' === $regexp[$i]) {                ++$i;                continue;            }            if ('(' !== $regexp[$i] || !isset($regexp[$i + 2])) {                continue;            }            if ('*' === $regexp[++$i] || '?' === $regexp[$i]) {                ++$i;                continue;            }            $regexp = substr_replace($regexp, '?:', $i, 0);            ++$i;        }        return $regexp;    }}