Fix CompletionTests_1_5.test0008 by adding provisional API

Signed-off-by: Rob Stryker <stryker@redhat.com>

Author: Rob Stryker

org.eclipse.jdt.core.javac/src/org/eclipse/jdt/internal/javac/dom/JavacTypeBinding.java

@@ -49,14 +49,15 @@
 import org.eclipse.jdt.core.dom.IMethodBinding;
 import org.eclipse.jdt.core.dom.IModuleBinding;
 import org.eclipse.jdt.core.dom.IPackageBinding;
+import org.eclipse.jdt.core.dom.ISignatureProvider;
 import org.eclipse.jdt.core.dom.ITypeBinding;
 import org.eclipse.jdt.core.dom.IVariableBinding;
 import org.eclipse.jdt.core.dom.JavacBindingResolver;
+import org.eclipse.jdt.core.dom.JavacBindingResolver.BindingKeyException;
 import org.eclipse.jdt.core.dom.MethodDeclaration;
 import org.eclipse.jdt.core.dom.Modifier;
 import org.eclipse.jdt.core.dom.RecordDeclaration;
 import org.eclipse.jdt.core.dom.TypeDeclaration;
-import org.eclipse.jdt.core.dom.JavacBindingResolver.BindingKeyException;
 import org.eclipse.jdt.internal.compiler.codegen.ConstantPool;
 import org.eclipse.jdt.internal.core.BinaryType;
 import org.eclipse.jdt.internal.core.JavaElement;
@@ -67,12 +68,9 @@
 import com.sun.tools.javac.code.Attribute;
 import com.sun.tools.javac.code.Flags;
 import com.sun.tools.javac.code.Kinds;
-import com.sun.tools.javac.code.Symbol;
-import com.sun.tools.javac.code.Type;
-import com.sun.tools.javac.code.TypeTag;
-import com.sun.tools.javac.code.Types;
 import com.sun.tools.javac.code.Kinds.Kind;
 import com.sun.tools.javac.code.Kinds.KindSelector;
+import com.sun.tools.javac.code.Symbol;
 import com.sun.tools.javac.code.Symbol.ClassSymbol;
 import com.sun.tools.javac.code.Symbol.CompletionFailure;
 import com.sun.tools.javac.code.Symbol.MethodSymbol;
@@ -81,6 +79,7 @@
 import com.sun.tools.javac.code.Symbol.TypeSymbol;
 import com.sun.tools.javac.code.Symbol.TypeVariableSymbol;
 import com.sun.tools.javac.code.Symbol.VarSymbol;
+import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.code.Type.ArrayType;
 import com.sun.tools.javac.code.Type.ClassType;
 import com.sun.tools.javac.code.Type.ErrorType;
@@ -90,11 +89,13 @@
 import com.sun.tools.javac.code.Type.MethodType;
 import com.sun.tools.javac.code.Type.TypeVar;
 import com.sun.tools.javac.code.Type.WildcardType;
+import com.sun.tools.javac.code.TypeTag;
+import com.sun.tools.javac.code.Types;
 import com.sun.tools.javac.code.Types.FunctionDescriptorLookupError;
 import com.sun.tools.javac.util.Name;
 import com.sun.tools.javac.util.Names;
 
-public abstract class JavacTypeBinding implements ITypeBinding {
+public abstract class JavacTypeBinding implements ITypeBinding, ISignatureProvider {
 
 	private static final ITypeBinding[] NO_TYPE_ARGUMENTS = new ITypeBinding[0];
 
@@ -313,6 +314,10 @@ private static String removeTrailingSemicolon(String key) {
 		return key.endsWith(";") ? key.substring(0, key.length() - 1) : key;
 	}
 
+	public String getSignature() {
+		return getKey(true, true);
+	}
+	
 	private String getKey(Type t) {
 		return getKey(t, this.typeSymbol.flatName());
 	}
@@ -321,13 +326,21 @@ public String getKey(boolean includeTypeParameters) {
 		return getKey(this.type, this.typeSymbol.flatName(), includeTypeParameters);
 	}
 
+	public String getKey(boolean includeTypeParameters, boolean ignoreFilenames) {
+		return getKey(this.type, this.typeSymbol.flatName(), includeTypeParameters, ignoreFilenames);
+	}
+
 	public String getKey(Type t, Name n) {
 		return getKey(type, n, true);
 	}
+	
 	public String getKey(Type t, Name n, boolean includeTypeParameters) {
+		return getKey(t, n, includeTypeParameters, false);
+	}
+	public String getKey(Type t, Name n, boolean includeTypeParameters, boolean signatureMode) {
 		try {
 			StringBuilder builder = new StringBuilder();
-			getKey(builder, t, n, false, includeTypeParameters, this.resolver);
+			getKey(builder, t, n, false, includeTypeParameters, signatureMode, this.resolver);
 			return builder.toString();
 		} catch(BindingKeyException bke) {
 			return null;
@@ -344,6 +357,10 @@ static void getKey(StringBuilder builder, Type typeToBuild, boolean isLeaf, bool
 	}
 
 	static void getKey(StringBuilder builder, Type typeToBuild, Name n, boolean isLeaf, boolean includeParameters, JavacBindingResolver resolver) throws BindingKeyException {
+		getKey(builder, typeToBuild, n, isLeaf, includeParameters, false, resolver);
+	}
+	
+	static void getKey(StringBuilder builder, Type typeToBuild, Name n, boolean isLeaf, boolean includeParameters, boolean signatureMode, JavacBindingResolver resolver) throws BindingKeyException {
 		if (typeToBuild instanceof Type.JCNoType) {
 			return;
 		}
@@ -390,7 +407,11 @@ static void getKey(StringBuilder builder, Type typeToBuild, Name n, boolean isLe
 			 * but the test suite expects test0502.A$182,
 			 * where 182 is the location in the source of the symbol.
 			 */
-			builder.append(n.toString().replace('.', '/'));
+			if( signatureMode ) {
+				builder.append(n.toString());
+			} else {
+				builder.append(n.toString().replace('.', '/'));
+			}
 			// This is a hack and will likely need to be enhanced
 			if (typeToBuild.tsym instanceof ClassSymbol classSymbol && !(classSymbol.type instanceof ErrorType) && classSymbol.owner instanceof PackageSymbol) {
 				JavaFileObject sourcefile = classSymbol.sourcefile;
@@ -402,7 +423,7 @@ static void getKey(StringBuilder builder, Type typeToBuild, Name n, boolean isLe
 					} catch (IllegalArgumentException e) {
 						// probably: uri is not a valid path
 					}
-					if (fileName != null && !fileName.startsWith(classSymbol.getSimpleName().toString())) {
+					if (fileName != null && !signatureMode && !fileName.startsWith(classSymbol.getSimpleName().toString())) {
 						// There are multiple top-level types in this file,
 						// inject 'FileName~' before the type name to show that this type came from `FileName.java`
 						// (eg. Lorg/eclipse/jdt/FileName~MyTopLevelType;)

org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/DOMCompletionContext.java

@@ -200,9 +200,7 @@ public char[][] getExpectedTypesSignatures() {
 			return null;
 		}
 		var res = this.expectedTypes.getExpectedTypes().stream() //
-				.map(type -> type.getKey()) //
-				.map(name -> name.replace('/', '.'))
-				.map(String::toCharArray) //
+				.map(type -> DOMCompletionEngineBuilder.getSignature(type)) //
 				.toArray(char[][]::new);
 		return res.length == 0 ? null : res;
 	}

org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/DOMCompletionEngineBuilder.java

@@ -14,6 +14,7 @@
 package org.eclipse.jdt.internal.codeassist;
 
 import org.eclipse.jdt.core.dom.IMethodBinding;
+import org.eclipse.jdt.core.dom.ISignatureProvider;
 import org.eclipse.jdt.core.dom.ITypeBinding;
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
@@ -188,8 +189,15 @@ static char[] getSignature(IMethodBinding methodBinding) {
 		}
 	}
 
+	static String getSignatureAsString(ITypeBinding typeBinding) {
+		if( typeBinding instanceof ISignatureProvider isp) {
+			return isp.getSignature();
+		}
+		return typeBinding.getKey().replace('/', '.');
+	}
+
 	static char[] getSignature(ITypeBinding typeBinding) {
-		return typeBinding.getKey().replace('/', '.').toCharArray();
+		return getSignatureAsString(typeBinding).toCharArray();
 	}
 
 }

org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ISignatureProvider.java

@@ -0,0 +1,94 @@
+/*******************************************************************************
+ * Copyright (c) 2025 IBM Corporation and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package org.eclipse.jdt.core.dom;
+
+/**
+ * A signature provider is an object, usually a binding of some type,
+ * that is capable of providing a signature, such as a method signature
+ * or a type signature.
+ *
+ * This class is Provisional API for use by JDT/UI or JDT/Debug, which may possibly be removed in a future version.
+ *
+ * @since 3.42
+ * @noimplement This interface is not intended to be implemented by clients.
+ *
+ */
+public interface ISignatureProvider {
+	/**
+	 * Returns the signature for this object.
+	 * <p>
+	 * Within a single cluster of bindings (produced by the same call to an
+	 * {@code ASTParser#create*(*)} method)), each binding has a distinct signature.
+	 * The signatures are generated in a manner that is predictable and as
+	 * stable as possible. This last property makes these signatures useful for
+	 * comparing bindings between different clusters of bindings (for example,
+	 * the bindings between the "before" and "after" ASTs of the same
+	 * compilation unit).
+	 * </p>
+	 * <p>
+	 * The exact details of how the keys are generated is unspecified.
+	 * However, it is a function of the following information:
+	 * <ul>
+	 * <li>packages - the name of the package (for an unnamed package,
+	 *   some internal id)</li>
+	 * <li>classes or interfaces - the VM name of the type and the key
+	 *   of its package</li>
+	 * <li>array types - the key of the component type and number of
+	 *   dimensions</li>
+	 * <li>primitive types - the name of the primitive type</li>
+	 * <li>fields - the name of the field and the key of its declaring
+	 *   type</li>
+	 * <li>methods - the name of the method, the key of its declaring
+	 *   type, and the keys of the parameter types</li>
+	 * <li>constructors - the key of its declaring class, and the
+	 *   keys of the parameter types</li>
+	 * <li>local variables - the name of the local variable, the index of the
+	 *   declaring block relative to its parent, the key of its method</li>
+	 * <li>local types - the name of the type, the index of the declaring
+	 *   block relative to its parent, the key of its method</li>
+	 * <li>anonymous types - the occurrence count of the anonymous
+	 *   type relative to its declaring type, the key of its declaring type</li>
+	 * <li>enum types - treated like classes</li>
+	 * <li>annotation types - treated like interfaces</li>
+	 * <li>type variables - the name of the type variable and
+	 * the key of the generic type or generic method that declares that
+	 * type variable</li>
+	 * <li>wildcard types - the key of the optional wildcard type bound</li>
+     * <li>capture type bindings - the key of the wildcard captured</li>
+	 * <li>generic type instances - the key of the generic type and the keys
+	 * of the type arguments used to instantiate it, and whether the
+	 * instance is explicit (a parameterized type reference) or
+	 * implicit (a raw type reference)</li>
+	 * <li>generic method instances - the key of the generic method and the keys
+	 * of the type arguments used to instantiate it, and whether the
+	 * instance is explicit (a parameterized method reference) or
+	 * implicit (a raw method reference)</li>
+	 * <li>members of generic type instances - the key of the generic type
+	 * instance and the key of the corresponding member in the generic
+	 * type</li>
+	 * <li>annotations - the key of the annotated element and the key of
+	 * the annotation type</li>
+	 * </ul>
+	 * <p>
+	 * The key for a type binding does <em>not</em> contain {@link ITypeBinding#getTypeAnnotations() type annotations},
+	 * so type bindings with different type annotations may have the same key (iff they denote the same un-annotated type).
+	 * By construction, this also applies to method bindings if their declaring types contain type annotations.
+	 * </p>
+	 * <p>Note that the key for member value pair bindings is
+	 * not yet implemented. This method returns <code>null</code> for that kind of bindings.<br>
+	 * Recovered bindings have a unique key.
+	 * </p>
+	 *
+	 * @return the key for this binding
+	 */
+	public String getSignature();
+}

org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/TypeBinding.java

@@ -21,6 +21,7 @@
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.compiler.CharOperation;
+import org.eclipse.jdt.internal.codeassist.impl.Engine;
 import org.eclipse.jdt.internal.compiler.ast.StringLiteral;
 import org.eclipse.jdt.internal.compiler.ast.Wildcard;
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
@@ -35,7 +36,7 @@
 /**
  * Internal implementation of type bindings.
  */
-class TypeBinding implements ITypeBinding {
+class TypeBinding implements ITypeBinding, ISignatureProvider {
 	private static final StringLiteral EXPRESSION = new org.eclipse.jdt.internal.compiler.ast.StringLiteral(0,0);
 
 	protected static final IMethodBinding[] NO_METHOD_BINDINGS = new IMethodBinding[0];
@@ -571,6 +572,11 @@ private JavaElement getUnresolvedJavaElement(org.eclipse.jdt.internal.compiler.l
 		return null;
 	}
 
+	@Override
+	public String getSignature() {
+		return new String(Engine.getSignature(this.binding));
+	}
+
 	@Override
 	public String getKey() {
 		if (this.key == null) {