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

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

private SignatureHelp doHelp(String file, int row, int column) throws IOException {
    TextDocumentIdentifier document = new TextDocumentIdentifier();

    document.setUri(FindResource.uri(file).toString());

    Position position = new Position();

    position.setLine(row - 1);
    position.setCharacter(column - 1);

    TextDocumentPositionParams p = new TextDocumentPositionParams();

    p.setTextDocument(document);
    p.setPosition(position);

    try {
        return server.getTextDocumentService().signatureHelp(p).get();
    } catch (InterruptedException | ExecutionException e) {
        throw new RuntimeException(e);
    }
}

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

@Test
public void testSignatureHelp_singleMethod() throws JavaModelException {
    IPackageFragment pack1 = sourceFolder.createPackageFragment("test1", false, null);
    StringBuilder buf = new StringBuilder();
    buf.append("package test1;\n");
    buf.append("public class E {\n");
    buf.append("   /** This is a method */\n");
    buf.append("   public int foo(String s) { }\n");
    buf.append("   public int bar(String s) { this.foo() }\n");
    buf.append("}\n");
    ICompilationUnit cu = pack1.createCompilationUnit("E.java", buf.toString(), false, null);

    SignatureHelp help = getSignatureHelp(cu, 4, 39);
    assertNotNull(help);
    assertEquals(help.getSignatures().size(), 1);
    assertEquals(help.getSignatures().get(0).getLabel(), "foo(String s) : int");
    assertTrue(help.getSignatures().get(0).getDocumentation().length() > 0);
}

@Test
public void testSignatureHelp_multipeMethod() throws JavaModelException {
    IPackageFragment pack1 = sourceFolder.createPackageFragment("test1", false, null);
    StringBuilder buf = new StringBuilder();
    buf.append("package test1;\n");
    buf.append("public class E {\n");
    buf.append("   public int foo(String s) { }\n");
    buf.append("   public int foo(int s) { }\n");
    buf.append("   public int foo(int s, String s) { }\n");
    buf.append("   public int bar(String s) { this.foo(2,  ) }\n");
    buf.append("}\n");
    ICompilationUnit cu = pack1.createCompilationUnit("E.java", buf.toString(), false, null);

    SignatureHelp help = getSignatureHelp(cu, 5, 42);
    assertNotNull(help);
    assertEquals(help.getSignatures().size(), 3);
    assertEquals(help.getActiveParameter(), (Integer) 1);
    assertEquals(help.getSignatures().get(help.getActiveSignature()).getLabel(), "foo(int s, String s) : int");
}

@Override
public CompletableFuture<SignatureHelp> signatureHelp(final TextDocumentPositionParams params) {
  final Function1<CancelIndicator, SignatureHelp> _function = (CancelIndicator cancelIndicator) -> {
    final URI uri = this._uriExtensions.toUri(params.getTextDocument().getUri());
    final IResourceServiceProvider serviceProvider = this.languagesRegistry.getResourceServiceProvider(uri);
    ISignatureHelpService _get = null;
    if (serviceProvider!=null) {
      _get=serviceProvider.<ISignatureHelpService>get(ISignatureHelpService.class);
    }
    final ISignatureHelpService helper = _get;
    if ((helper == null)) {
      return ISignatureHelpService.EMPTY;
    }
    final Function2<Document, XtextResource, SignatureHelp> _function_1 = (Document doc, XtextResource resource) -> {
      return helper.getSignatureHelp(doc, resource, params, cancelIndicator);
    };
    return this.workspaceManager.<SignatureHelp>doRead(uri, _function_1);
  };
  return this.requestManager.<SignatureHelp>runRead(_function);
}

private Optional<SignatureHelp> get() {
    if (cursor.getLeaf().getKind() == Tree.Kind.METHOD_INVOCATION)
        return Optional.of(methodHelp((MethodInvocationTree) cursor.getLeaf()));
    if (cursor.getLeaf().getKind() == Tree.Kind.NEW_CLASS)
        return Optional.of(constructorHelp((NewClassTree) cursor.getLeaf()));
    if (cursor.getParentPath().getLeaf().getKind() == Tree.Kind.METHOD_INVOCATION)
        return Optional.of(methodHelp((MethodInvocationTree) cursor.getParentPath().getLeaf()));
    if (cursor.getParentPath().getLeaf().getKind() == Tree.Kind.NEW_CLASS)
        return Optional.of(constructorHelp((NewClassTree) cursor.getParentPath().getLeaf()));
    else return Optional.empty();
}

@Test
public void partlyFilledIn() throws IOException {
    SignatureHelp help = doHelp("/org/javacs/example/SignatureHelp.java", 8, 39);

    assertThat(help.getSignatures(), hasSize(2));
    assertThat(help.getActiveSignature(), equalTo(1));
    assertThat(help.getActiveParameter(), equalTo(1));
}

@Test
public void constructor() throws IOException {
    SignatureHelp help = doHelp("/org/javacs/example/SignatureHelp.java", 9, 27);

    assertThat(help.getSignatures(), hasSize(1));
    assertThat(help.getSignatures().get(0).getLabel(), startsWith("SignatureHelp"));
}

@Test
public void platformConstructor() throws IOException {
    SignatureHelp help = doHelp("/org/javacs/example/SignatureHelp.java", 10, 26);

    assertThat(help.getSignatures(), not(empty()));
    assertThat(help.getSignatures().get(0).getLabel(), startsWith("ArrayList"));
    assertThat(help.getSignatures().get(0).getDocumentation(), not(nullValue()));
}

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

@Test
public void testSignatureHelp_binary() throws JavaModelException {
    IPackageFragment pack1 = sourceFolder.createPackageFragment("test1", false, null);
    StringBuilder buf = new StringBuilder();
    buf.append("package test1;\n");
    buf.append("public class E {\n");
    buf.append("   public int bar(String s) { System.out.println(  }\n");
    buf.append("}\n");
    ICompilationUnit cu = pack1.createCompilationUnit("E.java", buf.toString(), false, null);

    SignatureHelp help = getSignatureHelp(cu, 2, 50);
    assertNotNull(help);
    assertTrue(help.getSignatures().size() >= 10);
    assertTrue(help.getSignatures().get(help.getActiveSignature()).getLabel().matches("println\\(\\w+ \\w+\\) : void"));
}

@Override
public SignatureHelp getSignatureHelp(final XtextResource resource, final int offset) {
  Preconditions.<XtextResource>checkNotNull(resource, "resource");
  Preconditions.checkArgument((offset >= 0), ("offset >= 0. Was: " + Integer.valueOf(offset)));
  final EObject object = this.offsetHelper.resolveContainedElementAt(resource, offset);
  if ((object instanceof OperationCall)) {
    final String operationName = this.getOperationName(((OperationCall)object));
    boolean _isNullOrEmpty = StringExtensions.isNullOrEmpty(operationName);
    boolean _not = (!_isNullOrEmpty);
    if (_not) {
      return this.getSignatureHelp(((OperationCall)object), operationName, offset);
    }
  }
  return ISignatureHelpService.EMPTY;
}

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

@Override
public CompletableFuture<SignatureHelp> signatureHelp(TextDocumentPositionParams position) {
    LOGGER.info("signatureHelp: " + position.getTextDocument());
    return CompletableFuture.completedFuture(null);
}

static Optional<SignatureHelp> help(
        FocusedResult compiled, int line, int column, Javadocs docs) {
    long offset = compiled.compilationUnit.getLineMap().getPosition(line, column);

    return compiled.cursor.flatMap(c -> new Signatures(c, offset, compiled.task, docs).get());
}

@Test
public void signatureHelp() throws IOException {
    SignatureHelp help = doHelp("/org/javacs/example/SignatureHelp.java", 7, 36);

    assertThat(help.getSignatures(), hasSize(2));
}

@Override
public CompletableFuture<SignatureHelp> signatureHelp(
    final TextDocumentPositionParams position) {
  // TODO Auto-generated method stub
  return null;
}

@Override
public CompletableFuture<SignatureHelp> signatureHelp(TextDocumentPositionParams position) {
    logInfo(">> document/signatureHelp");
    SignatureHelpHandler handler = new SignatureHelpHandler(preferenceManager);
    return computeAsync((cc) -> handler.signatureHelp(position, toMonitor(cc)));
}

private SignatureHelp getSignatureHelp(ICompilationUnit cu, int line, int character) {
    String payload = createSignatureHelpRequest(cu, line, character);
    TextDocumentPositionParams position = getParams(payload);
    return handler.signatureHelp(position, monitor);
}

@Override
public SignatureHelp getSignatureHelp(final Document document, final XtextResource resource, final TextDocumentPositionParams params, final CancelIndicator cancelIndicator) {
  final int offset = document.getOffSet(params.getPosition());
  return this.getSignatureHelp(resource, offset);
}

@Pure
public Procedure1<? super SignatureHelp> getAssertSignatureHelp() {
  return this.assertSignatureHelp;
}

public void setAssertSignatureHelp(final Procedure1<? super SignatureHelp> assertSignatureHelp) {
  this.assertSignatureHelp = assertSignatureHelp;
}

@Override
public SignatureHelp getSignatureHelp(final XtextResource resource, final int offset) {
    return EMPTY;
}

@Override
public SignatureHelp getSignatureHelp(Document document, XtextResource resource, TextDocumentPositionParams params, CancelIndicator cancelIndicator) {
    return EMPTY;
}

@Override
public CompletableFuture<SignatureHelp> signatureHelp(TextDocumentPositionParams position) {
    throw new UnsupportedOperationException();
}

@Override
public CompletableFuture<SignatureHelp> signatureHelp(TextDocumentPositionParams position) {
  return null;
}

protected String toExpectation(final Object it) {
  if (it instanceof Integer) {
    return _toExpectation((Integer)it);
  } else if (it instanceof List) {
    return _toExpectation((List<?>)it);
  } else if (it instanceof DocumentHighlightKind) {
    return _toExpectation((DocumentHighlightKind)it);
  } else if (it instanceof String) {
    return _toExpectation((String)it);
  } else if (it == null) {
    return _toExpectation((Void)null);
  } else if (it instanceof Map) {
    return _toExpectation((Map<Object, Object>)it);
  } else if (it instanceof CodeLens) {
    return _toExpectation((CodeLens)it);
  } else if (it instanceof ColoringInformation) {
    return _toExpectation((ColoringInformation)it);
  } else if (it instanceof Command) {
    return _toExpectation((Command)it);
  } else if (it instanceof CompletionItem) {
    return _toExpectation((CompletionItem)it);
  } else if (it instanceof DocumentHighlight) {
    return _toExpectation((DocumentHighlight)it);
  } else if (it instanceof Hover) {
    return _toExpectation((Hover)it);
  } else if (it instanceof Location) {
    return _toExpectation((Location)it);
  } else if (it instanceof Position) {
    return _toExpectation((Position)it);
  } else if (it instanceof Range) {
    return _toExpectation((Range)it);
  } else if (it instanceof SignatureHelp) {
    return _toExpectation((SignatureHelp)it);
  } else if (it instanceof SymbolInformation) {
    return _toExpectation((SymbolInformation)it);
  } else if (it instanceof TextEdit) {
    return _toExpectation((TextEdit)it);
  } else if (it instanceof WorkspaceEdit) {
    return _toExpectation((WorkspaceEdit)it);
  } else if (it instanceof Either) {
    return _toExpectation((Either<?, ?>)it);
  } else {
    throw new IllegalArgumentException("Unhandled parameter types: " +
      Arrays.<Object>asList(it).toString());
  }
}

/**
 * The signature help request is sent from the client to the server to
 * request signature information at a given cursor position.
 * 
 * Registration Options: SignatureHelpRegistrationOptions
 */
@JsonRequest
CompletableFuture<SignatureHelp> signatureHelp(TextDocumentPositionParams position);

/**
 * Returns with a {@link SignatureHelp signature help} instance for a
 * resource at a given offset. This method never returns with {@code null}.
 * 
 * @param resource
 *            the resource to extract the help for a method/operation
 *            signature.
 * @param offset
 *            the offset of the cursor in the resource.
 * 
 * @return a signature help instance.
 */
@Deprecated
SignatureHelp getSignatureHelp(final XtextResource resource, final int offset);

/**
 * The signature help request is sent from the client to the server to
 * request signature information at a given cursor position.
 * 
 * Registration Options: SignatureHelpRegistrationOptions
 */
@JsonRequest
CompletableFuture<SignatureHelp> signatureHelp(TextDocumentPositionParams position);

/**
 * GWT client implementation of {@link
 * TextDocumentService#signatureHelp(TextDocumentPositionParams)}
 *
 * @param params
 * @return
 */
public Promise<SignatureHelp> signatureHelp(TextDocumentPositionParams params) {
  return transmitDtoAndReceiveDto(params, "textDocument/signatureHelp", SignatureHelp.class);
}

SignatureHelp getSignatureHelp(Document document, XtextResource resource, TextDocumentPositionParams params, CancelIndicator cancelIndicator);