Example #1
0
 public function getGoToLocations($offset, $nodes)
 {
     $this->run();
     $name = null;
     $node = null;
     if (count($nodes) >= 2 && $nodes[0] instanceof Name) {
         $name = Type::nameToString($nodes[0]);
         $node = $nodes[1];
     }
     $locations = [];
     if ($node !== null && ($node instanceof Expr\Instanceof_ || $node instanceof Expr\New_ || $node instanceof Stmt\Catch_ || $node instanceof Stmt\Function_ || $node instanceof Stmt\ClassMethod || $node instanceof Expr\Closure || $node instanceof Param || $node instanceof Stmt\Class_ || $node instanceof Stmt\Interface_ || $node instanceof Stmt\TraitUse || $node instanceof Stmt\TraitUseAdaptation)) {
         foreach ($this->reflection->findClass($name) as $class) {
             if ($class->getLocation() !== null) {
                 $locations[] = $class->getLocation();
             }
         }
     }
     return $locations;
 }
Example #2
0
 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;
 }
Example #3
0
 public function enterNode(Node $node)
 {
     array_push($this->nodePathFromTop, $node);
     $classes = [];
     if ($node instanceof Expr\Instanceof_ || $node instanceof Expr\New_ || $node instanceof Expr\ClassConstFetch || $node instanceof Expr\StaticPropertyFetch || $node instanceof Expr\StaticCall) {
         $classes[] = $node->class;
     } elseif ($node instanceof Stmt\Catch_ || $node instanceof Param) {
         $classes[] = $node->type;
     } elseif ($node instanceof Stmt\Function_ || $node instanceof Stmt\ClassMethod || $node instanceof Expr\Closure) {
         $classes[] = $node->returnType;
     } elseif ($node instanceof Stmt\Class_) {
         $classes[] = $node->extends;
         $classes = array_merge($classes, $node->implements);
     } elseif ($node instanceof Stmt\Interface_) {
         $classes = array_merge($classes, $node->extends);
     } elseif ($node instanceof Stmt\TraitUse) {
         $classes = array_merge($classes, $node->traits);
     } elseif ($node instanceof Stmt\TraitUseAdaptation) {
         $classes[] = $node->trait;
     }
     foreach ($classes as $class) {
         if (is_object($class) && $class instanceof Name) {
             $name = Type::nameToString($class);
             if (!in_array(strtolower($name), ['self', 'parent', 'static']) && empty($this->reflection->findClass($name))) {
                 $range = Range::fromNode($class, $this->file->getPath());
                 $fixes = [];
                 if ($this->namespaceReflection !== null && $class->isUnqualified()) {
                     foreach ($this->namespaceReflection->findFullyQualifiedClasses($class->toString()) as $fqname) {
                         //$fixes[] = new Fix([new FixChunk($range, $fqname)], $fqname);
                         $fixes[] = $this->getFix($fqname);
                     }
                 }
                 $this->diagnostics[] = new Diagnostic([$range], 'Undefined class', $fixes);
             }
         }
     }
 }
Example #4
0
 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);
     }
 }