import org.eclipse.lsp4j.SignatureInformation; //导入依赖的package包/类
private SignatureHelp constructorHelp(NewClassTree leaf) {
    Trees trees = Trees.instance(task);
    TreePath identifierPath =
            TreePath.getPath(cursor.getCompilationUnit(), leaf.getIdentifier());
    Element classElement = trees.getElement(identifierPath);
    List<ExecutableElement> candidates =
            classElement
                    .getEnclosedElements()
                    .stream()
                    .filter(member -> member.getKind() == ElementKind.CONSTRUCTOR)
                    .map(method -> (ExecutableElement) method)
                    .collect(Collectors.toList());
    List<SignatureInformation> signatures =
            candidates
                    .stream()
                    .map(member -> constructorInfo(member))
                    .collect(Collectors.toList());
    int activeSignature = candidates.indexOf(classElement);

    return new SignatureHelp(
            signatures,
            activeSignature < 0 ? null : activeSignature,
            activeParameter(leaf.getArguments()));
}
 

import org.eclipse.lsp4j.SignatureInformation; //导入依赖的package包/类
private SignatureHelp methodHelp(MethodInvocationTree leaf) {
    Trees trees = Trees.instance(task);
    TreePath methodPath = TreePath.getPath(cursor.getCompilationUnit(), leaf.getMethodSelect());
    Element methodElement = trees.getElement(methodPath);
    Name name = methodElement.getSimpleName();
    List<ExecutableElement> candidates =
            methodElement
                    .getEnclosingElement()
                    .getEnclosedElements()
                    .stream()
                    .filter(
                            member ->
                                    member.getKind() == ElementKind.METHOD
                                            && member.getSimpleName().equals(name))
                    .map(method -> (ExecutableElement) method)
                    .collect(Collectors.toList());
    List<SignatureInformation> signatures =
            candidates.stream().map(member -> methodInfo(member)).collect(Collectors.toList());
    int activeSignature = candidates.indexOf(methodElement);

    return new SignatureHelp(
            signatures,
            activeSignature < 0 ? null : activeSignature,
            activeParameter(leaf.getArguments()));
}
 

import org.eclipse.lsp4j.SignatureInformation; //导入依赖的package包/类
public SignatureHelp getSignatureHelp(IProgressMonitor monitor) {
	SignatureHelp signatureHelp = new SignatureHelp();
	response.setProposals(proposals);
	CompletionResponses.store(response);

	List<SignatureInformation> infos = new ArrayList<>();
	for (int i = 0; i < proposals.size(); i++) {
		if (!monitor.isCanceled()) {
			infos.add(this.toSignatureInformation(proposals.get(i)));
		} else {
			return signatureHelp;
		}
	}
	infos.sort((SignatureInformation a, SignatureInformation b) -> a.getParameters().size() - b.getParameters().size());
	signatureHelp.getSignatures().addAll(infos);

	return signatureHelp;
}
 

import org.eclipse.lsp4j.SignatureInformation; //导入依赖的package包/类
private SignatureInformation constructorInfo(ExecutableElement method) {
    Optional<ConstructorDoc> doc = docs.constructorDoc(docs.methodKey(method));
    Optional<String> docText =
            doc.flatMap(constructor -> Optional.ofNullable(constructor.commentText()))
                    .map(Javadocs::htmlToMarkdown)
                    .map(Javadocs::firstSentence);

    return new SignatureInformation(
            Hovers.methodSignature(method, false, true),
            docText.orElse(null),
            paramInfo(method));
}
 

import org.eclipse.lsp4j.SignatureInformation; //导入依赖的package包/类
private SignatureInformation methodInfo(ExecutableElement method) {
    Optional<MethodDoc> doc = docs.methodDoc(docs.methodKey(method));
    Optional<String> docText =
            doc.flatMap(Javadocs::commentText)
                    .map(Javadocs::htmlToMarkdown)
                    .map(Javadocs::firstSentence);

    return new SignatureInformation(
            Hovers.methodSignature(method, true, true),
            docText.orElse(null),
            paramInfo(method));
}
 

import org.eclipse.lsp4j.SignatureInformation; //导入依赖的package包/类
public SignatureInformation toSignatureInformation(CompletionProposal methodProposal) {
	SignatureInformation $ = new SignatureInformation();
	StringBuilder desription = descriptionProvider.createMethodProposalDescription(methodProposal);
	$.setLabel(desription.toString());
	$.setDocumentation(this.computeJavaDoc(methodProposal));

	char[] signature = SignatureUtil.fix83600(methodProposal.getSignature());
	char[][] parameterNames = methodProposal.findParameterNames(null);
	char[][] parameterTypes = Signature.getParameterTypes(signature);

	for (int i = 0; i < parameterTypes.length; i++) {
		parameterTypes[i] = Signature.getSimpleName(Signature.toCharArray(SignatureUtil.getLowerBound(parameterTypes[i])));
	}

	if (Flags.isVarargs(methodProposal.getFlags())) {
		int index = parameterTypes.length - 1;
		parameterTypes[index] = convertToVararg(parameterTypes[index]);
	}

	List<ParameterInformation> parameterInfos = new LinkedList<>();
	for (int i = 0; i < parameterTypes.length; i++) {
		StringBuilder builder = new StringBuilder();
		builder.append(parameterTypes[i]);
		builder.append(' ');
		builder.append(parameterNames[i]);

		parameterInfos.add(new ParameterInformation(builder.toString(), null));
	}

	$.setParameters(parameterInfos);

	return $;
}
 

import org.eclipse.lsp4j.SignatureInformation; //导入依赖的package包/类
public SignatureHelp signatureHelp(TextDocumentPositionParams position, IProgressMonitor monitor) {

		SignatureHelp help = new SignatureHelp();

		if (!preferenceManager.getPreferences(null).isSignatureHelpEnabled()) {
			return help;
		}

		try {
			ICompilationUnit unit = JDTUtils.resolveCompilationUnit(position.getTextDocument().getUri());
			final int offset = JsonRpcHelpers.toOffset(unit.getBuffer(), position.getPosition().getLine(), position.getPosition().getCharacter());
			int[] contextInfomation = getContextInfomation(unit.getBuffer(), offset);
			if (contextInfomation[0] == -1) {
				return help;
			}
			SignatureHelpRequestor collector = new SignatureHelpRequestor(unit, contextInfomation[0] + 1);

			if (offset > -1 && !monitor.isCanceled()) {
				unit.codeComplete(contextInfomation[0] + 1, collector, monitor);
				help = collector.getSignatureHelp(monitor);

				if (help != null) {
					int currentParameter = contextInfomation[1];
					List<SignatureInformation> infos = help.getSignatures();
					for (int i = 0; i < infos.size(); i++) {
						if (infos.get(i).getParameters().size() >= currentParameter + 1) {
							help.setActiveSignature(i);
							help.setActiveParameter(currentParameter);
							break;
						}
					}
				}
			}
		} catch (CoreException ex) {
			JavaLanguageServerPlugin.logException("Find signatureHelp failure ", ex);
		}
		return help;
	}
 

import org.eclipse.lsp4j.SignatureInformation; //导入依赖的package包/类
protected String _toExpectation(final SignatureHelp it) {
  String _xblockexpression = null;
  {
    int _size = it.getSignatures().size();
    boolean _tripleEquals = (_size == 0);
    if (_tripleEquals) {
      StringConcatenation _builder = new StringConcatenation();
      _builder.append("Signature index is expected to be null when no signatures are available. Was: ");
      Integer _activeSignature = it.getActiveSignature();
      _builder.append(_activeSignature);
      _builder.append(".");
      Assert.assertNull(_builder.toString(), 
        it.getActiveSignature());
      return "<empty>";
    }
    Assert.assertNotNull("Active signature index must not be null when signatures are available.", it.getActiveSignature());
    String _xifexpression = null;
    Integer _activeParameter = it.getActiveParameter();
    boolean _tripleEquals_1 = (_activeParameter == null);
    if (_tripleEquals_1) {
      _xifexpression = "<empty>";
    } else {
      _xifexpression = it.getSignatures().get((it.getActiveSignature()).intValue()).getParameters().get(
        (it.getActiveParameter()).intValue()).getLabel();
    }
    final String param = _xifexpression;
    StringConcatenation _builder_1 = new StringConcatenation();
    final Function1<SignatureInformation, String> _function = (SignatureInformation it_1) -> {
      return it_1.getLabel();
    };
    String _join = IterableExtensions.join(ListExtensions.<SignatureInformation, String>map(it.getSignatures(), _function), " | ");
    _builder_1.append(_join);
    _builder_1.append(" | ");
    _builder_1.append(param);
    _xblockexpression = _builder_1.toString();
  }
  return _xblockexpression;
}
 

import org.eclipse.lsp4j.SignatureInformation; //导入依赖的package包/类
public SignatureHelpImpl(org.eclipse.lsp4j.SignatureHelp dto) {
  activeParameter = Optional.fromNullable(dto.getActiveParameter());
  activeSignature = Optional.fromNullable(dto.getActiveSignature());
  signatureInfos = new ArrayList<>(dto.getSignatures().size());
  for (SignatureInformation SignatureInformation : dto.getSignatures()) {
    signatureInfos.add(new SignatureInfoImpl(SignatureInformation));
  }
}
 

import org.eclipse.lsp4j.SignatureInformation; //导入依赖的package包/类
public SignatureHelp() {
  ArrayList<SignatureInformation> _arrayList = new ArrayList<SignatureInformation>();
  this.signatures = _arrayList;
}
 

import org.eclipse.lsp4j.SignatureInformation; //导入依赖的package包/类
/**
 * One or more signatures.
 */
@Pure
@NonNull
public List<SignatureInformation> getSignatures() {
  return this.signatures;
}
 

import org.eclipse.lsp4j.SignatureInformation; //导入依赖的package包/类
/**
 * One or more signatures.
 */
public void setSignatures(@NonNull final List<SignatureInformation> signatures) {
  this.signatures = signatures;
}
 

import org.eclipse.lsp4j.SignatureInformation; //导入依赖的package包/类
public SignatureInfoImpl(SignatureInformation dto) {
  this.dto = dto;
}