icedream
/
php-language-server
1
0
Fork 0
Code Releases Activity

Merge 58fb1b9e13 into e75c1592fc

pull/61/merge
Felix Becker 2016-10-10 15:03:21 +00:00 committed by GitHub
parent e75c1592fc 58fb1b9e13
commit cc3b67318e
11 changed files with 221 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/LanguageServer.php
View File

@ -153,7 +153,7 @@ class LanguageServer extends \AdvancedJsonRpc\Dispatcher
$shortName = substr($file, strlen($rootPath) + 1);
$this->client->window->logMessage(MessageType::INFO, "Parsing file $fileNum/$numTotalFiles: $shortName.");
$this->project->getDocument($uri)->updateContent(file_get_contents($file));
$this->project->getDocument($uri)->updateContent(file_get_contents($file), false);
Loop\setTimeout($processFile, 0);
} else {

157
src/PhpDocument.php
View File

@ -8,6 +8,8 @@ use LanguageServer\NodeVisitor\{NodeAtPositionFinder, ReferencesAdder, Definitio
use PhpParser\{Error, Comment, Node, ParserFactory, NodeTraverser, Lexer, Parser};
use PhpParser\PrettyPrinter\Standard as PrettyPrinter;
use PhpParser\NodeVisitor\NameResolver;
use Exception;
use function LanguageServer\uriToPath;
class PhpDocument
{
@ -53,14 +55,14 @@ class PhpDocument
*
* @var Node[]
*/
private $stmts = [];
private $statements;
/**
* Map from fully qualified name (FQN) to Node
*
* @var Node[]
*/
private $definitions = [];
private $definitions;
/**
* Map from fully qualified name (FQN) to array of nodes that reference the symbol
@ -84,87 +86,56 @@ class PhpDocument
}
/**
* Returns all symbols in this document.
* Returns true if the content of this document is being held in memory
*
* @return SymbolInformation[]|null
* @return bool
*/
public function getSymbols()
public function isLoaded()
{
if (!isset($this->definitions)) {
return null;
}
$nodeSymbolKindMap = [
Node\Stmt\Class_::class => SymbolKind::CLASS_,
Node\Stmt\Trait_::class => SymbolKind::CLASS_,
Node\Stmt\Interface_::class => SymbolKind::INTERFACE,
Node\Stmt\Namespace_::class => SymbolKind::NAMESPACE,
Node\Stmt\Function_::class => SymbolKind::FUNCTION,
Node\Stmt\ClassMethod::class => SymbolKind::METHOD,
Node\Stmt\PropertyProperty::class => SymbolKind::PROPERTY,
Node\Const_::class => SymbolKind::CONSTANT
];
$symbols = [];
foreach ($this->definitions as $fqn => $node) {
$class = get_class($node);
if (!isset($nodeSymbolKindMap[$class])) {
continue;
}
$symbol = new SymbolInformation();
$symbol->kind = $nodeSymbolKindMap[$class];
$symbol->name = (string)$node->name;
$symbol->location = Location::fromNode($node);
$parts = preg_split('/(::|\\\\)/', $fqn);
array_pop($parts);
$symbol->containerName = implode('\\', $parts);
$symbols[] = $symbol;
}
return $symbols;
return isset($this->content);
}
/**
* Returns symbols in this document filtered by query string.
* Loads the content from disk and saves statements and definitions in memory
*
* @param string $query The search query
* @return SymbolInformation[]|null
* @return void
*/
public function findSymbols(string $query)
public function load()
{
$symbols = $this->getSymbols();
if ($symbols === null) {
return null;
}
if ($query === '') {
return $symbols;
}
return array_filter($symbols, function($symbol) use ($query) {
return stripos($symbol->name, $query) !== false;
});
$this->updateContent(file_get_contents(uriToPath($this->getUri())), true);
}
/**
* Updates the content on this document.
* Unloads the content, statements and definitions from memory
*
* @return void
*/
public function unload()
{
unset($this->content);
unset($this->statements);
unset($this->definitions);
unset($this->references);
}
/**
* Re-parses a source file, updates symbols and reports parsing errors
* that may have occured as diagnostics.
*
* @param string $content
* @param bool $keepInMemory Wether to keep content, statements and definitions in memory or only update project definitions
* @return void
*/
public function updateContent(string $content)
public function updateContent(string $content, bool $keepInMemory = true)
{
$keepInMemory = $keepInMemory || $this->isLoaded();
if ($keepInMemory) {
$this->content = $content;
$this->parse();
}
/**
* Re-parses a source file, updates symbols, reports parsing errors
* that may have occured as diagnostics and returns parsed nodes.
*
* @return void
*/
public function parse()
{
$stmts = null;
$errors = [];
try {
$stmts = $this->parser->parse($this->content);
$stmts = $this->parser->parse($content);
} catch (\PhpParser\Error $e) {
// Lexer can throw errors. e.g for unterminated comments
// unfortunately we don't get a location back
@ -177,8 +148,8 @@ class PhpDocument
foreach ($errors as $error) {
$diagnostic = new Diagnostic();
$diagnostic->range = new Range(
new Position($error->getStartLine() - 1, $error->hasColumnInfo() ? $error->getStartColumn($this->content) - 1 : 0),
new Position($error->getEndLine() - 1, $error->hasColumnInfo() ? $error->getEndColumn($this->content) : 0)
new Position($error->getStartLine() - 1, $error->hasColumnInfo() ? $error->getStartColumn($content) - 1 : 0),
new Position($error->getEndLine() - 1, $error->hasColumnInfo() ? $error->getEndColumn($content) : 0)
);
$diagnostic->severity = DiagnosticSeverity::ERROR;
$diagnostic->source = 'php';
@ -199,7 +170,7 @@ class PhpDocument
$traverser->addVisitor(new ReferencesAdder($this));
// Add column attributes to nodes
$traverser->addVisitor(new ColumnCalculator($this->content));
$traverser->addVisitor(new ColumnCalculator($content));
// Collect all definitions
$definitionCollector = new DefinitionCollector;
@ -207,13 +178,15 @@ class PhpDocument
$traverser->traverse($stmts);
$this->definitions = $definitionCollector->definitions;
// Register this document on the project for all the symbols defined in it
foreach ($definitionCollector->definitions as $fqn => $node) {
$this->project->addDefinitionDocument($fqn, $this);
}
$this->stmts = $stmts;
if ($keepInMemory) {
$this->statements = $stmts;
$this->definitions = $definitionCollector->definitions;
}
}
}
@ -234,12 +207,29 @@ class PhpDocument
* Returns this document's text content.
*
* @return string
* @throws Exception If the content was not loaded
*/
public function getContent()
{
if (!isset($this->content)) {
throw new Exception('Content is not loaded');
}
return $this->content;
}
/**
* Returns this document's AST.
*
* @return Node[]
*/
public function &getStatements()
{
if (!isset($this->statements)) {
$this->parse($this->getContent());
}
return $this->statements;
}
/**
* Returns the URI of the document
*
@ -258,13 +248,10 @@ class PhpDocument
*/
public function getNodeAtPosition(Position $position)
{
if ($this->stmts === null) {
return null;
}
$traverser = new NodeTraverser;
$finder = new NodeAtPositionFinder($position);
$traverser->addVisitor($finder);
$traverser->traverse($this->stmts);
$traverser->traverse($this->getStatements());
return $finder->node;
}
@ -276,7 +263,21 @@ class PhpDocument
*/
public function getDefinitionByFqn(string $fqn)
{
return $this->definitions[$fqn] ?? null;
return $this->getDefinitions()[$fqn] ?? null;
}
/**
* Returns a map from fully qualified name (FQN) to Nodes defined in this document
*
* @return Node[]
* @throws Exception If the definitions are not loaded
*/
public function &getDefinitions()
{
if (!isset($this->definitions)) {
throw new Exception('Definitions of this document are not loaded');
}
return $this->definitions;
}
/**
@ -287,7 +288,7 @@ class PhpDocument
*/
public function isDefined(string $fqn): bool
{
return isset($this->definitions[$fqn]);
return isset($this->getDefinitions()[$fqn]);
}
/**
@ -306,16 +307,11 @@ class PhpDocument
*/
public function getDefinedFqn(Node $node)
{
if ($node instanceof Node\Name) {
$nameNode = $node;
$node = $node->getAttribute('parentNode');
}
// Only the class node should count as the definition, not the name node
// Anonymous classes don't count as a definition
if ($node instanceof Node\Stmt\ClassLike && !isset($nameNode) && isset($node->name)) {
if ($node instanceof Node\Stmt\ClassLike && isset($node->name)) {
// Class, interface or trait declaration
return (string)$node->namespacedName;
} else if ($node instanceof Node\Stmt\Function_ && !isset($nameNode)) {
} else if ($node instanceof Node\Stmt\Function_) {
// Function: use functionName() as the name
return (string)$node->namespacedName . '()';
} else if ($node instanceof Node\Stmt\ClassMethod) {
@ -485,6 +481,9 @@ class PhpDocument
return null;
}
$document = $this->project->getDefinitionDocument($fqn);
if (!$document->isLoaded()) {
$document->load();
}
if (!isset($document)) {
return null;
}

29
src/Project.php
View File

@ -83,6 +83,17 @@ class Project
return $this->definitions[$fqn] ?? null;
}
/**
* Returns an associative array [string => PhpDocument]
* that maps fully qualified symbol names to loaded PhpDocuments
*
* @return PhpDocument[]
*/
public function &getDefinitionDocuments()
{
return $this->definitions;
}
/**
* Returns true if the given FQN is defined in the project
*
@ -93,22 +104,4 @@ class Project
{
return isset($this->definitions[$fqn]);
}
/**
* Finds symbols in all documents, filtered by query parameter.
*
* @param string $query
* @return SymbolInformation[]
*/
public function findSymbols(string $query)
{
$queryResult = [];
foreach ($this->documents as $uri => $document) {
$documentQueryResult = $document->findSymbols($query);
if ($documentQueryResult !== null) {
$queryResult = array_merge($queryResult, $documentQueryResult);
}
}
return $queryResult;
}
}

36
src/Protocol/SymbolInformation.php
View File

@ -3,6 +3,7 @@
namespace LanguageServer\Protocol;
use PhpParser\Node;
use Exception;
/**
* Represents information about programming constructs like variables, classes,
@ -37,4 +38,39 @@ class SymbolInformation
* @var string|null
*/
public $containerName;
/**
* Converts a Node to a SymbolInformation
*
* @param Node $node
* @param string $fqn If given, $containerName will be extracted from it
* @return self
*/
public static function fromNode(Node $node, string $fqn = null)
{
$nodeSymbolKindMap = [
Node\Stmt\Class_::class => SymbolKind::CLASS_,
Node\Stmt\Trait_::class => SymbolKind::CLASS_,
Node\Stmt\Interface_::class => SymbolKind::INTERFACE,
Node\Stmt\Namespace_::class => SymbolKind::NAMESPACE,
Node\Stmt\Function_::class => SymbolKind::FUNCTION,
Node\Stmt\ClassMethod::class => SymbolKind::METHOD,
Node\Stmt\PropertyProperty::class => SymbolKind::PROPERTY,
Node\Const_::class => SymbolKind::CONSTANT
];
$class = get_class($node);
if (!isset($nodeSymbolKindMap[$class])) {
throw new Exception("Not a declaration node: $class");
}
$symbol = new self;
$symbol->kind = $nodeSymbolKindMap[$class];
$symbol->name = (string)$node->name;
$symbol->location = Location::fromNode($node);
if ($fqn !== null) {
$parts = preg_split('/(::|\\\\)/', $fqn);
array_pop($parts);
$symbol->containerName = implode('\\', $parts);
}
return $symbol;
}
}

21
src/Server/TextDocument.php
View File

@ -14,7 +14,8 @@ use LanguageServer\Protocol\{
Position,
FormattingOptions,
TextEdit,
Location
Location,
SymbolInformation
};
/**
@ -49,7 +50,11 @@ class TextDocument
*/
public function documentSymbol(TextDocumentIdentifier $textDocument): array
{
return $this->project->getDocument($textDocument->uri)->getSymbols();
$symbols = [];
foreach ($this->project->getDocument($textDocument->uri)->getDefinitions() as $fqn => $node) {
$symbols[] = SymbolInformation::fromNode($node, $fqn);
}
return $symbols;
}
/**
@ -77,6 +82,18 @@ class TextDocument
$this->project->getDocument($textDocument->uri)->updateContent($contentChanges[0]->text);
}
/**
* The document close notification is sent from the client to the server when the document got closed in the client.
* The document's truth now exists where the document's uri points to (e.g. if the document's uri is a file uri the
* truth now exists on disk).
*
* @param \LanguageServer\Protocol\TextDocumentItem $textDocument The document that was closed
* @return void
*/
public function didClose(TextDocumentIdentifier $textDocument)
{
$this->project->getDocument($textDocument->uri)->unload();
}
/**
* The document formatting request is sent from the server to the client to format a whole document.

11
src/Server/Workspace.php
View File

@ -53,6 +53,15 @@ class Workspace
*/
public function symbol(string $query): array
{
return $this->project->findSymbols($query);
$symbols = [];
foreach ($this->project->getDefinitionDocuments() as $fqn => $document) {
if ($query === '' || stripos($fqn, $query) !== false) {
if (!$document->isLoaded()) {
$document->load();
}
$symbols[] = SymbolInformation::fromNode($document->getDefinitionByFqn($fqn), $fqn);
}
}
return $symbols;
}
}

4
tests/PhpDocumentTest.php
View File

@ -28,9 +28,7 @@ class PhpDocumentTest extends TestCase
$document->updateContent("<?php\n$\$a = 'foo';\n\$bar = 'baz';\n");
$symbols = $document->getSymbols();
$this->assertEquals([], json_decode(json_encode($symbols), true));
$this->assertEquals([], $document->getDefinitions());
}
public function testGetNodeAtPosition()

48
tests/ProjectTest.php
View File

@ -36,52 +36,4 @@ class ProjectTest extends TestCase
$this->assertSame($document1, $document2);
}
public function testFindSymbols()
{
$this->project->getDocument('file:///document1.php')->updateContent("<?php\nfunction foo() {}\nfunction bar() {}\n");
$this->project->getDocument('file:///document2.php')->updateContent("<?php\nfunction baz() {}\nfunction frob() {}\n");
$this->project->getDocument('invalid_file')->updateContent(file_get_contents(__DIR__ . '/../fixtures/invalid_file.php'));
$symbols = $this->project->findSymbols('ba');
$this->assertEquals([
[
'name' => 'bar',
'kind' => SymbolKind::FUNCTION,
'location' => [
'uri' => 'file:///document1.php',
'range' => [
'start' => [
'line' => 2,
'character' => 0
],
'end' => [
'line' => 2,
'character' => 17
]
]
],
'containerName' => null
],
[
'name' => 'baz',
'kind' => SymbolKind::FUNCTION,
'location' => [
'uri' => 'file:///document2.php',
'range' => [
'start' => [
'line' => 1,
'character' => 0
],
'end' => [
'line' => 1,
'character' => 17
]
]
],
'containerName' => null
]
], json_decode(json_encode($symbols), true));
}
}

34
tests/Server/TextDocument/DidCloseTest.php Normal file
View File

@ -0,0 +1,34 @@
<?php
declare(strict_types = 1);
namespace LanguageServer\Tests\Server\TextDocument;
use PHPUnit\Framework\TestCase;
use LanguageServer\Tests\MockProtocolStream;
use LanguageServer\{Server, Client, LanguageClient, Project};
use LanguageServer\Protocol\{TextDocumentItem, TextDocumentIdentifier};
use Exception;
class DidCloseTest extends TestCase
{
public function test()
{
$client = new LanguageClient(new MockProtocolStream());
$project = new Project($client);
$textDocument = new Server\TextDocument($project, $client);
$phpDocument = $project->getDocument('whatever');
$phpDocument->updateContent('hello world');
$textDocumentItem = new TextDocumentItem();
$textDocumentItem->uri = 'whatever';
$textDocumentItem->languageId = 'php';
$textDocumentItem->version = 1;
$textDocumentItem->text = 'hello world';
$textDocument->didOpen($textDocumentItem);
$textDocument->didClose(new TextDocumentIdentifier($textDocumentItem->uri));
$this->expectException(Exception::class);
$phpDocument->getContent();
}
}

10
tests/Server/TextDocument/FormattingTest.php
View File

@ -57,14 +57,4 @@ class FormattingTest extends TestCase
'newText' => $expected
]], json_decode(json_encode($result), true));
}
public function testFormattingInvalidUri()
{
$client = new LanguageClient(new MockProtocolStream());
$project = new Project($client);
$textDocument = new Server\TextDocument($project, $client);
$result = $textDocument->formatting(new TextDocumentIdentifier('whatever'), new FormattingOptions());
$this->assertSame([], $result);
}
}

45
tests/Server/Workspace/SymbolTest.php
View File

@ -1,13 +1,14 @@
<?php
declare(strict_types = 1);
namespace LanguageServer\Tests\Server;
namespace LanguageServer\Tests\Server\Workspace;
use PHPUnit\Framework\TestCase;
use LanguageServer\Tests\MockProtocolStream;
use LanguageServer\{Server, Client, LanguageClient, Project, PhpDocument};
use LanguageServer\Protocol\{TextDocumentItem, TextDocumentIdentifier, SymbolKind, DiagnosticSeverity, FormattingOptions};
use AdvancedJsonRpc\{Request as RequestBody, Response as ResponseBody};
use function LanguageServer\pathToUri;
class SymbolTest extends TestCase
{
@ -16,13 +17,25 @@ class SymbolTest extends TestCase
*/
private $workspace;
/**
* @var string
*/
private $symbolsUri;
/**
* @var string
*/
private $referencesUri;
public function setUp()
{
$client = new LanguageClient(new MockProtocolStream());
$project = new Project($client);
$this->workspace = new Server\Workspace($project, $client);
$project->getDocument('symbols')->updateContent(file_get_contents(__DIR__ . '/../../../fixtures/symbols.php'));
$project->getDocument('references')->updateContent(file_get_contents(__DIR__ . '/../../../fixtures/references.php'));
$this->symbolsUri = pathToUri(realpath(__DIR__ . '/../../../fixtures/symbols.php'));
$this->referencesUri = pathToUri(realpath(__DIR__ . '/../../../fixtures/references.php'));
$project->getDocument($this->symbolsUri)->updateContent(file_get_contents($this->symbolsUri), false);
$project->getDocument($this->referencesUri)->updateContent(file_get_contents($this->referencesUri), false);
}
public function testEmptyQueryReturnsAllSymbols()
@ -34,7 +47,7 @@ class SymbolTest extends TestCase
'name' => 'TEST_CONST',
'kind' => SymbolKind::CONSTANT,
'location' => [
'uri' => 'symbols',
'uri' => $this->symbolsUri,
'range' => [
'start' => [
'line' => 4,
@ -52,7 +65,7 @@ class SymbolTest extends TestCase
'name' => 'TestClass',
'kind' => SymbolKind::CLASS_,
'location' => [
'uri' => 'symbols',
'uri' => $this->symbolsUri,
'range' => [
'start' => [
'line' => 6,
@ -70,7 +83,7 @@ class SymbolTest extends TestCase
'name' => 'TEST_CLASS_CONST',
'kind' => SymbolKind::CONSTANT,
'location' => [
'uri' => 'symbols',
'uri' => $this->symbolsUri,
'range' => [
'start' => [
'line' => 8,
@ -88,7 +101,7 @@ class SymbolTest extends TestCase
'name' => 'staticTestProperty',
'kind' => SymbolKind::PROPERTY,
'location' => [
'uri' => 'symbols',
'uri' => $this->symbolsUri,
'range' => [
'start' => [
'line' => 9,
@ -106,7 +119,7 @@ class SymbolTest extends TestCase
'name' => 'testProperty',
'kind' => SymbolKind::PROPERTY,
'location' => [
'uri' => 'symbols',
'uri' => $this->symbolsUri,
'range' => [
'start' => [
'line' => 10,
@ -124,7 +137,7 @@ class SymbolTest extends TestCase
'name' => 'staticTestMethod',
'kind' => SymbolKind::METHOD,
'location' => [
'uri' => 'symbols',
'uri' => $this->symbolsUri,
'range' => [
'start' => [
'line' => 12,
@ -142,7 +155,7 @@ class SymbolTest extends TestCase
'name' => 'testMethod',
'kind' => SymbolKind::METHOD,
'location' => [
'uri' => 'symbols',
'uri' => $this->symbolsUri,
'range' => [
'start' => [
'line' => 17,
@ -160,7 +173,7 @@ class SymbolTest extends TestCase
'name' => 'TestTrait',
'kind' => SymbolKind::CLASS_,
'location' => [
'uri' => 'symbols',
'uri' => $this->symbolsUri,
'range' => [
'start' => [
'line' => 23,
@ -178,7 +191,7 @@ class SymbolTest extends TestCase
'name' => 'TestInterface',
'kind' => SymbolKind::INTERFACE,
'location' => [
'uri' => 'symbols',
'uri' => $this->symbolsUri,
'range' => [
'start' => [
'line' => 28,
@ -196,7 +209,7 @@ class SymbolTest extends TestCase
'name' => 'test_function',
'kind' => SymbolKind::FUNCTION,
'location' => [
'uri' => 'symbols',
'uri' => $this->symbolsUri,
'range' => [
'start' => [
'line' => 33,
@ -214,7 +227,7 @@ class SymbolTest extends TestCase
'name' => 'whatever',
'kind' => SymbolKind::FUNCTION,
'location' => [
'uri' => 'references',
'uri' => $this->referencesUri,
'range' => [
'start' => [
'line' => 15,
@ -240,7 +253,7 @@ class SymbolTest extends TestCase
'name' => 'staticTestMethod',
'kind' => SymbolKind::METHOD,
'location' => [
'uri' => 'symbols',
'uri' => $this->symbolsUri,
'range' => [
'start' => [
'line' => 12,
@ -258,7 +271,7 @@ class SymbolTest extends TestCase
'name' => 'testMethod',
'kind' => SymbolKind::METHOD,
'location' => [
'uri' => 'symbols',
'uri' => $this->symbolsUri,
'range' => [
'start' => [
'line' => 17,