use of com.github.antlrjavaparser.api.expr.QualifiedNameExpr in project spring-roo by spring-projects.
the class JavaParserUtils method getJavaType.
/**
* Resolves the effective {@link JavaType} a {@link NameExpr} represents.
* <p>
* You should use {@link #getJavaType(CompilationUnitServices, Type, Set)}
* where possible so that type arguments are preserved (a {@link NameExpr}
* does not contain type arguments).
* <p>
* A name expression can be either qualified or unqualified.
* <p>
* If a name expression is qualified and the qualification starts with a
* lowercase letter, that represents the fully-qualified name. If the
* qualification starts with an uppercase letter, the package name is
* prepended to the qualifier.
* <p>
* If a name expression is unqualified, the imports are scanned. If the
* unqualified name expression is found in the imports, that import
* declaration represents the fully-qualified name. If the unqualified name
* expression is not found in the imports, it indicates the name to find is
* either in the same package as the qualified name expression, or the type
* relates to a member of java.lang. If part of java.lang, the fully
* qualified name is treated as part of java.lang. Otherwise the compilation
* unit package plus unqualified name expression represents the fully
* qualified name expression.
*
* @param compilationUnitServices for package management (required)
* @param nameToFind to locate (required)
* @param typeParameters names to consider type parameters (can be null if
* there are none)
* @return the effective Java type (never null)
*/
public static JavaType getJavaType(final CompilationUnitServices compilationUnitServices, final NameExpr nameToFind, final Set<JavaSymbolName> typeParameters) {
Validate.notNull(compilationUnitServices, "Compilation unit services required");
Validate.notNull(nameToFind, "Name to find is required");
final JavaPackage compilationUnitPackage = compilationUnitServices.getCompilationUnitPackage();
if (nameToFind instanceof QualifiedNameExpr) {
final QualifiedNameExpr qne = (QualifiedNameExpr) nameToFind;
// Handle qualified name expressions that are related to inner types
// (eg Foo.Bar)
final NameExpr qneQualifier = qne.getQualifier();
final NameExpr enclosedBy = getNameExpr(compilationUnitServices.getEnclosingTypeName().getSimpleTypeName());
if (isEqual(qneQualifier, enclosedBy)) {
// This qualified name expression is simply an inner type
// reference
final String name = compilationUnitServices.getEnclosingTypeName().getFullyQualifiedTypeName() + "." + nameToFind.getName();
return new JavaType(name, compilationUnitServices.getEnclosingTypeName());
}
// package (ROO-1210)
if (qne.toString().length() > 1 && Character.isUpperCase(qne.toString().charAt(0))) {
// First letter is uppercase, so this likely requires prepending
// of some package name
final ImportDeclaration importDeclaration = getImportDeclarationFor(compilationUnitServices, qne.getQualifier());
if (importDeclaration == null) {
if (!compilationUnitPackage.getFullyQualifiedPackageName().equals("")) {
// package
return new JavaType(compilationUnitServices.getCompilationUnitPackage().getFullyQualifiedPackageName() + "." + qne.toString());
}
} else {
return new JavaType(importDeclaration.getName() + "." + qne.getName());
}
// This name expression (which contains a dot) had its qualifier
// imported, so let's use the import
} else {
// a package
return new JavaType(qne.toString());
}
}
if ("?".equals(nameToFind.getName())) {
return new JavaType(OBJECT.getFullyQualifiedTypeName(), 0, DataType.TYPE, JavaType.WILDCARD_NEITHER_ARG, null);
}
// list
if (typeParameters != null && typeParameters.contains(new JavaSymbolName(nameToFind.getName()))) {
return new JavaType(nameToFind.getName(), 0, DataType.VARIABLE, null, null);
}
// Check if we are looking for the enclosingType itself
final NameExpr enclosingTypeName = getNameExpr(compilationUnitServices.getEnclosingTypeName().getSimpleTypeName());
if (isEqual(enclosingTypeName, nameToFind)) {
return compilationUnitServices.getEnclosingTypeName();
}
// check if the compilation unit itself declares that type
for (final TypeDeclaration internalType : compilationUnitServices.getInnerTypes()) {
final NameExpr nameExpr = getNameExpr(internalType.getName());
if (isEqual(nameExpr, nameToFind)) {
// Found, so now we need to convert the internalType to a proper
// JavaType
final String name = compilationUnitServices.getEnclosingTypeName().getFullyQualifiedTypeName() + "." + nameToFind.getName();
return new JavaType(name);
}
}
final ImportDeclaration importDeclaration = getImportDeclarationFor(compilationUnitServices, nameToFind);
if (importDeclaration == null) {
if (JdkJavaType.isPartOfJavaLang(nameToFind.getName())) {
return new JavaType("java.lang." + nameToFind.getName());
}
final String name = compilationUnitPackage.getFullyQualifiedPackageName().equals("") ? nameToFind.getName() : compilationUnitPackage.getFullyQualifiedPackageName() + "." + nameToFind.getName();
return new JavaType(name);
}
return new JavaType(importDeclaration.getName().toString());
}
use of com.github.antlrjavaparser.api.expr.QualifiedNameExpr in project spring-roo by spring-projects.
the class JavaParserUtils method getImportDeclarationFor.
/**
* Looks up the import declaration applicable to the presented name
* expression.
* <p>
* If a fully-qualified name is passed to this method, the corresponding
* import will be evaluated for a complete match. If a simple name is passed
* to this method, the corresponding import will be evaluated if its simple
* name matches. This therefore reflects the normal Java semantics for using
* simple type names that have been imported.
*
* @param compilationUnitServices the types in the compilation unit
* (required)
* @param nameExpr the expression to locate an import for (which would
* generally be a {@link NameExpr} and thus not have a package
* identifier; required)
* @return the relevant import, or null if there is no import for the
* expression
*/
private static ImportDeclaration getImportDeclarationFor(final CompilationUnitServices compilationUnitServices, final NameExpr nameExpr) {
Validate.notNull(compilationUnitServices, "Compilation unit services required");
Validate.notNull(nameExpr, "Name expression required");
final List<ImportDeclaration> imports = compilationUnitServices.getImports();
for (final ImportDeclaration candidate : imports) {
final NameExpr candidateNameExpr = candidate.getName();
if (!candidate.toString().contains("*")) {
Validate.isInstanceOf(QualifiedNameExpr.class, candidateNameExpr, "Expected import '%s' to use a fully-qualified type name", candidate);
}
if (nameExpr instanceof QualifiedNameExpr) {
// is a full match
if (isEqual(nameExpr, candidateNameExpr)) {
return candidate;
}
} else {
// qualified-name package
if (candidateNameExpr.getName().equals(nameExpr.getName())) {
return candidate;
}
}
}
return null;
}
use of com.github.antlrjavaparser.api.expr.QualifiedNameExpr in project spring-roo by spring-projects.
the class JavaParserClassOrInterfaceTypeDetailsBuilder method build.
@Override
public ClassOrInterfaceTypeDetails build() {
Validate.notEmpty(compilationUnit.getTypes(), "No types in compilation unit, so unable to continue parsing");
ClassOrInterfaceDeclaration clazz = null;
EnumDeclaration enumClazz = null;
final StringBuilder sb = new StringBuilder(compilationUnit.getPackage().getName().toString());
if (name.getEnclosingType() != null) {
sb.append(".").append(name.getEnclosingType().getSimpleTypeName());
}
compilationUnitPackage = new JavaPackage(sb.toString());
// Determine the type name, adding type parameters if possible
final JavaType newName = JavaParserUtils.getJavaType(compilationUnitServices, typeDeclaration);
// Revert back to the original type name (thus avoiding unnecessary
// inferences about java.lang types; see ROO-244)
name = new JavaType(newName.getFullyQualifiedTypeName(), newName.getEnclosingType(), newName.getArray(), newName.getDataType(), newName.getArgName(), newName.getParameters(), name.getModule());
final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(declaredByMetadataId);
physicalTypeCategory = PhysicalTypeCategory.CLASS;
if (typeDeclaration instanceof ClassOrInterfaceDeclaration) {
clazz = (ClassOrInterfaceDeclaration) typeDeclaration;
if (clazz.isInterface()) {
physicalTypeCategory = PhysicalTypeCategory.INTERFACE;
}
} else if (typeDeclaration instanceof EnumDeclaration) {
enumClazz = (EnumDeclaration) typeDeclaration;
physicalTypeCategory = PhysicalTypeCategory.ENUMERATION;
}
Validate.notNull(physicalTypeCategory, "%s (%s for %s)", UNSUPPORTED_MESSAGE_PREFIX, typeDeclaration.getClass().getSimpleName(), name);
cidBuilder.setName(name);
cidBuilder.setPhysicalTypeCategory(physicalTypeCategory);
imports = compilationUnit.getImports();
if (imports == null) {
imports = new ArrayList<ImportDeclaration>();
compilationUnit.setImports(imports);
}
// Verify the package declaration appears to be correct
if (compilationUnitPackage.equals(name.getPackage()) != true) {
String warningStr = "[Warning] Compilation unit package '" + compilationUnitPackage + "' unexpected for type '" + name.getPackage() + "', it may be a nested class.";
LOGGER.log(Level.WARNING, warningStr);
}
for (final ImportDeclaration importDeclaration : imports) {
if (importDeclaration.getName() instanceof QualifiedNameExpr) {
final String qualifier = ((QualifiedNameExpr) importDeclaration.getName()).getQualifier().toString();
final String simpleName = importDeclaration.getName().getName();
final String fullName = qualifier + "." + simpleName;
// We want to calculate these...
final JavaType type = new JavaType(fullName);
final JavaPackage typePackage = importDeclaration.isAsterisk() ? new JavaPackage(fullName) : type.getPackage();
// Process any comments for the import
final CommentStructure commentStructure = new CommentStructure();
JavaParserCommentMetadataBuilder.updateCommentsToRoo(commentStructure, importDeclaration);
final ImportMetadataBuilder newImport = new ImportMetadataBuilder(declaredByMetadataId, 0, typePackage, type, importDeclaration.isStatic(), importDeclaration.isAsterisk());
newImport.setCommentStructure(commentStructure);
cidBuilder.add(newImport.build());
}
}
// Convert Java Parser modifier into JDK modifier
cidBuilder.setModifier(JavaParserUtils.getJdkModifier(typeDeclaration.getModifiers()));
// Type parameters
final Set<JavaSymbolName> typeParameterNames = new HashSet<JavaSymbolName>();
for (final JavaType param : name.getParameters()) {
final JavaSymbolName arg = param.getArgName();
// Fortunately type names can only appear at the top-level
if (arg != null && !JavaType.WILDCARD_NEITHER_ARG.equals(arg) && !JavaType.WILDCARD_EXTENDS_ARG.equals(arg) && !JavaType.WILDCARD_SUPER_ARG.equals(arg)) {
typeParameterNames.add(arg);
}
}
List<ClassOrInterfaceType> implementsList;
List<AnnotationExpr> annotationsList = null;
List<BodyDeclaration> members = null;
if (clazz != null) {
final List<ClassOrInterfaceType> extendsList = clazz.getExtends();
if (extendsList != null) {
for (final ClassOrInterfaceType candidate : extendsList) {
final JavaType javaType = JavaParserUtils.getJavaTypeNow(compilationUnitServices, candidate, typeParameterNames);
cidBuilder.addExtendsTypes(javaType);
}
}
final List<JavaType> extendsTypes = cidBuilder.getExtendsTypes();
// Obtain the superclass, if this is a class and one is available
if (physicalTypeCategory == PhysicalTypeCategory.CLASS && extendsTypes.size() == 1) {
final JavaType superclass = extendsTypes.get(0);
final String superclassId = typeLocationService.getPhysicalTypeIdentifier(superclass);
PhysicalTypeMetadata superPtm = null;
if (superclassId != null) {
superPtm = (PhysicalTypeMetadata) metadataService.get(superclassId);
}
if (superPtm != null && superPtm.getMemberHoldingTypeDetails() != null) {
cidBuilder.setSuperclass(superPtm.getMemberHoldingTypeDetails());
}
}
implementsList = clazz.getImplements();
if (implementsList != null) {
for (final ClassOrInterfaceType candidate : implementsList) {
final JavaType javaType = JavaParserUtils.getJavaTypeNow(compilationUnitServices, candidate, typeParameterNames);
cidBuilder.addImplementsType(javaType);
}
}
annotationsList = typeDeclaration.getAnnotations();
members = clazz.getMembers();
}
if (enumClazz != null) {
final List<EnumConstantDeclaration> constants = enumClazz.getEntries();
if (constants != null) {
for (final EnumConstantDeclaration enumConstants : constants) {
cidBuilder.addEnumConstant(new JavaSymbolName(enumConstants.getName()));
}
}
implementsList = enumClazz.getImplements();
annotationsList = enumClazz.getAnnotations();
members = enumClazz.getMembers();
}
if (annotationsList != null) {
for (final AnnotationExpr candidate : annotationsList) {
final AnnotationMetadata md = JavaParserAnnotationMetadataBuilder.getInstance(candidate, compilationUnitServices).build();
final CommentStructure commentStructure = new CommentStructure();
JavaParserCommentMetadataBuilder.updateCommentsToRoo(commentStructure, candidate);
md.setCommentStructure(commentStructure);
cidBuilder.addAnnotation(md);
}
}
if (members != null) {
// type in the signature of the enclosing type
for (final BodyDeclaration bodyDeclaration : members) {
if (bodyDeclaration instanceof TypeDeclaration) {
// Found a type
innerTypes.add((TypeDeclaration) bodyDeclaration);
}
}
for (final BodyDeclaration member : members) {
if (member instanceof FieldDeclaration) {
final FieldDeclaration castMember = (FieldDeclaration) member;
for (final VariableDeclarator var : castMember.getVariables()) {
final FieldMetadata field = JavaParserFieldMetadataBuilder.getInstance(declaredByMetadataId, castMember, var, compilationUnitServices, typeParameterNames).build();
final CommentStructure commentStructure = new CommentStructure();
JavaParserCommentMetadataBuilder.updateCommentsToRoo(commentStructure, member);
field.setCommentStructure(commentStructure);
cidBuilder.addField(field);
}
}
if (member instanceof MethodDeclaration) {
final MethodDeclaration castMember = (MethodDeclaration) member;
final MethodMetadata method = JavaParserMethodMetadataBuilder.getInstance(declaredByMetadataId, castMember, compilationUnitServices, typeParameterNames).build();
final CommentStructure commentStructure = new CommentStructure();
JavaParserCommentMetadataBuilder.updateCommentsToRoo(commentStructure, member);
method.setCommentStructure(commentStructure);
cidBuilder.addMethod(method);
}
if (member instanceof ConstructorDeclaration) {
final ConstructorDeclaration castMember = (ConstructorDeclaration) member;
final ConstructorMetadata constructor = JavaParserConstructorMetadataBuilder.getInstance(declaredByMetadataId, castMember, compilationUnitServices, typeParameterNames).build();
final CommentStructure commentStructure = new CommentStructure();
JavaParserCommentMetadataBuilder.updateCommentsToRoo(commentStructure, member);
constructor.setCommentStructure(commentStructure);
cidBuilder.addConstructor(constructor);
}
if (member instanceof TypeDeclaration) {
final TypeDeclaration castMember = (TypeDeclaration) member;
final JavaType innerType = new JavaType(castMember.getName(), name);
final String innerTypeMetadataId = PhysicalTypeIdentifier.createIdentifier(innerType, PhysicalTypeIdentifier.getPath(declaredByMetadataId));
final ClassOrInterfaceTypeDetails cid = new JavaParserClassOrInterfaceTypeDetailsBuilder(compilationUnit, compilationUnitServices, castMember, innerTypeMetadataId, innerType, metadataService, typeLocationService).build();
cidBuilder.addInnerType(cid);
}
}
}
return cidBuilder.build();
}
use of com.github.antlrjavaparser.api.expr.QualifiedNameExpr in project spring-roo by spring-projects.
the class JavaParserTypeParsingService method updateOutput.
/**
* Appends the presented class to the end of the presented body
* declarations. The body declarations appear within the presented
* compilation unit. This is used to progressively build inner types.
*
* @param compilationUnit the work-in-progress compilation unit (required)
* @param enclosingCompilationUnitServices
* @param cid the new class to add (required)
* @param parent the class body declarations a subclass should be added to
* (may be null, which denotes a top-level type within the
* compilation unit)
*/
private void updateOutput(final CompilationUnit compilationUnit, CompilationUnitServices enclosingCompilationUnitServices, final ClassOrInterfaceTypeDetails cid, final List<BodyDeclaration> parent) {
// Append the new imports this class declares
Validate.notNull(compilationUnit.getImports(), "Compilation unit imports should be non-null when producing type '%s'", cid.getName());
for (final ImportMetadata importType : cid.getRegisteredImports()) {
ImportDeclaration importDeclaration;
if (!importType.isAsterisk()) {
NameExpr typeToImportExpr;
if (importType.getImportType().getEnclosingType() == null) {
typeToImportExpr = new QualifiedNameExpr(new NameExpr(importType.getImportType().getPackage().getFullyQualifiedPackageName()), importType.getImportType().getSimpleTypeName());
} else {
typeToImportExpr = new QualifiedNameExpr(new NameExpr(importType.getImportType().getEnclosingType().getFullyQualifiedTypeName()), importType.getImportType().getSimpleTypeName());
}
importDeclaration = new ImportDeclaration(typeToImportExpr, importType.isStatic(), false);
} else {
importDeclaration = new ImportDeclaration(new NameExpr(importType.getImportPackage().getFullyQualifiedPackageName()), importType.isStatic(), importType.isAsterisk());
}
JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(importDeclaration, importType.getCommentStructure());
compilationUnit.getImports().add(importDeclaration);
}
// Create a class or interface declaration to represent this actual type
final int javaParserModifier = JavaParserUtils.getJavaParserModifier(cid.getModifier());
TypeDeclaration typeDeclaration;
ClassOrInterfaceDeclaration classOrInterfaceDeclaration;
// Implements handling
final List<ClassOrInterfaceType> implementsList = new ArrayList<ClassOrInterfaceType>();
for (final JavaType current : cid.getImplementsTypes()) {
implementsList.add(JavaParserUtils.getResolvedName(cid.getName(), current, compilationUnit));
}
if (cid.getPhysicalTypeCategory() == PhysicalTypeCategory.INTERFACE || cid.getPhysicalTypeCategory() == PhysicalTypeCategory.CLASS) {
final boolean isInterface = cid.getPhysicalTypeCategory() == PhysicalTypeCategory.INTERFACE;
if (parent == null) {
// Top level type
typeDeclaration = new ClassOrInterfaceDeclaration(javaParserModifier, isInterface, cid.getName().getNameIncludingTypeParameters().replace(cid.getName().getPackage().getFullyQualifiedPackageName() + ".", ""));
classOrInterfaceDeclaration = (ClassOrInterfaceDeclaration) typeDeclaration;
} else {
// Inner type
typeDeclaration = new ClassOrInterfaceDeclaration(javaParserModifier, isInterface, cid.getName().getSimpleTypeName());
classOrInterfaceDeclaration = (ClassOrInterfaceDeclaration) typeDeclaration;
if (cid.getName().getParameters().size() > 0) {
classOrInterfaceDeclaration.setTypeParameters(new ArrayList<TypeParameter>());
for (final JavaType param : cid.getName().getParameters()) {
NameExpr pNameExpr = JavaParserUtils.importTypeIfRequired(cid.getName(), compilationUnit.getImports(), param);
final String tempName = StringUtils.replace(pNameExpr.toString(), param.getArgName() + " extends ", "", 1);
pNameExpr = new NameExpr(tempName);
final ClassOrInterfaceType pResolvedName = JavaParserUtils.getClassOrInterfaceType(pNameExpr);
classOrInterfaceDeclaration.getTypeParameters().add(new TypeParameter(param.getArgName().getSymbolName(), Collections.singletonList(pResolvedName)));
}
}
}
// Superclass handling
final List<ClassOrInterfaceType> extendsList = new ArrayList<ClassOrInterfaceType>();
for (final JavaType current : cid.getExtendsTypes()) {
if (!OBJECT.equals(current)) {
extendsList.add(JavaParserUtils.getResolvedName(cid.getName(), current, compilationUnit));
}
}
if (extendsList.size() > 0) {
classOrInterfaceDeclaration.setExtends(extendsList);
}
// Implements handling
if (implementsList.size() > 0) {
classOrInterfaceDeclaration.setImplements(implementsList);
}
} else {
typeDeclaration = new EnumDeclaration(javaParserModifier, cid.getName().getSimpleTypeName());
}
typeDeclaration.setMembers(new ArrayList<BodyDeclaration>());
Validate.notNull(typeDeclaration.getName(), "Missing type declaration name for '%s'", cid.getName());
// If adding a new top-level type, must add it to the compilation unit
// types
Validate.notNull(compilationUnit.getTypes(), "Compilation unit types must not be null when attempting to add '%s'", cid.getName());
if (parent == null) {
// Top-level class
compilationUnit.getTypes().add(typeDeclaration);
} else {
// Inner class
parent.add(typeDeclaration);
}
// CompilationUnitServices needs to be created
if (enclosingCompilationUnitServices == null) {
// Create a compilation unit so that we can use JavaType*Metadata
// static methods directly
enclosingCompilationUnitServices = new CompilationUnitServices() {
@Override
public JavaPackage getCompilationUnitPackage() {
return cid.getName().getPackage();
}
@Override
public JavaType getEnclosingTypeName() {
return cid.getName();
}
@Override
public List<ImportDeclaration> getImports() {
return compilationUnit.getImports();
}
@Override
public List<TypeDeclaration> getInnerTypes() {
return compilationUnit.getTypes();
}
@Override
public PhysicalTypeCategory getPhysicalTypeCategory() {
return cid.getPhysicalTypeCategory();
}
};
}
final CompilationUnitServices finalCompilationUnitServices = enclosingCompilationUnitServices;
// A hybrid CompilationUnitServices must be provided that references the
// enclosing types imports and package
final CompilationUnitServices compilationUnitServices = new CompilationUnitServices() {
@Override
public JavaPackage getCompilationUnitPackage() {
return finalCompilationUnitServices.getCompilationUnitPackage();
}
@Override
public JavaType getEnclosingTypeName() {
return cid.getName();
}
@Override
public List<ImportDeclaration> getImports() {
return finalCompilationUnitServices.getImports();
}
@Override
public List<TypeDeclaration> getInnerTypes() {
return compilationUnit.getTypes();
}
@Override
public PhysicalTypeCategory getPhysicalTypeCategory() {
return cid.getPhysicalTypeCategory();
}
};
// Add type annotations
final List<AnnotationExpr> annotations = new ArrayList<AnnotationExpr>();
typeDeclaration.setAnnotations(annotations);
for (final AnnotationMetadata candidate : cid.getAnnotations()) {
JavaParserAnnotationMetadataBuilder.addAnnotationToList(compilationUnitServices, annotations, candidate);
}
// ROO-3834: Generating default Javadoc inside class if class doesn't contains JavaDoc
List<Comment> classComments = compilationUnit.getComments();
if (classComments == null || classComments.isEmpty()) {
CommentStructure defaultCommentStructure = new CommentStructure();
String defaultComment = "= ".concat(cid.getType().getSimpleTypeName()).concat("\n \nTODO Auto-generated class documentation");
defaultCommentStructure.addComment(new JavadocComment(defaultComment), CommentLocation.BEGINNING);
if (annotations.isEmpty()) {
JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(typeDeclaration, defaultCommentStructure);
} else {
// If exists some annotation, include comment before the existing annotations
AnnotationExpr firstAnnotation = annotations.get(0);
JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(firstAnnotation, defaultCommentStructure);
}
}
// Add enum constants and interfaces
if (typeDeclaration instanceof EnumDeclaration && cid.getEnumConstants().size() > 0) {
final EnumDeclaration enumDeclaration = (EnumDeclaration) typeDeclaration;
final List<EnumConstantDeclaration> constants = new ArrayList<EnumConstantDeclaration>();
enumDeclaration.setEntries(constants);
for (final JavaSymbolName constant : cid.getEnumConstants()) {
addEnumConstant(constants, constant);
}
// Implements handling
if (implementsList.size() > 0) {
enumDeclaration.setImplements(implementsList);
}
}
// Add fields
for (final FieldMetadata candidate : cid.getDeclaredFields()) {
JavaParserFieldMetadataBuilder.addField(compilationUnitServices, typeDeclaration.getMembers(), candidate);
}
// Add constructors
for (final ConstructorMetadata candidate : cid.getDeclaredConstructors()) {
JavaParserConstructorMetadataBuilder.addConstructor(compilationUnitServices, typeDeclaration.getMembers(), candidate, null);
}
// Add methods
for (final MethodMetadata candidate : cid.getDeclaredMethods()) {
JavaParserMethodMetadataBuilder.addMethod(compilationUnitServices, typeDeclaration.getMembers(), candidate, null);
}
// Add inner types
for (final ClassOrInterfaceTypeDetails candidate : cid.getDeclaredInnerTypes()) {
updateOutput(compilationUnit, compilationUnitServices, candidate, typeDeclaration.getMembers());
}
final HashSet<String> imported = new HashSet<String>();
final ArrayList<ImportDeclaration> imports = new ArrayList<ImportDeclaration>();
for (final ImportDeclaration importDeclaration : compilationUnit.getImports()) {
JavaPackage importPackage = null;
JavaType importType = null;
if (importDeclaration.isAsterisk()) {
importPackage = new JavaPackage(importDeclaration.getName().toString());
} else {
importType = new JavaType(importDeclaration.getName().toString());
importPackage = importType.getPackage();
}
if (importPackage.equals(cid.getName().getPackage()) && importDeclaration.isAsterisk()) {
continue;
}
if (importPackage.equals(cid.getName().getPackage()) && importType != null && importType.getEnclosingType() == null) {
continue;
}
if (importType != null && importType.equals(cid.getName())) {
continue;
}
if (!imported.contains(importDeclaration.getName().toString())) {
imports.add(importDeclaration);
imported.add(importDeclaration.getName().toString());
}
}
Collections.sort(imports, new Comparator<ImportDeclaration>() {
@Override
public int compare(final ImportDeclaration importDeclaration, final ImportDeclaration importDeclaration1) {
return importDeclaration.getName().toString().compareTo(importDeclaration1.getName().toString());
}
});
compilationUnit.setImports(imports);
}
use of com.github.antlrjavaparser.api.expr.QualifiedNameExpr in project spring-roo by spring-projects.
the class JavaParserUtils method importExpressionIfRequired.
/**
* Recognises {@link Expression}s of type {@link FieldAccessExpr} and
* {@link ClassExpr} and automatically imports them if required, returning
* the correct {@link Expression} that should subsequently be used.
* <p>
* Even if an {@link Expression} is not resolved by this method into a type
* and/or imported, the method guarantees to always return an
* {@link Expression} that the caller can subsequently use in place of the
* passed {@link Expression}. In practical terms, the {@link Expression}
* passed to this method will be returned unless the type was already
* imported, just imported, or represented a java.lang type.
*
* @param targetType the compilation unit target type (required)
* @param imports the existing imports (required)
* @param value that expression, which need not necessarily be resolvable to
* a type (required)
* @return the expression to now use, as appropriately resolved (never
* returns null)
*/
public static Expression importExpressionIfRequired(final JavaType targetType, final List<ImportDeclaration> imports, final Expression value) {
Validate.notNull(targetType, "Target type required");
Validate.notNull(imports, "Imports required");
Validate.notNull(value, "Expression value required");
if (value instanceof FieldAccessExpr) {
final Expression scope = ((FieldAccessExpr) value).getScope();
final String field = ((FieldAccessExpr) value).getField();
if (scope instanceof QualifiedNameExpr) {
final String packageName = ((QualifiedNameExpr) scope).getQualifier().getName();
final String simpleName = ((QualifiedNameExpr) scope).getName();
final String fullyQualifiedName = packageName + "." + simpleName;
final JavaType javaType = new JavaType(fullyQualifiedName);
final NameExpr nameToUse = importTypeIfRequired(targetType, imports, javaType);
if (!(nameToUse instanceof QualifiedNameExpr)) {
return new FieldAccessExpr(nameToUse, field);
}
}
} else if (value instanceof ClassExpr) {
final Type type = ((ClassExpr) value).getType();
if (type instanceof ClassOrInterfaceType) {
final JavaType javaType = new JavaType(((ClassOrInterfaceType) type).getName());
final NameExpr nameToUse = importTypeIfRequired(targetType, imports, javaType);
if (!(nameToUse instanceof QualifiedNameExpr)) {
return new ClassExpr(new ClassOrInterfaceType(javaType.getSimpleTypeName()));
}
} else if (type instanceof ReferenceType && ((ReferenceType) type).getType() instanceof ClassOrInterfaceType) {
final ClassOrInterfaceType cit = (ClassOrInterfaceType) ((ReferenceType) type).getType();
final JavaType javaType = new JavaType(cit.getName());
final NameExpr nameToUse = importTypeIfRequired(targetType, imports, javaType);
if (!(nameToUse instanceof QualifiedNameExpr)) {
return new ClassExpr(new ClassOrInterfaceType(javaType.getSimpleTypeName()));
}
}
} else if (value instanceof ArrayInitializerExpr) {
List<Expression> values = ((ArrayInitializerExpr) value).getValues();
for (Expression expressionValue : values) {
// Check annotation expression
if (expressionValue instanceof NormalAnnotationExpr) {
Validate.isInstanceOf(NormalAnnotationExpr.class, expressionValue, "Attempting to add >1 annotation member-value pair requires an existing normal annotation expression");
final List<MemberValuePair> annotationPairs = ((NormalAnnotationExpr) expressionValue).getPairs();
for (final MemberValuePair pair : annotationPairs) {
final Expression toUse = JavaParserUtils.importExpressionIfRequired(targetType, imports, pair.getValue());
pair.setValue(toUse);
}
}
}
}
// Make no changes
return value;
}
Aggregations