added static completer and static typeresolver

mkusher · mkusher · commit e4ffd09cf5cb · 2015-05-23T21:36:31.000+03:00
diff --git a/bin/server.php b/bin/server.php
@@ -4,8 +4,10 @@
 use React\Http\Response;
 use React\Http\Request;
 
-require "app/config/bin.php";
-require "vendor/autoload.php";
+define("ROOT", dirname(__DIR__));
+
+require ROOT . "/app/config/bin.php";
+require ROOT . "/vendor/autoload.php";
 
 $noFsIO = false;
 $port = 15155;
diff --git a/src/Complete/CompleteEngine.php b/src/Complete/CompleteEngine.php
@@ -116,10 +116,10 @@ protected function processFileContent(Project $project, $lines, $line, $file){
             return;
         }
         $fqcn = $project->getIndex()->findFQCNByFile($file);
-        if(!$fqcn instanceof FQN){
+        if (!$fqcn instanceof FQN) {
             $fqcn = new FQN();
         }
-        if(!array_key_exists($file, $this->cachePool)){
+        if (!array_key_exists($file, $this->cachePool)) {
             $this->cachePool[$file] = [0, [], []];
         }
         if($this->isValidCache($file, $content)){
diff --git a/src/Complete/Completer/CompleterFactory.php b/src/Complete/Completer/CompleterFactory.php
@@ -12,12 +12,14 @@ public function __construct(
         InterfaceNameCompleter $interfaceNameCompleter,
         NamespaceCompleter $namespaceCompleter,
         ObjectCompleter $objectCompleter,
+        StaticCompleter $staticCompleter,
         UseCompleter $useCompleter
     ){
         $this->classNameCompleter = $classNameCompleter;
         $this->interfaceNameCompleter = $interfaceNameCompleter;
         $this->namespaceCompleter = $namespaceCompleter;
         $this->objectCompleter = $objectCompleter;
+        $this->staticCompleter = $staticCompleter;
         $this->useCompleter = $useCompleter;
     }
     public function getCompleter(Context $context){
@@ -36,12 +38,16 @@ public function getCompleter(Context $context){
         elseif($context->isThis() || $context->isObject()){
             return $this->objectCompleter;
         }
+        elseif($context->isClassStatic()){
+            return $this->staticCompleter;
+        }
         return null;
     }
 
     private $classNameCompleter;
     private $interfaceNameCompleter;
     private $namespaceCompleter;
     private $objectCompleter;
+    private $staticCompleter;
     private $useCompleter;
 }
diff --git a/src/Complete/Completer/StaticCompleter.php b/src/Complete/Completer/StaticCompleter.php
@@ -0,0 +1,90 @@
+<?php
+
+namespace Complete\Completer;
+
+use Entity\Project;
+use Entity\FQCN;
+use Entity\Node\MethodData;
+use Entity\Node\ClassProperty;
+use Entity\Node\InterfaceData;
+use Entity\Completion\Context;
+use Entity\Completion\Entry;
+use Entity\Completion\Scope;
+use Entity\Collection\Specification;
+use Psr\Log\LoggerInterface;
+
+class StaticCompleter {
+    public function __construct(LoggerInterface $logger){
+        $this->logger = $logger;
+    }
+    public function getEntries(Project $project, Context $context){
+        /** @var FQCN $fqcn */
+        list($fqcn, $isThis) = $context->getData();
+        $this->logger->addDebug('creating static entries');
+        if(!$fqcn instanceof FQCN){
+            return [];
+        }
+        $index = $project->getIndex();
+        $this->logger->addDebug('Creating completion for ' . $fqcn->toString());
+        $class = $index->findClassByFQCN($fqcn);
+        if(empty($class)){
+            $class = $index->findInterfaceByFQCN($fqcn);
+        }
+        if(empty($class)){
+            return [];
+        }
+        $entries = [];
+        $spec = new Specification($isThis ? 'private' : 'public', true);
+        if($class->methods !== null){
+            foreach($class->methods->all($spec) AS $method){
+                $entry = $this->createEntryForMethod($method);
+                $entries[$method->name] = $entry;
+            }
+        }
+        if($class instanceof InterfaceData){
+            return $entries;
+        }
+        if($class->properties !== null){
+            foreach($class->properties->all($spec) AS $property){
+                $entries[$property->name] = $this->createEntryForProperty($property);
+            }
+        }
+        if($class->constants !== null)
+        {
+            foreach($class->constants->all() as $const){
+                $entries[$const] = $this->createEntryForConst($const);
+            }
+        }
+        ksort($entries);
+        return $entries;
+    }
+
+    /**
+     * Creates menu entry for MethodData
+     *
+     * @param MethodData $method a method
+     * @return Entry
+     */
+    protected function createEntryForMethod(MethodData $method){
+        return new Entry(
+            $method->name,
+            $method->getSignature(),
+            sprintf("%s\n%s\n", $method->getSignature(), $method->doc)
+        );
+    }
+
+    protected function createEntryForProperty(ClassProperty $prop){
+        $type = $prop->type instanceof FQCN ? $prop->type->toString() : 'mixed';
+        return new Entry(
+            $prop->name,
+            $type
+        );
+    }
+
+    protected function createEntryForConst($const){
+        return new Entry($const);
+    }
+
+    /** @property LoggerInterface */
+    private $logger;
+}
diff --git a/src/Complete/Resolver/ContextResolver.php b/src/Complete/Resolver/ContextResolver.php
@@ -6,19 +6,24 @@
 use Entity\Completion\Context;
 use Entity\Completion\Scope;
 use Entity\Index;
+use Entity\FQCN;
 use Parser\ErrorFreePhpParser;
+use Parser\UseParser;
 use Psr\Log\LoggerInterface;
 use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Name;
 
 class ContextResolver{
     public function __construct(
         ErrorFreePhpParser $parser,
         NodeTypeResolver $typeResolver,
-        LoggerInterface $logger
+        LoggerInterface $logger,
+        UseParser $useParser
     ){
         $this->parser = $parser;
         $this->typeResolver = $typeResolver;
         $this->logger = $logger;
+        $this->useParser = $useParser;
     }
     public function getContext($badLine, Index $index, Scope $scope = null){
         if(empty($badLine)){
@@ -62,9 +67,27 @@ protected function createContext(Scope $scope, Token $token, $badLine, Index $in
             else {
                 $workingNode = $nodes;
             }
+            $isThis = false;
+            if($workingNode instanceof Variable && $workingNode->name === 'this')
+            {
+                $isThis = true;
+            }
+            if(
+                $workingNode instanceof Name
+            )
+            {
+                $nodeFQCN = $this->useParser->getFQCN($workingNode);
+                if(
+                    $scope->getFQCN() instanceof FQCN
+                    && $nodeFQCN->toString() === $scope->getFQCN()->toString()
+                )
+                {
+                    $isThis = true;
+                }
+            }
             $context->setData([
                 $this->typeResolver->getChainType($workingNode, $index, $scope),
-                $workingNode instanceof Variable && $workingNode->name === 'this'
+                $isThis
             ]);
         }
         if($token->isUseOperator()
@@ -107,4 +130,5 @@ protected function prepareLine($badLine){
     private $logger;
     private $parser;
     private $typeResolver;
+    private $useParser;
 }
diff --git a/src/Complete/Resolver/NodeTypeResolver.php b/src/Complete/Resolver/NodeTypeResolver.php
@@ -7,8 +7,11 @@
 use Entity\FQN;
 use Entity\Completion\Scope;
 use Parser\UseParser;
+use PhpParser\Node\Name;
 use PhpParser\Node\Expr\Variable;
 use PhpParser\Node\Expr\PropertyFetch;
+use PhpParser\Node\Expr\StaticPropertyFetch;
+use PhpParser\Node\Expr\StaticCall;
 use PhpParser\Node\Expr\MethodCall;
 use PhpParser\Node\Expr\New_;
 use Psr\Log\LoggerInterface;
@@ -34,7 +37,9 @@ public function __construct(
     public function getType($node, Index $index, Scope $scope){
         if($node instanceof Variable
             || $node instanceof PropertyFetch
+            || $node instanceof StaticPropertyFetch
             || $node instanceof MethodCall
+            || $node instanceof StaticCall
         ){
             return $this->getChainType($node, $index, $scope);
         }
@@ -43,9 +48,6 @@ public function getType($node, Index $index, Scope $scope){
         }
         return null;
     }
-    public function getNewType($node, Index $index, Scope $scope){
-
-    }
 
     /**
      * Calculates type of the passed chained node
@@ -75,19 +77,28 @@ public function getChainType($node, Index $index, Scope $scope){
                 }
                 $type = $this->getPropertyType($block['name'], $type, $index);
             }
+            elseif($block['type'] === 'class'){
+                $type = $block['name'];
+            }
         }
         return $type;
     }
     protected function createChain($node){
         $chain = [];
         while(!($node instanceof Variable)){
-            if($node instanceof PropertyFetch){
+            if(
+                $node instanceof PropertyFetch
+                || $node instanceof StaticPropertyFetch
+            ){
                 $chain[] = [
                     'type' => 'property',
                     'name' => $node->name
                 ];
             }
-            elseif($node instanceof MethodCall){
+            elseif(
+                $node instanceof MethodCall
+                || $node instanceof StaticCall
+            ){
                 $chain[] = [
                     'type' => 'method',
                     'name' => $node->name
@@ -98,12 +109,21 @@ protected function createChain($node){
             }
             $node = $node->var;
         }
+        if(property_exists($node, 'class')){
+            $node = $node->class;
+        }
         if($node instanceof Variable){
             $chain[] = [
                 'type' => 'var',
                 'name' => $node->name
             ];
         }
+        elseif($node instanceof Name){
+            $chain[] = [
+                'type' => 'class',
+                'name' => $this->useParser->getFQCN($node)
+            ];
+        }
         return array_reverse($chain);
     }
     protected function getVarType($name, Scope $scope){
diff --git a/src/Entity/Collection/ConstCollection.php b/src/Entity/Collection/ConstCollection.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace Entity\Collection;
+
+class ConstCollection {
+
+    public function __construct($class){
+        $this->class = $class;
+        $this->map['class'] = 'class';
+    }
+    public function add($constant){
+        $this->map[$constant] = $constant;
+    }
+    public function all(Specification $spec = null){
+        $consts = $this->map;
+        $parent = $this->class->getParent();
+        if($parent instanceof ClassData){
+            $props = array_merge(
+                $parent->properties->all(),
+                $consts
+            );
+        }
+        sort($consts);
+        return $consts;
+    }
+    public function get($propName, $spec = null){
+        if(array_key_exists($propName, $this->map)){
+            $const = $this->map[$propName];
+            return $const;
+        }
+        $parent = $this->class->getParent();
+        if($parent instanceof ClassData){
+            return $parent->properties->get($name);
+        }
+    }
+
+    private $map        = [];
+    private $class;
+}
diff --git a/src/Entity/Collection/MethodsCollection.php b/src/Entity/Collection/MethodsCollection.php
@@ -24,7 +24,7 @@ public function remove(MethodData $method){
     }
     public function get($name, Specification $spec = null){
         if($spec === null){
-            $spec = new Specification('private', false, true);
+            $spec = new Specification('private', true, true);
         }
         if(array_key_exists($name, $this->methods)){
             $method = $this->methods[$name];
diff --git a/src/Entity/Completion/Token.php b/src/Entity/Completion/Token.php
@@ -19,6 +19,7 @@ public function add($code, $symbol){
             $this->addType(self::T_CONTINUE_PROCESS);
             break;
         case T_VARIABLE:
+        case T_DOUBLE_COLON:
         case T_OBJECT_OPERATOR:
             if($this->isWhitespace()){
                 $this->addType(self::T_UNKNOWN);
@@ -112,6 +113,13 @@ protected function removeType($type){
         }
     }
 
+    /**
+     * @return Token
+     */
+    protected static function test(){
+
+    }
+
     const T_UNKNOWN             = -1;
     const T_CONTINUE_PROCESS    = 1;
     const T_TERMINATE           = 2;
@@ -128,7 +136,7 @@ protected function removeType($type){
     protected static $MAP = [
         T_VARIABLE              => Token::T_VAR,
         T_OBJECT_OPERATOR       => Token::T_OBJECT_OPERATOR,
-        T_STATIC                => Token::T_STATIC_OPERATOR,
+        T_DOUBLE_COLON          => Token::T_STATIC_OPERATOR,
         T_USE                   => Token::T_USE_OPERATOR,
         T_NAMESPACE             => Token::T_NAMESPACE_OPERATOR,
         T_NEW                   => Token::T_NEW_OPERATOR,
diff --git a/src/Entity/Node/ClassData.php b/src/Entity/Node/ClassData.php

Original file line number	Diff line number	Diff line change
`@@ -116,10 +116,10 @@ protected function processFileContent(Project $project, $lines, $line, $file){`
`116`	`116`	`return;`
`117`	`117`	`}`
`118`	`118`	`$fqcn = $project->getIndex()->findFQCNByFile($file);`
`119`		`- if(!$fqcn instanceof FQN){`
	`119`	`+ if (!$fqcn instanceof FQN) {`
`120`	`120`	`$fqcn = new FQN();`
`121`	`121`	`}`
`122`		`- if(!array_key_exists($file, $this->cachePool)){`
	`122`	`+ if (!array_key_exists($file, $this->cachePool)) {`
`123`	`123`	`$this->cachePool[$file] = [0, [], []];`
`124`	`124`	`}`
`125`	`125`	`if($this->isValidCache($file, $content)){`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public function remove(MethodData $method){`
`24`	`24`	`}`
`25`	`25`	`public function get($name, Specification $spec = null){`
`26`	`26`	`if($spec === null){`
`27`		`- $spec = new Specification('private', false, true);`
	`27`	`+ $spec = new Specification('private', true, true);`
`28`	`28`	`}`
`29`	`29`	`if(array_key_exists($name, $this->methods)){`
`30`	`30`	`$method = $this->methods[$name];`