PHPSA\Compiler\Expression\MethodCall

Complexity

Total Complexity

12

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	8

Test Coverage

Coverage

0%

Importance

Changes	5
Bugs	1	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
B	compile()	0	56	9
A	parseArgs()	0	12	3

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

namespace PHPSA\Compiler\Expression;

use PhpParser\Node\Expr\Variable;
use PHPSA\Check;
use PHPSA\CompiledExpression;
use PHPSA\Context;
use PHPSA\Definition\ClassDefinition;
use PHPSA\Compiler\Expression;

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->isObject()) {
            /** @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(
                            'mcall.undefined',
                            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');
                        return new CompiledExpression;
                    }

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

                    return $method->run(clone $context, $compiledArguments);
                }

                return new CompiledExpression;
            }
        } elseif (!$leftCE->canBeObject()) {
            $context->notice(
                'mcall.not-object',
                'Is not object cannot be called like this',
                $expr->var,
                Check::CHECK_ALPHA
            );
        }

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

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

Parameters which have default values should be placed at the end.

    {
        $compiled = array();

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

        return $compiled;
    }
}