public function test_Variable_this() { $refl = $this->getMockBuilder(Reflection::class)->disableOriginalConstructor()->getMock(); $var1 = new Expr\Variable('this'); $class = new Stmt\Class_('C', ['stmts' => [new Stmt\ClassMethod('f', ['stmts' => [$var1]])]], ['namespacedName' => new Name\FullyQualified('C')]); $this->infer([$class], $refl); $this->assertTrue($var1->getAttribute('type')->equals(Type::object_('\\C'))); }
protected function resolveDocTagType(Type $type) { return $type->walk(function (Type $type) { if ($type instanceof ObjectType) { $nameStr = $type->getClass(); if ($nameStr !== null && $nameStr !== '') { if ($nameStr[0] === '\\') { $name = new FullyQualified(substr($nameStr, 1)); } else { $name = new Name($nameStr); } $name = $this->resolveClassName($name)->getAttribute('resolved'); $nameStr = $name->toString(); if ($name instanceof FullyQualified) { $nameStr = '\\' . $nameStr; } return Type::object_($nameStr); } } return $type; }); }
public function test_StaticCall() { $class = (new Class_())->setName('\\C'); $method = (new Method())->setName('qaz')->setClass($class)->setStatic(true)->setDocReturnType(Type::object_('\\X\\Y')); $prop = (new Property())->setName('$wsx')->setClass($class)->setStatic(true)->setType(Type::string_()); $const = (new ClassConst())->setName('EDC')->setClass($class); $cls = new Name\FullyQualified('C'); $id = new Identifier('q'); $expr = new Expr\StaticCall($cls, $id, []); $completions = $this->complete([$id, $expr], [$method], [$prop], [$const]); $this->assertCount(3, $completions); $this->assertSame('qaz', $completions[0]->getInsertion()); $this->assertSame('qaz()', $completions[0]->getDisplay()); $this->assertSame('static_method', $completions[0]->getKind()); $this->assertSame('Y', $completions[0]->getType()); $this->assertSame('EDC', $completions[1]->getInsertion()); $this->assertSame('EDC', $completions[1]->getDisplay()); $this->assertSame('class_const', $completions[1]->getKind()); $this->assertSame('$wsx', $completions[2]->getInsertion()); $this->assertSame('$wsx', $completions[2]->getDisplay()); $this->assertSame('static_property', $completions[2]->getKind()); $this->assertSame('string', $completions[2]->getType()); }
public function leaveNode(Node $node) { if ($node instanceof Stmt\Function_ || $node instanceof Stmt\ClassMethod || $node instanceof Expr\Closure) { array_pop($this->functionScopeStack); } elseif ($node instanceof Stmt\ClassLike) { array_pop($this->classStack); array_pop($this->functionScopeStack); } if (!$node instanceof Expr) { return; } $type = null; $reflections = null; if ($node instanceof Expr\Variable) { if (is_string($node->name)) { if ($node->name === 'this') { $type = $this->getCurrentClass(); } elseif (array_key_exists('$' . $node->name, $this->getCurrentFunctionScope())) { $type = $this->getCurrentFunctionScope()['$' . $node->name]; } } } elseif ($node instanceof Expr\FuncCall) { $reflections = []; if ($node->name instanceof Name) { $reflections = $this->reflection->findFunction(Type::nameToString($node->name)); } else { $reflections = $this->findMethods($node->name->getAttribute('type'), '__invoke'); } $type = $this->functionsReturnType($reflections); // TODO: ConstFetch } elseif ($node instanceof Expr\MethodCall) { $reflections = []; if (is_string($node->name) || $node->name instanceof Identifier) { $reflections = $this->findMethods($node->var->getAttribute('type'), (string) $node->name); } $type = $this->functionsReturnType($reflections); } elseif ($node instanceof Expr\StaticCall) { $reflections = []; if ($node->class instanceof Name && (is_string($node->name) || $node->name instanceof Identifier)) { $reflections = $this->findMethods(Type::object_(Type::nameToString($node->class)), (string) $node->name, true); } $type = $this->functionsReturnType($reflections); } elseif ($node instanceof Expr\PropertyFetch) { $reflections = []; if (is_string($node->name) || $node->name instanceof Identifier) { $reflections = $this->findProperties($node->var->getAttribute('type'), '$' . (string) $node->name); } $type = $this->variablesType($reflections); } elseif ($node instanceof Expr\StaticPropertyFetch) { $reflections = []; if ($node->class instanceof Name && is_string($node->name)) { $reflections = $this->findProperties(Type::object_(Type::nameToString($node->class)), '$' . $node->name, true); } $type = $this->variablesType($reflections); } elseif ($node instanceof Expr\ClassConstFetch) { // TODO ::class $reflections = []; if ($node->class instanceof Name) { $reflections = $this->findClassConsts(Type::object_(Type::nameToString($node->class)), (string) $node->name); } $type = $this->constsType($reflections); } elseif ($node instanceof Expr\ArrayDimFetch) { $arrayType = $node->var->getAttribute('type'); $altTypes = [$arrayType]; if ($arrayType instanceof AlternativesType) { $altTypes = $arrayType->getAlternatives(); } $types = []; foreach ($altTypes as $altType) { if ($altType instanceof ArrayType) { $types[] = $altType->getValueType(); } elseif ($altType instanceof ObjectType) { $types[] = $this->functionsReturnType($this->findMethods($altType, 'offsetGet')); // TODO: check for ArrayAccess } } $type = $types !== [] ? Type::alternatives($types) : Type::mixed_(); } elseif ($node instanceof Expr\Array_) { $type = Type::array_(); } elseif ($node instanceof Expr\New_) { if ($node->class instanceof Name) { $type = Type::object_(Type::nameToString($node->class)); } else { $type = Type::object_(); } } elseif ($node instanceof Expr\Clone_) { $type = $node->expr->getAttribute('type'); } elseif ($node instanceof Expr\Closure) { $type = Type::object_('\\Closure'); } elseif ($node instanceof Expr\Cast\Array_) { $exprType = $node->expr->getAttribute('type'); $altTypes = [$exprType]; if ($exprType instanceof AlternativesType) { $altTypes = $exprType->getAlternatives(); } $types = []; foreach ($altTypes as $altType) { if ($altType instanceof ArrayType) { $types[] = $altType; } else { $types[] = Type::array_(); // TODO primitives: (array)int --> int[] } } $type = $types !== [] ? Type::alternatives($types) : Type::mixed_(); } elseif ($node instanceof Expr\Cast\Object_) { $exprType = $node->expr->getAttribute('type'); $altTypes = [$exprType]; if ($exprType instanceof AlternativesType) { $altTypes = $exprType->getAlternatives(); } $types = []; foreach ($altTypes as $altType) { if ($altType instanceof ObjectType) { $types[] = $altType; } else { $types[] = Type::object_('\\stdClass'); } } $type = $types !== [] ? Type::alternatives($types) : Type::mixed_(); } elseif ($node instanceof Expr\Include_) { $type = Type::mixed_(); // TODO: Yield_ // TODO: YieldFrom } if ($type !== null) { $node->setAttribute('type', $type); } if ($reflections !== null) { $node->setAttribute('reflections', $reflections); } }
public function complete($offset) { $this->run(); $nodes = $this->parser->getNodesAtOffset($offset, true); $node = null; if (count($nodes) > 0) { $node = $nodes[0]; if ($node instanceof Identifier || $node instanceof ErrorNode\Nothing) { $node = count($nodes) > 1 ? $nodes[1] : null; } } $completions = []; $ctxClass = null; foreach ($nodes as $ctxNode) { if ($ctxNode instanceof Stmt\ClassLike) { $ctxClass = $ctxNode->hasAttribute('namespacedName') ? Type::nameToString($ctxNode->getAttribute('namespacedName')) : $node->name; break; } } if ($node instanceof Expr\MethodCall || $node instanceof Expr\PropertyFetch) { $methods = $this->findMethods($node->var->getAttribute('type')); $properties = $this->findProperties($node->var->getAttribute('type')); $methods = $this->reflection->filterAvailableMembers($methods, $ctxClass); $properties = $this->reflection->filterAvailableMembers($properties, $ctxClass); $completions = array_merge($this->formatMethods($methods), $this->formatProperties($properties)); } elseif ($node instanceof Expr\StaticCall || $node instanceof Expr\StaticPropertyFetch || $node instanceof Expr\ClassConstFetch) { // TODO: Support static call on an object: $object::staticMethod() etc. // TODO: Filter out non-static members outside the inheritance // chain - while static calls to them are allowed in PHP, they // are pretty useless. $staticOnly = true; foreach ($nodes as $ctxNode) { if ($ctxNode instanceof Stmt\ClassMethod) { $staticOnly = $ctxNode->isStatic(); break; } } $methods = $this->findMethods(Type::object_(Type::nameToString($node->class)), $staticOnly); $properties = $this->findProperties(Type::object_(Type::nameToString($node->class)), $staticOnly); $consts = $this->findClassConsts(Type::object_(Type::nameToString($node->class))); $methods = $this->reflection->filterAvailableMembers($methods, $ctxClass); $properties = $this->reflection->filterAvailableMembers($properties, $ctxClass); $completions = array_merge($this->formatMethods($methods), $this->formatClassConsts($consts), $this->formatProperties($properties, true)); } return $completions; }