Constant completion (#499)

* Support for completing constants

* Constant completion

* Added completion section

* Updated CHANGELOG

CHANGELOG.md

@@ -6,6 +6,12 @@ Changelog
 Features:
 
   - [CodeTransforn] Extract expression
+  - [Completion] Support constant completion
+
+Improvements:
+
+  - [Completion] Support namespaced functions, fixes #473
+  - [Docs] Added section on completion
 
 ## 2018-06-16 0.6.0
 

couscous.yml

@@ -36,6 +36,9 @@ menu:
         reference:
             name: Reference
             items:
+                completion:
+                    text: Completion
+                    relativeUrl: completion.html
                 navigation:
                     text: Navigation
                     relativeUrl: navigation.html

doc/README.md

@@ -35,6 +35,7 @@ Phpactor is made up of a few different packages:
 - [phpactor/class-to-file](https://github.com/phpactor/class-to-file): Convert files to class names and vice-versa.
 - [phpactor/code-builder](https://github.com/phpactor/code-builder): Library for creating and idempotently updating source code.
 - [phpactor/code-transform](https://github.com/phpactor/code-transform): Transform code.
+- [phpactor/completion](https://github.com/phpactor/completion): Completion library.
 - [phpactor/path-finder](https://github.com/phpactor/path-finder): Simple for file relationships when they share common path segments.
 - [phpactor/source-code-filesystem](https://github.com/phpactor/source-code-filesystem): Manage source code trees.
 - [phpactor/test-utils](https://github.com/phpactor/test-utils): Shared test utilities for Phpactor

doc/completion.md

@@ -0,0 +1,124 @@
+Completion
+==========
+
+Phpactor provides completion for:
+
+- **Class names**: All PSR compliant classes in the project and vendor tree.
+- **Class members**: Methods, constants, properties of auto-loadable classes.
+- **Functions**: Built-in and bootstrapped.
+- **Constants**: Built-in and bootstrapped.
+- **Parameters**: Will suggest appropriate local variables for method parameters.
+
+Uniquely, Phpactor does not pre-index anything, completion happens in _real
+time_, file locations are guessed based on composer locations (or brute forced
+if not using composer). For non-autoloadable entities (e.g. functions) it is
+assumed that these are defined during bootstrap.
+
+Type inference
+--------------
+
+Phpactors type inference is based on
+[WorseReflection](https://github.com/phpactot/worse-reflection).
+
+### Assert
+
+When encountering an `assert` with `instanceof` it will cast the variable
+to that type, or a union of that type. See also [#instanceof](#instanceof).
+
+```php
+assert($foo instanceof Hello);
+assert($foo instanceof Hello || $foo instanceof Goodbye)
+
+$foo-> // type: Hello|Goodbye
+```
+
+### Assignments
+
+Phpactor will track assignemnts:
+
+```php
+$a = 'hello';
+$b = $a;
+$b; // type: string
+```
+
+### Catch
+
+```php
+
+try {
+   // something
+} catch (MyException $e) {
+    $e-> // type: MyException
+}
+```
+
+### Foreach
+
+Understands `foreach` with the docblock array annotation:
+
+```php
+/** @var Hello[] $foos */
+$foos = [];
+
+foreach ($foos as $foo) {
+    $foo-> // type:Hello
+}
+```
+
+Also understands simple generics:
+
+```php
+/** @var ArrayIterator<Hello> $foos */
+$foos = new ArrayIterator([ new Hello() ]);
+
+foreach ($foos as $foo) {
+    $foo-> // type:Hello
+}
+```
+
+### FunctionLike
+
+Understands annonymous functions:
+
+```
+$barfoo = new Barfoo();
+$function = function (Foobar $foobar) use ($barfoo) {
+    $foobar-> // type: Foobar
+    $barfoo-> // type: Barfoo
+}
+```
+
+### InstanceOf
+
+`if` statements are evaluated, if they contain `instanceof` then the type is
+inferred:
+
+```php
+if ($foobar instanceof Hello) {
+    $foobar-> // type: Hello
+}
+```
+
+```php
+if (false === $foobar instanceof Hello) {
+    return;
+}
+
+$foobar-> // type: Hello
+```
+
+```php
+if ($foobar instanceof Hello || $foobar instanceof Goodbye) {
+    $foobar-> // type: Hello|Goodbye
+}
+```
+
+### Variables
+
+Phpactor supports type injection via. docblock:
+
+```
+/** @var Foobar $foobar */
+$foobar-> // type: Foobar
+```

lib/Extension/Completion/CompletionExtension.php

@@ -3,12 +3,13 @@
 namespace Phpactor\Extension\Completion;
 
 use Phpactor\Completion\Bridge\TolerantParser\SourceCodeFilesystem\ScfClassCompletor;
+use Phpactor\Completion\Bridge\TolerantParser\WorseReflection\WorseConstantCompletor;
 use Phpactor\Completion\Bridge\WorseReflection\Formatter\FunctionFormatter;
 use Phpactor\Completion\Bridge\WorseReflection\Formatter\MethodFormatter;
 use Phpactor\Completion\Bridge\WorseReflection\Formatter\VariableFormatter;
 use Phpactor\Completion\Bridge\TolerantParser\ChainTolerantCompletor;
 use Phpactor\Completion\Bridge\TolerantParser\WorseReflection\WorseClassMemberCompletor;
-use Phpactor\Completion\Bridge\TolerantParser\WorseReflection\WorseBuiltInFunctionCompletor;
+use Phpactor\Completion\Bridge\TolerantParser\WorseReflection\WorseFunctionCompletor;
 use Phpactor\Completion\Bridge\TolerantParser\WorseReflection\WorseParameterCompletor;
 use Phpactor\Completion\Bridge\TolerantParser\WorseReflection\WorseLocalVariableCompletor;
 use Phpactor\Completion\Core\Formatter\ObjectFormatter;
@@ -95,13 +96,17 @@ private function registerCompletion(ContainerBuilder $container)
             );
         }, [ 'completion.tolerant_completor' => []]);
 
-        $container->register('completion.completor.builtin_function', function (Container $container) {
-            return new WorseBuiltInFunctionCompletor(
+        $container->register('completion.completor.function', function (Container $container) {
+            return new WorseFunctionCompletor(
                 $container->get('reflection.reflector'),
                 $container->get('completion.formatter')
             );
         }, [ 'completion.tolerant_completor' => []]);
 
+        $container->register('completion.completor.constant', function (Container $container) {
+            return new WorseConstantCompletor();
+        }, [ 'completion.tolerant_completor' => []]);
+
         $container->register('completion.formatter', function (Container $container) {
             return new ObjectFormatter([
                 new TypeFormatter(),