From 8237c6939e9af1e182d50687f9e456deebd6b172 Mon Sep 17 00:00:00 2001 From: azerr Date: Fri, 12 Jul 2024 15:12:09 +0200 Subject: [PATCH] Support for inner Enum Fixes #963 Signed-off-by: azerr --- .../resolver/AbstractTypeResolver.java | 53 +++++++++++-------- .../jdt/internal/resolver/ITypeResolver.java | 3 +- .../datamodel/TemplateRecordsSupport.java | 2 +- .../utils/QuteReflectionAnnotationUtils.java | 2 +- 4 files changed, 36 insertions(+), 24 deletions(-) diff --git a/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/internal/resolver/AbstractTypeResolver.java b/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/internal/resolver/AbstractTypeResolver.java index 1292cb559..b5d4dcc39 100644 --- a/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/internal/resolver/AbstractTypeResolver.java +++ b/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/internal/resolver/AbstractTypeResolver.java @@ -68,12 +68,12 @@ public List resolveExtendedType() { try { String superTypeSignature = primaryType.getSuperclassTypeSignature(); if (superTypeSignature != null) { - extendedTypes.add(resolveTypeSignature(superTypeSignature)); + extendedTypes.add(resolveTypeSignature(superTypeSignature, primaryType)); } String[] superInterfaceTypeSignature = primaryType.getSuperInterfaceTypeSignatures(); if (superInterfaceTypeSignature != null) { for (String string : superInterfaceTypeSignature) { - extendedTypes.add(resolveTypeSignature(string)); + extendedTypes.add(resolveTypeSignature(string, primaryType)); } } @@ -89,7 +89,7 @@ public String resolveFieldSignature(IField field) { StringBuilder signature = new StringBuilder(field.getElementName()); signature.append(" : "); try { - signature.append(resolveTypeSignature(field.getTypeSignature(), false)); + signature.append(resolveTypeSignature(field.getTypeSignature(), false, field.getDeclaringType())); } catch (JavaModelException e) { LOGGER.log(Level.SEVERE, "Error while resolving field type '" + field.getElementName() + "'", e); } @@ -111,8 +111,7 @@ public String resolveMethodSignature(IMethod method) { ILocalVariable parameter = parameters[i]; signature.append(parameter.getElementName()); signature.append(" : "); - signature.append( - resolveLocalVariableSignature(parameter, varargs && i == parameters.length - 1)); + signature.append(resolveLocalVariableSignature(parameter, varargs && i == parameters.length - 1)); } } } catch (JavaModelException e) { @@ -121,7 +120,7 @@ public String resolveMethodSignature(IMethod method) { } signature.append(')'); try { - String returnType = resolveTypeSignature(method.getReturnType(), false); + String returnType = resolveTypeSignature(method.getReturnType(), false, method.getDeclaringType()); signature.append(" : "); signature.append(returnType); } catch (JavaModelException e) { @@ -133,23 +132,24 @@ public String resolveMethodSignature(IMethod method) { @Override public String resolveLocalVariableSignature(ILocalVariable parameter, boolean varargs) { - return resolveTypeSignature(parameter.getTypeSignature(), varargs); + return resolveTypeSignature(parameter.getTypeSignature(), varargs, + parameter.getDeclaringMember().getDeclaringType()); } @Override - public String resolveTypeSignature(String typeSignature) { - return resolveTypeSignature(typeSignature, false); + public String resolveTypeSignature(String typeSignature, IType declaringType) { + return resolveTypeSignature(typeSignature, false, declaringType); } - private String resolveTypeSignature(String typeSignature, boolean varargs) { + private String resolveTypeSignature(String typeSignature, boolean varargs, IType declaringType) { if (typeSignature.charAt(0) == '[') { - return doResolveTypeSignature(typeSignature.substring(1, typeSignature.length())) + return doResolveTypeSignature(typeSignature.substring(1, typeSignature.length()), declaringType) + (varargs ? "..." : "[]"); } - return doResolveTypeSignature(typeSignature); + return doResolveTypeSignature(typeSignature, declaringType); } - private String doResolveTypeSignature(String typeSignature) { + private String doResolveTypeSignature(String typeSignature, IType declaringType) { // Example: for 'class A extends B' the type signature is // 'QB;' // The method should return 'B' @@ -162,15 +162,17 @@ private String doResolveTypeSignature(String typeSignature) { } case Signature.C_RESOLVED: { if (typeSignature.indexOf('$') != -1) { - // We cannot use Signature.toString(typeSignature); from JDT because it replaces '$' (for inner class) with '.' - // ex : Ljava.util.Set;>; the JDT Signature.toString returns java.util.Set> + // We cannot use Signature.toString(typeSignature); from JDT because it replaces + // '$' (for inner class) with '.' + // ex : Ljava.util.Set;>; the JDT + // Signature.toString returns java.util.Set> // and not java.util.Set> - return doResolveTypeSignatureWithoutJDT(typeSignature); + return doResolveTypeSignatureWithoutJDT(typeSignature, declaringType); } return Signature.toString(typeSignature); } case Signature.C_UNRESOLVED: - return doResolveTypeSignatureWithoutJDT(typeSignature); + return doResolveTypeSignatureWithoutJDT(typeSignature, declaringType); } // ex : // - Ljava.lang.Long; @@ -178,14 +180,23 @@ private String doResolveTypeSignature(String typeSignature) { return Signature.toString(typeSignature); } - public String doResolveTypeSignatureWithoutJDT(String typeSignature) { + public String doResolveTypeSignatureWithoutJDT(String typeSignature, IType declaringType) { int startGeneric = typeSignature.indexOf('<'); boolean hasGeneric = startGeneric != -1; if (!hasGeneric) { // Example : 'QString'; // Remove the 'Q' start and the ';' end. boolean endsWithColon = typeSignature.charAt(typeSignature.length() - 1) == Signature.C_NAME_END; - return resolveSimpleType(typeSignature.substring(1, typeSignature.length() - (endsWithColon ? 1 : 0))); + String simpleType = typeSignature.substring(1, typeSignature.length() - (endsWithColon ? 1 : 0)); + String resolved = resolveSimpleType(simpleType); + ; + if (resolved.equals(simpleType)) { + IType type = declaringType.getType(simpleType); + if (type != null && type.exists()) { + return resolveJavaTypeSignature(type); + } + } + return resolved; } // Example : @@ -195,7 +206,7 @@ public String doResolveTypeSignatureWithoutJDT(String typeSignature) { String typeErasure = typeSignature.substring(0, startGeneric); // ex : List StringBuilder result = new StringBuilder(); - result.append(doResolveTypeSignature(typeErasure + Signature.C_NAME_END)); + result.append(doResolveTypeSignature(typeErasure + Signature.C_NAME_END, declaringType)); result.append('<'); int bracket = 0; @@ -216,7 +227,7 @@ public String doResolveTypeSignatureWithoutJDT(String typeSignature) { result.append(","); } String s = typeSignature.substring(start, i); - result.append(doResolveTypeSignature(s + Signature.C_NAME_END)); + result.append(doResolveTypeSignature(s + Signature.C_NAME_END, declaringType)); nbTypeParams++; start = i + 1; } diff --git a/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/internal/resolver/ITypeResolver.java b/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/internal/resolver/ITypeResolver.java index 3c26abb52..fd26387ed 100644 --- a/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/internal/resolver/ITypeResolver.java +++ b/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/internal/resolver/ITypeResolver.java @@ -17,6 +17,7 @@ import org.eclipse.jdt.core.IJavaElement; import org.eclipse.jdt.core.ILocalVariable; import org.eclipse.jdt.core.IMethod; +import org.eclipse.jdt.core.IType; /** * Type resolver API. @@ -85,7 +86,7 @@ default String resolveSignature(IJavaElement javaElement) { * @return the resolved Java type signature from the given String * typeSignature. */ - String resolveTypeSignature(String typeSignature); + String resolveTypeSignature(String typeSignature, IType declaringType); /** * Returns the Java field signature from the given JDT field. diff --git a/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/internal/template/datamodel/TemplateRecordsSupport.java b/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/internal/template/datamodel/TemplateRecordsSupport.java index c263a772c..942015eac 100644 --- a/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/internal/template/datamodel/TemplateRecordsSupport.java +++ b/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/internal/template/datamodel/TemplateRecordsSupport.java @@ -98,7 +98,7 @@ private static DataModelTemplate createTemplateDataModel(ITy for (IField field : type.getRecordComponents()) { DataModelParameter parameter = new DataModelParameter(); parameter.setKey(field.getElementName()); - parameter.setSourceType(typeResolver.resolveTypeSignature(field.getTypeSignature())); + parameter.setSourceType(typeResolver.resolveTypeSignature(field.getTypeSignature(), field.getDeclaringType())); template.getParameters().add(parameter); } diff --git a/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/utils/QuteReflectionAnnotationUtils.java b/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/utils/QuteReflectionAnnotationUtils.java index 7981dcae4..19729b89c 100644 --- a/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/utils/QuteReflectionAnnotationUtils.java +++ b/qute.jdt/com.redhat.qute.jdt/src/main/java/com/redhat/qute/jdt/utils/QuteReflectionAnnotationUtils.java @@ -223,6 +223,6 @@ private static RegisterForReflectionAnnotation createRegisterForReflection( private static String resolveTarget(String target, ITypeResolver typeResolver) { // - return typeResolver.resolveTypeSignature(Signature.C_UNRESOLVED + target + Signature.C_NAME_END); + return typeResolver.resolveTypeSignature(Signature.C_UNRESOLVED + target + Signature.C_NAME_END, null); } }