@@ -442,11 +442,10 @@ private List<Completion> convert(final JTextComponent comp,
 				text);
 			final Completion c;
 			if (params != null) {
-				final String returnType = item.getLabelDetails() == null ? null : item
-					.getLabelDetails().getDescription();
+				// NB: No return type: LSP has no field for one. The detail (e.g.
+				// the full signature) is the short description.
 				final SciJavaFunctionCompletion fc = new SciJavaFunctionCompletion(this,
-					name, returnType == null ? "" : returnType, edits);
-				fc.setReturnValueDescription(returnType == null ? "" : returnType);
+					name, null, edits);
 				fc.setShortDescription(item.getDetail());
 				fc.setDescription(description);
 				fc.setParams(rstaParams(comp, name, params, overloads.get(name)));
 
@@ -107,21 +107,32 @@ else if (c == ',' && depth == 0) {
 
 	/**
 	 * A parameter (e.g. {@code java.lang.String name}) with simple type names
-	 * ({@code String name}).
+	 * ({@code String name}). One written name first (e.g.
+	 * {@code name: str}) is kept as it is.
 	 */
 	static String simple(final String parameter) {
+		if (parameter.contains(":")) return parameter;
 		final int space = parameter.lastIndexOf(' ');
 		if (space < 0) return parameter;
 		final String type = parameter.substring(0, space);
 		return type.substring(type.lastIndexOf('.') + 1) + parameter.substring(
 			space);
 	}
 
-	/** Splits a parameter into its type (or null) and its name. */
+	/**
+	 * Splits a parameter into its type (or null) and its name: written type
+	 * first (e.g. {@code double a}) or name first (e.g. {@code a: float}), and
+	 * without a default (e.g. {@code a: float = 1.0}).
+	 */
 	static String[] typeAndName(final String parameter) {
-		final int space = parameter.lastIndexOf(' ');
-		return space < 0 ? new String[] { null, parameter } : new String[] {
-			parameter.substring(0, space).trim(), parameter.substring(space + 1) };
+		final int eq = parameter.indexOf('=');
+		final String p = (eq < 0 ? parameter : parameter.substring(0, eq)).trim();
+		final int colon = p.indexOf(':');
+		if (colon >= 0) return new String[] { p.substring(colon + 1).trim(), p
+			.substring(0, colon).trim() };
+		final int space = p.lastIndexOf(' ');
+		return space < 0 ? new String[] { null, p } : new String[] { p.substring(0,
+			space).trim(), p.substring(space + 1) };
 	}
 
 	private static String label(final String signature,
 
@@ -43,6 +43,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.BiFunction;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
 
 import javax.swing.JLabel;
 import javax.swing.JList;
@@ -52,18 +53,20 @@
 import org.eclipse.lsp4j.CompletionItemKind;
 import org.eclipse.lsp4j.CompletionList;
 import org.eclipse.lsp4j.CompletionParams;
+import org.eclipse.lsp4j.ParameterInformation;
 import org.eclipse.lsp4j.Range;
 import org.eclipse.lsp4j.SignatureHelp;
+import org.eclipse.lsp4j.SignatureInformation;
 import org.eclipse.lsp4j.TextEdit;
 import org.eclipse.lsp4j.jsonrpc.messages.Either;
 import org.fife.ui.autocomplete.Completion;
 import org.fife.ui.autocomplete.ParameterizedCompletion;
 import org.fife.ui.rsyntaxtextarea.RSyntaxTextArea;
 import org.junit.Test;
-import org.scijava.code.lsp.jvm.Callable;
 import org.scijava.code.lsp.Environment;
-import org.scijava.code.lsp.Positions;
 import org.scijava.code.lsp.jvm.AbstractInProcessLanguageServer;
+import org.scijava.code.lsp.CompletionItems;
+import org.scijava.code.lsp.Positions;
 
 /**
  * Tests that {@link SciJavaCompletionProvider} faithfully bridges a language
@@ -140,17 +143,16 @@ public void testCallablesBecomeFunctionCompletionsWithChoices() {
 
 		// A callable completion taking one ij.gui.Roi parameter; and, inside its
 		// argument list, an in-scope variable fitting it (and a method).
-		final Callable addRoi = new Callable("addRoi", Collections.singletonList(
-			new Callable.Param("roi", "ij.gui.Roi")), "void").kind(
-				CompletionItemKind.Method);
+		final CompletionItem addRoi = CompletionItems.methodSnippet("addRoi",
+			Collections.singletonList("roi"), "(ij.gui.Roi roi)");
 		final FakeServer server = new FakeServer();
 		server.complete = (doc, caret) -> {
 			if (!doc.lineTo(caret).endsWith("(")) {
-				return FakeServer.items(doc, 0, caret, addRoi.toItem());
+				return FakeServer.items(doc, 0, caret, addRoi);
 			}
 			final CompletionItem myRoi = new CompletionItem("myRoi");
 			myRoi.setKind(CompletionItemKind.Variable);
-			return FakeServer.items(doc, caret, caret, myRoi, addRoi.toItem());
+			return FakeServer.items(doc, caret, caret, myRoi, addRoi);
 		};
 		final SciJavaCompletionProvider provider = new SciJavaCompletionProvider(
 			FakeServers.session(server));
@@ -178,7 +180,7 @@ public void testCallablesRenderWithSignatures() {
 
 		final FakeServer server = new FakeServer();
 		server.complete = (doc, caret) -> FakeServer.items(doc, 0, caret, method(
-			completionText, "long[]").toItem());
+			completionText, "long[]"));
 		final SciJavaCompletionProvider provider = new SciJavaCompletionProvider(
 			FakeServers.session(server));
 
@@ -199,10 +201,10 @@ public void testParameterTooltipListsOtherOverloads() {
 
 		final FakeServer server = new FakeServer();
 		server.complete = (doc, caret) -> FakeServer.items(doc, 0, caret, //
-			method("img.getAt", "int[]").toItem(), //
-			method("img.getAt", "net.imglib2.Localizable").toItem(), //
-			method("img.getAt", "int[]").toItem(), // e.g. a bridge method
-			method("img.getAtX", "long[]").toItem());
+			method("img.getAt", "int[]"), //
+			method("img.getAt", "net.imglib2.Localizable"), //
+			method("img.getAt", "int[]"), // e.g. a bridge method
+			method("img.getAtX", "long[]"));
 		final SciJavaCompletionProvider provider = new SciJavaCompletionProvider(
 			FakeServers.session(server));
 		final List<Completion> completions = provider.getCompletionsImpl(area);
@@ -232,22 +234,20 @@ public void testParameterTooltipShowsSignatureHelp() {
 		area.setText("a");
 		area.setCaretPosition(1);
 
-		final Callable ints = method("a", "int", "int");
-		final Callable strings = method("a", "java.lang.String");
-		final Callable floats = method("a", "float", "float");
-		final Callable longs = method("a", "long", "long");
 		final String[] askedText = { null };
 		final int[] askedCaret = { -1 };
 		final FakeServer server = new FakeServer();
-		server.complete = (doc, caret) -> FakeServer.items(doc, 0, caret, ints
-			.toItem(), strings.toItem(), floats.toItem(), longs.toItem());
+		server.complete = (doc, caret) -> FakeServer.items(doc, 0, caret, method(
+			"a", "int", "int"), method("a", "java.lang.String"), method("a", "float",
+				"float"), method("a", "long", "long"));
 		server.help = (doc, caret) -> {
 			askedText[0] = doc.text();
 			askedCaret[0] = caret;
 			// The server orders the signatures, best fits first: here, as for a
 			// float typed as the first argument.
-			return new SignatureHelp(Arrays.asList(floats.toSignature(), ints
-				.toSignature(), longs.toSignature(), strings.toSignature()), 0, 1);
+			return new SignatureHelp(Arrays.asList(signature("a", "float", "float"),
+				signature("a", "int", "int"), signature("a", "long", "long"), signature(
+					"a", "java.lang.String")), 0, 1);
 		};
 		final SciJavaCompletionProvider provider = new SciJavaCompletionProvider(
 			FakeServers.session(server));
@@ -273,14 +273,12 @@ public void testParameterTooltipIgnoresOtherCalls() {
 		final RSyntaxTextArea area = new RSyntaxTextArea();
 		area.setText("a");
 		area.setCaretPosition(1);
-		final Callable ints = method("a", "int", "int");
-		final Callable floats = method("a", "float", "float");
 		final FakeServer server = new FakeServer();
-		server.complete = (doc, caret) -> FakeServer.items(doc, 0, caret, ints
-			.toItem(), floats.toItem());
+		server.complete = (doc, caret) -> FakeServer.items(doc, 0, caret, method(
+			"a", "int", "int"), method("a", "float", "float"));
 		// The caret is in a call nested in a's arguments: b's signatures.
 		server.help = (doc, caret) -> new SignatureHelp(Collections.singletonList(
-			method("b", "double").toSignature()), 0, 0);
+			signature("b", "double")), 0, 0);
 		final SciJavaCompletionProvider provider = new SciJavaCompletionProvider(
 			FakeServers.session(server));
 		final ParameterizedCompletion intOverload =
@@ -300,9 +298,8 @@ public void testLazyDescriptions() {
 		final AtomicInteger asked = new AtomicInteger();
 		final FakeServer server = new FakeServer();
 		server.complete = (doc, caret) -> FakeServer.items(doc, 3, caret, //
-			server.described(new Callable("zeros", Collections.singletonList(
-				new Callable.Param("shape", "int")), null).kind(
-					CompletionItemKind.Method).toItem(), () -> {
+			server.described(CompletionItems.methodSnippet("zeros",
+				Collections.singletonList("shape"), "(int shape)"), () -> {
 						asked.incrementAndGet();
 						return "Return a new array of zeros.";
 					}), //
@@ -413,15 +410,35 @@ public void testRequestCarriesScriptPath() {
 
 	// -- Helper methods --
 
-	private static Callable method(final String name,
+	/** A method's completion, with parameters p0, p1, ... of the types. */
+	private static CompletionItem method(final String name,
+		final String... paramTypes)
+	{
+		final List<String> names = new ArrayList<>();
+		for (int i = 0; i < paramTypes.length; i++) names.add("p" + i);
+		return CompletionItems.methodSnippet(name, names, "(" + String.join(
+			", ", params(paramTypes)) + ")");
+	}
+
+	/** A method's signature, with parameters p0, p1, ... of the types. */
+	private static SignatureInformation signature(final String name,
 		final String... paramTypes)
 	{
-		final List<Callable.Param> params = new ArrayList<>();
+		final List<String> params = params(paramTypes);
+		final SignatureInformation s = new SignatureInformation(name + "(" + String
+			.join(", ", params) + ") -> java.lang.Object");
+		s.setParameters(params.stream().map(ParameterInformation::new).collect(
+			Collectors.toList()));
+		return s;
+	}
+
+	/** E.g. {@code int p0}, {@code float p1}. */
+	private static List<String> params(final String... paramTypes) {
+		final List<String> out = new ArrayList<>();
 		for (int i = 0; i < paramTypes.length; i++) {
-			params.add(new Callable.Param("p" + i, paramTypes[i]));
+			out.add(paramTypes[i] + " p" + i);
 		}
-		return new Callable(name, params, "java.lang.Object").kind(
-			CompletionItemKind.Method);
+		return out;
 	}
 
 	/** "zeros", replacing what follows the dot, up to the end of the text. */
 
@@ -0,0 +1,68 @@
+/*
+ * #%L
+ * Script Editor and Interpreter for SciJava script languages.
+ * %%
+ * Copyright (C) 2009 - 2026 SciJava developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.ui.swing.script.autocompletion;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+/**
+ * Tests {@link SignatureLabel}'s reading of parameters, whichever way a
+ * language writes them.
+ *
+ * @author Gabriel Selzer
+ */
+public class SignatureLabelTest {
+
+	@Test
+	public void testTypeAndName() {
+		// Type first, e.g. Java's.
+		assertArrayEquals(new String[] { "java.util.Map<K, V>", "m" },
+			SignatureLabel.typeAndName("java.util.Map<K, V> m"));
+		// Name first, e.g. Python's; with or without a default.
+		assertArrayEquals(new String[] { "int | None", "indent" }, SignatureLabel
+			.typeAndName("indent: int | None = None"));
+		assertArrayEquals(new String[] { "float", "a" }, SignatureLabel
+			.typeAndName("a: float"));
+		// Untyped.
+		assertArrayEquals(new String[] { null, "kw" }, SignatureLabel.typeAndName(
+			"kw"));
+		assertArrayEquals(new String[] { null, "kw" }, SignatureLabel.typeAndName(
+			"kw=1"));
+	}
+
+	@Test
+	public void testSimple() {
+		assertEquals("String s", SignatureLabel.simple("java.lang.String s"));
+		// Name first: as it is.
+		assertEquals("p: os.PathLike", SignatureLabel.simple("p: os.PathLike"));
+	}
+}