Java 类org.eclipse.lsp4j.SignatureInformation 实例源码

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()));
}

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()));
}

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;
}

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));
}

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));
}

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 $;
}

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;
    }

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;
}

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));
  }
}

public SignatureHelp() {
  ArrayList<SignatureInformation> _arrayList = new ArrayList<SignatureInformation>();
  this.signatures = _arrayList;
}

public SignatureHelp(@NonNull final List<SignatureInformation> signatures, final Integer activeSignature, final Integer activeParameter) {
  this.signatures = signatures;
  this.activeSignature = activeSignature;
  this.activeParameter = activeParameter;
}

/**
 * One or more signatures.
 */
@Pure
@NonNull
public List<SignatureInformation> getSignatures() {
  return this.signatures;
}

/**
 * One or more signatures.
 */
public void setSignatures(@NonNull final List<SignatureInformation> signatures) {
  this.signatures = signatures;
}

public SignatureHelp() {
  ArrayList<SignatureInformation> _arrayList = new ArrayList<SignatureInformation>();
  this.signatures = _arrayList;
}

public SignatureHelp(@NonNull final List<SignatureInformation> signatures, final Integer activeSignature, final Integer activeParameter) {
  this.signatures = signatures;
  this.activeSignature = activeSignature;
  this.activeParameter = activeParameter;
}

/**
 * One or more signatures.
 */
@Pure
@NonNull
public List<SignatureInformation> getSignatures() {
  return this.signatures;
}

/**
 * One or more signatures.
 */
public void setSignatures(@NonNull final List<SignatureInformation> signatures) {
  this.signatures = signatures;
}

public SignatureInfoImpl(SignatureInformation dto) {
  this.dto = dto;
}