Sign upLogin

etsy/phan

View on GitHub
Star
internal/extract_arg_info.php

Summary

Maintainability
D
2 days
Test Coverage

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

    private static function checkOpcacheAndReflectionAreConsistent(CodeBase $code_base, array $reflection_data, array $opcache_data): void
    {
        foreach ($opcache_data as $function_name => $opcache_type) {
            $reflection_type = $reflection_data[$function_name] ?? null;
            if (!$reflection_type) {
Severity: Minor
Found in internal/extract_arg_info.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

File extract_arg_info.php has 251 lines of code (exceeds 250 allowed). Consider refactoring.
Open

#!/usr/bin/env php
<?php

declare(strict_types=1);
Severity: Minor
Found in internal/extract_arg_info.php - About 2 hrs to fix

    Method extractUnionType has 49 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        private static function extractUnionType(array $flags): UnionType
    {
        static $type_lookup = null;
        if ($type_lookup === null) {
            $type_lookup = [
    Severity: Minor
    Found in internal/extract_arg_info.php - About 1 hr to fix

      Function extractInfoFromOpcache has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
      Open

          private static function extractInfoFromOpcache(string $contents): array
    {
        $lines = explode("\n", $contents);
        $result = [];
        foreach ($lines as $line) {
      Severity: Minor
      Found in internal/extract_arg_info.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 extractInfoFromReflection has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
      Open

          private static function extractInfoFromReflection(): array
    {
        $result = [];
        $function_names = get_defined_functions();
        unset($function_names['user']);
      Severity: Minor
      Found in internal/extract_arg_info.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 arrayTypeFromFlags has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
      Open

          private static function arrayTypeFromFlags(array $flag_set): UnionType
    {
        // 1. Convert key types from opcache to Phan's representation
        if (isset($flag_set['MAY_BE_ARRAY_KEY_ANY'])) {
            $key_type = GenericArrayType::KEY_MIXED;
      Severity: Minor
      Found in internal/extract_arg_info.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 arrayTypeFromFlags has 39 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          private static function arrayTypeFromFlags(array $flag_set): UnionType
    {
        // 1. Convert key types from opcache to Phan's representation
        if (isset($flag_set['MAY_BE_ARRAY_KEY_ANY'])) {
            $key_type = GenericArrayType::KEY_MIXED;
      Severity: Minor
      Found in internal/extract_arg_info.php - About 1 hr to fix

        Method main has 37 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            public static function main(): void
    {
        Shim::load();
        global $argv;
        if (count($argv) !== 2) {
        Severity: Minor
        Found in internal/extract_arg_info.php - About 1 hr to fix

          Method extractInfoFromReflection has 27 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              private static function extractInfoFromReflection(): array
    {
        $result = [];
        $function_names = get_defined_functions();
        unset($function_names['user']);
          Severity: Minor
          Found in internal/extract_arg_info.php - About 1 hr to fix

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

                private static function extractUnionType(array $flags): UnionType
    {
        static $type_lookup = null;
        if ($type_lookup === null) {
            $type_lookup = [
            Severity: Minor
            Found in internal/extract_arg_info.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

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

                private static function checkOpcacheAndReflectionAreConsistent(CodeBase $code_base, array $reflection_data, array $opcache_data): void
    {
        foreach ($opcache_data as $function_name => $opcache_type) {
            $reflection_type = $reflection_data[$function_name] ?? null;
            if (!$reflection_type) {
            Severity: Minor
            Found in internal/extract_arg_info.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 OpcacheFuncInfoParser has a coupling between objects value of 20. Consider to reduce the number of dependencies under 13.
            Open

            class OpcacheFuncInfoParser
{
    const OVERRIDES = [
        'config_get_hash' => null,  // skip php debug method
        // wrong handling of string for 32-bit
            Severity: Minor
            Found in internal/extract_arg_info.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

            The method main() contains an exit expression.
            Open

                        exit(1);
            Severity: Minor
            Found in internal/extract_arg_info.php by phpmd

            ExitExpression

            Since: 0.2

            An exit-expression within regular code is untestable and therefore it should be avoided. Consider to move the exit-expression into some kind of startup script where an error/exception code is returned to the calling environment.

            Example

            class Foo {
    public function bar($param)  {
        if ($param === 42) {
            exit(23);
        }
    }
}

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

            The method main() contains an exit expression.
            Open

                        exit(1);
            Severity: Minor
            Found in internal/extract_arg_info.php by phpmd

            ExitExpression

            Since: 0.2

            An exit-expression within regular code is untestable and therefore it should be avoided. Consider to move the exit-expression into some kind of startup script where an error/exception code is returned to the calling environment.

            Example

            class Foo {
    public function bar($param)  {
        if ($param === 42) {
            exit(23);
        }
    }
}

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

            The method main() contains an exit expression.
            Open

                        exit(1);
            Severity: Minor
            Found in internal/extract_arg_info.php by phpmd

            ExitExpression

            Since: 0.2

            An exit-expression within regular code is untestable and therefore it should be avoided. Consider to move the exit-expression into some kind of startup script where an error/exception code is returned to the calling environment.

            Example

            class Foo {
    public function bar($param)  {
        if ($param === 42) {
            exit(23);
        }
    }
}

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

            There are no issues that match your filters.

            Category
            Status