PHPSA\Compiler\Expression\MethodCall

Complexity

Total Complexity

11

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	8

Test Coverage

Coverage

65.91%

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
B	compile()	0	55	8
A	parseArgs()	0	12	3

<?php
/**
 * @author Patsura Dmitry https://github.com/ovr <talk@dmtry.me>
 */

namespace PHPSA\Compiler\Expression;

use PHPSA\Check;
use PHPSA\CompiledExpression;
use PHPSA\Context;
use PHPSA\Definition\ClassDefinition;

class MethodCall extends AbstractExpressionCompiler
{
    protected $name = 'PhpParser\Node\Expr\MethodCall';

    /**
     * @param \PhpParser\Node\Expr\MethodCall $expr
     * @param Context $context
     * @return CompiledExpression
     */
    protected function compile($expr, Context $context)
    {
        $expressionCompiler = $context->getExpressionCompiler();
        $methodNameCE = $expressionCompiler->compile($expr->name);

        $compiledArguments = $this->parseArgs($expr->args, $context);

        $leftCE = $expressionCompiler->compile($expr->var);
        if ($leftCE->canBeObject()) {
            /** @var ClassDefinition $calledObject */
            $calledObject = $leftCE->getValue();
            if ($calledObject instanceof ClassDefinition) {
                $methodName = $methodNameCE->isString() ? $methodNameCE->getValue() : false;
                if ($methodName) {
                    if (!$calledObject->hasMethod($methodName, true)) {
                        $context->notice(
                            'language_error',
                            sprintf('Method %s() does not exist in %s scope', $methodName, $calledObject->getName()),
                            $expr
                        );

                        //it's needed to exit
                        return new CompiledExpression();
                    }

                    $method = $calledObject->getMethod($methodName, true);
                    if (!$method) {
                        $context->debug('getMethod is not working', $expr);
                        return new CompiledExpression();
                    }

                    if ($method->isStatic()) {
                        $context->notice(
                            'language_error',
                            "Method {$methodName}() is static but called like a class method",
                            $expr
                        );
                    }

                    return $method->run(clone $context, $compiledArguments);
                }
            }
            return new CompiledExpression();
        } else {
            $context->notice(
                'language_error',
                sprintf('$%s is not an object and cannot be called like this', $expr->var->name),

The property name does not seem to exist in PhpParser\Node\Expr.

                $expr->var,
                Check::CHECK_ALPHA
            );
        }

        $context->debug('[Unknown] @todo MethodCall', $expr);
        return new CompiledExpression();
    }

    /**
     * @param \PhpParser\Node\Arg[] $arguments
     * @param Context $context
     * @return CompiledExpression[]
     */
    protected function parseArgs(array $arguments, Context $context)
    {
        $compiled = [];

        if ($arguments) {

The expression $arguments of type PhpParser\Node\Arg[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            foreach ($arguments as $argument) {
                $compiled[] = $context->getExpressionCompiler()->compile($argument->value);
            }
        }

        return $compiled;
    }
}