/**
* Visit a node with kind `\ast\AST_CLASS`
*
* @param Node $node
* A node to parse
*
* @return Context
* A new or an unchanged context resulting from
* parsing the node
*/
public function visitClass(Node $node) : Context
{
if ($node->flags & \ast\flags\CLASS_ANONYMOUS) {
$class_name = AST::unqualifiedNameForAnonymousClassNode($node, $this->context);
} else {
$class_name = $node->name;
}
// This happens now and then and I have no idea
// why.
if (empty($class_name)) {
return $this->context;
}
assert(!empty($class_name), "Class must have name in {$this->context}");
$class_fqsen = FullyQualifiedClassName::fromStringInContext($class_name, $this->context);
// Hunt for an available alternate ID if necessary
$alternate_id = 0;
while ($this->code_base->hasClassWithFQSEN($class_fqsen)) {
$class_fqsen = $class_fqsen->withAlternateId(++$alternate_id);
}
// Build the class from what we know so far
$clazz = new Clazz($this->context->withLineNumberStart($node->lineno ?? 0)->withLineNumberEnd($node->endLineno ?? -1), $class_name, UnionType::fromStringInContext($class_name, $this->context), $node->flags ?? 0);
// Override the FQSEN with the found alternate ID
$clazz->setFQSEN($class_fqsen);
// Add the class to the code base as a globally
// accessible object
$this->code_base->addClass($clazz);
// Look to see if we have a parent class
if (!empty($node->children['extends'])) {
$parent_class_name = $node->children['extends']->children['name'];
// Check to see if the name isn't fully qualified
if ($node->children['extends']->flags & \ast\flags\NAME_NOT_FQ) {
if ($this->context->hasNamespaceMapFor(T_CLASS, $parent_class_name)) {
// Get a fully-qualified name
$parent_class_name = (string) $this->context->getNamespaceMapFor(T_CLASS, $parent_class_name);
} else {
$parent_class_name = $this->context->getNamespace() . '\\' . $parent_class_name;
}
}
// The name is fully qualified. Make sure it looks
// like it is
if (0 !== strpos($parent_class_name, '\\')) {
$parent_class_name = '\\' . $parent_class_name;
}
$parent_fqsen = FullyQualifiedClassName::fromStringInContext($parent_class_name, $this->context);
// Set the parent for the class
$clazz->setParentClassFQSEN($parent_fqsen);
}
// Add any implemeneted interfaces
if (!empty($node->children['implements'])) {
$interface_list = AST::qualifiedNameList($this->context, $node->children['implements']);
foreach ($interface_list as $name) {
$clazz->addInterfaceClassFQSEN(FullyQualifiedClassName::fromFullyQualifiedString($name));
}
}
// Update the context to signal that we're now
// within a class context.
$context = $clazz->getContext()->withClassFQSEN($class_fqsen);
return $context;
}
/**
* @param Node $node
* A node of the type indicated by the method name that we'd
* like to figure out the type that it produces.
*
* @return string
* The class name represented by the given call
*/
public function visitNew(Node $node) : string
{
// Things of the form `new $class_name();`
if ($node->children['class']->kind == \ast\AST_VAR) {
return '';
}
// Anonymous class
// $v = new class { ... }
if ($node->children['class']->kind == \ast\AST_CLASS && $node->children['class']->flags & \ast\flags\CLASS_ANONYMOUS) {
return AST::unqualifiedNameForAnonymousClassNode($node->children['class'], $this->context);
}
// Things of the form `new $method->name()`
if ($node->children['class']->kind !== \ast\AST_NAME) {
return '';
}
$class_name = $node->children['class']->children['name'];
if (!in_array($class_name, ['self', 'static', 'parent'])) {
return (string) UnionTypeVisitor::unionTypeFromClassNode($this->code_base, $this->context, $node->children['class']);
}
if (!$this->context->isInClassScope()) {
Log::err(Log::ESTATIC, "Cannot access {$class_name}:: when no class scope is active", $this->context->getFile(), $node->lineno);
return '';
}
if ($class_name == 'static') {
return (string) $this->context->getClassFQSEN();
}
if ($class_name == 'self') {
if ($this->context->isGlobalScope()) {
assert(false, "Unimplemented branch is required for {$this->context}");
} else {
return (string) $this->context->getClassFQSEN();
}
}
if ($class_name == 'parent') {
$clazz = $this->context->getClassInScope($this->code_base);
if (!$clazz->hasParentClassFQSEN()) {
return '';
}
return (string) $clazz->getParentClassFQSEN();
}
return '';
}
/**
* Visit a node with kind `\ast\AST_CLASS`
*
* @param Node $node
* A node to parse
*
* @return Context
* A new or an unchanged context resulting from
* parsing the node
*/
public function visitClass(Node $node) : Context
{
if ($node->flags & \ast\flags\CLASS_ANONYMOUS) {
$class_name = AST::unqualifiedNameForAnonymousClassNode($node, $this->context);
} else {
$class_name = $node->name;
}
assert(!empty($class_name), "Class name cannot be empty");
$alternate_id = 0;
// Hunt for the alternate of this class defined
// in this file
do {
$class_fqsen = FullyQualifiedClassName::fromStringInContext($class_name, $this->context)->withAlternateId($alternate_id++);
if (!$this->code_base->hasClassWithFQSEN($class_fqsen)) {
Log::err(Log::EFATAL, "Can't find class {$class_fqsen} - aborting", $this->context->getFile(), $node->lineno);
}
$clazz = $this->code_base->getClassByFQSEN($class_fqsen);
} while ($this->context->getFile() != $clazz->getContext()->getFile() || $this->context->getLineNumberStart() != $clazz->getContext()->getLineNumberStart());
return $clazz->getContext()->withClassFQSEN($class_fqsen);
}
private function visitClassNode(Node $node) : UnionType
{
// Things of the form `new $class_name();`
if ($node->kind == \ast\AST_VAR) {
return new UnionType();
}
// Anonymous class of form `new class { ... }`
if ($node->kind == \ast\AST_CLASS && $node->flags & \ast\flags\CLASS_ANONYMOUS) {
// Generate a stable name for the anonymous class
$anonymous_class_name = AST::unqualifiedNameForAnonymousClassNode($node, $this->context);
// Turn that into a fully qualified name
$fqsen = FullyQualifiedClassName::fromStringInContext($anonymous_class_name, $this->context);
// Turn that into a union type
return Type::fromFullyQualifiedString($fqsen)->asUnionType();
}
// Things of the form `new $method->name()`
if ($node->kind !== \ast\AST_NAME) {
return new UnionType();
}
// Get the name of the class
$class_name = $node->children['name'];
// If this is a straight-forward class name, recurse into the
// class node and get its type
if (!Type::isSelfTypeString($class_name)) {
// TODO: does anyone else call this method?
return self::unionTypeFromClassNode($this->code_base, $this->context, $node);
}
// This is a self-referential node
if (!$this->context->isInClassScope()) {
Log::err(Log::ESTATIC, "Cannot access {$class_name} when not in a class scope", $this->context->getFile(), $node->lineno);
return new UnionType();
}
// Reference to a parent class
if ($class_name === 'parent') {
$class = $this->context->getClassInScope($this->code_base);
if (!$class->hasParentClassFQSEN()) {
Log::err(Log::ESTATIC, "Reference to parent of parentless class {$class->getFQSEN()}", $this->context->getFile(), $node->lineno);
return new UnionType();
}
return Type::fromFullyQualifiedString((string) $class->getParentClassFQSEN())->asUnionType();
}
return Type::fromFullyQualifiedString((string) $this->context->getClassFQSEN())->asUnionType();
}
