Declare parameters with the types Jython converts them to

Jython hands scripts Python values for strings, numbers and booleans
(e.g. a java.lang.String becomes a unicode, whose Java methods fail),
and array.array for arrays. Declaring them so, Jython's analysis no
longer offers Java members that fail at run time (e.g.
name.toUpperCase), and jedi sees the same types as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: gselzer

src/main/java/org/scijava/plugins/scripting/jython/JythonDialect.java

@@ -28,6 +28,7 @@
  */
 package org.scijava.plugins.scripting.jython;
 
+import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -37,13 +38,15 @@
 import org.scijava.code.lsp.script.ScriptDialect;
 
 /**
- * How Jython scripts see their script parameters: as the Java objects
- * themselves (primitives boxed), e.g. {@code net.imglib2.img.Img}.
+ * How Jython scripts see their script parameters: as the Python values Jython
+ * converts them to (e.g. {@code str} for strings, {@code int} for integers,
+ * {@code array.array} for arrays), or else as the Java objects themselves
+ * (e.g. {@code net.imglib2.img.Img}).
  * <p>
- * Each is declared as an instance of its class, in code both Jython's own
+ * Each is declared as an instance of its type, in code both Jython's own
  * analysis (Python 2) and a Python language server knowing the Java packages
  * from stubs (see {@link JavaStubs}) read: e.g. {@code import net.imglib2.img;
- * image = net.imglib2.img.Img()}. (Arrays are lists.)
+ * image = net.imglib2.img.Img(); name = str()}.
  * </p>
  *
  * @author Gabriel Selzer
@@ -52,13 +55,20 @@ class JythonDialect implements ScriptDialect {
 
 	@Override
 	public String runtimeType(final Class<?> type) {
-		return boxed(type).getName();
+		final Class<?> t = boxed(type);
+		// NB: As Jython converts them (Py.java2py).
+		if (t == String.class || t == Character.class) return "str";
+		if (t == Integer.class || t == Long.class || t == Short.class ||
+			t == Byte.class || t == BigInteger.class) return "int";
+		if (t == Double.class || t == Float.class) return "float";
+		if (t == Boolean.class) return "bool";
+		if (t.isArray()) return "array.array";
+		return t.getName();
 	}
 
 	@Override
 	public String declare(final String name, final String type) {
-		return name + " = " + (type.startsWith("[") ? "list" : type.replace('$',
-			'.')) + "()";
+		return name + " = " + type.replace('$', '.') + "()";
 	}
 
 	@Override
@@ -68,17 +78,20 @@ public List<String> imports(final Collection<String> types) {
 		return imports;
 	}
 
-	/** The Java packages of the given types that a declaration refers to. */
+	/**
+	 * The packages or modules of the given types that a declaration refers to
+	 * (none for builtins, e.g. {@code str}).
+	 */
 	static Set<String> packages(final Collection<String> types) {
 		final Set<String> packages = new TreeSet<>();
 		for (final String t : types) {
-			if (!t.startsWith("[") && t.lastIndexOf('.') > 0) packages.add(t
-				.substring(0, t.lastIndexOf('.')));
+			if (t.lastIndexOf('.') > 0) packages.add(t.substring(0, t.lastIndexOf(
+				'.')));
 		}
 		return packages;
 	}
 
-	/** Maps primitive types to their wrappers, whose members can be listed. */
+	/** Maps primitive types to their wrappers. */
 	private static Class<?> boxed(final Class<?> type) {
 		if (!type.isPrimitive()) return type;
 		if (type == int.class) return Integer.class;

src/test/java/org/scijava/plugins/scripting/jython/JythonCompletionTest.java

@@ -140,13 +140,16 @@ public void testScriptParameters() {
 			"#@ NoSuchType mystery\n";
 		assertTrue(complete(header + "x = na").contains("name"));
 		assertTrue(complete(header + "myst").contains("mystery"));
-		final List<String> nameMembers = complete(header + "name.toUpp");
-		assertTrue("expected name.toUpperCase among " + nameMembers, nameMembers
-			.contains("name.toUpperCase"));
+		// As the Python values Jython converts them to: e.g. strings are str,
+		// whose members are Python's, not java.lang.String's.
+		final List<String> nameMembers = complete(header + "name.upp");
+		assertTrue("expected name.upper among " + nameMembers, nameMembers
+			.contains("name.upper"));
+		assertTrue(complete(header + "name.toUpp").isEmpty());
 		// Outputs are known too, even before the script assigns them.
-		assertTrue(complete(header + "greeting.len").contains("greeting.length"));
-		// Primitive parameters complete as their wrapper type.
-		assertTrue(complete(header + "count.intV").contains("count.intValue"));
+		assertTrue(complete(header + "greeting.st").contains("greeting.strip"));
+		// Numbers are int, not java.lang.Integer.
+		assertFalse(complete(header + "count.intV").contains("count.intValue"));
 	}
 
 	@Test

src/test/java/org/scijava/plugins/scripting/jython/JythonServerCompletionTest.java

@@ -120,16 +120,21 @@ public void testDeclarations() {
 		final JythonDialect dialect = new JythonDialect();
 		assertEquals("img = net.imglib2.img.Img()", dialect.declare("img",
 			"net.imglib2.img.Img"));
-		assertEquals("n = java.lang.Integer()", dialect.declare("n", dialect
-			.runtimeType(int.class)));
+		// As Jython converts them: e.g. strings and numbers to Python's.
+		assertEquals("str", dialect.runtimeType(String.class));
+		assertEquals("int", dialect.runtimeType(int.class));
+		assertEquals("int", dialect.runtimeType(Long.class));
+		assertEquals("float", dialect.runtimeType(double.class));
+		assertEquals("bool", dialect.runtimeType(boolean.class));
+		assertEquals("array.array", dialect.runtimeType(double[].class));
+		assertEquals("java.math.BigDecimal", dialect.runtimeType(
+			java.math.BigDecimal.class));
+		assertEquals("n = int()", dialect.declare("n", "int"));
 		assertEquals("e = java.util.Map.Entry()", dialect.declare("e",
 			"java.util.Map$Entry"));
-		assertEquals("a = list()", dialect.declare("a", dialect.runtimeType(
-			double[].class)));
-		assertEquals(Arrays.asList("import java.lang", "import java.util",
+		assertEquals(Arrays.asList("import array", "import java.util",
 			"import net.imglib2.img"), dialect.imports(Arrays.asList(
-				"net.imglib2.img.Img", "java.lang.String", "java.util.Map$Entry",
-				"[D")));
+				"net.imglib2.img.Img", "str", "java.util.Map$Entry", "array.array")));
 		assertTrue(JythonServerPlugin.isJython(jython));
 	}
 }