Sign upLogin

etsy/phan

View on GitHub
Star
src/Phan/AST/Parser.php

Summary

Maintainability
F
3 days
Test Coverage

File Parser.php has 444 lines of code (exceeds 250 allowed). Consider refactoring.
Open

<?php

declare(strict_types=1);

namespace Phan\AST;
Severity: Minor
Found in src/Phan/AST/Parser.php - About 6 hrs to fix

    Function guessErrorColumnUsingTokens has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.
    Open

        private static function guessErrorColumnUsingTokens(
        FileCacheEntry $file_cache_entry,
        Error $native_parse_error
    ): int {
        if (!\function_exists('token_get_all')) {
    Severity: Minor
    Found in src/Phan/AST/Parser.php - About 4 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    The class Parser has an overall complexity of 95 which is very high. The configured complexity threshold is 50.
    Open

    class Parser
{
    /** @var ?Cache<ParseResult> */
    private static $cache = null;
    Severity: Minor
    Found in src/Phan/AST/Parser.php by phpmd

    Function parseCodePolyfill has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.
    Open

        public static function parseCodePolyfill(CodeBase $code_base, Context $context, string $file_path, string $file_contents, bool $suppress_parse_errors, ?Request $request, array &$errors = []): Node
    {
        // @phan-suppress-next-line PhanRedundantCondition
        if (!\in_array(Config::AST_VERSION, TolerantASTConverter::SUPPORTED_AST_VERSIONS, true)) {
            throw new \Error(\sprintf("Unexpected polyfill version: want %s, got %d", \implode(', ', TolerantASTConverter::SUPPORTED_AST_VERSIONS), Config::AST_VERSION));
    Severity: Minor
    Found in src/Phan/AST/Parser.php - About 3 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Method parseCodePolyfill has 53 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        public static function parseCodePolyfill(CodeBase $code_base, Context $context, string $file_path, string $file_contents, bool $suppress_parse_errors, ?Request $request, array &$errors = []): Node
    {
        // @phan-suppress-next-line PhanRedundantCondition
        if (!\in_array(Config::AST_VERSION, TolerantASTConverter::SUPPORTED_AST_VERSIONS, true)) {
            throw new \Error(\sprintf("Unexpected polyfill version: want %s, got %d", \implode(', ', TolerantASTConverter::SUPPORTED_AST_VERSIONS), Config::AST_VERSION));
    Severity: Major
    Found in src/Phan/AST/Parser.php - About 2 hrs to fix

      Method guessErrorColumnUsingTokens has 50 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          private static function guessErrorColumnUsingTokens(
        FileCacheEntry $file_cache_entry,
        Error $native_parse_error
    ): int {
        if (!\function_exists('token_get_all')) {
      Severity: Minor
      Found in src/Phan/AST/Parser.php - About 2 hrs to fix

        Method parseCodeHandlingDeprecation has 38 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            private static function parseCodeHandlingDeprecation(CodeBase $code_base, Context $context, string $file_contents, string $file_path): Node
    {
        global $__no_echo_phan_errors;
        // Suppress errors such as "declare(encoding=...) ignored because Zend multibyte feature is turned off by settings" (#1076)
        // E_COMPILE_WARNING can't be caught by a PHP error handler,
        Severity: Minor
        Found in src/Phan/AST/Parser.php - About 1 hr to fix

          Function removeShebang has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
          Open

              public static function removeShebang(string $file_contents): string
    {
        if (\substr($file_contents, 0, 2) !== "#!") {
            return $file_contents;
        }
          Severity: Minor
          Found in src/Phan/AST/Parser.php - About 1 hr to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Function computeColumnForTokenAtIndex has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
          Open

              private static function computeColumnForTokenAtIndex(array $tokens, int $i, int $desired_line): int
    {
        if ($i <= 0) {
            return 1;
        }
          Severity: Minor
          Found in src/Phan/AST/Parser.php - About 1 hr to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Method guessErrorColumnUsingPolyfill has 30 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              private static function guessErrorColumnUsingPolyfill(
        CodeBase $code_base,
        Context $context,
        string $file_path,
        FileCacheEntry $file_cache_entry,
          Severity: Minor
          Found in src/Phan/AST/Parser.php - About 1 hr to fix

            Function handleParseError has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
            Open

                public static function handleParseError(
        CodeBase $code_base,
        Context $context,
        string $file_path,
        string $file_contents,
            Severity: Minor
            Found in src/Phan/AST/Parser.php - About 55 mins to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Method parseCodePolyfill has 7 arguments (exceeds 4 allowed). Consider refactoring.
            Open

                public static function parseCodePolyfill(CodeBase $code_base, Context $context, string $file_path, string $file_contents, bool $suppress_parse_errors, ?Request $request, array &$errors = []): Node
            Severity: Major
            Found in src/Phan/AST/Parser.php - About 50 mins to fix

              Method handleParseError has 7 arguments (exceeds 4 allowed). Consider refactoring.
              Open

                      CodeBase $code_base,
        Context $context,
        string $file_path,
        string $file_contents,
        bool $suppress_parse_errors,
              Severity: Major
              Found in src/Phan/AST/Parser.php - About 50 mins to fix

                Function guessErrorColumnUsingPolyfill has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                Open

                    private static function guessErrorColumnUsingPolyfill(
        CodeBase $code_base,
        Context $context,
        string $file_path,
        FileCacheEntry $file_cache_entry,
                Severity: Minor
                Found in src/Phan/AST/Parser.php - About 45 mins to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

                Method guessErrorColumnUsingPolyfill has 6 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                        CodeBase $code_base,
        Context $context,
        string $file_path,
        FileCacheEntry $file_cache_entry,
        Error $native_parse_error,
                Severity: Minor
                Found in src/Phan/AST/Parser.php - About 45 mins to fix

                  Method parseCode has 6 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                          CodeBase $code_base,
        Context $context,
        ?Request $request,
        string $file_path,
        string $file_contents,
                  Severity: Minor
                  Found in src/Phan/AST/Parser.php - About 45 mins to fix

                    Method emitSyntaxErrorForNativeParseError has 6 arguments (exceeds 4 allowed). Consider refactoring.
                    Open

                            CodeBase $code_base,
        Context $context,
        string $file_path,
        FileCacheEntry $file_cache_entry,
        Error $native_parse_error,
                    Severity: Minor
                    Found in src/Phan/AST/Parser.php - About 45 mins to fix

                      Function createConverter has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                      Open

                          private static function createConverter(string $file_path, string $file_contents, Request $request = null): TolerantASTConverter
    {
        if ($request) {
            if ($request->shouldUseMappingPolyfill($file_path)) {
                // TODO: Rename to something better
                      Severity: Minor
                      Found in src/Phan/AST/Parser.php - About 35 mins to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Avoid too many return statements within this method.
                      Open

                              return self::computeColumnForTokenAtIndex($tokens, $candidates[0], $desired_line);
                      Severity: Major
                      Found in src/Phan/AST/Parser.php - About 30 mins to fix

                        The method parseCodePolyfill() has an NPath complexity of 624. The configured NPath complexity threshold is 200.
                        Open

                            public static function parseCodePolyfill(CodeBase $code_base, Context $context, string $file_path, string $file_contents, bool $suppress_parse_errors, ?Request $request, array &$errors = []): Node
    {
        // @phan-suppress-next-line PhanRedundantCondition
        if (!\in_array(Config::AST_VERSION, TolerantASTConverter::SUPPORTED_AST_VERSIONS, true)) {
            throw new \Error(\sprintf("Unexpected polyfill version: want %s, got %d", \implode(', ', TolerantASTConverter::SUPPORTED_AST_VERSIONS), Config::AST_VERSION));
                        Severity: Minor
                        Found in src/Phan/AST/Parser.php by phpmd

                        NPathComplexity

                        Since: 0.1

                        The NPath complexity of a method is the number of acyclic execution paths through that method. A threshold of 200 is generally considered the point where measures should be taken to reduce complexity.

                        Example

                        class Foo {
    function bar() {
        // lots of complicated code
    }
}

                        Source https://phpmd.org/rules/codesize.html#npathcomplexity

                        The method guessErrorColumnUsingTokens() has an NPath complexity of 1776. The configured NPath complexity threshold is 200.
                        Open

                            private static function guessErrorColumnUsingTokens(
        FileCacheEntry $file_cache_entry,
        Error $native_parse_error
    ): int {
        if (!\function_exists('token_get_all')) {
                        Severity: Minor
                        Found in src/Phan/AST/Parser.php by phpmd

                        NPathComplexity

                        Since: 0.1

                        The NPath complexity of a method is the number of acyclic execution paths through that method. A threshold of 200 is generally considered the point where measures should be taken to reduce complexity.

                        Example

                        class Foo {
    function bar() {
        // lots of complicated code
    }
}

                        Source https://phpmd.org/rules/codesize.html#npathcomplexity

                        The method guessErrorColumnUsingTokens() has a Cyclomatic Complexity of 15. The configured cyclomatic complexity threshold is 10.
                        Open

                            private static function guessErrorColumnUsingTokens(
        FileCacheEntry $file_cache_entry,
        Error $native_parse_error
    ): int {
        if (!\function_exists('token_get_all')) {
                        Severity: Minor
                        Found in src/Phan/AST/Parser.php by phpmd

                        CyclomaticComplexity

                        Since: 0.1

                        Complexity is determined by the number of decision points in a method plus one for the method entry. The decision points are 'if', 'while', 'for', and 'case labels'. Generally, 1-4 is low complexity, 5-7 indicates moderate complexity, 8-10 is high complexity, and 11+ is very high complexity.

                        Example

                        // Cyclomatic Complexity = 11
class Foo {
1   public function example() {
2       if ($a == $b) {
3           if ($a1 == $b1) {
                fiddle();
4           } elseif ($a2 == $b2) {
                fiddle();
            } else {
                fiddle();
            }
5       } elseif ($c == $d) {
6           while ($c == $d) {
                fiddle();
            }
7        } elseif ($e == $f) {
8           for ($n = 0; $n < $h; $n++) {
                fiddle();
            }
        } else {
            switch ($z) {
9               case 1:
                    fiddle();
                    break;
10              case 2:
                    fiddle();
                    break;
11              case 3:
                    fiddle();
                    break;
                default:
                    fiddle();
                    break;
            }
        }
    }
}

                        Source https://phpmd.org/rules/codesize.html#cyclomaticcomplexity

                        The method parseCodePolyfill() has a Cyclomatic Complexity of 13. The configured cyclomatic complexity threshold is 10.
                        Open

                            public static function parseCodePolyfill(CodeBase $code_base, Context $context, string $file_path, string $file_contents, bool $suppress_parse_errors, ?Request $request, array &$errors = []): Node
    {
        // @phan-suppress-next-line PhanRedundantCondition
        if (!\in_array(Config::AST_VERSION, TolerantASTConverter::SUPPORTED_AST_VERSIONS, true)) {
            throw new \Error(\sprintf("Unexpected polyfill version: want %s, got %d", \implode(', ', TolerantASTConverter::SUPPORTED_AST_VERSIONS), Config::AST_VERSION));
                        Severity: Minor
                        Found in src/Phan/AST/Parser.php by phpmd

                        CyclomaticComplexity

                        Since: 0.1

                        Complexity is determined by the number of decision points in a method plus one for the method entry. The decision points are 'if', 'while', 'for', and 'case labels'. Generally, 1-4 is low complexity, 5-7 indicates moderate complexity, 8-10 is high complexity, and 11+ is very high complexity.

                        Example

                        // Cyclomatic Complexity = 11
class Foo {
1   public function example() {
2       if ($a == $b) {
3           if ($a1 == $b1) {
                fiddle();
4           } elseif ($a2 == $b2) {
                fiddle();
            } else {
                fiddle();
            }
5       } elseif ($c == $d) {
6           while ($c == $d) {
                fiddle();
            }
7        } elseif ($e == $f) {
8           for ($n = 0; $n < $h; $n++) {
                fiddle();
            }
        } else {
            switch ($z) {
9               case 1:
                    fiddle();
                    break;
10              case 2:
                    fiddle();
                    break;
11              case 3:
                    fiddle();
                    break;
                default:
                    fiddle();
                    break;
            }
        }
    }
}

                        Source https://phpmd.org/rules/codesize.html#cyclomaticcomplexity

                        The class Parser has a coupling between objects value of 25. Consider to reduce the number of dependencies under 13.
                        Open

                        class Parser
{
    /** @var ?Cache<ParseResult> */
    private static $cache = null;
                        Severity: Minor
                        Found in src/Phan/AST/Parser.php by phpmd

                        CouplingBetweenObjects

                        Since: 1.1.0

                        A class with too many dependencies has negative impacts on several quality aspects of a class. This includes quality criteria like stability, maintainability and understandability

                        Example

                        class Foo {
    /**
     * @var \foo\bar\X
     */
    private $x = null;

    /**
     * @var \foo\bar\Y
     */
    private $y = null;

    /**
     * @var \foo\bar\Z
     */
    private $z = null;

    public function setFoo(\Foo $foo) {}
    public function setBar(\Bar $bar) {}
    public function setBaz(\Baz $baz) {}

    /**
     * @return \SplObjectStorage
     * @throws \OutOfRangeException
     * @throws \InvalidArgumentException
     * @throws \ErrorException
     */
    public function process(\Iterator $it) {}

    // ...
}

                        Source https://phpmd.org/rules/design.html#couplingbetweenobjects

                        Avoid variables with short names like $i. Configured minimum length is 3.
                        Open

                            private static function computeColumnForTokenAtIndex(array $tokens, int $i, int $desired_line): int
                        Severity: Minor
                        Found in src/Phan/AST/Parser.php by phpmd

                        ShortVariable

                        Since: 0.2

                        Detects when a field, local, or parameter has a very short name.

                        Example

                        class Something {
    private $q = 15; // VIOLATION - Field
    public static function main( array $as ) { // VIOLATION - Formal
        $r = 20 + $this->q; // VIOLATION - Local
        for (int $i = 0; $i < 10; $i++) { // Not a Violation (inside FOR)
            $r += $this->q;
        }
    }
}

                        Source https://phpmd.org/rules/naming.html#shortvariable

                        Avoid variables with short names like $c. Configured minimum length is 3.
                        Open

                                    $c = $file_contents[$i];
                        Severity: Minor
                        Found in src/Phan/AST/Parser.php by phpmd

                        ShortVariable

                        Since: 0.2

                        Detects when a field, local, or parameter has a very short name.

                        Example

                        class Something {
    private $q = 15; // VIOLATION - Field
    public static function main( array $as ) { // VIOLATION - Formal
        $r = 20 + $this->q; // VIOLATION - Local
        for (int $i = 0; $i < 10; $i++) { // Not a Violation (inside FOR)
            $r += $this->q;
        }
    }
}

                        Source https://phpmd.org/rules/naming.html#shortvariable

                        There are no issues that match your filters.

                        Category
                        Status