Examples with CompletionList org.eclipse.lsp4j.CompletionList used on opensource projects

Example 26 with CompletionList

use of org.eclipse.lsp4j.CompletionList in project eclipse.jdt.ls by eclipse.

the class CompletionHandlerTest method testCompletion_import_type.

@Test
public void testCompletion_import_type() throws JavaModelException {
    ICompilationUnit unit = getWorkingCopy("src/java/Foo.java", "import java.sq \n" + "public class Foo {\n" + "	void foo() {\n" + "   java.util.Ma\n" + "	}\n" + "}\n");
    int[] loc = findCompletionLocation(unit, "java.util.Ma");
    CompletionList list = server.completion(JsonMessageHelper.getParams(createCompletionRequest(unit, loc[0], loc[1]))).join().getRight();
    assertNotNull(list);
    assertEquals(1, list.getItems().size());
    CompletionItem item = list.getItems().get(0);
    assertEquals(CompletionItemKind.Class, item.getKind());
    assertEquals("Map", item.getInsertText());
    assertNull(item.getAdditionalTextEdits());
    assertNull(item.getTextEdit());
    CompletionItem resolvedItem = server.resolveCompletionItem(item).join();
    assertNotNull(resolvedItem.getTextEdit());
    assertTextEdit(3, 3, 15, "java.util.Map", resolvedItem.getTextEdit());
// Not checking the range end character
}

Example 27 with CompletionList

use of org.eclipse.lsp4j.CompletionList in project xtext-core by eclipse.

the class UnknownProjectConfigTest method checkCompletion.

protected void checkCompletion(String uri) throws Exception {
    CompletableFuture<Either<List<CompletionItem>, CompletionList>> completionItems = languageServer.completion(new CompletionParams(new TextDocumentIdentifier(uri), new Position(0, 10)));
    Either<List<CompletionItem>, CompletionList> result = completionItems.get();
    List<CompletionItem> items = null;
    if (result.isLeft()) {
        items = result.getLeft();
    } else {
        items = result.getRight().getItems();
    }
    String actualCompletionItems = Strings.toUnixLineSeparator(toExpectation(items));
    String expectedCompletionItems = "Foo (TypeDeclaration) -> Foo [[0, 10] .. [0, 10]]\n" + "boolean -> boolean [[0, 10] .. [0, 10]]\n" + "int -> int [[0, 10] .. [0, 10]]\n" + "op -> op [[0, 10] .. [0, 10]]\n" + "string -> string [[0, 10] .. [0, 10]]\n" + "void -> void [[0, 10] .. [0, 10]]\n" + "} -> } [[0, 10] .. [0, 10]]\n" + "{ -> { [[0, 9] .. [0, 10]]\n" + "   + } [[0, 11] .. [0, 11]]\n";
    assertEquals(expectedCompletionItems, actualCompletionItems);
}

Example 28 with CompletionList

use of org.eclipse.lsp4j.CompletionList in project xtext-core by eclipse.

the class LanguageServerImpl method completion.

/**
 * Compute the completion items.
 */
protected Either<List<CompletionItem>, CompletionList> completion(CancelIndicator originalCancelIndicator, CompletionParams params) {
    URI uri = getURI(params);
    ContentAssistService contentAssistService = getService(uri, ContentAssistService.class);
    if (contentAssistService == null) {
        return Either.forRight(new CompletionList());
    }
    BufferedCancelIndicator cancelIndicator = new BufferedCancelIndicator(originalCancelIndicator);
    return Either.forRight(workspaceManager.doRead(uri, (doc, res) -> contentAssistService.createCompletionList(doc, res, params, cancelIndicator)));
}

Example 29 with CompletionList

use of org.eclipse.lsp4j.CompletionList in project xtext-core by eclipse.

the class ContentAssistService method createCompletionList.

public CompletionList createCompletionList(Document document, XtextResource resource, CompletionParams params, CancelIndicator cancelIndicator) {
    try {
        CompletionList result = new CompletionList();
        result.setIsIncomplete(true);
        IdeContentProposalAcceptor acceptor = proposalAcceptorProvider.get();
        int caretOffset = document.getOffSet(params.getPosition());
        Position caretPosition = params.getPosition();
        TextRegion position = new TextRegion(caretOffset, 0);
        try {
            createProposals(document.getContents(), position, caretOffset, resource, acceptor);
        } catch (Throwable t) {
            if (!operationCanceledManager.isOperationCanceledException(t)) {
                throw t;
            }
        }
        int idx = 0;
        for (ContentAssistEntry it : acceptor.getEntries()) {
            CompletionItem item = toCompletionItem(it, caretOffset, caretPosition, document);
            item.setSortText(Strings.padStart(Integer.toString(idx), 5, '0'));
            result.getItems().add(item);
            idx++;
        }
        return result;
    } catch (Throwable e) {
        throw Exceptions.sneakyThrow(e);
    }
}

Example 30 with CompletionList

use of org.eclipse.lsp4j.CompletionList in project vscode-nextgenas by BowlerHatLLC.

the class ActionScriptTextDocumentService method actionScriptCompletionWithNode.

private CompletableFuture<CompletionList> actionScriptCompletionWithNode(TextDocumentPositionParams position, IASNode offsetNode) {
    CompletionList result = new CompletionList();
    result.setIsIncomplete(false);
    result.setItems(new ArrayList<>());
    if (offsetNode == null) {
        //we couldn't find a node at the specified location
        autoCompletePackageBlock(result);
        return CompletableFuture.completedFuture(result);
    }
    IASNode parentNode = offsetNode.getParent();
    IASNode nodeAtPreviousOffset = null;
    if (parentNode != null) {
        nodeAtPreviousOffset = parentNode.getContainingNode(currentOffset - 1);
    }
    if (!isActionScriptCompletionAllowedInNode(position, offsetNode)) {
        //if we're inside a node that shouldn't have completion!
        return CompletableFuture.completedFuture(new CompletionList());
    }
    //variable types
    if (offsetNode instanceof IVariableNode) {
        IVariableNode variableNode = (IVariableNode) offsetNode;
        IExpressionNode nameExpression = variableNode.getNameExpressionNode();
        IExpressionNode typeNode = variableNode.getVariableTypeNode();
        int line = position.getPosition().getLine();
        int column = position.getPosition().getCharacter();
        if (line >= nameExpression.getEndLine() && line <= typeNode.getLine()) {
            if ((line != nameExpression.getEndLine() && line != typeNode.getLine()) || (line == nameExpression.getEndLine() && column > nameExpression.getEndColumn()) || (line == typeNode.getLine() && column <= typeNode.getColumn())) {
                autoCompleteTypes(offsetNode, result);
            }
            return CompletableFuture.completedFuture(result);
        }
    }
    if (parentNode != null && parentNode instanceof IVariableNode) {
        IVariableNode variableNode = (IVariableNode) parentNode;
        if (offsetNode == variableNode.getVariableTypeNode()) {
            autoCompleteTypes(parentNode, result);
            return CompletableFuture.completedFuture(result);
        }
    }
    //function return types
    if (offsetNode instanceof IFunctionNode) {
        IFunctionNode functionNode = (IFunctionNode) offsetNode;
        IContainerNode parameters = functionNode.getParametersContainerNode();
        IExpressionNode typeNode = functionNode.getReturnTypeNode();
        if (typeNode != null) {
            int line = position.getPosition().getLine();
            int column = position.getPosition().getCharacter();
            if (line >= parameters.getEndLine() && column > parameters.getEndColumn() && line <= typeNode.getLine() && column <= typeNode.getColumn()) {
                autoCompleteTypes(offsetNode, result);
                return CompletableFuture.completedFuture(result);
            }
        }
    }
    if (parentNode != null && parentNode instanceof IFunctionNode) {
        IFunctionNode functionNode = (IFunctionNode) parentNode;
        if (offsetNode == functionNode.getReturnTypeNode()) {
            autoCompleteTypes(parentNode, result);
            return CompletableFuture.completedFuture(result);
        }
    }
    //new keyword types
    if (parentNode != null && parentNode instanceof IFunctionCallNode) {
        IFunctionCallNode functionCallNode = (IFunctionCallNode) parentNode;
        if (functionCallNode.getNameNode() == offsetNode && functionCallNode.isNewExpression()) {
            autoCompleteTypes(parentNode, result);
            return CompletableFuture.completedFuture(result);
        }
    }
    if (nodeAtPreviousOffset != null && nodeAtPreviousOffset instanceof IKeywordNode && nodeAtPreviousOffset.getNodeID() == ASTNodeID.KeywordNewID) {
        autoCompleteTypes(nodeAtPreviousOffset, result);
        return CompletableFuture.completedFuture(result);
    }
    //as and is keyword types
    if (parentNode != null && parentNode instanceof IBinaryOperatorNode && (parentNode.getNodeID() == ASTNodeID.Op_AsID || parentNode.getNodeID() == ASTNodeID.Op_IsID)) {
        IBinaryOperatorNode binaryOperatorNode = (IBinaryOperatorNode) parentNode;
        if (binaryOperatorNode.getRightOperandNode() == offsetNode) {
            autoCompleteTypes(parentNode, result);
            return CompletableFuture.completedFuture(result);
        }
    }
    if (nodeAtPreviousOffset != null && nodeAtPreviousOffset instanceof IBinaryOperatorNode && (nodeAtPreviousOffset.getNodeID() == ASTNodeID.Op_AsID || nodeAtPreviousOffset.getNodeID() == ASTNodeID.Op_IsID)) {
        autoCompleteTypes(nodeAtPreviousOffset, result);
        return CompletableFuture.completedFuture(result);
    }
    //class extends keyword
    if (offsetNode instanceof IClassNode && nodeAtPreviousOffset != null && nodeAtPreviousOffset instanceof IKeywordNode && nodeAtPreviousOffset.getNodeID() == ASTNodeID.KeywordExtendsID) {
        autoCompleteTypes(offsetNode, result);
        return CompletableFuture.completedFuture(result);
    }
    //class implements keyword
    if (offsetNode instanceof IClassNode && nodeAtPreviousOffset != null && nodeAtPreviousOffset instanceof IKeywordNode && nodeAtPreviousOffset.getNodeID() == ASTNodeID.KeywordImplementsID) {
        autoCompleteTypes(offsetNode, result);
        return CompletableFuture.completedFuture(result);
    }
    //interface extends keyword
    if (offsetNode instanceof IInterfaceNode && nodeAtPreviousOffset != null && nodeAtPreviousOffset instanceof IKeywordNode && nodeAtPreviousOffset.getNodeID() == ASTNodeID.KeywordExtendsID) {
        autoCompleteTypes(offsetNode, result);
        return CompletableFuture.completedFuture(result);
    }
    //package (must be before member access)
    if (offsetNode instanceof IPackageNode) {
        IPackageNode packageNode = (IPackageNode) offsetNode;
        autoCompletePackageName(packageNode.getPackageName(), result);
        return CompletableFuture.completedFuture(result);
    }
    if (parentNode != null && parentNode instanceof FullNameNode) {
        IASNode gpNode = parentNode.getParent();
        if (gpNode != null && gpNode instanceof IPackageNode) {
            IPackageNode packageNode = (IPackageNode) gpNode;
            autoCompletePackageName(packageNode.getPackageName(), result);
        }
    }
    if (parentNode != null && parentNode instanceof IPackageNode) {
        //we'll get here if the last character in the package name is .
        IPackageNode packageNode = (IPackageNode) parentNode;
        IExpressionNode nameNode = packageNode.getNameExpressionNode();
        if (offsetNode == nameNode) {
            autoCompletePackageName(packageNode.getPackageName(), result);
            return CompletableFuture.completedFuture(result);
        }
    }
    //import (must be before member access)
    if (parentNode != null && parentNode instanceof IImportNode) {
        IImportNode importNode = (IImportNode) parentNode;
        IExpressionNode nameNode = importNode.getImportNameNode();
        if (offsetNode == nameNode) {
            String importName = importNode.getImportName();
            importName = importName.substring(0, position.getPosition().getCharacter() - nameNode.getColumn());
            autoCompleteImport(importName, result);
            return CompletableFuture.completedFuture(result);
        }
    }
    if (parentNode != null && parentNode instanceof FullNameNode) {
        IASNode gpNode = parentNode.getParent();
        if (gpNode != null && gpNode instanceof IImportNode) {
            IImportNode importNode = (IImportNode) gpNode;
            IExpressionNode nameNode = importNode.getImportNameNode();
            if (parentNode == nameNode) {
                String importName = importNode.getImportName();
                importName = importName.substring(0, position.getPosition().getCharacter() - nameNode.getColumn());
                autoCompleteImport(importName, result);
                return CompletableFuture.completedFuture(result);
            }
        }
    }
    if (nodeAtPreviousOffset != null && nodeAtPreviousOffset instanceof IImportNode) {
        autoCompleteImport("", result);
        return CompletableFuture.completedFuture(result);
    }
    //member access
    if (offsetNode instanceof IMemberAccessExpressionNode) {
        IMemberAccessExpressionNode memberAccessNode = (IMemberAccessExpressionNode) offsetNode;
        IExpressionNode leftOperand = memberAccessNode.getLeftOperandNode();
        IExpressionNode rightOperand = memberAccessNode.getRightOperandNode();
        int line = position.getPosition().getLine();
        int column = position.getPosition().getCharacter();
        if (line >= leftOperand.getEndLine() && line <= rightOperand.getLine()) {
            if ((line != leftOperand.getEndLine() && line != rightOperand.getLine()) || (line == leftOperand.getEndLine() && column > leftOperand.getEndColumn()) || (line == rightOperand.getLine() && column <= rightOperand.getColumn())) {
                autoCompleteMemberAccess(memberAccessNode, result);
                return CompletableFuture.completedFuture(result);
            }
        }
    }
    if (parentNode != null && parentNode instanceof IMemberAccessExpressionNode) {
        IMemberAccessExpressionNode memberAccessNode = (IMemberAccessExpressionNode) parentNode;
        //you would expect that the offset node could only be the right
        //operand, but it's actually possible for it to be the left operand,
        //even if the . has been typed! only sometimes, though.
        boolean isValidLeft = true;
        if (offsetNode == memberAccessNode.getLeftOperandNode() && memberAccessNode.getRightOperandNode() instanceof IIdentifierNode) {
            //if the left and right operands both exist, then this is not
            //member access and we should skip ahead
            isValidLeft = false;
        }
        if (offsetNode == memberAccessNode.getRightOperandNode() || isValidLeft) {
            autoCompleteMemberAccess(memberAccessNode, result);
            return CompletableFuture.completedFuture(result);
        }
    }
    if (nodeAtPreviousOffset != null && nodeAtPreviousOffset instanceof IMemberAccessExpressionNode) {
        //depending on the left operand, if a . is typed, the member access
        //may end up being the previous node instead of the parent or offset
        //node, so check if the right operand is empty
        IMemberAccessExpressionNode memberAccessNode = (IMemberAccessExpressionNode) nodeAtPreviousOffset;
        IExpressionNode rightOperandNode = memberAccessNode.getRightOperandNode();
        if (rightOperandNode instanceof IIdentifierNode) {
            IIdentifierNode identifierNode = (IIdentifierNode) rightOperandNode;
            if (identifierNode.getName().equals("")) {
                autoCompleteMemberAccess(memberAccessNode, result);
                return CompletableFuture.completedFuture(result);
            }
        }
    }
    //local scope
    do {
        //nodes to check
        if (offsetNode instanceof IScopedNode) {
            IScopedNode scopedNode = (IScopedNode) offsetNode;
            //include all members and local things that are in scope
            autoCompleteScope(scopedNode, false, result);
            //include all public definitions
            IASScope scope = scopedNode.getScope();
            IDefinition definitionToSkip = scope.getDefinition();
            autoCompleteDefinitions(result, false, false, null, definitionToSkip);
            return CompletableFuture.completedFuture(result);
        }
        offsetNode = offsetNode.getParent();
    } while (offsetNode != null);
    return CompletableFuture.completedFuture(result);
}