////////////////////////////////////////////////////////////////////////////////
// Copyright 2019 Prominic.NET, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License
//
// Author: Prominic.NET, Inc.
// No warranty of merchantability or fitness of any kind.
// Use this software at your own risk.
////////////////////////////////////////////////////////////////////////////////
package net.prominic.groovyls;
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import org.codehaus.groovy.GroovyBugError;
import org.codehaus.groovy.ast.ASTNode;
import org.codehaus.groovy.control.ErrorCollector;
import org.codehaus.groovy.control.MultipleCompilationErrorsException;
import org.codehaus.groovy.control.Phases;
import org.codehaus.groovy.control.messages.Message;
import org.codehaus.groovy.control.messages.SyntaxErrorMessage;
import org.codehaus.groovy.syntax.SyntaxException;
import org.eclipse.lsp4j.CompletionItem;
import org.eclipse.lsp4j.CompletionList;
import org.eclipse.lsp4j.CompletionParams;
import org.eclipse.lsp4j.Diagnostic;
import org.eclipse.lsp4j.DiagnosticSeverity;
import org.eclipse.lsp4j.DidChangeConfigurationParams;
import org.eclipse.lsp4j.DidChangeTextDocumentParams;
import org.eclipse.lsp4j.DidChangeWatchedFilesParams;
import org.eclipse.lsp4j.DidCloseTextDocumentParams;
import org.eclipse.lsp4j.DidOpenTextDocumentParams;
import org.eclipse.lsp4j.DidSaveTextDocumentParams;
import org.eclipse.lsp4j.DocumentSymbol;
import org.eclipse.lsp4j.DocumentSymbolParams;
import org.eclipse.lsp4j.Hover;
import org.eclipse.lsp4j.Location;
import org.eclipse.lsp4j.LocationLink;
import org.eclipse.lsp4j.Position;
import org.eclipse.lsp4j.PublishDiagnosticsParams;
import org.eclipse.lsp4j.Range;
import org.eclipse.lsp4j.ReferenceParams;
import org.eclipse.lsp4j.RenameParams;
import org.eclipse.lsp4j.SignatureHelp;
import org.eclipse.lsp4j.SymbolInformation;
import org.eclipse.lsp4j.TextDocumentContentChangeEvent;
import org.eclipse.lsp4j.TextDocumentIdentifier;
import org.eclipse.lsp4j.TextDocumentPositionParams;
import org.eclipse.lsp4j.VersionedTextDocumentIdentifier;
import org.eclipse.lsp4j.WorkspaceEdit;
import org.eclipse.lsp4j.WorkspaceSymbolParams;
import org.eclipse.lsp4j.jsonrpc.messages.Either;
import org.eclipse.lsp4j.services.LanguageClient;
import org.eclipse.lsp4j.services.LanguageClientAware;
import org.eclipse.lsp4j.services.TextDocumentService;
import org.eclipse.lsp4j.services.WorkspaceService;
import net.prominic.groovyls.compiler.ast.ASTNodeVisitor;
import net.prominic.groovyls.compiler.control.GroovyLSCompilationUnit;
import net.prominic.groovyls.config.ICompilationUnitFactory;
import net.prominic.groovyls.providers.CompletionProvider;
import net.prominic.groovyls.providers.DefinitionProvider;
import net.prominic.groovyls.providers.DocumentSymbolProvider;
import net.prominic.groovyls.providers.HoverProvider;
import net.prominic.groovyls.providers.ReferenceProvider;
import net.prominic.groovyls.providers.RenameProvider;
import net.prominic.groovyls.providers.SignatureHelpProvider;
import net.prominic.groovyls.providers.TypeDefinitionProvider;
import net.prominic.groovyls.providers.WorkspaceSymbolProvider;
import net.prominic.groovyls.util.FileContentsTracker;
import net.prominic.groovyls.util.GroovyLanguageServerUtils;
import net.prominic.lsp.utils.Positions;
public class GroovyServices implements TextDocumentService, WorkspaceService, LanguageClientAware {
private static final Pattern PATTERN_CONSTRUCTOR_CALL = Pattern.compile(".*new \\w*$");
private LanguageClient languageClient;
private Path workspaceRoot;
private ICompilationUnitFactory compilationUnitFactory;
private GroovyLSCompilationUnit compilationUnit;
private ASTNodeVisitor astVisitor;
private Map<URI, List<Diagnostic>> prevDiagnosticsByFile;
private FileContentsTracker fileContentsTracker = new FileContentsTracker();
private URI previousContext = null;
public GroovyServices(ICompilationUnitFactory factory) {
compilationUnitFactory = factory;
}
public void setWorkspaceRoot(Path workspaceRoot) {
this.workspaceRoot = workspaceRoot;
createOrUpdateCompilationUnit();
}
@Override
public void connect(LanguageClient client) {
languageClient = client;
}
// --- NOTIFICATIONS
@Override
public void didOpen(DidOpenTextDocumentParams params) {
fileContentsTracker.didOpen(params);
URI uri = URI.create(params.getTextDocument().getUri());
compileAndVisitAST(uri);
}
@Override
public void didChange(DidChangeTextDocumentParams params) {
fileContentsTracker.didChange(params);
URI uri = URI.create(params.getTextDocument().getUri());
compileAndVisitAST(uri);
}
@Override
public void didClose(DidCloseTextDocumentParams params) {
fileContentsTracker.didClose(params);
URI uri = URI.create(params.getTextDocument().getUri());
compileAndVisitAST(uri);
}
@Override
public void didSave(DidSaveTextDocumentParams params) {
// nothing to handle on save at this time
}
@Override
public void didChangeWatchedFiles(DidChangeWatchedFilesParams params) {
boolean isSameUnit = createOrUpdateCompilationUnit();
Set<URI> urisWithChanges = params.getChanges().stream().map(fileEvent -> URI.create(fileEvent.getUri()))
.collect(Collectors.toSet());
compile();
if (isSameUnit) {
visitAST(urisWithChanges);
} else {
visitAST();
}
}
@Override
public void didChangeConfiguration(DidChangeConfigurationParams params) {
if (!(params.getSettings() instanceof JsonObject)) {
return;
}
JsonObject settings = (JsonObject) params.getSettings();
this.updateClasspath(settings);
}
private void updateClasspath(JsonObject settings) {
List<String> classpathList = new ArrayList<>();
if (settings.has("groovy") && settings.get("groovy").isJsonObject()) {
JsonObject groovy = settings.get("groovy").getAsJsonObject();
if (groovy.has("classpath") && groovy.get("classpath").isJsonArray()) {
JsonArray classpath = groovy.get("classpath").getAsJsonArray();
classpath.forEach(element -> {
classpathList.add(element.getAsString());
});
}
}
if (!classpathList.equals(compilationUnitFactory.getAdditionalClasspathList())) {
compilationUnitFactory.setAdditionalClasspathList(classpathList);
createOrUpdateCompilationUnit();
compile();
visitAST();
previousContext = null;
}
}
// --- REQUESTS
@Override
public CompletableFuture<Hover> hover(TextDocumentPositionParams params) {
URI uri = URI.create(params.getTextDocument().getUri());
recompileIfContextChanged(uri);
HoverProvider provider = new HoverProvider(astVisitor);
return provider.provideHover(params.getTextDocument(), params.getPosition());
}
@Override
public CompletableFuture<Either<List<CompletionItem>, CompletionList>> completion(CompletionParams params) {
TextDocumentIdentifier textDocument = params.getTextDocument();
Position position = params.getPosition();
URI uri = URI.create(textDocument.getUri());
recompileIfContextChanged(uri);
String originalSource = null;
ASTNode offsetNode = astVisitor.getNodeAtLineAndColumn(uri, position.getLine(), position.getCharacter());
if (offsetNode == null) {
originalSource = fileContentsTracker.getContents(uri);
VersionedTextDocumentIdentifier versionedTextDocument = new VersionedTextDocumentIdentifier(
textDocument.getUri(), 1);
int offset = Positions.getOffset(originalSource, position);
String lineBeforeOffset = originalSource.substring(offset - position.getCharacter(), offset);
Matcher matcher = PATTERN_CONSTRUCTOR_CALL.matcher(lineBeforeOffset);
TextDocumentContentChangeEvent changeEvent = null;
if (matcher.matches()) {
changeEvent = new TextDocumentContentChangeEvent(new Range(position, position), 0, "a()");
} else {
changeEvent = new TextDocumentContentChangeEvent(new Range(position, position), 0, "a");
}
DidChangeTextDocumentParams didChangeParams = new DidChangeTextDocumentParams(versionedTextDocument,
Collections.singletonList(changeEvent));
//if the offset node is null, there is probably a syntax error.
//a completion request is usually triggered by the . character, and
//if there is no property name after the dot, it will cause a syntax
//error.
//this hack adds a placeholder property name in the hopes that it
//will correctly create a PropertyExpression to use for completion.
//we'll restore the original text after we're done handling the
//completion request.
didChange(didChangeParams);
}
CompletableFuture<Either<List<CompletionItem>, CompletionList>> result = null;
try {
CompletionProvider provider = new CompletionProvider(astVisitor, compilationUnit.getClassLoader());
result = provider.provideCompletion(params.getTextDocument(), params.getPosition(), params.getContext());
} finally {
if (originalSource != null) {
VersionedTextDocumentIdentifier versionedTextDocument = new VersionedTextDocumentIdentifier(
textDocument.getUri(), 1);
TextDocumentContentChangeEvent changeEvent = new TextDocumentContentChangeEvent(null, 0,
originalSource);
DidChangeTextDocumentParams didChangeParams = new DidChangeTextDocumentParams(versionedTextDocument,
Collections.singletonList(changeEvent));
didChange(didChangeParams);
}
}
return result;
}
@Override
public CompletableFuture<Either<List<? extends Location>, List<? extends LocationLink>>> definition(
TextDocumentPositionParams params) {
URI uri = URI.create(params.getTextDocument().getUri());
recompileIfContextChanged(uri);
DefinitionProvider provider = new DefinitionProvider(astVisitor);
return provider.provideDefinition(params.getTextDocument(), params.getPosition());
}
@Override
public CompletableFuture<SignatureHelp> signatureHelp(TextDocumentPositionParams params) {
TextDocumentIdentifier textDocument = params.getTextDocument();
Position position = params.getPosition();
URI uri = URI.create(textDocument.getUri());
recompileIfContextChanged(uri);
String originalSource = null;
ASTNode offsetNode = astVisitor.getNodeAtLineAndColumn(uri, position.getLine(), position.getCharacter());
if (offsetNode == null) {
originalSource = fileContentsTracker.getContents(uri);
VersionedTextDocumentIdentifier versionedTextDocument = new VersionedTextDocumentIdentifier(
textDocument.getUri(), 1);
TextDocumentContentChangeEvent changeEvent = new TextDocumentContentChangeEvent(
new Range(position, position), 0, ")");
DidChangeTextDocumentParams didChangeParams = new DidChangeTextDocumentParams(versionedTextDocument,
Collections.singletonList(changeEvent));
//if the offset node is null, there is probably a syntax error.
//a signature help request is usually triggered by the ( character,
//and if there is no matching ), it will cause a syntax error.
//this hack adds a placeholder ) character in the hopes that it
//will correctly create a ArgumentListExpression to use for
//signature help.
//we'll restore the original text after we're done handling the
//signature help request.
didChange(didChangeParams);
}
try {
SignatureHelpProvider provider = new SignatureHelpProvider(astVisitor);
return provider.provideSignatureHelp(params.getTextDocument(), params.getPosition());
} finally {
if (originalSource != null) {
VersionedTextDocumentIdentifier versionedTextDocument = new VersionedTextDocumentIdentifier(
textDocument.getUri(), 1);
TextDocumentContentChangeEvent changeEvent = new TextDocumentContentChangeEvent(null, 0,
originalSource);
DidChangeTextDocumentParams didChangeParams = new DidChangeTextDocumentParams(versionedTextDocument,
Collections.singletonList(changeEvent));
didChange(didChangeParams);
}
}
}
@Override
public CompletableFuture<Either<List<? extends Location>, List<? extends LocationLink>>> typeDefinition(
TextDocumentPositionParams params) {
URI uri = URI.create(params.getTextDocument().getUri());
recompileIfContextChanged(uri);
TypeDefinitionProvider provider = new TypeDefinitionProvider(astVisitor);
return provider.provideTypeDefinition(params.getTextDocument(), params.getPosition());
}
@Override
public CompletableFuture<List<? extends Location>> references(ReferenceParams params) {
URI uri = URI.create(params.getTextDocument().getUri());
recompileIfContextChanged(uri);
ReferenceProvider provider = new ReferenceProvider(astVisitor);
return provider.provideReferences(params.getTextDocument(), params.getPosition());
}
@Override
public CompletableFuture<List<Either<SymbolInformation, DocumentSymbol>>> documentSymbol(
DocumentSymbolParams params) {
URI uri = URI.create(params.getTextDocument().getUri());
recompileIfContextChanged(uri);
DocumentSymbolProvider provider = new DocumentSymbolProvider(astVisitor);
return provider.provideDocumentSymbols(params.getTextDocument());
}
@Override
public CompletableFuture<List<? extends SymbolInformation>> symbol(WorkspaceSymbolParams params) {
WorkspaceSymbolProvider provider = new WorkspaceSymbolProvider(astVisitor);
return provider.provideWorkspaceSymbols(params.getQuery());
}
@Override
public CompletableFuture<WorkspaceEdit> rename(RenameParams params) {
URI uri = URI.create(params.getTextDocument().getUri());
recompileIfContextChanged(uri);
RenameProvider provider = new RenameProvider(astVisitor, fileContentsTracker);
return provider.provideRename(params);
}
// --- INTERNAL
private void visitAST() {
if (compilationUnit == null) {
return;
}
astVisitor = new ASTNodeVisitor();
astVisitor.visitCompilationUnit(compilationUnit);
}
private void visitAST(Set<URI> uris) {
if (astVisitor == null) {
visitAST();
return;
}
if (compilationUnit == null) {
return;
}
astVisitor.visitCompilationUnit(compilationUnit, uris);
}
private boolean createOrUpdateCompilationUnit() {
if (compilationUnit != null) {
File targetDirectory = compilationUnit.getConfiguration().getTargetDirectory();
if (targetDirectory != null && targetDirectory.exists()) {
try {
Files.walk(targetDirectory.toPath()).sorted(Comparator.reverseOrder()).map(Path::toFile)
.forEach(File::delete);
} catch (IOException e) {
System.err.println("Failed to delete target directory: " + targetDirectory.getAbsolutePath());
compilationUnit = null;
return false;
}
}
}
GroovyLSCompilationUnit oldCompilationUnit = compilationUnit;
compilationUnit = compilationUnitFactory.create(workspaceRoot, fileContentsTracker);
fileContentsTracker.resetChangedFiles();
if (compilationUnit != null) {
File targetDirectory = compilationUnit.getConfiguration().getTargetDirectory();
if (targetDirectory != null && !targetDirectory.exists() && !targetDirectory.mkdirs()) {
System.err.println("Failed to create target directory: " + targetDirectory.getAbsolutePath());
}
}
return compilationUnit != null && compilationUnit.equals(oldCompilationUnit);
}
protected void recompileIfContextChanged(URI newContext) {
if (previousContext == null || previousContext.equals(newContext)) {
return;
}
fileContentsTracker.forceChanged(newContext);
compileAndVisitAST(newContext);
}
private void compileAndVisitAST(URI contextURI) {
Set<URI> uris = Collections.singleton(contextURI);
boolean isSameUnit = createOrUpdateCompilationUnit();
compile();
if (isSameUnit) {
visitAST(uris);
} else {
visitAST();
}
previousContext = contextURI;
}
private void compile() {
if (compilationUnit == null) {
return;
}
try {
//AST is completely built after the canonicalization phase
//for code intelligence, we shouldn't need to go further
//http://groovy-lang.org/metaprogramming.html#_compilation_phases_guide
compilationUnit.compile(Phases.CANONICALIZATION);
} catch (MultipleCompilationErrorsException e) {
// ignore
} catch (GroovyBugError e) {
System.err.println("Unexpected exception in language server when compiling Groovy.");
e.printStackTrace(System.err);
} catch (Exception e) {
System.err.println("Unexpected exception in language server when compiling Groovy.");
e.printStackTrace(System.err);
}
Set<PublishDiagnosticsParams> diagnostics = handleErrorCollector(compilationUnit.getErrorCollector());
diagnostics.stream().forEach(languageClient::publishDiagnostics);
}
private Set<PublishDiagnosticsParams> handleErrorCollector(ErrorCollector collector) {
Map<URI, List<Diagnostic>> diagnosticsByFile = new HashMap<>();
@SuppressWarnings("unchecked")
List<Message> errors = collector.getErrors();
if (errors != null) {
errors.stream().filter((Object message) -> message instanceof SyntaxErrorMessage)
.forEach((Object message) -> {
SyntaxErrorMessage syntaxErrorMessage = (SyntaxErrorMessage) message;
SyntaxException cause = syntaxErrorMessage.getCause();
Range range = GroovyLanguageServerUtils.syntaxExceptionToRange(cause);
Diagnostic diagnostic = new Diagnostic();
diagnostic.setRange(range);
diagnostic.setSeverity(cause.isFatal() ? DiagnosticSeverity.Error : DiagnosticSeverity.Warning);
diagnostic.setMessage(cause.getMessage());
URI uri = Paths.get(cause.getSourceLocator()).toUri();
diagnosticsByFile.computeIfAbsent(uri, (key) -> new ArrayList<>()).add(diagnostic);
});
}
Set<PublishDiagnosticsParams> result = diagnosticsByFile.entrySet().stream()
.map(entry -> new PublishDiagnosticsParams(entry.getKey().toString(), entry.getValue()))
.collect(Collectors.toSet());
if (prevDiagnosticsByFile != null) {
for (URI key : prevDiagnosticsByFile.keySet()) {
if (!diagnosticsByFile.containsKey(key)) {
// send an empty list of diagnostics for files that had
// diagnostics previously or they won't be cleared
result.add(new PublishDiagnosticsParams(key.toString(), new ArrayList<>()));
}
}
}
prevDiagnosticsByFile = diagnosticsByFile;
return result;
}
}
