feat: Show variable definition as documentation

Resolve documentation requests immediately

Author: temanbrcom

server/src/main/java/org/eclipse/lsp/cobol/service/CobolLanguageServer.java

@@ -93,7 +93,7 @@ public CompletableFuture<InitializeResult> initialize(@NonNull InitializeParams
     ServerCapabilities capabilities = new ServerCapabilities();
 
     capabilities.setTextDocumentSync(Full);
-    capabilities.setCompletionProvider(new CompletionOptions(true, emptyList()));
+    capabilities.setCompletionProvider(new CompletionOptions(false, emptyList()));
     capabilities.setDefinitionProvider(TRUE);
     capabilities.setReferencesProvider(TRUE);
     capabilities.setDocumentFormattingProvider(TRUE);

server/src/main/java/org/eclipse/lsp/cobol/service/CobolTextDocumentService.java

@@ -14,13 +14,22 @@
  */
 package org.eclipse.lsp.cobol.service;
 
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableMap;
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import lombok.Builder;
+import lombok.NonNull;
+import lombok.extern.slf4j.Slf4j;
 import org.eclipse.lsp.cobol.core.annotation.CheckServerShutdownState;
 import org.eclipse.lsp.cobol.core.annotation.DisposableService;
 import org.eclipse.lsp.cobol.domain.databus.api.DataBusBroker;
 import org.eclipse.lsp.cobol.domain.event.api.EventObserver;
 import org.eclipse.lsp.cobol.domain.event.model.AnalysisFinishedEvent;
-import org.eclipse.lsp.cobol.domain.event.model.DataEventType;
 import org.eclipse.lsp.cobol.domain.event.model.AnalysisResultEvent;
+import org.eclipse.lsp.cobol.domain.event.model.DataEventType;
 import org.eclipse.lsp.cobol.domain.event.model.RunAnalysisEvent;
 import org.eclipse.lsp.cobol.service.delegates.actions.CodeActions;
 import org.eclipse.lsp.cobol.service.delegates.communications.Communications;
@@ -31,15 +40,6 @@
 import org.eclipse.lsp.cobol.service.delegates.validations.AnalysisResult;
 import org.eclipse.lsp.cobol.service.delegates.validations.LanguageEngineFacade;
 import org.eclipse.lsp.cobol.service.utils.CustomThreadPoolExecutor;
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.ImmutableMap;
-import com.google.gson.Gson;
-import com.google.gson.JsonObject;
-import com.google.inject.Inject;
-import com.google.inject.Singleton;
-import lombok.Builder;
-import lombok.NonNull;
-import lombok.extern.slf4j.Slf4j;
 import org.eclipse.lsp4j.*;
 import org.eclipse.lsp4j.jsonrpc.messages.Either;
 import org.eclipse.lsp4j.services.TextDocumentService;
@@ -69,7 +69,9 @@
 @Slf4j
 @Singleton
 public class CobolTextDocumentService
-    implements TextDocumentService, EventObserver<RunAnalysisEvent>, DisposableService,
+    implements TextDocumentService,
+        EventObserver<RunAnalysisEvent>,
+        DisposableService,
         ExtendedApiService {
   private static final List<String> COBOL_IDS = Arrays.asList("cobol", "cbl", "cob");
   private static final String GIT_FS_URI = "gitfs:/";
@@ -140,17 +142,6 @@ public CompletableFuture<Either<List<CompletionItem>, CompletionList>> completio
             reportExceptionIfThrown(createDescriptiveErrorMessage("completion lookup", uri)));
   }
 
-  @Override
-  @CheckServerShutdownState
-  public CompletableFuture<CompletionItem> resolveCompletionItem(CompletionItem unresolved) {
-    return supplyAsync(
-            () -> completions.resolveDocumentationFor(unresolved),
-            executors.getThreadPoolExecutor())
-        .whenComplete(
-            reportExceptionIfThrown(
-                createDescriptiveErrorMessage("completion resolving", unresolved.getLabel())));
-  }
-
   @Override
   @CheckServerShutdownState
   public CompletableFuture<List<? extends Location>> definition(
@@ -270,21 +261,24 @@ public CompletableFuture<AnalysisResult> analysis(@NonNull JsonObject json) {
     AnalysisResultEvent event = new Gson().fromJson(json.toString(), AnalysisResultEvent.class);
     String uri = Optional.ofNullable(event).map(AnalysisResultEvent::getUri).orElse("");
     return CompletableFuture.supplyAsync(
-        () -> Optional.ofNullable(docs.get(uri))
-            .map(CobolDocumentModel::getAnalysisResult)
-            .orElse(null),
-        executors.getThreadPoolExecutor())
+            () ->
+                Optional.ofNullable(docs.get(uri))
+                    .map(CobolDocumentModel::getAnalysisResult)
+                    .orElse(null),
+            executors.getThreadPoolExecutor())
         .whenComplete(
             reportExceptionIfThrown(createDescriptiveErrorMessage("analysis retrieving", uri)));
   }
 
   private void registerEngineAndAnalyze(String uri, String text) {
     String fileExtension = extractExtension(uri);
     if (fileExtension != null && !isCobolFile(fileExtension)) {
-      outlineMap.computeIfPresent(uri, (k, v) -> {
-        v.complete(Collections.singletonList(new DocumentSymbol()));
-        return v;
-      });
+      outlineMap.computeIfPresent(
+          uri,
+          (k, v) -> {
+            v.complete(Collections.singletonList(new DocumentSymbol()));
+            return v;
+          });
       communications.notifyThatExtensionIsUnsupported(fileExtension);
     } else {
       communications.notifyThatLoadingInProgress(uri);
@@ -407,11 +401,9 @@ public CompletableFuture<List<Either<SymbolInformation, DocumentSymbol>>> docume
   public CompletableFuture<Hover> hover(TextDocumentPositionParams position) {
     String uri = position.getTextDocument().getUri();
     return CompletableFuture.<Hover>supplyAsync(
-        () -> hoverProvider.getHover(docs.get(uri), position),
-        executors.getThreadPoolExecutor())
-        .whenComplete(
-            reportExceptionIfThrown(createDescriptiveErrorMessage("getting hover", uri)));
-
+            () -> hoverProvider.getHover(docs.get(uri), position),
+            executors.getThreadPoolExecutor())
+        .whenComplete(reportExceptionIfThrown(createDescriptiveErrorMessage("getting hover", uri)));
   }
 
   private void registerDocument(String uri, CobolDocumentModel document) {

server/src/main/java/org/eclipse/lsp/cobol/service/delegates/completions/Completion.java

@@ -14,70 +14,28 @@
  */
 package org.eclipse.lsp.cobol.service.delegates.completions;
 
+import lombok.NonNull;
 import org.eclipse.lsp.cobol.service.CobolDocumentModel;
 import org.eclipse.lsp4j.CompletionItem;
-import org.eclipse.lsp4j.CompletionItemKind;
 
-import lombok.NonNull;
 import javax.annotation.Nullable;
 import java.util.Collection;
 
 /**
  * Completion provider that allows to resolve autocomplete requests with specific items based on
  * type. The type of completion items may be dynamic (depends on the current document) and static
  * (does not depend on the document).
- *
- * <p>Use getSortOrderPrefix() to specify the order of the completions. It should go from dynamic to
- * static, from the most common the most rare.
  */
 public interface Completion {
 
   /**
-   * Retrieve a collection of string that are going to be converted into completion items. Use
-   * document to retrieve dynamic data or some special stuff for static data.
+   * Provide a list of completion items of specific kind
    *
+   * @param token - token to filter the suggestions
    * @param document - object that contains text and analysis output
    * @return collection of strings to be converted into completion items
    */
   @NonNull
-  Collection<String> getCompletionSource(@Nullable CobolDocumentModel document);
-
-  /**
-   * Try to resolve the documentation for the completion item by its label
-   *
-   * @param label - A code part user typed in the IDE to be completed
-   * @return the description for the label or null if not resolved
-   */
-  @Nullable
-  default String tryResolve(@NonNull String label) {
-    return null;
-  }
-
-  /**
-   * Get a prefix for the completion item to apply sort with the expected order
-   *
-   * @return a string containing number for proper sorting
-   */
-  @NonNull
-  String getSortOrderPrefix();
-
-  /**
-   * Get kind for the completion items to add specific icons on the client side.
-   *
-   * @return CompletionItemKind for the provided completions
-   */
-  @NonNull
-  CompletionItemKind getKind();
-
-  /**
-   * Set special values to the given item if it is needed. Return the given element with no changes
-   * by default
-   *
-   * @param item - a CompletionItem to be customized
-   * @return a CompletionItem item with some special values set or the given item in the other case
-   */
-  @NonNull
-  default CompletionItem customize(@NonNull CompletionItem item) {
-    return item;
-  }
+  Collection<CompletionItem> getCompletionItems(
+      @NonNull String token, @Nullable CobolDocumentModel document);
 }

server/src/main/java/org/eclipse/lsp/cobol/service/delegates/completions/CompletionStorage.java

@@ -24,6 +24,10 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 
+/**
+ * This class represents a storage for static completion content, e.g. keywords. It provides
+ * elements as strings and documentation for them if provided.
+ */
 @Slf4j
 public abstract class CompletionStorage {
   private Map<String, String> storage = new HashMap<>();
@@ -67,11 +71,10 @@ private void fillInStorage(Properties props) {
                     entry -> processDescription(entry.getValue().toString())));
   }
   /**
-   * If description consist of several rows, then line breaks symbols should be replaced with actual
-   * ones.
+   * Replace line break tags with actual line breaks
    *
-   * @param desc - Raw description retrieved from storage
-   * @return THe description properly split in lines
+   * @param desc - raw description retrieved from storage
+   * @return the description properly split in lines
    */
   private String processDescription(String desc) {
     return desc.replace("<br>", "\r\n\r\n");

server/src/main/java/org/eclipse/lsp/cobol/service/delegates/completions/Completions.java

@@ -14,25 +14,23 @@
  */
 package org.eclipse.lsp.cobol.service.delegates.completions;
 
-import org.eclipse.lsp.cobol.domain.modules.ServiceModule;
-import org.eclipse.lsp.cobol.service.CobolDocumentModel;
 import com.google.inject.Inject;
 import com.google.inject.Singleton;
+import lombok.NonNull;
 import lombok.extern.slf4j.Slf4j;
+import org.eclipse.lsp.cobol.domain.modules.ServiceModule;
+import org.eclipse.lsp.cobol.service.CobolDocumentModel;
 import org.eclipse.lsp4j.CompletionItem;
 import org.eclipse.lsp4j.CompletionList;
 import org.eclipse.lsp4j.CompletionParams;
-import org.eclipse.lsp4j.MarkupContent;
 
-import lombok.NonNull;
 import javax.annotation.Nullable;
+import java.util.Collection;
 import java.util.List;
-import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
+
+import static java.util.stream.Collectors.toList;
 
 /**
  * This class is used as a delegate for code completion operations. It requires type-specific
@@ -57,11 +55,9 @@ public class Completions {
   }
 
   /**
-   * Collect completion suggestions for a token in the document. The documentation for the
-   * completion suggestion is not resolving in order to speed-up the autocomplete request
-   * processing, so the list to return is marked as Incomplete. Use resolveDocumentationFor() to
-   * fill-in the documentation. Document may be null if the request is invoked before the didOpen()
-   * request was resolved and the document model is not stored on the server yet.
+   * Collect completion suggestions for a token in the document. Document may be null if the request
+   * is invoked before the didOpen() request has been resolved, and the document model is not stored
+   * on the server yet.
    *
    * @param document - document model that should be used to retrieve the required token. May be
    *     null.
@@ -72,50 +68,17 @@ public class Completions {
   @NonNull
   public CompletionList collectFor(
       @Nullable CobolDocumentModel document, @NonNull CompletionParams params) {
-    return new CompletionList(true, collectCompletions(document, params));
-  }
-
-  /**
-   * Fills in the documentation for CompletionItem by its label. The documentation is marked-up
-   * using a Markdown notation. If there is no documentation could be provided, then the
-   * documentation is a {@link MarkupContent} with null as a value.
-   *
-   * @param unresolved - CompletionItem to be resolved
-   * @return the given CompletionItem with resolved documentation
-   */
-  @NonNull
-  public CompletionItem resolveDocumentationFor(@NonNull CompletionItem unresolved) {
-    unresolved.setDocumentation(
-        wrapWithMarkup(
-            providers.stream()
-                .map(it -> it.tryResolve(unresolved.getLabel()))
-                .filter(Objects::nonNull)
-                .findAny()
-                .orElse(null)));
-
-    return unresolved;
-  }
-
-  @NonNull
-  private MarkupContent wrapWithMarkup(@Nullable String desc) {
-    MarkupContent markupContent = new MarkupContent();
-    markupContent.setKind("markdown");
-    markupContent.setValue(desc);
-    return markupContent;
+    return new CompletionList(false, collectCompletions(document, params));
   }
 
   @NonNull
   private List<CompletionItem> collectCompletions(
       @Nullable CobolDocumentModel document, @NonNull CompletionParams params) {
-    String token = retrieveToken(document, params);
     return providers
         .parallelStream()
-        .flatMap(
-            it ->
-                it.getCompletionSource(document).stream()
-                    .filter(startsWithIgnoreCase(token))
-                    .map(convertToCompletionItem(it)))
-        .collect(Collectors.toList());
+        .map(it -> it.getCompletionItems(retrieveToken(document, params), document))
+        .flatMap(Collection::stream)
+        .collect(toList());
   }
 
   @NonNull
@@ -125,27 +88,4 @@ private String retrieveToken(
         .map(it -> it.getTokenBeforePosition(params.getPosition()))
         .orElse("");
   }
-  /**
-   * Returns predicate which may be used to filter strings that starts with a given string ignoring
-   * case. Code example: list.stream().filter(CompletionUtils.startsWithIgnoreCase("string");
-   *
-   * @param token - The string that the checking string should start with
-   * @return Predicate that may be used in Stream.filter()
-   */
-  @NonNull
-  private Predicate<String> startsWithIgnoreCase(@NonNull String token) {
-    return word -> word.regionMatches(true, 0, token, 0, token.length());
-  }
-
-  @NonNull
-  private Function<String, CompletionItem> convertToCompletionItem(@NonNull Completion it) {
-    return word -> {
-      CompletionItem item = new CompletionItem();
-      item.setLabel(word);
-      item.setInsertText(word);
-      item.setKind(it.getKind());
-      item.setSortText(it.getSortOrderPrefix() + word);
-      return it.customize(item);
-    };
-  }
 }