Examples with ClassOrInterfaceType com.github.antlrjavaparser.api.type.ClassOrInterfaceType used on opensource projects

Example 11 with ClassOrInterfaceType

use of com.github.antlrjavaparser.api.type.ClassOrInterfaceType 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 12 with ClassOrInterfaceType

use of com.github.antlrjavaparser.api.type.ClassOrInterfaceType 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);
}

Example 13 with ClassOrInterfaceType

use of com.github.antlrjavaparser.api.type.ClassOrInterfaceType 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;
}

Example 14 with ClassOrInterfaceType

use of com.github.antlrjavaparser.api.type.ClassOrInterfaceType in project spring-roo by spring-projects.

the class JavaParserUtils method importParametersForType.

public static ReferenceType importParametersForType(final JavaType targetType, final List<ImportDeclaration> imports, final JavaType typeToImport) {
    Validate.notNull(targetType, "Target type is required");
    Validate.notNull(imports, "Compilation unit imports required");
    Validate.notNull(typeToImport, "Java type to import is required");
    final ClassOrInterfaceType cit = getClassOrInterfaceType(importTypeIfRequired(targetType, imports, typeToImport));
    // Add any type arguments presented for the return type
    if (typeToImport.getParameters().size() > 0) {
        final List<Type> typeArgs = new ArrayList<Type>();
        cit.setTypeArgs(typeArgs);
        for (final JavaType parameter : typeToImport.getParameters()) {
            typeArgs.add(JavaParserUtils.importParametersForType(targetType, imports, parameter));
        }
    }
    final ReferenceType refType = new ReferenceType(cit);
    // Handle arrays
    if (typeToImport.isArray()) {
        refType.setArrayCount(typeToImport.getArray());
    }
    return refType;
}

Example 15 with ClassOrInterfaceType

use of com.github.antlrjavaparser.api.type.ClassOrInterfaceType in project spring-roo by spring-projects.

the class JavaParserUtils method getJavaTypeNow.

/**
 * Resolves the effective {@link JavaType} a {@link ClassOrInterfaceType}
 * represents, including any type arguments.
 *
 * @param compilationUnitServices for package management (required)
 * @param cit the class or interface type to resolve (required)
 * @return the effective Java type (never null)
 */
public static JavaType getJavaTypeNow(final CompilationUnitServices compilationUnitServices, final ClassOrInterfaceType cit, final Set<JavaSymbolName> typeParameters) {
    Validate.notNull(compilationUnitServices, "Compilation unit services required");
    Validate.notNull(cit, "ClassOrInterfaceType required");
    final JavaPackage compilationUnitPackage = compilationUnitServices.getCompilationUnitPackage();
    Validate.notNull(compilationUnitPackage, "Compilation unit package required");
    String typeName = cit.getName();
    ClassOrInterfaceType scope = cit.getScope();
    while (scope != null) {
        typeName = scope.getName() + "." + typeName;
        scope = scope.getScope();
    }
    final NameExpr nameExpr = getNameExpr(typeName);
    final JavaType effectiveType = getJavaType(compilationUnitServices, nameExpr, typeParameters);
    // Handle any type arguments
    final List<JavaType> parameterTypes = new ArrayList<JavaType>();
    if (cit.getTypeArgs() != null) {
        for (final Type ta : cit.getTypeArgs()) {
            parameterTypes.add(getJavaType(compilationUnitServices, ta, typeParameters));
        }
    }
    return new JavaType(effectiveType.getFullyQualifiedTypeName(), effectiveType.getArray(), effectiveType.getDataType(), null, parameterTypes);
}