Railt\Compiler\ParsingResult

Complexity

Total Complexity

10

Size/Duplication

Total Lines	96
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

0%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getParser()	0	8	2
A	getLexer()	0	16	4
A	getRules()	0	10	2
A	getBuilders()	0	6	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\Compiler;

use Railt\Compiler\Builder\Buildable;
use Railt\Compiler\Reader\PragmaParser;
use Railt\Compiler\Reader\ProductionParser;
use Railt\Compiler\Reader\RuleAnalyzer;
use Railt\Compiler\Reader\TokenParser;
use Railt\Compiler\Lexer\NativeStateless;
use Railt\Compiler\Lexer\Stateless;
use Railt\Compiler\Parser;
use Railt\Compiler\Parser\Runtime as ParserRuntime;
use Railt\Compiler\ParserInterface;

/**
 * Class Result
 */
class ParsingResult
{
    /**
     * @var PragmaParser
     */
    private $pragma;

    /**
     * @var TokenParser
     */
    private $tokens;

    /**
     * @var ProductionParser
     */
    private $productions;

    /**
     * @var Stateless
     */
    private $lexer;

    /**
     * @var ParserInterface|ParserRuntime
     */
    private $parser;

    /**
     * Result constructor.
     * @param PragmaParser $pragma
     * @param TokenParser $tokens
     * @param ProductionParser $productions
     */
    public function __construct(PragmaParser $pragma, TokenParser $tokens, ProductionParser $productions)
    {
        $this->pragma      = $pragma;
        $this->tokens      = $tokens;
        $this->productions = $productions;
    }

    /**
     * @return ParserInterface|Parser
     */
    public function getParser(): ParserInterface
    {
        if ($this->parser === null) {
            $this->parser = new Parser($this->getLexer(), $this->getRules());

It seems like new \Railt\Compiler\Parser($this->getLexer(), $this->getRules()) of type object<Railt\Compiler\Parser> is incompatible with the declared type object<Railt\Compiler\ParserInterface>|object<Railt\Compiler\Parser\Runtime> of property $parser.

        }

        return $this->parser;
    }

    /**
     * @return Stateless
     */
    public function getLexer(): Stateless
    {
        if ($this->lexer === null) {
            $this->lexer = new NativeStateless();

It seems like new \Railt\Compiler\Lexer\NativeStateless() of type object<Railt\Compiler\Lexer\NativeStateless> is incompatible with the declared type object<Railt\Compiler\Lexer\Stateless> of property $lexer.

            foreach ($this->tokens->getTokens() as $name => $pcre) {
                $this->lexer->add($name, $pcre);
            }

            foreach ($this->tokens->getSkippedTokens() as $name) {
                $this->lexer->skip($name);
            }
        }

        return $this->lexer;
    }

    /**
     * @return array
     */
    public function getRules(): array
    {
        $result = [];

        foreach ($this->getBuilders() as $key => $builder) {
            $result[$key] = $builder->toRule();
        }

        return $result;
    }

    /**
     * @return array|Buildable[]
     */
    public function getBuilders(): iterable
    {
        $analyzer = new RuleAnalyzer($this->getLexer());

        return $analyzer->analyze($this->productions->getRules());
    }
}