WIP: polish

Signed-off-by: BoykoAlex <alex.boyko@broadcom.com>

Author: BoykoAlex

headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/beans/BeanCompletionProposal.java

@@ -16,7 +16,6 @@
 import java.util.function.Supplier;
 
 import org.apache.commons.text.similarity.JaroWinklerSimilarity;
-import org.checkerframework.checker.signature.qual.FullyQualifiedName;
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.Assignment;
@@ -32,11 +31,11 @@
 import org.eclipse.text.edits.InsertEdit;
 import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.text.edits.TextEdit;
-import org.openrewrite.java.tree.JavaType;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.ide.vscode.boot.java.handlers.BootJavaCompletionEngine;
 import org.springframework.ide.vscode.boot.java.jdt.refactoring.InjectBeanConstructorRefactoring;
+import org.springframework.ide.vscode.boot.java.jdt.refactoring.JavaType;
 import org.springframework.ide.vscode.commons.java.IJavaProject;
 import org.springframework.ide.vscode.commons.languageserver.completion.DocumentEdits;
 import org.springframework.ide.vscode.commons.languageserver.completion.ICompletionProposalWithScore;
@@ -58,7 +57,7 @@ public class BeanCompletionProposal implements ICompletionProposalWithScore {
 	private IDocument doc;
 	private IJavaProject project;
 	private String beanId;
-	private String beanType;
+	private JavaType beanType;
 	private String fieldName;
 	private String className;
 	private double score;
@@ -75,7 +74,7 @@ public BeanCompletionProposal(ASTNode node, int offset, IDocument doc, IJavaProj
 		this.doc = doc;
 		this.project = project;
 		this.beanId = beanId;
-		this.beanType = beanType;
+		this.beanType = JavaType.parse(beanType);
 		this.fieldName = fieldName;
 		this.className = className;
 		this.prefix = computePrefix();
@@ -172,7 +171,7 @@ public String getDetail() {
 	public CompletionItemLabelDetails getLabelDetails() {
 		CompletionItemLabelDetails labelDetails = new CompletionItemLabelDetails();
 		labelDetails.setDetail(SHORT_DESCRIPTION);
-//		labelDetails.setDescription(((FullyQualifiedName) JavaType.parse(beanType)).getSimpleName());
+		labelDetails.setDescription(beanType.getDisplayName());
 		return labelDetails;
 	}
 

headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/jdt/refactoring/ArrayTypeName.java

@@ -11,6 +11,7 @@
 package org.springframework.ide.vscode.boot.java.jdt.refactoring;
 
 import java.util.List;
+import java.util.Objects;
 
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.Type;
@@ -73,4 +74,17 @@ public String toString() {
 		return componentType + "[]".repeat(dimensions);
 	}
 
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) return true;
+		if (o == null || getClass() != o.getClass()) return false;
+		ArrayTypeName that = (ArrayTypeName) o;
+		return dimensions == that.dimensions && componentType.equals(that.componentType);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(componentType, dimensions);
+	}
+
 }

headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/jdt/refactoring/ClassName.java

@@ -11,6 +11,7 @@
 package org.springframework.ide.vscode.boot.java.jdt.refactoring;
 
 import java.util.List;
+import java.util.Objects;
 
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.Type;
@@ -133,12 +134,14 @@ public boolean equals(Object o) {
 		if (this == o) return true;
 		if (o == null || getClass() != o.getClass()) return false;
 		ClassName that = (ClassName) o;
-		return getFullyQualifiedName().equals(that.getFullyQualifiedName());
+		return simpleName.equals(that.simpleName)
+				&& packageName.equals(that.packageName)
+				&& Objects.equals(declaringClass, that.declaringClass);
 	}
 
 	@Override
 	public int hashCode() {
-		return getFullyQualifiedName().hashCode();
+		return Objects.hash(packageName, simpleName, declaringClass);
 	}
 
 }

headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/jdt/refactoring/InjectBeanConstructorRefactoring.java

@@ -14,7 +14,6 @@
 import java.util.List;
 import java.util.Map;
 
-import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.Assignment;
@@ -67,52 +66,74 @@ public class InjectBeanConstructorRefactoring {
 
 	private final CompilationUnit cu;
 	private final String source;
-	private final String fullyQualifiedBeanType;
+	private final JavaType beanType;
 	private final String fieldName;
 	private final String targetClassFqName;
 	private final boolean addFieldAssignment;
 	private final Map<String, String> formatterOptions;
 
 	/**
-	 * Create a new bean constructor injection refactoring.
+	 * Create a new bean constructor injection refactoring from a pre-parsed {@link JavaType}.
+	 * <p>
+	 * Use this constructor when the caller already has a parsed {@link JavaType} instance
+	 * to avoid redundant parsing.
 	 *
-	 * @param cu                   the already-parsed {@link CompilationUnit}. The caller provides
-	 *                             it — in the completion flow it comes from the CU cache; in tests
-	 *                             it can be a simple {@code ASTParser}-created CU.
-	 * @param source               the full Java source text of the compilation unit. Required because
-	 *                             the DOM {@link CompilationUnit} does not retain the original source
-	 *                             text, and {@link ASTRewrite#rewriteAST(org.eclipse.jface.text.IDocument, Map)}
-	 *                             needs it to compute correct text edits.
-	 * @param fullyQualifiedBeanType the fully qualified type name of the bean to inject
-	 *                               (e.g. {@code "org.springframework.samples.petclinic.owner.OwnerRepository"})
+	 * @param cu                   the already-parsed {@link CompilationUnit}
+	 * @param source               the full Java source text of the compilation unit
+	 * @param beanType             the parsed type of the bean to inject
 	 * @param fieldName            the desired field name for the injected bean
 	 * @param targetClassFqName    the fully qualified name of the class to inject the bean into
 	 * @param addFieldAssignment   whether to add the {@code this.field = field} assignment
-	 *                             in the constructor body. Pass {@code false} when the caller
-	 *                             handles the assignment separately (e.g. as the primary text edit
-	 *                             in a completion proposal when the cursor is inside a constructor)
+	 *                             in the constructor body
 	 * @param formatterOptions     JavaCore formatter options controlling indentation, tab/space
-	 *                             settings, etc. These are passed directly to
-	 *                             {@link ASTRewrite#rewriteAST(org.eclipse.jface.text.IDocument, Map)}.
-	 *                             A sensible default can be obtained via {@link JavaCore#getOptions()}.
+	 *                             settings, etc.
 	 */
 	public InjectBeanConstructorRefactoring(
 			CompilationUnit cu,
 			String source,
-			String fullyQualifiedBeanType,
+			JavaType beanType,
 			String fieldName,
 			String targetClassFqName,
 			boolean addFieldAssignment,
 			Map<String, String> formatterOptions) {
 		this.cu = cu;
 		this.source = source;
-		this.fullyQualifiedBeanType = fullyQualifiedBeanType;
+		this.beanType = beanType;
 		this.fieldName = fieldName;
 		this.targetClassFqName = targetClassFqName;
 		this.addFieldAssignment = addFieldAssignment;
 		this.formatterOptions = formatterOptions;
 	}
 
+	/**
+	 * Create a new bean constructor injection refactoring from a type name string.
+	 * <p>
+	 * Convenience constructor that parses the type string into a {@link JavaType}.
+	 * Use {@code $} for inner classes (e.g. {@code "java.util.Map$Entry"}).
+	 *
+	 * @param cu                       the already-parsed {@link CompilationUnit}
+	 * @param source                   the full Java source text of the compilation unit
+	 * @param fullyQualifiedBeanType   the fully qualified type name of the bean to inject
+	 *                                 (e.g. {@code "org.springframework.samples.petclinic.owner.OwnerRepository"})
+	 * @param fieldName                the desired field name for the injected bean
+	 * @param targetClassFqName        the fully qualified name of the class to inject the bean into
+	 * @param addFieldAssignment       whether to add the {@code this.field = field} assignment
+	 *                                 in the constructor body
+	 * @param formatterOptions         JavaCore formatter options controlling indentation, tab/space
+	 *                                 settings, etc.
+	 */
+	public InjectBeanConstructorRefactoring(
+			CompilationUnit cu,
+			String source,
+			String fullyQualifiedBeanType,
+			String fieldName,
+			String targetClassFqName,
+			boolean addFieldAssignment,
+			Map<String, String> formatterOptions) {
+		this(cu, source, JavaType.parse(fullyQualifiedBeanType), fieldName, targetClassFqName,
+				addFieldAssignment, formatterOptions);
+	}
+
 	/**
 	 * Compute the JDT {@link TextEdit} representing all source modifications.
 	 *
@@ -129,35 +150,28 @@ public TextEdit computeEdit() throws Exception {
 			return null;
 		}
 
-		// Parse the (possibly parameterized) type string using the type model
-		JavaType javaType = JavaType.parse(fullyQualifiedBeanType);
-
 		// Step 1: Add private final field
-		Type fieldType = javaType.toType(ast);
+		Type fieldType = beanType.toType(ast);
 		FieldDeclaration newField = addField(rewrite, ast, targetClass, fieldType);
 
 		// Step 2: Find or create constructor and add parameter + assignment
 		MethodDeclaration constructor = findConstructor(targetClass);
 		if (constructor == null) {
-			Type ctorParamType = javaType.toType(ast);
+			Type ctorParamType = beanType.toType(ast);
 			createConstructor(rewrite, ast, targetClass, ctorParamType, newField);
 		} else {
-			Type ctorParamType = javaType.toType(ast);
+			Type ctorParamType = beanType.toType(ast);
 			addParameterToConstructor(rewrite, ast, constructor, ctorParamType);
 			if (addFieldAssignment) {
 				addFieldAssignment(rewrite, ast, constructor);
 			}
 		}
 
 		// Step 3: Add imports for all referenced class types (sorted for correct insertion order)
-		List<ClassName> classNames = javaType.getAllClassNames();
-		List<String> sortedImports = new ArrayList<>();
+		List<ClassName> classNames = new ArrayList<>(beanType.getAllClassNames());
+		classNames.sort((a, b) -> a.getFullyQualifiedName().compareTo(b.getFullyQualifiedName()));
 		for (ClassName cn : classNames) {
-			sortedImports.add(cn.getFullyQualifiedName());
-		}
-		sortedImports.sort(String::compareTo);
-		for (String fqName : sortedImports) {
-			addImport(rewrite, ast, cu, fqName);
+			addImport(rewrite, ast, cu, cn);
 		}
 
 		// Generate Eclipse TextEdit
@@ -339,23 +353,29 @@ private void addFieldAssignment(ASTRewrite rewrite, AST ast, MethodDeclaration c
 
 	// ========== Import ==========
 
-	private static void addImport(ASTRewrite rewrite, AST ast, CompilationUnit cu, String fullyQualifiedName) {
+	private static void addImport(ASTRewrite rewrite, AST ast, CompilationUnit cu, ClassName className) {
+		String packageName = className.getPackageName();
+
 		// Don't add import for java.lang types
-		if (fullyQualifiedName.startsWith("java.lang.") && fullyQualifiedName.indexOf('.', 10) == -1) {
+		if ("java.lang".equals(packageName)) {
+			return;
+		}
+
+		// Don't add import for default package types
+		if (packageName.isEmpty()) {
 			return;
 		}
 
 		// Don't add import if type is in the same package
 		if (cu.getPackage() != null) {
-			String packageName = cu.getPackage().getName().getFullyQualifiedName();
-			String typePackage = fullyQualifiedName.contains(".")
-					? fullyQualifiedName.substring(0, fullyQualifiedName.lastIndexOf('.'))
-					: "";
-			if (packageName.equals(typePackage)) {
+			String cuPackage = cu.getPackage().getName().getFullyQualifiedName();
+			if (cuPackage.equals(packageName)) {
 				return;
 			}
 		}
 
+		String fullyQualifiedName = className.getFullyQualifiedName();
+
 		// Check if import already exists
 		for (Object importObj : cu.imports()) {
 			ImportDeclaration imp = (ImportDeclaration) importObj;

headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/jdt/refactoring/JavaType.java

@@ -36,7 +36,7 @@
  *
  * @author Alex Boyko
  */
-interface JavaType {
+public interface JavaType {
 
 	/**
 	 * Returns a human-readable display name for this type using short (simple) names.

headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/jdt/refactoring/ParameterizedClassName.java

@@ -13,6 +13,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 import java.util.stream.Collectors;
 
 import org.eclipse.jdt.core.dom.AST;
@@ -115,4 +116,17 @@ public String toString() {
 		return getFullyQualifiedName();
 	}
 
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) return true;
+		if (o == null || getClass() != o.getClass()) return false;
+		ParameterizedClassName that = (ParameterizedClassName) o;
+		return erasure.equals(that.erasure) && typeArguments.equals(that.typeArguments);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(erasure, typeArguments);
+	}
+
 }

headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/jdt/refactoring/WildcardName.java

@@ -12,6 +12,7 @@
 
 import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.Type;
@@ -89,4 +90,17 @@ public String toString() {
 		return "? " + (upperBound ? "extends" : "super") + " " + bound;
 	}
 
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) return true;
+		if (o == null || getClass() != o.getClass()) return false;
+		WildcardName that = (WildcardName) o;
+		return upperBound == that.upperBound && Objects.equals(bound, that.bound);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(bound, upperBound);
+	}
+
 }