import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
@Override
public List<CompletionItem> apply(CamelCatalog catalog) {
	Stream<EndpointOptionModel> endpointOptions = ModelHelper.generateComponentModel(catalog.componentJSonSchema(camelComponentName), true).getEndpointOptions().stream();
	return endpointOptions
			.filter(endpoint -> "parameter".equals(endpoint.getKind()))
			.filter(endpoint -> {
				String group = endpoint.getGroup();
				if (isProducer) {
					return !"consumer".equals(group);
				} else {
					return !"producer".equals(group);
				}
			})
			.map(parameter -> {
				CompletionItem completionItem = new CompletionItem(parameter.getName());
				String insertText = parameter.getName() + "=";
				if(parameter.getDefaultValue() != null) {
					insertText += parameter.getDefaultValue();
				}
				completionItem.setInsertText(insertText);
				return completionItem;
			})
			.collect(Collectors.toList());
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
public CompletableFuture<List<CompletionItem>> getCompletions(Position position) {
	if(textDocumentItem != null) {
		try {
			Node correspondingCamelNode = parserFileHelper.getCorrespondingCamelNodeForCompletion(textDocumentItem, position.getLine());
			if (correspondingCamelNode != null) {
				String line = parserFileHelper.getLine(textDocumentItem, position);
				String camelComponentUri = parserFileHelper.getCamelComponentUri(textDocumentItem, position);
				CamelURIInstance camelURIInstance = new CamelURIInstance(camelComponentUri, correspondingCamelNode);
				int positionInCamelUri = position.getCharacter() - line.indexOf("uri=") - 5;
				CamelUriElementInstance camelUriElementInstance = camelURIInstance.getSpecificElement(positionInCamelUri);
				return camelUriElementInstance.getCompletions(camelCatalog, positionInCamelUri);
			}
		} catch (Exception e) {
			LOGGER.error("Error searching for corresponding node elements", e);
		}
	}
	return CompletableFuture.completedFuture(Collections.emptyList());
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
@Test
public void testChangeEventUpdatesStoredText() throws Exception {
	CamelLanguageServer camelLanguageServer = initializeLanguageServer("<to uri=\"\" xmlns=\"http://camel.apache.org/schema/blueprint\"></to>\n");
	
	DidChangeTextDocumentParams changeEvent = new DidChangeTextDocumentParams();
	VersionedTextDocumentIdentifier textDocument = new VersionedTextDocumentIdentifier();
	textDocument.setUri(DUMMY_URI);
	changeEvent.setTextDocument(textDocument);
	TextDocumentContentChangeEvent contentChange = new TextDocumentContentChangeEvent("<to xmlns=\"http://camel.apache.org/schema/blueprint\" uri=\"\"></to>\n");
	changeEvent.setContentChanges(Collections.singletonList(contentChange));
	camelLanguageServer.getTextDocumentService().didChange(changeEvent);
	
	//check old position doesn't provide completion
	CompletableFuture<Either<List<CompletionItem>, CompletionList>> completionsAtOldPosition = getCompletionFor(camelLanguageServer, new Position(0, 11));
	assertThat(completionsAtOldPosition.get().getLeft()).isEmpty();
	
	//check new position provides completion
	CompletableFuture<Either<List<CompletionItem>, CompletionList>> completionsAtNewPosition = getCompletionFor(camelLanguageServer, new Position(0, 58));
	assertThat(completionsAtNewPosition.get().getLeft()).isNotEmpty();
	
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
/**
 * Complete constructor with minimal type information.
 *
 * <p>This is important when we're autocompleting new ? with a class that we haven't yet
 * imported. We don't yet have detailed type information or javadocs, and it's expensive to
 * retrieve them. So we autocomplete a minimal constructor, and let signature-help fill in the
 * details.
 */
private CompletionItem completeConstructor(
        String packageName, String className, boolean hasTypeParameters) {
    CompletionItem item = new CompletionItem();
    String qualifiedName = packageName.isEmpty() ? className : packageName + "." + className;
    String key = String.format("%s#<init>", className);
    String insertText = className;

    if (hasTypeParameters) insertText += "<>";

    insertText += "($0)";

    item.setKind(CompletionItemKind.Constructor);
    item.setLabel(className);
    item.setDetail(packageName);
    item.setInsertText(insertText);
    item.setInsertTextFormat(InsertTextFormat.Snippet);
    item.setCommand(TRIGGER_SIGNATURE_HELP);
    item.setFilterText(className);
    item.setAdditionalTextEdits(addImport(qualifiedName));
    item.setSortText("3/" + className);
    item.setData(key);

    return item;
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
@Test
public void addImport() {
    String file = "/org/javacs/example/AutocompleteOther.java";

    // Name of class
    List<? extends CompletionItem> items = items(file, 9, 17);

    for (CompletionItem item : items) {
        if ("ArrayList".equals(item.getLabel())) {
            assertThat(item.getAdditionalTextEdits(), not(nullValue()));
            assertThat(item.getAdditionalTextEdits(), not(empty()));

            return;
        }
    }

    fail("No ArrayList in " + items);
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
@Test
public void dontImportSamePackage() {
    String file = "/org/javacs/example/AutocompleteOther.java";

    // Name of class
    List<? extends CompletionItem> items = items(file, 6, 10);

    for (CompletionItem item : items) {
        if ("AutocompleteMember".equals(item.getLabel())) {
            assertThat(item.getAdditionalTextEdits(), either(empty()).or(nullValue()));

            return;
        }
    }

    fail("No AutocompleteMember in " + items);
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
@Test
public void dontImportJavaLang() {
    String file = "/org/javacs/example/AutocompleteOther.java";

    // Name of class
    List<? extends CompletionItem> items = items(file, 11, 38);

    for (CompletionItem item : items) {
        if ("ArrayIndexOutOfBoundsException".equals(item.getLabel())) {
            assertThat(item.getAdditionalTextEdits(), either(empty()).or(nullValue()));

            return;
        }
    }

    fail("No ArrayIndexOutOfBoundsException in " + items);
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
@Test
public void dontImportSelf() {
    String file = "/org/javacs/example/AutocompleteOther.java";

    // Name of class
    List<? extends CompletionItem> items = items(file, 6, 10);

    for (CompletionItem item : items) {
        if ("AutocompleteOther".equals(item.getLabel())) {
            assertThat(item.getAdditionalTextEdits(), either(empty()).or(nullValue()));

            return;
        }
    }

    fail("No AutocompleteOther in " + items);
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
@Test
public void dontImportAlreadyImported() {
    String file = "/org/javacs/example/AutocompleteOther.java";

    // Name of class
    List<? extends CompletionItem> items = items(file, 12, 14);

    for (CompletionItem item : items) {
        if ("Arrays".equals(item.getLabel())) {
            assertThat(item.getAdditionalTextEdits(), either(empty()).or(nullValue()));

            return;
        }
    }

    fail("No Arrays in " + items);
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
@Test
public void dontImportAlreadyImportedStar() {
    String file = "/org/javacs/example/AutocompleteOther.java";

    // Name of class
    List<? extends CompletionItem> items = items(file, 10, 26);

    for (CompletionItem item : items) {
        if ("ArrayBlockingQueue".equals(item.getLabel())) {
            assertThat(item.getAdditionalTextEdits(), either(empty()).or(nullValue()));

            return;
        }
    }

    fail("No ArrayBlockingQueue in " + items);
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
@Test
public void autoImportConstructor() throws IOException {
    String file = "/org/javacs/example/AutocompleteConstructor.java";

    // Static methods
    List<? extends CompletionItem> items = items(file, 6, 19);
    List<String> suggestions = Lists.transform(items, i -> i.getInsertText());

    assertThat(suggestions, hasItems("ArrayList<>($0)"));

    for (CompletionItem each : items) {
        if (each.getInsertText().equals("ArrayList<>"))
            assertThat(
                    "new ? auto-imports",
                    each.getAdditionalTextEdits(),
                    both(not(empty())).and(not(nullValue())));
    }
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
@Test
public void importClass() throws IOException {
    String file = "/org/javacs/example/AutocompletePackage.java";

    // Static methods
    List<? extends CompletionItem> items = items(file, 4, 25);
    List<String> suggestions = Lists.transform(items, i -> i.getLabel());

    assertThat(suggestions, hasItems("OtherPackagePublic"));
    assertThat(suggestions, not(hasItems("OtherPackagePrivate")));

    for (CompletionItem item : items) {
        if (item.getLabel().equals("OtherPackagePublic"))
            assertThat(
                    "Don't import when completing imports",
                    item.getAdditionalTextEdits(),
                    either(empty()).or(nullValue()));
    }
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
@Test
public void otherPackageId() throws IOException {
    String file = "/org/javacs/example/AutocompleteOtherPackage.java";

    // Static methods
    List<? extends CompletionItem> items = items(file, 5, 14);
    List<String> suggestions = Lists.transform(items, i -> i.getLabel());

    assertThat(suggestions, hasItems("OtherPackagePublic"));
    assertThat(suggestions, not(hasItems("OtherPackagePrivate")));

    for (CompletionItem item : items) {
        if (item.getLabel().equals("OtherPackagePublic"))
            assertThat(
                    "Auto-import OtherPackagePublic",
                    item.getAdditionalTextEdits(),
                    not(empty()));
    }
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
public synchronized void getCompletions(final SSymbol name,
    final Set<CompletionItem> results) {
  for (Variable v : variables) {
    matchAndAdd(name, v.name, results, CompletionItemKind.Variable);
  }

  for (SInvokable m : methods) {
    matchAndAdd(name, m.getSignature(), results, CompletionItemKind.Method);
  }

  for (SlotDefinition s : slots) {
    matchAndAdd(name, s.getName(), results, CompletionItemKind.Field);
  }

  for (MixinDefinition c : classes) {
    matchAndAdd(name, c.getName(), results, CompletionItemKind.Class);
    matchAndAdd(name, c.getPrimaryFactorySelector(), results,
        CompletionItemKind.Constructor);
  }
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
void createTypeProposalLabel(char[] fullName, CompletionItem item) {
	// only display innermost type name as type name, using any
	// enclosing types as qualification
	int qIndex= findSimpleNameStart(fullName);

	String name = new String(fullName, qIndex, fullName.length - qIndex);
	StringBuilder nameBuffer= new StringBuilder();
	nameBuffer.append(name);
	if (qIndex > 0) {
		nameBuffer.append(PACKAGE_NAME_SEPARATOR);
		nameBuffer.append(new String(fullName,0,qIndex-1));
	}
	item.setFilterText(name);
	item.setInsertText(name);
	item.setLabel(nameBuffer.toString());
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
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));
	}
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
@Test public void testRequest() throws Exception {
	
	TextDocumentPositionParams p = new TextDocumentPositionParams();
	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();
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
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));
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
Either<List<CompletionItem>, CompletionList> completion(TextDocumentPositionParams position,
		IProgressMonitor monitor) {
	List<CompletionItem> completionItems = null;
	try {
		ICompilationUnit unit = JDTUtils.resolveCompilationUnit(position.getTextDocument().getUri());
		completionItems = this.computeContentAssist(unit,
				position.getPosition().getLine(),
				position.getPosition().getCharacter(), monitor);
	} catch (OperationCanceledException ignorable) {
		// No need to pollute logs when query is cancelled
		monitor.setCanceled(true);
	} catch (Exception e) {
		JavaLanguageServerPlugin.logException("Problem with codeComplete for " +  position.getTextDocument().getUri(), e);
		monitor.setCanceled(true);
	}
	CompletionList $ = new CompletionList();
	if (monitor.isCanceled()) {
		$.setIsIncomplete(true);
		completionItems = null;
		JavaLanguageServerPlugin.logInfo("Completion request cancelled");
	} else {
		JavaLanguageServerPlugin.logInfo("Completion request completed");
	}
	$.setItems(completionItems == null ? Collections.emptyList() : completionItems);
	return Either.forRight($);
}
 

import org.eclipse.lsp4j.CompletionItem; //导入依赖的package包/类
@Override
public CompletableFuture<Either<List<CompletionItem>, CompletionList>> completion(TextDocumentPositionParams position) {
	logInfo(">> document/completion");
	CompletionHandler handler = new CompletionHandler();
	final IProgressMonitor[] monitors = new IProgressMonitor[1];
	CompletableFuture<Either<List<CompletionItem>, CompletionList>> result = computeAsync((cc) -> {
		monitors[0] = toMonitor(cc);
		if (Boolean.getBoolean(JAVA_LSP_JOIN_ON_COMPLETION)) {
			try {
				Job.getJobManager().join(DocumentLifeCycleHandler.DOCUMENT_LIFE_CYCLE_JOBS, monitors[0]);
			} catch (OperationCanceledException ignorable) {
				// No need to pollute logs when query is cancelled
			} catch (InterruptedException e) {
				JavaLanguageServerPlugin.logException(e.getMessage(), e);
			}
		}
		return handler.completion(position, monitors[0]);
	});
	result.join();
	if (monitors[0].isCanceled()) {
		result.cancel(true);
	}
	return result;
}