Enable LS to operate without accessing the file system

composer.json

@@ -29,7 +29,11 @@
         "sabre/event": "^5.0",
         "felixfbecker/advanced-json-rpc": "^2.0",
         "squizlabs/php_codesniffer" : "^2.7",
-        "symfony/debug": "^3.1"
+        "symfony/debug": "^3.1",
+        "netresearch/jsonmapper": "^1.0",
+        "webmozart/path-util": "^2.3",
+        "webmozart/glob": "^4.1",
+        "sabre/uri": "^2.0"
     },
     "minimum-stability": "dev",
     "prefer-stable": true,

src/Client/TextDocument.php

@@ -4,8 +4,9 @@
 namespace LanguageServer\Client;
 
 use LanguageServer\ClientHandler;
-use LanguageServer\Protocol\Message;
+use LanguageServer\Protocol\{Message, TextDocumentItem, TextDocumentIdentifier};
 use Sabre\Event\Promise;
+use JsonMapper;
 
 /**
  * Provides method handlers for all textDocument/* methods
@@ -17,9 +18,15 @@ class TextDocument
      */
     private $handler;
 
-    public function __construct(ClientHandler $handler)
+    /**
+     * @var JsonMapper
+     */
+    private $mapper;
+
+    public function __construct(ClientHandler $handler, JsonMapper $mapper)
     {
         $this->handler = $handler;
+        $this->mapper = $mapper;
     }
 
     /**
@@ -36,4 +43,21 @@ public function publishDiagnostics(string $uri, array $diagnostics): Promise
             'diagnostics' => $diagnostics
         ]);
     }
+
+    /**
+     * The content request is sent from a server to a client
+     * to request the current content of a text document identified by the URI
+     *
+     * @param TextDocumentIdentifier $textDocument The document to get the content for
+     * @return Promise <TextDocumentItem> The document's current content
+     */
+    public function xcontent(TextDocumentIdentifier $textDocument): Promise
+    {
+        return $this->handler->request(
+            'textDocument/xcontent',
+            ['textDocument' => $textDocument]
+        )->then(function ($result) {
+            return $this->mapper->map($result, new TextDocumentItem);
+        });
+    }
 }

src/Client/Workspace.php

@@ -0,0 +1,47 @@
+<?php
+declare(strict_types = 1);
+
+namespace LanguageServer\Client;
+
+use LanguageServer\ClientHandler;
+use LanguageServer\Protocol\TextDocumentIdentifier;
+use Sabre\Event\Promise;
+use JsonMapper;
+
+/**
+ * Provides method handlers for all workspace/* methods
+ */
+class Workspace
+{
+    /**
+     * @var ClientHandler
+     */
+    private $handler;
+
+    /**
+     * @var JsonMapper
+     */
+    private $mapper;
+
+    public function __construct(ClientHandler $handler, JsonMapper $mapper)
+    {
+        $this->handler = $handler;
+        $this->mapper = $mapper;
+    }
+
+    /**
+     * Returns a list of all files in a directory
+     *
+     * @param string $base The base directory (defaults to the workspace)
+     * @return Promise <TextDocumentIdentifier[]> Array of documents
+     */
+    public function xfiles(string $base = null): Promise
+    {
+        return $this->handler->request(
+            'workspace/xfiles',
+            ['base' => $base]
+        )->then(function (array $textDocuments) {
+            return $this->mapper->mapArray($textDocuments, [], TextDocumentIdentifier::class);
+        });
+    }
+}

src/LanguageClient.php

@@ -3,6 +3,8 @@
 
 namespace LanguageServer;
 
+use JsonMapper;
+
 class LanguageClient
 {
     /**
@@ -19,11 +21,20 @@ class LanguageClient
      */
     public $window;
 
+    /**
+     * Handles workspace/* methods
+     *
+     * @var Client\Workspace
+     */
+    public $workspace;
+
     public function __construct(ProtocolReader $reader, ProtocolWriter $writer)
     {
         $handler = new ClientHandler($reader, $writer);
+        $mapper = new JsonMapper;
 
-        $this->textDocument = new Client\TextDocument($handler);
+        $this->textDocument = new Client\TextDocument($handler, $mapper);
         $this->window = new Client\Window($handler);
+        $this->workspace = new Client\Workspace($handler, $mapper);
     }
 }

src/LanguageServer.php

@@ -10,12 +10,18 @@
     Message,
     MessageType,
     InitializeResult,
-    SymbolInformation
+    SymbolInformation,
+    TextDocumentIdentifier
 };
 use AdvancedJsonRpc;
-use Sabre\Event\Loop;
+use Sabre\Event\{Loop, Promise};
+use function Sabre\Event\coroutine;
 use Exception;
 use Throwable;
+use Webmozart\Glob\Iterator\GlobIterator;
+use Webmozart\Glob\Glob;
+use Webmozart\PathUtil\Path;
+use Sabre\Uri;
 
 class LanguageServer extends AdvancedJsonRpc\Dispatcher
 {
@@ -38,6 +44,11 @@ class LanguageServer extends AdvancedJsonRpc\Dispatcher
     public $completionItem;
     public $codeLens;
 
+    /**
+     * ClientCapabilities
+     */
+    private $clientCapabilities;
+
     private $protocolReader;
     private $protocolWriter;
     private $client;
@@ -55,40 +66,42 @@ public function __construct(ProtocolReader $reader, ProtocolWriter $writer)
         parent::__construct($this, '/');
         $this->protocolReader = $reader;
         $this->protocolReader->on('message', function (Message $msg) {
-            // Ignore responses, this is the handler for requests and notifications
-            if (AdvancedJsonRpc\Response::isResponse($msg->body)) {
-                return;
-            }
-            $result = null;
-            $error = null;
-            try {
-                // Invoke the method handler to get a result
-                $result = $this->dispatch($msg->body);
-            } catch (AdvancedJsonRpc\Error $e) {
-                // If a ResponseError is thrown, send it back in the Response
-                $error = $e;
-            } catch (Throwable $e) {
-                // If an unexpected error occured, send back an INTERNAL_ERROR error response
-                $error = new AdvancedJsonRpc\Error($e->getMessage(), AdvancedJsonRpc\ErrorCode::INTERNAL_ERROR, null, $e);
-            }
-            // Only send a Response for a Request
-            // Notifications do not send Responses
-            if (AdvancedJsonRpc\Request::isRequest($msg->body)) {
-                if ($error !== null) {
-                    $responseBody = new AdvancedJsonRpc\ErrorResponse($msg->body->id, $error);
-                } else {
-                    $responseBody = new AdvancedJsonRpc\SuccessResponse($msg->body->id, $result);
+            coroutine(function () use ($msg) {
+                // Ignore responses, this is the handler for requests and notifications
+                if (AdvancedJsonRpc\Response::isResponse($msg->body)) {
+                    return;
                 }
-                $this->protocolWriter->write(new Message($responseBody));
-            }
+                $result = null;
+                $error = null;
+                try {
+                    // Invoke the method handler to get a result
+                    $result = yield $this->dispatch($msg->body);
+                } catch (AdvancedJsonRpc\Error $e) {
+                    // If a ResponseError is thrown, send it back in the Response
+                    $error = $e;
+                } catch (Throwable $e) {
+                    // If an unexpected error occured, send back an INTERNAL_ERROR error response
+                    $error = new AdvancedJsonRpc\Error(
+                        $e->getMessage(),
+                        AdvancedJsonRpc\ErrorCode::INTERNAL_ERROR,
+                        null,
+                        $e
+                    );
+                }
+                // Only send a Response for a Request
+                // Notifications do not send Responses
+                if (AdvancedJsonRpc\Request::isRequest($msg->body)) {
+                    if ($error !== null) {
+                        $responseBody = new AdvancedJsonRpc\ErrorResponse($msg->body->id, $error);
+                    } else {
+                        $responseBody = new AdvancedJsonRpc\SuccessResponse($msg->body->id, $result);
+                    }
+                    $this->protocolWriter->write(new Message($responseBody));
+                }
+            })->otherwise('\\LanguageServer\\crash');
         });
         $this->protocolWriter = $writer;
         $this->client = new LanguageClient($reader, $writer);
-
-        $this->project = new Project($this->client);
-
-        $this->textDocument = new Server\TextDocument($this->project, $this->client);
-        $this->workspace = new Server\Workspace($this->project, $this->client);
     }
 
     /**
@@ -102,10 +115,14 @@ public function __construct(ProtocolReader $reader, ProtocolWriter $writer)
     public function initialize(int $processId, ClientCapabilities $capabilities, string $rootPath = null): InitializeResult
     {
         $this->rootPath = $rootPath;
+        $this->clientCapabilities = $capabilities;
+        $this->project = new Project($this->client, $capabilities);
+        $this->textDocument = new Server\TextDocument($this->project, $this->client);
+        $this->workspace = new Server\Workspace($this->project, $this->client);
 
         // start building project index
         if ($rootPath !== null) {
-            $this->indexProject();
+            $this->indexProject()->otherwise('\\LanguageServer\\crash');
         }
 
         $serverCapabilities = new ServerCapabilities();
@@ -136,6 +153,7 @@ public function initialize(int $processId, ClientCapabilities $capabilities, str
      */
     public function shutdown()
     {
+        unset($this->project);
     }
 
     /**
@@ -151,42 +169,71 @@ public function exit()
     /**
      * Parses workspace files, one at a time.
      *
-     * @return void
+     * @return Promise <void>
      */
-    private function indexProject()
+    private function indexProject(): Promise
     {
-        $fileList = findFilesRecursive($this->rootPath, '/^.+\.php$/i');
-        $numTotalFiles = count($fileList);
-
-        $startTime = microtime(true);
-        $fileNum = 0;
-
-        $processFile = function () use (&$fileList, &$fileNum, &$processFile, $numTotalFiles, $startTime) {
-            if ($fileNum < $numTotalFiles) {
-                $file = $fileList[$fileNum];
-                $uri = pathToUri($file);
-                $fileNum++;
-                $shortName = substr($file, strlen($this->rootPath) + 1);
-
-                if (filesize($file) > 500000) {
-                    $this->client->window->logMessage(MessageType::INFO, "Not parsing $shortName because it exceeds size limit of 0.5MB");
-                } else {
-                    $this->client->window->logMessage(MessageType::INFO, "Parsing file $fileNum/$numTotalFiles: $shortName.");
+        return coroutine(function () {
+            $textDocuments = yield $this->findPhpFiles();
+            $count = count($textDocuments);
+
+            $startTime = microtime(true);
+
+            yield Promise\all(array_map(function ($textDocument, $i) use ($count) {
+                return coroutine(function () use ($textDocument, $i, $count) {
+                    // Give LS to the chance to handle requests while indexing
+                    yield timeout();
+                    $this->client->window->logMessage(
+                        MessageType::INFO,
+                        "Parsing file $i/$count: {$textDocument->uri}"
+                    );
                     try {
-                        $this->project->loadDocument($uri);
+                        yield $this->project->loadDocument($textDocument->uri);
                     } catch (Exception $e) {
-                        $this->client->window->logMessage(MessageType::ERROR, "Error parsing file $shortName: " . (string)$e);
+                        $this->client->window->logMessage(
+                            MessageType::ERROR,
+                            "Error parsing file {$textDocument->uri}: " . (string)$e
+                        );
                     }
-                }
+                });
+            }, $textDocuments, array_keys($textDocuments)));
+
+            $duration = (int)(microtime(true) - $startTime);
+            $mem = (int)(memory_get_usage(true) / (1024 * 1024));
+            $this->client->window->logMessage(
+                MessageType::INFO,
+                "All $count PHP files parsed in $duration seconds. $mem MiB allocated."
+            );
+        });
+    }
 
-                Loop\setTimeout($processFile, 0);
+    /**
+     * Returns all PHP files in the workspace.
+     * If the client does not support workspace/files, it falls back to searching the file system directly.
+     *
+     * @return Promise <TextDocumentIdentifier[]>
+     */
+    private function findPhpFiles(): Promise
+    {
+        return coroutine(function () {
+            $textDocuments = [];
+            $pattern = Path::makeAbsolute('**/*.php', $this->rootPath);
+            if ($this->clientCapabilities->xfilesProvider) {
+                // Use xfiles request
+                foreach (yield $this->client->workspace->xfiles() as $textDocument) {
+                    $path = Uri\parse($textDocument->uri)['path'];
+                    if (Glob::match($path, $pattern)) {
+                        $textDocuments[] = $textDocument;
+                    }
+                }
             } else {
-                $duration = (int)(microtime(true) - $startTime);
-                $mem = (int)(memory_get_usage(true) / (1024 * 1024));
-                $this->client->window->logMessage(MessageType::INFO, "All $numTotalFiles PHP files parsed in $duration seconds. $mem MiB allocated.");
+                // Use the file system
+                foreach (new GlobIterator($pattern) as $path) {
+                    $textDocuments[] = new TextDocumentIdentifier(pathToUri($path));
+                    yield timeout();
+                }
             }
-        };
-
-        Loop\setTimeout($processFile, 0);
+            return $textDocuments;
+        });
     }
 }