Examples with ConstructorMetadata org.springframework.roo.classpath.details.ConstructorMetadata used on opensource projects

Example 6 with ConstructorMetadata

use of org.springframework.roo.classpath.details.ConstructorMetadata in project spring-roo by spring-projects.

the class MemberDetailsBuilder method tag.

public <T> void tag(final T toModify, final CustomDataKey<T> key, final Object value) {
    if (toModify instanceof FieldMetadata) {
        final CustomDataBuilder customDataBuilder = new CustomDataBuilder();
        customDataBuilder.put(key, value);
        doModification((FieldMetadata) toModify, customDataBuilder.build());
    } else if (toModify instanceof MethodMetadata) {
        final CustomDataBuilder customDataBuilder = new CustomDataBuilder();
        customDataBuilder.put(key, value);
        doModification((MethodMetadata) toModify, customDataBuilder.build());
    } else if (toModify instanceof ConstructorMetadata) {
        final CustomDataBuilder customDataBuilder = new CustomDataBuilder();
        customDataBuilder.put(key, value);
        doModification((ConstructorMetadata) toModify, customDataBuilder.build());
    } else if (toModify instanceof MemberHoldingTypeDetails) {
        final CustomDataBuilder customDataBuilder = new CustomDataBuilder();
        customDataBuilder.put(key, value);
        doModification((MemberHoldingTypeDetails) toModify, customDataBuilder.build());
    }
}

Example 7 with ConstructorMetadata

use of org.springframework.roo.classpath.details.ConstructorMetadata in project spring-roo by spring-projects.

the class IdentifierMetadata method getNoArgConstructor.

/**
 * Locates the no-arg constructor for this class, if available.
 * <p>
 * If a class defines a no-arg constructor, it is returned (irrespective of
 * access modifiers).
 * <p>
 * If a class does not define a no-arg constructor, one might be created. It
 * will only be created if the {@link RooIdentifier#noArgConstructor} is
 * true AND there is at least one other constructor declared in the source
 * file. If a constructor is created, it will have a private access
 * modifier.
 *
 * @return the constructor (may return null if no constructor is to be
 *         produced)
 */
private ConstructorMetadataBuilder getNoArgConstructor() {
    // Search for an existing constructor
    final List<JavaType> parameterTypes = new ArrayList<JavaType>();
    final ConstructorMetadata result = governorTypeDetails.getDeclaredConstructor(parameterTypes);
    if (result != null) {
        // Found an existing no-arg constructor on this class
        return null;
    }
    // Create the constructor
    final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder();
    bodyBuilder.appendFormalLine("super();");
    final ConstructorMetadataBuilder constructorBuilder = new ConstructorMetadataBuilder(getId());
    constructorBuilder.setModifier(publicNoArgConstructor ? Modifier.PUBLIC : Modifier.PRIVATE);
    constructorBuilder.setParameterTypes(AnnotatedJavaType.convertFromJavaTypes(parameterTypes));
    constructorBuilder.setBodyBuilder(bodyBuilder);
    return constructorBuilder;
}

Example 8 with ConstructorMetadata

use of org.springframework.roo.classpath.details.ConstructorMetadata 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();
}

Example 9 with ConstructorMetadata

use of org.springframework.roo.classpath.details.ConstructorMetadata in project spring-roo by spring-projects.

the class JavaParserConstructorMetadataBuilder method addConstructor.

// TODO: Should parse the throws types from JavaParser source
public static void addConstructor(final CompilationUnitServices compilationUnitServices, final List<BodyDeclaration> members, final ConstructorMetadata constructor, final Set<JavaSymbolName> typeParameters) {
    Validate.notNull(compilationUnitServices, "Compilation unit services required");
    Validate.notNull(members, "Members required");
    Validate.notNull(constructor, "Method required");
    // Start with the basic constructor
    final ConstructorDeclaration d = new ConstructorDeclaration();
    d.setModifiers(JavaParserUtils.getJavaParserModifier(constructor.getModifier()));
    d.setName(PhysicalTypeIdentifier.getJavaType(constructor.getDeclaredByMetadataId()).getSimpleTypeName());
    // Add any constructor-level annotations (not parameter annotations)
    final List<AnnotationExpr> annotations = new ArrayList<AnnotationExpr>();
    d.setAnnotations(annotations);
    for (final AnnotationMetadata annotation : constructor.getAnnotations()) {
        JavaParserAnnotationMetadataBuilder.addAnnotationToList(compilationUnitServices, annotations, annotation);
    }
    // Add any constructor parameters, including their individual
    // annotations and type parameters
    final List<Parameter> parameters = new ArrayList<Parameter>();
    d.setParameters(parameters);
    int index = -1;
    for (final AnnotatedJavaType constructorParameter : constructor.getParameterTypes()) {
        index++;
        // Add the parameter annotations applicable for this parameter type
        final List<AnnotationExpr> parameterAnnotations = new ArrayList<AnnotationExpr>();
        for (final AnnotationMetadata parameterAnnotation : constructorParameter.getAnnotations()) {
            JavaParserAnnotationMetadataBuilder.addAnnotationToList(compilationUnitServices, parameterAnnotations, parameterAnnotation);
        }
        // Compute the parameter name
        final String parameterName = constructor.getParameterNames().get(index).getSymbolName();
        // Compute the parameter type
        Type parameterType = null;
        if (constructorParameter.getJavaType().isPrimitive()) {
            parameterType = JavaParserUtils.getType(constructorParameter.getJavaType());
        } else {
            final Type finalType = JavaParserUtils.getResolvedName(constructorParameter.getJavaType(), constructorParameter.getJavaType(), compilationUnitServices);
            final ClassOrInterfaceType cit = JavaParserUtils.getClassOrInterfaceType(finalType);
            // Add any type arguments presented for the return type
            if (constructorParameter.getJavaType().getParameters().size() > 0) {
                final List<Type> typeArgs = new ArrayList<Type>();
                cit.setTypeArgs(typeArgs);
                for (final JavaType parameter : constructorParameter.getJavaType().getParameters()) {
                    // NameExpr importedParameterType =
                    // JavaParserUtils.importTypeIfRequired(compilationUnitServices.getEnclosingTypeName(),
                    // compilationUnitServices.getImports(), parameter);
                    // typeArgs.add(JavaParserUtils.getReferenceType(importedParameterType));
                    typeArgs.add(JavaParserUtils.importParametersForType(compilationUnitServices.getEnclosingTypeName(), compilationUnitServices.getImports(), parameter));
                }
            }
            parameterType = finalType;
        }
        // Create a Java Parser constructor parameter and add it to the list
        // of parameters
        final Parameter p = new Parameter(parameterType, new VariableDeclaratorId(parameterName));
        p.setAnnotations(parameterAnnotations);
        parameters.add(p);
    }
    // Set the body
    if (constructor.getBody() == null || constructor.getBody().length() == 0) {
        d.setBlock(new BlockStmt());
    } else {
        // There is a body.
        // We need to make a fake constructor that we can have JavaParser
        // parse.
        // Easiest way to do that is to build a simple source class
        // containing the required method and re-parse it.
        final StringBuilder sb = new StringBuilder();
        sb.append("class TemporaryClass {\n");
        sb.append("  TemporaryClass() {\n");
        sb.append(constructor.getBody());
        sb.append("\n");
        sb.append("  }\n");
        sb.append("}\n");
        final ByteArrayInputStream bais = new ByteArrayInputStream(sb.toString().getBytes());
        CompilationUnit ci;
        try {
            ci = JavaParser.parse(bais);
        } catch (final IOException e) {
            throw new IllegalStateException("Illegal state: Unable to parse input stream", e);
        } catch (final ParseException pe) {
            throw new IllegalStateException("Illegal state: JavaParser did not parse correctly", pe);
        }
        final List<TypeDeclaration> types = ci.getTypes();
        if (types == null || types.size() != 1) {
            throw new IllegalArgumentException("Method body invalid");
        }
        final TypeDeclaration td = types.get(0);
        final List<BodyDeclaration> bodyDeclarations = td.getMembers();
        if (bodyDeclarations == null || bodyDeclarations.size() != 1) {
            throw new IllegalStateException("Illegal state: JavaParser did not return body declarations correctly");
        }
        final BodyDeclaration bd = bodyDeclarations.get(0);
        if (!(bd instanceof ConstructorDeclaration)) {
            throw new IllegalStateException("Illegal state: JavaParser did not return a method declaration correctly");
        }
        final ConstructorDeclaration cd = (ConstructorDeclaration) bd;
        d.setBlock(cd.getBlock());
    }
    // already exists
    for (final BodyDeclaration bd : members) {
        if (bd instanceof ConstructorDeclaration) {
            // Next constructor should appear after this current constructor
            final ConstructorDeclaration cd = (ConstructorDeclaration) bd;
            if (cd.getParameters().size() == d.getParameters().size()) {
                // Possible match, we need to consider parameter types as
                // well now
                final ConstructorMetadata constructorMetadata = new JavaParserConstructorMetadataBuilder(constructor.getDeclaredByMetadataId(), cd, compilationUnitServices, typeParameters).build();
                boolean matchesFully = true;
                for (final AnnotatedJavaType existingParameter : constructorMetadata.getParameterTypes()) {
                    if (!existingParameter.getJavaType().equals(constructor.getParameterTypes().get(index))) {
                        matchesFully = false;
                        break;
                    }
                }
                if (matchesFully) {
                    throw new IllegalStateException("Constructor '" + constructor.getParameterNames() + "' already exists with identical parameters");
                }
            }
        }
    }
    // ROO-3834: Append Javadoc
    CommentStructure commentStructure = constructor.getCommentStructure();
    if (constructor.getCommentStructure() != null) {
        // annotation
        if (annotations != null && annotations.size() > 0) {
            AnnotationExpr firstAnnotation = annotations.get(0);
            JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(firstAnnotation, commentStructure);
        // Otherwise, add comments to the field declaration line
        } else {
            JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(d, commentStructure);
        }
    } else {
        // ROO-3834: Append default Javadoc if not exists a comment structure,
        // including constructor params
        CommentStructure defaultCommentStructure = new CommentStructure();
        List<String> parameterNames = new ArrayList<String>();
        for (JavaSymbolName name : constructor.getParameterNames()) {
            parameterNames.add(name.getSymbolName());
        }
        JavadocComment javadocComment = new JavadocComment("TODO Auto-generated constructor documentation", parameterNames, null, null);
        defaultCommentStructure.addComment(javadocComment, CommentLocation.BEGINNING);
        constructor.setCommentStructure(defaultCommentStructure);
        // annotation
        if (annotations != null && annotations.size() > 0) {
            AnnotationExpr firstAnnotation = annotations.get(0);
            JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(firstAnnotation, defaultCommentStructure);
        // Otherwise, add comments to the constructor declaration line
        } else {
            JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(d, defaultCommentStructure);
        }
    }
    // Add the constructor to the end of the compilation unit
    members.add(d);
}

Example 10 with ConstructorMetadata

use of org.springframework.roo.classpath.details.ConstructorMetadata 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);
}