Follow scijava-code-lsp's ScriptDialect.header

The dialect writes its imports and declarations in one header line, and
names the packages it imports only for them, to hide from completion.

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

Author: gselzer

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

@@ -32,6 +32,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
 
@@ -41,10 +42,11 @@
 import org.scijava.script.ScriptLanguage;
 
 /**
- * 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}).
+ * Describes how to turn Jython scripts into plain Jython code. Scripts see
+ * their 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 type, in code both Jython's own
  * analysis (Python 2) and a Python language server knowing the Java packages
@@ -68,7 +70,36 @@ public String languageId() {
 	}
 
 	@Override
-	public String parameterType(final Class<?> type) {
+	public Header header(final Map<String, Class<?>> parameters) {
+		// Declare each parameter as an instance of its type, for type reasoning
+		final List<String> types = new ArrayList<>();
+		final List<String> declarations = new ArrayList<>();
+		parameters.forEach((name, type) -> {
+			final String t = parameterType(type);
+			types.add(t);
+			declarations.add(name + " = " + t.replace('$', '.') + "()");
+		});
+		// And import the packages of those types, before the declarations
+		final List<String> code = new ArrayList<>();
+		final Set<String> hidden = new TreeSet<>();
+		for (final String p : packages(types)) {
+			code.add("import " + p);
+			// NB: "import a.b" binds a.
+			hidden.add(p.split("\\.")[0]);
+		}
+		code.addAll(declarations);
+		// Combine into a Header
+		return new Header(String.join("; ", code), hidden);
+	}
+
+	/**
+	 * @param type the Java type (of a SciJava Script parameter) declared in the
+	 *          script
+	 * @return the type of the object given to the script by Jython: a Python
+	 *         type for the values Jython converts (e.g. {@code str}), or else
+	 *         the Java type itself
+	 */
+	static String parameterType(final Class<?> type) {
 		final Class<?> t = boxed(type);
 		// NB: As Jython converts them (Py.java2py).
 		if (t == String.class || t == Character.class) return "str";
@@ -80,25 +111,6 @@ public String parameterType(final Class<?> type) {
 		return t.getName();
 	}
 
-	@Override
-	public String declare(final String name, final String type) {
-		return name + " = " + type.replace('$', '.') + "()";
-	}
-
-	@Override
-	public List<String> imports(final Collection<String> types) {
-		final List<String> imports = new ArrayList<>();
-		for (final String p : packages(types)) imports.add("import " + p);
-		return imports;
-	}
-
-	@Override
-	public String imported(final String statement) {
-		// NB: "import a.b" binds a.
-		return statement.startsWith("import ") ? statement.substring(7).split(
-			"[.\\s]")[0] : null;
-	}
-
 	/**
 	 * The packages or modules of the given types that a declaration refers to
 	 * (none for builtins, e.g. {@code str}).

src/test/java/org/scijava/plugins/scripting/jython/completion/JythonDialectTest.java

@@ -33,7 +33,9 @@
 import static org.junit.Assert.assertTrue;
 
 import java.util.Arrays;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
@@ -43,6 +45,7 @@
 import org.junit.Test;
 import org.scijava.Context;
 import org.scijava.code.lsp.LanguageServerService;
+import org.scijava.code.lsp.ScriptDialect.Header;
 import org.scijava.code.lsp.ScriptSession;
 import org.scijava.script.ScriptLanguage;
 import org.scijava.script.ScriptService;
@@ -80,26 +83,37 @@ public void testScriptsAreServed() {
 	}
 
 	@Test
-	public void testDeclarations() {
-		final JythonDialect dialect = new JythonDialect();
-		assertEquals("img = net.imglib2.img.Img()", dialect.declare("img",
-			"net.imglib2.img.Img"));
+	public void testParameterType() {
 		// As Jython converts them: e.g. strings and numbers to Python's.
-		assertEquals("str", dialect.parameterType(String.class));
-		assertEquals("int", dialect.parameterType(int.class));
-		assertEquals("int", dialect.parameterType(Long.class));
-		assertEquals("float", dialect.parameterType(double.class));
-		assertEquals("bool", dialect.parameterType(boolean.class));
-		assertEquals("array.array", dialect.parameterType(double[].class));
-		assertEquals("java.math.BigDecimal", dialect.parameterType(
+		assertEquals("str", JythonDialect.parameterType(String.class));
+		assertEquals("int", JythonDialect.parameterType(int.class));
+		assertEquals("int", JythonDialect.parameterType(Long.class));
+		assertEquals("float", JythonDialect.parameterType(double.class));
+		assertEquals("bool", JythonDialect.parameterType(boolean.class));
+		assertEquals("array.array", JythonDialect.parameterType(
+			double[].class));
+		// Or else as the Java objects themselves.
+		assertEquals("java.math.BigDecimal", JythonDialect.parameterType(
 			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(Arrays.asList("import array", "import java.util",
-			"import net.imglib2.img"), dialect.imports(Arrays.asList(
-				"net.imglib2.img.Img", "str", "java.util.Map$Entry", "array.array")));
-		assertEquals("net", dialect.imported("import net.imglib2.img"));
+	}
+
+	@Test
+	public void testHeader() {
+		// Each parameter is declared as an instance of its type, whose package
+		// is imported.
+		final Map<String, Class<?>> parameters = new LinkedHashMap<>();
+		parameters.put("d", java.math.BigDecimal.class);
+		parameters.put("n", int.class);
+		parameters.put("e", Map.Entry.class);
+		parameters.put("a", double[].class);
+		final Header header = new JythonDialect().header(parameters);
+		assertEquals("import array; import java.math; import java.util; " +
+			"d = java.math.BigDecimal(); n = int(); " +
+			"e = java.util.Map.Entry(); a = array.array()", header.code());
+		// The names the imports bind ("import a.b" binds a) are the header's
+		// alone.
+		assertEquals(Arrays.asList("array", "java"), Arrays.asList(header
+			.hiddenNames().toArray()));
 	}
 
 	@Test