function importVarType(Property $prop)
{
$prop->getDocComment();
$comment = $prop->getDocComment();
if ($comment) {
$str = $comment->getText();
if (count($prop->props) >= 1) {
try {
$docBlock = $this->factory->create($str, $this->getDocBlockContext());
/** @var Var_[] $types */
$types = $docBlock->getTagsByName("var");
if (count($types) > 0) {
$type = strval($types[0]->getType());
if (!empty($type)) {
if ($type[0] == '\\') {
$type = substr($type, 1);
}
$prop->props[0]->setAttribute("namespacedType", strval($type));
}
}
} catch (\InvalidArgumentException $e) {
// Skip it.
}
}
}
}
private function enterProperty(Property $node)
{
if ($node->isPrivate()) {
foreach ($node->props as $property) {
$this->privateAttributes[$property->name] = $node;
}
}
}
public function visitProperty(Property $node)
{
$prop = $node->props[0];
$p = new PhpProperty($prop->name);
$p->setStatic($node->isStatic());
$p->setVisibility($this->getVisibility($node));
$this->parseValue($p, $prop);
$this->parseMemberDocblock($p, $node->getDocComment());
$this->struct->setProperty($p);
}
/**
* @param Stmt\Property $node
*
* @return string
*/
public function convert(Stmt\Property $node)
{
foreach ($node->props as $key => $prop) {
$prop->name = $this->reservedWordReplacer->replace($prop->name);
$node->props[$key] = $prop;
}
if ($node->props[0]->default instanceof Expr\Array_ && $node->isStatic() === true) {
$node->type = $node->type - Stmt\Class_::MODIFIER_STATIC;
$this->dispatcher->moveToNonStaticVar($node->props[0]->name);
$this->logger->logNode("Static attribute default array not supported in zephir, (see #188). Changed into non static. ", $node, $this->dispatcher->getMetadata()->getFullQualifiedNameClass());
}
return $this->dispatcher->pModifiers($node->type) . $this->dispatcher->pCommaSeparated($node->props) . ';';
}
/**
* @param \ReflectionProperty $accessedProperty
* @param string $nameSuffix
*/
public function __construct(\ReflectionProperty $accessedProperty, $nameSuffix)
{
$this->accessedProperty = $accessedProperty;
$originalName = $accessedProperty->getName();
$name = UniqueIdentifierGenerator::getIdentifier($originalName . $nameSuffix);
parent::__construct(Class_::MODIFIER_PRIVATE, [new PropertyProperty($name)]);
}
/**
* @param PropertyNode $node
* @param ReflectionClass $declaringClass
* @return ReflectionProperty
*/
public static function createFromNode(PropertyNode $node, ReflectionClass $declaringClass)
{
$prop = new self();
$prop->name = $node->props[0]->name;
$prop->declaringClass = $declaringClass;
if ($node->isPrivate()) {
$prop->visibility = self::IS_PRIVATE;
} elseif ($node->isProtected()) {
$prop->visibility = self::IS_PROTECTED;
} else {
$prop->visibility = self::IS_PUBLIC;
}
$prop->isStatic = $node->isStatic();
$prop->docBlockTypes = (new FindPropertyType())->__invoke($node, $prop);
return $prop;
}
/**
* @return string
*/
public function getDocComment()
{
if (!$this->node->hasAttribute('comments')) {
return '';
}
/* @var \PhpParser\Comment\Doc $comment */
$comment = $this->node->getAttribute('comments')[0];
return $comment->getReformattedText();
}
/**
* Given a property, attempt to find the type of the property
*
* @param PropertyNode $node
* @param ReflectionProperty $reflectionProperty
* @return Type[]
*/
public function __invoke(PropertyNode $node, ReflectionProperty $reflectionProperty)
{
$contextFactory = new ContextFactory();
$context = $contextFactory->createForNamespace($reflectionProperty->getDeclaringClass()->getNamespaceName(), $reflectionProperty->getDeclaringClass()->getLocatedSource()->getSource());
/* @var \PhpParser\Comment\Doc $comment */
if (!$node->hasAttribute('comments')) {
return [];
}
$comment = $node->getAttribute('comments')[0];
$docBlock = new DocBlock($comment->getReformattedText(), new DocBlock\Context($context->getNamespace(), $context->getNamespaceAliases()));
/* @var \phpDocumentor\Reflection\DocBlock\Tag\VarTag $varTag */
$resolvedTypes = [];
$varTags = $docBlock->getTagsByName('var');
foreach ($varTags as $varTag) {
$resolvedTypes = array_merge($resolvedTypes, (new ResolveTypes())->__invoke($varTag->getTypes(), $context));
}
return $resolvedTypes;
}
protected function getProperty(Property $node)
{
$prop = $node->props[0];
$p = new PhpProperty($prop->name);
$default = $prop->default;
if ($default !== null) {
$p->setDefaultValue($this->getValue($default));
}
$p->setStatic($node->isStatic());
$p->setVisibility($this->getVisibility($node));
$this->parseMemberDocblock($p, $node->getDocComment());
return $p;
}
private function processProperty(\PhpParser\Node\Stmt\Property $node) {
$property = $node->props[0];
$member = $this->unit->addMember($property->name);
$this->setVariableType($member, $property->type);
$this->setVariableDefaultValue($member, $property->default);
$visibility = 'public';
if ($node->isPrivate()) {
$visibility = 'private';
} elseif ($node->isProtected()) {
$visibility = 'protected';
}
$member->setVisibility($visibility);
$docComment = $node->getDocComment();
if ($docComment !== NULL) {
$block = $this->dockblocParser->parse($docComment, $this->aliasMap);
$member->setDocBlock($block);
}
$member->setLine($node->getLine());
}
/**
* @param Property $node
*
* @return RefProperty
*/
private function createProperty(Property $node)
{
$ref = new RefProperty();
$ref->class = $this->class;
$ref->name = $node->props[0]->name;
$ref->default = $this->getValue($node->props[0]->default);
if ($node->isPrivate()) {
$ref->visibility = Visibility::IS_PRIVATE;
} elseif ($node->isProtected()) {
$ref->visibility = Visibility::IS_PROTECTED;
} elseif ($node->isPublic()) {
$ref->visibility = Visibility::IS_PUBLIC;
}
$ref->isStatic = $node->isStatic();
$ref->line = $node->getLine();
$ref->docComment = $this->createDocComment($node);
return $ref;
}
/**
* {@inheritDoc}
*/
public function isStatic()
{
return $this->propertyTypeNode->isStatic();
}
/**
* @param Node\Stmt\Property $node
*/
protected function parseClassPropertyNode(Node\Stmt\Property $node)
{
foreach ($node->props as $property) {
$this->structuralElements[$this->currentStructuralElement->namespacedName->toString()]['properties'][] = ['name' => $property->name, 'startLine' => $node->getLine(), 'isPublic' => $node->isPublic(), 'isPrivate' => $node->isPrivate(), 'isStatic' => $node->isStatic(), 'isProtected' => $node->isProtected(), 'docComment' => $node->getDocComment() ? $node->getDocComment()->getText() : null];
}
}
/**
* @return int
*/
public function getLine()
{
return $this->propertyBefore->getLine();
}
/**
* @return int
*/
public function getLine()
{
return $this->propertyAfter->getLine();
}
public function addProperty(PropertyNode $node)
{
foreach ($node->props as $prop) {
$property = new ReflectionProperty($prop->name);
$property->setStartLine((int) $node->getAttribute('startLine'));
$property->setEndLine((int) $node->getAttribute('endLine'));
$property->setDocComment((string) $node->getDocComment());
$property->setStatic((bool) $node->isStatic());
if (!is_null($prop->default)) {
$value = $this->resolveValue($prop->default);
$property->setDefault(strtolower(gettype($value)), $value);
}
if ($node->isPrivate()) {
$property->setVisibility(ReflectionProperty::IS_PRIVATE);
} elseif ($node->isProtected()) {
$property->setVisibility(ReflectionProperty::IS_PROTECTED);
} else {
$property->setVisibility(ReflectionProperty::IS_PUBLIC);
}
$this->context->getReflection()->addProperty($property);
}
}
protected function addProperty(PropertyNode $node)
{
foreach ($node->props as $prop) {
$property = new PropertyReflection($prop->name, $prop->getLine());
$property->setModifiers($node->type);
$property->setDefault($prop->default);
$comment = $this->context->getDocBlockParser()->parse($node->getDocComment(), $this->context, $property);
$property->setDocComment($node->getDocComment());
$property->setShortDesc($comment->getShortDesc());
$property->setLongDesc($comment->getLongDesc());
if ($errors = $comment->getErrors()) {
$property->setErrors($errors);
} else {
if ($tag = $comment->getTag('var')) {
$property->setHint($this->resolveHint($tag[0][0]));
$property->setHintDesc($tag[0][1]);
}
$property->setTags($comment->getOtherTags());
}
if ($this->context->getFilter()->acceptProperty($property)) {
$this->context->getClass()->addProperty($property);
if ($errors) {
$this->context->addErrors((string) $property, $prop->getLine(), $errors);
}
}
}
}