Opcode::operandToString() - Code Metrics - Inspection of "Improve opcode emitting logic and add deferred inv..." - railt/sdl - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( e081e8...a6938b )

by Kirill

created 2018-08-28 00:15 UTC

Opcode::operandToString() B

↳ Parent: Opcode

Complexity

Conditions	8
Paths	8

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	8
nc	8
nop	1
dl	0
loc	28
rs	8.4444
c	0
b	0
f	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	Opcode::getOffset()	0	6	1
A	Opcode::getOperation()	0	4	1

<?php
/**
 * This file is part of Railt package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace Railt\SDL\Frontend\IR;

use Railt\Io\Readable;
use Railt\SDL\Renderer;

/**
 * Class Opcode
 */
class Opcode implements OpcodeInterface
{
    /**
     * @var array|string[]|null
     */
    protected static $opcodes;

    /**
     * @var int
     */
    private $operation;

    /**
     * @var array
     */
    private $operands;

    /**
     * @var int
     */
    private $id;

    /**
     * @var Readable
     */
    private $file;

    /**
     * @var int|null
     */
    private $offset;

    /**
     * Opcode constructor.
     * @param int $operation
     * @param mixed ...$operands
     */
    public function __construct(int $operation, ...$operands)
    {
        $this->operation = $operation;
        $this->operands = $operands;
    }

    /**
     * @param int $operation
     * @return Opcode
     */
    public function rebind(int $operation): Opcode
    {
        $this->operation = $operation;

        return $this;
    }

    /**
     * @param int $id
     * @param Readable $file
     * @param int $offset
     * @return Opcode
     */
    public function mount(int $id, Readable $file, int $offset = 0): Opcode
    {
        $this->id = $id;
        $this->file = $file;
        $this->offset = $offset;

        return $this;
    }

    /**
     * @return int
     */
    public function getId(): int
    {
        \assert($this->id !== null, 'Opcode is unmounted');

        return $this->id;
    }

    /**
     * @return int
     */
    public function getOffset(): int
    {
        \assert($this->offset !== null, 'Opcode is unmounted');

        return $this->offset;
    }

    /**
     * @return int
     */
    public function getOperation(): int
    {
        return $this->operation;
    }

    /**
     * @param int $id
     * @return mixed|null
     */
    public function getOperand(int $id)
    {
        return $this->operands[$id] ?? null;
    }

    /**
     * @return iterable
     */
    public function getOperands(): iterable
    {
        return $this->operands;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @return Readable
     */
    public function getFile(): Readable
    {
        \assert($this->file !== null, 'Opcode is unmounted');

        return $this->file;
    }

    /**
     * @return string
     */
    public function __toString(): string
    {
        $operands = [];

        foreach ($this->operands as $i => $operand) {
            $operands[] = \sprintf('%d => %s', $i, Renderer::render($operand));
        }

        return \vsprintf('#%s %s {%s}', [
            $this->id ?? '?',
            $this->getName(),
            \implode(', ', $operands),
        ]);
    }

    /**
     * @return string
     */
    public function getName(): string
    {
        return static::getOperationName($this->operation);
    }

    /**
     * @param int $operation
     * @return string
     */
    public static function getOperationName(int $operation): string
    {
        if (static::$opcodes === null) {
            static::$opcodes = [];

            try {
                $reflection = new \ReflectionClass(static::class);
                foreach ($reflection->getConstants() as $name => $value) {
                    static::$opcodes[$value] = $name;
                }
            } catch (\ReflectionException $e) {
                return '';
            }
        }

        return static::$opcodes[$operation] ?? static::$opcodes[static::RL_NOP];
    }
}


1			<?php
2			/**
3			* This file is part of Railt package.
4			*
5			* For the full copyright and license information, please view the LICENSE
6			* file that was distributed with this source code.
7			*/
8			declare(strict_types=1);
9
10			namespace Railt\SDL\Frontend\IR;
11
12			use Railt\Io\Readable;
13			use Railt\SDL\Renderer;
14
15			/**
16			* Class Opcode
17			*/
18			class Opcode implements OpcodeInterface
19			{
20			/**
21			* @var array\|string[]\|null
22			*/
23			protected static $opcodes;
24
25			/**
26			* @var int
27			*/
28			private $operation;
29
30			/**
31			* @var array
32			*/
33			private $operands;
34
35			/**
36			* @var int
37			*/
38			private $id;
39
40			/**
41			* @var Readable
42			*/
43			private $file;
44
45			/**
46			* @var int\|null
47			*/
48			private $offset;
49
50			/**
51			* Opcode constructor.
52			* @param int $operation
53			* @param mixed ...$operands
54			*/
55			public function __construct(int $operation, ...$operands)
56			{
57			$this->operation = $operation;
58			$this->operands = $operands;
59			}
60
61			/**
62			* @param int $operation
63			* @return Opcode
64			*/
65			public function rebind(int $operation): Opcode
66			{
67			$this->operation = $operation;
68
69			return $this;
70			}
71
72			/**
73			* @param int $id
74			* @param Readable $file
75			* @param int $offset
76			* @return Opcode
77			*/
78			public function mount(int $id, Readable $file, int $offset = 0): Opcode
79			{
80			$this->id = $id;
81			$this->file = $file;
82			$this->offset = $offset;
83
84			return $this;
85			}
86
87			/**
88			* @return int
89			*/
90			public function getId(): int
91			{
92			\assert($this->id !== null, 'Opcode is unmounted');
93
94			return $this->id;
95			}
96
97			/**
98			* @return int
99			*/
100			public function getOffset(): int
101			{
102			\assert($this->offset !== null, 'Opcode is unmounted');
103
104			return $this->offset;
105			}
106
107			/**
108			* @return int
109			*/
110			public function getOperation(): int
111			{
112			return $this->operation;
113			}
114
115			/**
116			* @param int $id
117			* @return mixed\|null
118			*/
119			public function getOperand(int $id)
120			{
121			return $this->operands[$id] ?? null;
122			}
123
124			/**
125			* @return iterable
126			*/
127			public function getOperands(): iterable
128			{
129			return $this->operands;
			0 ignored issues – show Bug Best Practice introduced 2018-08-28 00:18 UTC by Report Bug Copy Issue Report The return type of `return $this->operands;` (`array`) is incompatible with the return type declared by the interface `Railt\SDL\Frontend\IR\OpcodeInterface::getOperands` of type `Railt\SDL\Frontend\IR\iterable\|array`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
130			}
131
132			/**
133			* @return Readable
134			*/
135			public function getFile(): Readable
136			{
137			\assert($this->file !== null, 'Opcode is unmounted');
138
139			return $this->file;
140			}
141
142			/**
143			* @return string
144			*/
145			public function __toString(): string
146			{
147			$operands = [];
148
149			foreach ($this->operands as $i => $operand) {
150			$operands[] = \sprintf('%d => %s', $i, Renderer::render($operand));
151			}
152
153			return \vsprintf('#%s %s {%s}', [
154			$this->id ?? '?',
155			$this->getName(),
156			\implode(', ', $operands),
157			]);
158			}
159
160			/**
161			* @return string
162			*/
163			public function getName(): string
164			{
165			return static::getOperationName($this->operation);
166			}
167
168			/**
169			* @param int $operation
170			* @return string
171			*/
172			public static function getOperationName(int $operation): string
173			{
174			if (static::$opcodes === null) {
175			static::$opcodes = [];
176
177			try {
178			$reflection = new \ReflectionClass(static::class);
179			foreach ($reflection->getConstants() as $name => $value) {
180			static::$opcodes[$value] = $name;
181			}
182			} catch (\ReflectionException $e) {
183			return '';
184			}
185			}
186
187			return static::$opcodes[$operation] ?? static::$opcodes[static::RL_NOP];
188			}
189			}
190

railt / sdl

Push — master ( e081e8...a6938b )

Opcode::operandToString() B

Complexity

Size

Duplication

Importance

2 Methods

Duplication Side-by-Side

Filter issues like