phpactor / phpactor

Mainly a PHP Language Server with more features than you can shake a stick at

Phpactor

This project aims to provide heavy-lifting refactoring and introspection tools which can be used standalone or as the backend for a text editor to provide intelligent code completion.

• Accurate code completion including class name auto-import.
• Various refactoring,fixes and code generation options.
• Provides a Language Server
• Native VIM plugin (emacs plugin is in development).
• Navigation (jump to definition, related classes, references etc).
• More.

Installation

Phpactor is a general tool, it is not intended that it be installed as a project dependency.

See Installation for installation instructions.

Requirements

• PHP 8.1+
• Composer

Project Recommendations

Phpactor will perform better with Composer and, to a lesser extent, with GiT.

Documentation

Full documentation can be found on Read the Docs

Community

• Follow @phpactor on 🦣 Mastodon for latest news.
• Join the #phpactor channel on the Slack Symfony Devs channel.

Contributing

This package is open source and welcomes contributions! Feel free to open a pull request on this repository.

Support

• Create an issue on the main Phpactor repository.
• Join the #phpactor channel on the Slack Symfony Devs channel.

Sponsors

The following organisations are providing either financial support or free services. If you would like to support Phpactor development financially you can sponsor me.

Tinkerwell

Blackfire

phpactor's Issues

Generate class from type

Plugin inserts `0` for use statement if exception encounteed.

use Webmozart\PathUtil\Path;
use 0;

Don not include the _construct in completions.

[WR] Add reflection benchmarks

Reflection can be a bottleneck, should add benchmarks to avoid performance regressions.

[move] Handle case where file not under VCS

Project specific configuration

For example, some annoying projects use 2 autoloaders - in which case we would need a chain autoloader to take advantage of both of them.

Other options might include choosing the file location strategies (simple, git, compoesr), etc.

Closure support

Doesn't parse files with closures (??) won't complete in them.

Teleport to different aspects of the source code

Create a feature which will allow easy navigation to / or generation of related files (e.g. from a unit test, the source, from the source the unit test, from the unit test the benchmark, etc. etc. etc.)

---

Below each target represents an aspect of the source code, for example

• Source
• Unit test
• Benchmark

The kernel is the part of the file name (or class name) which remains constant.

When the teleporter is invoked:

• We replace <kernel> with (.*?) and run a regex on the current file name
  for each of the targets and find a match.
• We offer the user a choice of destinations from the remaining targets.
• When selected the kernel is replaced in the selected target
• The file is opened, if it does not exist it is created (using the existing
  create functionality).

teleport:
    targets:
        source: 
            pattern: "src/<kernel>.php$"
            create: default
        phpunit: 
            pattern: "tests/Unit/<kernel>Test.php$"
            create: phpunit_test
        benchmark: 
            pattern: "benchmark/<kernel>Bench.php$"
            create: benchmark

BR performance

Type resolution (TypeFromAst)

With static caching:

\Phpactor\Benchmark\PhpunitCompleteBench

    benchPhpunit                  I0 P0         [μ Mo]/r: 12,032,643.000 12,032,643.000 (μs)    [μSD μRSD]/r: 0.000μs 0.00%

Without

\Phpactor\Benchmark\PhpunitCompleteBench

    benchPhpunit                  I0 P0         [μ Mo]/r: 23,366,917.000 23,366,917.000 (μs)    [μSD μRSD]/r: 0.000μs 0.00%

Optimise omni-complete (find start)

Interface completion

Support for internal classes (e.g. IteratorAggregate)

Do not pollute autoloader

Currently the project autoloader(s) are require 'd causing contamination. This should be avoided.

Extract interface

Class copy fails silently

When copying a class/interface with a file/class name mismatch, the new file is created but the class in it is not renamed as is expected (because the class name of the original file was not resolved).

There should probably be some sort of warning in this case (maybe a generic health check on save)

Use statements should not be included after the class definition.

Currently if there is a use statement within a class definition, the included use will be appended to that, instead of the "real" use block (example is when a test is defining code examples).

Pictures | Images

Do not use dot file in project dir.

Do not use .phpactor.yml - it is annoying this file is not edited by a tool, use phpactor.yml instead.

Blow up early if neither composer nor GIT are available

Copy

As with mv but just copy the file (class) and replace the class name and namespace with the new filename (classname)

List "child" classes for given class.

Perform a search for child classes in the GIT Tree.

$ phpactor class:children Acme\AbstractCollection
Acme\RabbitCollection:/path/to/Acme/RabbitCollection
Acme\BearCollection:/path/to/Acme/BearCollection

Move type-inference stuff into Worse Reflection

Create a good frame builder and consider merging the type-inference library into Worse Reflection (i.e. better than the one in type-inference actually):

Track:

• Variable assignments
• Method injection.
• Class property assigns (types lazily evaluated)
• Variable positions.
• Store unresolved assigns (lazily evaluate types).

Final product should be able to:

• Produce an overlay showing the types of all variables in a script.

[Move] Transactional move

Support transactional moves, i.e. if an exception is encountered when moving things should be reverted to their original state before exiting.

This could be achieved by copying original files to temporary locations for the duration of the transaction and then removing them.

[plugin][use include] Doesn't return to cursor position if use already exists

Pipe file contents to commands instead of using FS

This will eliminate the need to save the file before using f.e. autocompletion any other offset-based commands.

Extract method

new Object completion

CONSTANT completion

Falls back to the last resolved reflection instead of null.

Object calls fall back to the last reflection instead of returning null e.g.

$this->foobar->barfoo->asd;

If barfoo cannot be resolved then it will fall back to the reflection class of foobar. But it should return NULL (as the completions for foobar have nothing to do with barfoo)

Implement contract on PHPUnit testcase implements all the things

Implementing contracts on a PHPUnit test case implements about 100 static methods things.

    /**
     * {@inheritDoc}
     */
    public static function assertArrayHasKey($key, $array, $message = '')
    {
    }

    /**
     * {@inheritDoc}
     */
    public static function assertArraySubset($subset, $array, $strict = false, $message = '')
    {
    }

    /**
     * {@inheritDoc}
     */
    public static function assertArrayNotHasKey($key, $array, $message = '')
    {
    }

    /**
     * {@inheritDoc}
     */
    public static function assertContains($needle, $haystack, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
    {
    }

    /**
     * {@inheritDoc}
     */
    public static function assertAttributeContains($needle, $haystackAttributeName, $haystackClassOrObject, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
    {
    }

    /**
     * {@inheritDoc}
     */
    public static function assertNotContains($needle, $haystack, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
    {
    }

    /**
     * {@inheritDoc}
     */
    public static function assertAttributeNotContains($needle, $haystackAttributeName, $haystackClassOrObject, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
    {
    }

    /**
     * {@inheritDoc}
     */
    public static function assertContainsOnly($type, $haystack, $isNativeType = null, $message = '')
    {
    }

    /**
     * {@inheritDoc}
     */
    public static function assertContainsOnlyInstancesOf($classname, $haystack, $message = '')
    {
    }

    /**
     * {@inheritDoc}
     */
    public static function assertAttributeContainsOnly($type, $haystackAttributeName, $haystackClassOrObject, $isNativeType = null, $message = '')
    {
    }

    /**
     * {@inheritDoc}
     */
    public static function assertNotContainsOnly($type, $haystack, $isNativeType = null, $message = '')
    {
    }

    /**
     * {@inheritDoc}
     */
    public static function assertAttributeNotContainsOnly($type, $haystackAttributeName, $haystackClassOrObject, $isNativeType = null, $message = '')
    {
    }

    /**
     * {@inheritDoc}
     */
    public static function assertCount($expectedCount, $haystack, $message = '')
    {
    }

    /**
     * {@inheritDoc}
     */
...

[Reflector] Reflect constant values / Value evaluation in general

[plugin][use include] Do not insert `0` instead of use on failure.

[plugin] Rename goto definition => goto type

We do not go to the definition, we go to the inferred type at the offset.

Static call completion

VIM Plugin

VIM Plugin:

• Execute command from within VIM and reload affected files.
• Execute commands based on cursor context.

"Add method" option when method does not exst/

Type inferer frame builder doesn't stop until EOF ?

[plugin|Reflection] Autocomplete constants

Goto definition

Using the class-to-file package it should be easy to use the tolerant-php-parser to get the FQN of any class reference and convert it to a file path.

[Autocomplete] Differentiate between static and instance calls.

Provide static / instance members as required (instead of both)

[Reflection/plugin] Method parameter "overlay"

Enable switching on an overlay which shows the names of method parameters.

• Add parameter offset numbers to reflection API.

Cannot include use for TestCase (phpunit)

Maybe class map not being taken into account?

[Application] Extract interface

Extract interface from a given class specifier or a glob:

$ phpactor class:extract:interface lib/Foobar.php lib/FoobarInterface.php

or

$ phpactor class:extract:interface lib/Foobar/* lib/Foobar/Api

Consider a way to transform names, e.g.:

$ phpactor class:extract:interface lib/Foobar/* lib/Foobar --transform="/^(.*+).php$/\1Interface.php"

Package as a PHAR

Would be cool to provide phar.

Generate method from offset

e.g. given that testMethod does not exist:

$rabbit = new Rabbit();
$rabbit->thump(Times::fromInt(12));

will generate the Thump method in Rabbit with the correct method signature.

PHPUnit `TestCase` not found on use insert

[Reflection] Use jetbrains PHPStorm stubs

https://github.com/JetBrains/phpstorm-stubs

Will probably need to write a script to extract the classes and make them locatable. This could be done on first execution and stored in a cache folder.

Include use statement

It should be reasonably fast to iterate over the composer paths for a given class name MyClass.php and use the class-to-file package to covert the found file to an FQN.

The service should provide 2 operations: returning a list of candidates and including the use statement (or could this be better done by VIM?).

Filesystem abstraction package (f.e. move files with git instead of raw FS).

Introduce a filesystem abstraction package (or that and a FileFinder package) for:

• Moving files (git mv).
• Finding files (git ls-files, RecursiveDirectoryIterator, Symfony\Finder, etc.).
• Specifying files (e.g. xml, yml, php, paths, max depth, etc.).

Should replace the Finder package in class-mover.

[Transformations] Detect indentation

Currently indentation is hard-coded to 4 spaces