private void createJavadocTypeProposalLabel(char[] fullName, CompletionItem item) { // only display innermost type name as type name, using any // enclosing types as qualification int qIndex= findSimpleNameStart(fullName); StringBuilder nameBuffer= new StringBuilder(); String name = new String(fullName, qIndex, fullName.length - qIndex); nameBuffer.append("{@link "); //$NON-NLS-1$ nameBuffer.append(name); nameBuffer.append('}'); item.setLabel(nameBuffer.toString()); item.setFilterText(name); if (qIndex > 0) { item.setDetail(new String(fullName, 0, qIndex - 1)); } }
private static void setMeta(CompletionItem item, BInvokableSymbol bSymbol) { item.setInsertTextFormat(InsertTextFormat.Snippet); item.setDetail(ItemResolverConstants.FUNCTION_TYPE); item.setKind(CompletionItemKind.Function); if (bSymbol != null && bSymbol.markdownDocumentation != null) { item.setDocumentation(bSymbol.markdownDocumentation.description); } }
private void createAnonymousTypeLabel(CompletionProposal proposal, CompletionItem item) { char[] declaringTypeSignature= proposal.getDeclarationSignature(); declaringTypeSignature= Signature.getTypeErasure(declaringTypeSignature); String name = new String(Signature.getSignatureSimpleName(declaringTypeSignature)); item.setInsertText(name); StringBuilder buf= new StringBuilder(); buf.append(name); buf.append('('); appendUnboundedParameterList(buf, proposal); buf.append(')'); buf.append(" "); //$NON-NLS-1$ buf.append("Anonymous Inner Type"); //TODO: consider externalization item.setLabel(buf.toString()); if (proposal.getRequiredProposals() != null) { char[] signatureQualifier= Signature.getSignatureQualifier(declaringTypeSignature); if (signatureQualifier.length > 0) { item.setDetail(String.valueOf(signatureQualifier)); } } setDeclarationSignature(item, String.valueOf(declaringTypeSignature)); }
/** * Creates and returns a completion item. * * @param bSymbol BSymbol * @param label label * @param type variable type * @return {@link CompletionItem} */ public static CompletionItem build(BVarSymbol bSymbol, String label, String type) { CompletionItem item = new CompletionItem(); item.setLabel(label); String[] delimiterSeparatedTokens = (label).split("\\."); item.setInsertText(delimiterSeparatedTokens[delimiterSeparatedTokens.length - 1]); item.setDetail((type.equals("")) ? ItemResolverConstants.NONE : type); setMeta(item, bSymbol); return item; }
private void populateTrueFalseKeywords(List<CompletionItem> completionItems) { CompletionItem trueItem = new CompletionItem(); trueItem.setLabel(ItemResolverConstants.TRUE_KEYWORD); trueItem.setInsertText(ItemResolverConstants.TRUE_KEYWORD); trueItem.setDetail(ItemResolverConstants.KEYWORD_TYPE); trueItem.setKind(CompletionItemKind.Value); completionItems.add(trueItem); CompletionItem falseItem = new CompletionItem(); falseItem.setLabel(ItemResolverConstants.FALSE_KEYWORD); falseItem.setInsertText(ItemResolverConstants.FALSE_KEYWORD); falseItem.setDetail(ItemResolverConstants.KEYWORD_TYPE); trueItem.setKind(CompletionItemKind.Value); completionItems.add(falseItem); } }
/** * Creates and returns a completion item. * * @param bSymbol BSymbol or null * @param label label * @return {@link CompletionItem} */ public static CompletionItem build(BTypeSymbol bSymbol, String label) { CompletionItem item = new CompletionItem(); item.setLabel(label); String[] delimiterSeparatedTokens = (label).split("\\."); item.setInsertText(delimiterSeparatedTokens[delimiterSeparatedTokens.length - 1]); item.setDetail(ItemResolverConstants.B_TYPE); setMeta(item, bSymbol); return item; }
/** * Updates the label and detail for {@link CompletionItem} with * <ul> * <li>the method name</li> * <li>the raw simple name of the declaring type</li> * </ul> * * @param methodProposal the method proposal to display * @param item the item to set values to */ private void createJavadocMethodProposalLabel(CompletionProposal methodProposal, CompletionItem item) { // method name item.setLabel(String.valueOf(methodProposal.getCompletion())); // declaring type String declaringType= extractDeclaringTypeFQN(methodProposal); declaringType= Signature.getSimpleName(declaringType); item.setDetail(declaringType); }
/** * Get completion items list for struct fields. * * @param structFields List of struct fields * @return {@link List} List of completion items for the struct fields */ public static List<CompletionItem> getStructFieldCompletionItems(List<BField> structFields) { List<CompletionItem> completionItems = new ArrayList<>(); structFields.forEach(bStructField -> { StringBuilder insertText = new StringBuilder(bStructField.getName().getValue() + ": "); if (bStructField.getType() instanceof BStructureType) { insertText.append("{").append(LINE_SEPARATOR).append("\t${1}").append(LINE_SEPARATOR).append("}"); } else { insertText.append("${1:").append(getDefaultValueForType(bStructField.getType())).append("}"); } CompletionItem fieldItem = new CompletionItem(); fieldItem.setInsertText(insertText.toString()); fieldItem.setInsertTextFormat(InsertTextFormat.Snippet); fieldItem.setLabel(bStructField.getName().getValue()); fieldItem.setDetail(ItemResolverConstants.FIELD_TYPE); fieldItem.setKind(CompletionItemKind.Field); fieldItem.setSortText(Priority.PRIORITY120.toString()); completionItems.add(fieldItem); }); return completionItems; }
private static CompletionItem getImportCompletion(String label, String insertText) { CompletionItem item = new CompletionItem(); item.setLabel(label); item.setInsertText(insertText); item.setKind(CompletionItemKind.Module); item.setDetail(ItemResolverConstants.PACKAGE_TYPE); return item; } }
item.setDetail(declBuf.toString());
private void createOverrideMethodProposalLabel(CompletionProposal methodProposal, CompletionItem item) { StringBuilder nameBuffer= new StringBuilder(); // method name String name = new String(methodProposal.getName()); item.setInsertText(name); nameBuffer.append(name); // parameters nameBuffer.append('('); appendUnboundedParameterList(nameBuffer, methodProposal); nameBuffer.append(')'); nameBuffer.append(RETURN_TYPE_SEPARATOR); // return type // TODO remove SignatureUtil.fix83600 call when bugs are fixed char[] returnType= createTypeDisplayName(SignatureUtil.getUpperBound(Signature.getReturnType(SignatureUtil.fix83600(methodProposal.getSignature())))); nameBuffer.append(returnType); item.setLabel(nameBuffer.toString()); item.setFilterText(name); // declaring type StringBuilder typeBuffer = new StringBuilder(); String declaringType= extractDeclaringTypeFQN(methodProposal); declaringType= Signature.getSimpleName(declaringType); typeBuffer.append(String.format("Override method in '%s'", declaringType)); item.setDetail(typeBuffer.toString()); setSignature(item, String.valueOf(methodProposal.getSignature())); setDeclarationSignature(item, String.valueOf(methodProposal.getDeclarationSignature())); setName(item, String.valueOf(methodProposal.getName())); }
private CompletionItem getMatchFieldSnippetCompletion(String snippet, String label) { CompletionItem completionItem = new CompletionItem(); completionItem.setInsertText(snippet); completionItem.setLabel(label); completionItem.setInsertTextFormat(InsertTextFormat.Snippet); completionItem.setDetail(ItemResolverConstants.SNIPPET_TYPE); completionItem.setKind(CompletionItemKind.Snippet); return completionItem; } }
/** * Populate a completion item with the given data and return it. * * @param insertText insert text * @param type type of the completion item * @param label completion item label * @return {@link CompletionItem} Populated Completion Item */ private CompletionItem populateCompletionItem(String insertText, String type, String label) { CompletionItem completionItem = new CompletionItem(); completionItem.setInsertText(insertText); completionItem.setDetail(type); completionItem.setLabel(label); completionItem.setKind(CompletionItemKind.Keyword); return completionItem; } }
/** * Get the completion item to fill all the struct fields. * * @param fields List of struct fields * @return {@link CompletionItem} Completion Item to fill all the options */ public static CompletionItem getFillAllStructFieldsItem(List<BField> fields) { List<String> fieldEntries = new ArrayList<>(); fields.forEach(bStructField -> { String defaultFieldEntry = bStructField.getName().getValue() + UtilSymbolKeys.PKG_DELIMITER_KEYWORD + " " + getDefaultValueForType(bStructField.getType()); fieldEntries.add(defaultFieldEntry); }); String insertText = String.join(("," + LINE_SEPARATOR), fieldEntries); String label = "Add All Attributes"; CompletionItem completionItem = new CompletionItem(); completionItem.setLabel(label); completionItem.setInsertText(insertText); completionItem.setDetail(ItemResolverConstants.NONE); completionItem.setKind(CompletionItemKind.Property); completionItem.setSortText(Priority.PRIORITY110.toString()); return completionItem; }
/** * Create a given completionItem's insert text. * * @param completionItem CompletionItem to modify * @param isSnippetSupported Whether snippet is expected or plain text expected * @return modified Completion Item */ public CompletionItem build(CompletionItem completionItem, boolean isSnippetSupported) { if (isSnippetSupported) { completionItem.setInsertText(this.snippet); completionItem.setInsertTextFormat(InsertTextFormat.Snippet); } else { completionItem.setInsertText(getPlainTextSnippet()); completionItem.setInsertTextFormat(InsertTextFormat.PlainText); } if (!label.isEmpty()) { completionItem.setLabel(label); } if (!detail.isEmpty()) { completionItem.setDetail(detail); } completionItem.setKind(getKind()); return completionItem; }
/** * Sort Completion Items based on a particular criteria. * * @param ctx Completion context * @param completionItems List of initial completion items */ @Override public void sortItems(LSServiceOperationContext ctx, List<CompletionItem> completionItems) { completionItems.forEach(completionItem -> { if (completionItem.getDetail().equals(ItemResolverConstants.B_TYPE)) { completionItem.setSortText(Priority.PRIORITY150.toString()); } else if (completionItem.getDetail().equals(ItemResolverConstants.FUNCTION_TYPE) && InsertTextFormat.Snippet.equals(completionItem.getInsertTextFormat())) { completionItem.setDetail(ItemResolverConstants.SNIPPET_TYPE); completionItem.setSortText(Priority.PRIORITY120.toString()); } else if (completionItem.getDetail().equals(ItemResolverConstants.FUNCTION_TYPE)) { completionItem.setSortText(Priority.PRIORITY140.toString()); } else if (InsertTextFormat.Snippet.equals(completionItem.getInsertTextFormat())) { completionItem.setDetail(ItemResolverConstants.SNIPPET_TYPE); completionItem.setSortText(Priority.PRIORITY110.toString()); } else { completionItem.setSortText(Priority.PRIORITY130.toString()); } }); } }
private static CompletionItem createExpandedAbbr(String abbr, Range abbreviationRange, String abbreviation, String syntax, String filter, ExpandOptions expandOptions) { String expandedText = null; try { expandedText = expand(abbr, expandOptions); } catch (Exception e) { } if (expandedText != null && isExpandedTextNoise(syntax, abbr, expandedText)) { expandedText = ""; } if (expandedText != null) { CompletionItem expandedAbbr = new CompletionItem(abbr); expandedAbbr.setTextEdit( new TextEdit(abbreviationRange, escapeNonTabStopDollar(addFinalTabStop(expandedText)))); expandedAbbr.setDocumentation(replaceTabStopsWithCursors(expandedText)); expandedAbbr.setInsertTextFormat(InsertTextFormat.Snippet); expandedAbbr.setDetail("Emmet Abbreviation"); expandedAbbr.setLabel(abbreviation + (filter != null ? "|" + filter.replaceAll(",", "|") : "")); return expandedAbbr; } return null; }
/** * Get the Ballerina Constant Completion Item. * * @param symbolInfo symbol information * @param context Language Server Operation Context * @return {@link CompletionItem} completion item */ private CompletionItem getBallerinaConstantCompletionItem(SymbolInfo symbolInfo, LSContext context) { BSymbol bSymbol = symbolInfo.getScopeEntry().symbol; if (!(bSymbol instanceof BConstantSymbol)) { return null; } CompletionItem completionItem = new CompletionItem(); completionItem.setLabel(bSymbol.getName().getValue()); completionItem.setInsertText(bSymbol.getName().getValue()); completionItem.setDetail(CommonUtil.getBTypeName(((BConstantSymbol) bSymbol).literalValueType, context)); completionItem.setDocumentation(ItemResolverConstants.CONSTANT_TYPE); completionItem.setKind(CompletionItemKind.Variable); return completionItem; } }
private CompletionItem adaptItem(TextDocument doc, ICompletionProposal completion, SortKeys sortkeys) throws Exception { CompletionItem item = new CompletionItem(); item.setLabel(completion.getLabel()); item.setKind(completion.getKind()); item.setSortText(sortkeys.next()); item.setFilterText(completion.getFilterText()); item.setDetail(completion.getDetail()); if (completion.isDeprecated()) { item.setDeprecated(completion.isDeprecated()); } resolveEdits(doc, completion, item); //Warning. Its not allowed by LSP spec to resolveEdits //lazy as we used to do in the past. if (resolver!=null) { item.setData(resolver.resolveLater(completion, doc)); } else { resolveItem(doc, completion, item); } return item; }
@Test public void testRequest() throws Exception { CompletionParams p = new CompletionParams(); p.setPosition(new Position(1,1)); p.setTextDocument(new TextDocumentIdentifier("test/foo.txt")); CompletionList result = new CompletionList(); result.setIsIncomplete(true); result.setItems(new ArrayList<>()); CompletionItem item = new CompletionItem(); item.setDetail("test"); item.setDocumentation("doc"); item.setFilterText("filter"); item.setInsertText("insert"); item.setKind(CompletionItemKind.Field); result.getItems().add(item); server.expectedRequests.put("textDocument/completion", new Pair<>(p, result)); CompletableFuture<Either<List<CompletionItem>, CompletionList>> future = clientLauncher.getRemoteProxy().getTextDocumentService().completion(p); Assert.assertEquals(Either.forRight(result).toString(), future.get(TIMEOUT, TimeUnit.MILLISECONDS).toString()); client.joinOnEmpty(); }