gossi\codegen\parser\visitor\MethodParserVisitor

Complexity

Total Complexity

18

Size/Duplication

Total Lines	93
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	16

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	visitMethod()	0	15	1
F	parseParams()	0	55	12
A	parseType()	0	7	2
A	parseBody()	0	7	3

<?php
declare(strict_types=1);

namespace gossi\codegen\parser\visitor;

use gossi\codegen\model\PhpMethod;
use gossi\codegen\model\PhpParameter;
use gossi\codegen\parser\PrettyPrinter;
use gossi\codegen\parser\visitor\parts\MemberParserPart;
use gossi\codegen\parser\visitor\parts\ValueParserPart;
use gossi\codegen\utils\TypeUtils;
use gossi\docblock\tags\ParamTag;
use PhpParser\Node\Identifier;
use PhpParser\Node\Name;
use PhpParser\Node\NullableType;
use PhpParser\Node\Stmt\ClassMethod;

class MethodParserVisitor extends StructParserVisitor {

	use MemberParserPart;
	use ValueParserPart;

	public function visitMethod(ClassMethod $node) {
		$m = new PhpMethod($node->name->name);
		$m->setAbstract($node->isAbstract());
		$m->setFinal($node->isFinal());
		$m->setVisibility($this->getVisibility($node));
		$m->setStatic($node->isStatic());
		$m->setReferenceReturned($node->returnsByRef());

		$this->parseMemberDocblock($m, $node->getDocComment());
		$this->parseParams($m, $node);

$m is of type object<gossi\codegen\model\AbstractPhpMember>|object<gossi\codegen\model\PhpConstant>, but the function expects a object<gossi\codegen\model\PhpMethod>.

		$this->parseType($m, $node);

$m is of type object<gossi\codegen\model\AbstractPhpMember>|object<gossi\codegen\model\PhpConstant>, but the function expects a object<gossi\codegen\model\PhpMethod>.

		$this->parseBody($m, $node);

		$this->struct->addMethod($m);
	}

	private function parseParams(PhpMethod $m, ClassMethod $node) {
		$params = $m->getDocblock()->getTags('param');
		foreach ($node->params as $param) {
			$name = $param->var ? $param->var->name : $param->name;

			$p = new PhpParameter();
			$p->setName($name);
			$p->setPassedByReference($param->byRef);

            $type = null;
            if ($param->type instanceof NullableType) {
                $param->type = $param->type->type;
                $p->setNullable(true);
            }
            if ($param->type instanceof Identifier) {
                $param->type = $param->type->name;

It seems like $param->type->name of type string is incompatible with the declared type null|object<PhpParser\Node\Identifier>|object<PhpParser\Node\Name>|object<PhpParser\Node\NullableType>|object<PhpParser\Node\UnionType> of property $type.

            }
            if (is_string($param->type)) {
				$type = $param->type;
			}
			if ($param->type instanceof Name) {
                $type = implode('\\', $param->type->parts);
                $qualifiedType = TypeUtils::guessQualifiedName($this->struct, $type);
                if ($type !== $qualifiedType) {
                    $type = $qualifiedType;
                } else {
                    $type = '\\'.$type;
                }
            }

			if ($type) {

The expression $type of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

                $p->addType($type);
            }

			$this->parseValue($p, $param);

			if ($p->getExpression() === 'null') {
                $p->setNullable(true);
            }

			$tag = $params->find($p, static function (ParamTag $t, $p) {
				return $t->getVariable() === '$' . $p->getName();
			});

			if ($tag !== null) {
			    $types = TypeUtils::expressionToTypes($tag->getType());
			    foreach ($types as $type) {
                    $p->addType(TypeUtils::guessQualifiedName($this->struct, $type));
                }
			    $p->setTypeDescription($tag->getDescription());
			}

			$m->addParameter($p);
		}
	}

	private function parseType(PhpMethod &$m, ClassMethod $node) {

The parameter $node is not used and could be removed.

		$returns = $m->getDocblock()->getTags('return');
		if ($returns->size() > 0) {
			$return = $returns->get(0);
			$m->addType($return->getType())->setTypeDescription($return->getDescription());
		}
	}

	private function parseBody(PhpMethod &$m, ClassMethod $node) {
		$stmts = $node->getStmts();
		if (is_array($stmts) && count($stmts)) {
			$prettyPrinter = new PrettyPrinter();
			$m->setBody($prettyPrinter->prettyPrint($stmts));
		}
	}
}