org.springframework.roo.classpath.antlrjavaparser

Class JavaParserUtils

java.lang.Object

org.springframework.roo.classpath.antlrjavaparser.JavaParserUtils

public final class JavaParserUtils
extends Object

Assists with the usage of Java Parser.

This class is for internal use by the Java Parser module and should NOT be used by other code.

Since:

1.0

Author:

Ben Alex

Method Summary

Modifier and Type	Method and Description
static com.github.antlrjavaparser.api.type.ClassOrInterfaceType	getClassOrInterfaceType(com.github.antlrjavaparser.api.expr.NameExpr nameExpr) Converts the indicated NameExpr into a ClassOrInterfaceType.
static com.github.antlrjavaparser.api.type.ClassOrInterfaceType	getClassOrInterfaceType(com.github.antlrjavaparser.api.type.Type type) Returns the final ClassOrInterfaceType from a Type
static int	getJavaParserModifier(int modifiers) Converts a JDK Modifier integer into the equivalent Java Parser modifier.
static org.springframework.roo.model.JavaType	getJavaType(CompilationUnitServices compilationUnitServices, com.github.antlrjavaparser.api.expr.NameExpr nameToFind, Set<org.springframework.roo.model.JavaSymbolName> typeParameters) Resolves the effective JavaType a NameExpr represents.
static org.springframework.roo.model.JavaType	getJavaType(CompilationUnitServices compilationUnitServices, com.github.antlrjavaparser.api.body.TypeDeclaration typeDeclaration) Resolves the effective JavaType a ClassOrInterfaceDeclaration represents, including any type parameters.
static org.springframework.roo.model.JavaType	getJavaType(CompilationUnitServices compilationUnitServices, com.github.antlrjavaparser.api.type.Type type, Set<org.springframework.roo.model.JavaSymbolName> typeParameters) Resolves the effective JavaType a Type represents.
static org.springframework.roo.model.JavaType	getJavaTypeNow(CompilationUnitServices compilationUnitServices, com.github.antlrjavaparser.api.type.ClassOrInterfaceType cit, Set<org.springframework.roo.model.JavaSymbolName> typeParameters) Resolves the effective JavaType a ClassOrInterfaceType represents, including any type arguments.
static int	getJdkModifier(int modifiers) Converts a Java Parser modifier integer into a JDK Modifier integer.
static com.github.antlrjavaparser.api.expr.NameExpr	getNameExpr(com.github.antlrjavaparser.api.expr.AnnotationExpr annotationExpr) Obtains the name expression (NameExpr) for the passed AnnotationExpr, which is the annotation's type.
static com.github.antlrjavaparser.api.expr.NameExpr	getNameExpr(String className) Converts the presented class name into a name expression (either a NameExpr or QualifiedNameExpr depending on whether a package was presented).
static com.github.antlrjavaparser.api.type.ReferenceType	getReferenceType(com.github.antlrjavaparser.api.expr.NameExpr nameExpr) Converts the indicated JavaType into a ReferenceType.
static com.github.antlrjavaparser.api.type.ClassOrInterfaceType	getResolvedName(org.springframework.roo.model.JavaType target, org.springframework.roo.model.JavaType current, com.github.antlrjavaparser.api.CompilationUnit compilationUnit)
static com.github.antlrjavaparser.api.type.Type	getResolvedName(org.springframework.roo.model.JavaType target, org.springframework.roo.model.JavaType current, CompilationUnitServices compilationUnit)
static com.github.antlrjavaparser.api.type.Type	getType(org.springframework.roo.model.JavaType javaType) Given a primitive type, computes the corresponding Java Parser type.
static com.github.antlrjavaparser.api.expr.Expression	importExpressionIfRequired(org.springframework.roo.model.JavaType targetType, List<com.github.antlrjavaparser.api.ImportDeclaration> imports, com.github.antlrjavaparser.api.expr.Expression value) Recognises Expressions of type FieldAccessExpr and ClassExpr and automatically imports them if required, returning the correct Expression that should subsequently be used.
static com.github.antlrjavaparser.api.type.ReferenceType	importParametersForType(org.springframework.roo.model.JavaType targetType, List<com.github.antlrjavaparser.api.ImportDeclaration> imports, org.springframework.roo.model.JavaType typeToImport)
static com.github.antlrjavaparser.api.expr.NameExpr	importTypeIfRequired(org.springframework.roo.model.JavaType targetType, List<com.github.antlrjavaparser.api.ImportDeclaration> imports, org.springframework.roo.model.JavaType typeToImport) Attempts to import the presented JavaType.
static com.github.antlrjavaparser.api.body.TypeDeclaration	locateTypeDeclaration(com.github.antlrjavaparser.api.CompilationUnit compilationUnit, org.springframework.roo.model.JavaType javaType) Searches a compilation unit and locates the declaration with the given type's simple name.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

getClassOrInterfaceType

public static com.github.antlrjavaparser.api.type.ClassOrInterfaceType getClassOrInterfaceType(com.github.antlrjavaparser.api.expr.NameExpr nameExpr)

Converts the indicated NameExpr into a ClassOrInterfaceType.

Note that no effort is made to manage imports etc.

Parameters:

nameExpr - to convert (required)

Returns:

the corresponding ClassOrInterfaceType (never null)

getJavaParserModifier

public static int getJavaParserModifier(int modifiers)

Converts a JDK Modifier integer into the equivalent Java Parser modifier.

Parameters:

modifiers - the JDK int

Returns:

the equivalent Java Parser int

getJavaType

public static org.springframework.roo.model.JavaType getJavaType(CompilationUnitServices compilationUnitServices,
                                                                 com.github.antlrjavaparser.api.expr.NameExpr nameToFind,
                                                                 Set<org.springframework.roo.model.JavaSymbolName> typeParameters)

Resolves the effective JavaType a NameExpr represents.

You should use getJavaType(CompilationUnitServices, Type, Set) where possible so that type arguments are preserved (a NameExpr does not contain type arguments).

A name expression can be either qualified or unqualified.

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.

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.

Parameters:

compilationUnitServices - for package management (required)

nameToFind - to locate (required)

typeParameters - names to consider type parameters (can be null if there are none)

Returns:

the effective Java type (never null)

getJavaType

public static org.springframework.roo.model.JavaType getJavaType(CompilationUnitServices compilationUnitServices,
                                                                 com.github.antlrjavaparser.api.type.Type type,
                                                                 Set<org.springframework.roo.model.JavaSymbolName> typeParameters)

Resolves the effective JavaType a Type represents. A Type includes low-level types such as void, arrays and primitives.

Parameters:

compilationUnitServices - to use for package resolution (required)

type - to locate (required)

typeParameters - names to consider type parameters (can be null if there are none)

Returns:

the JavaType, with proper indication of primitive and array status (never null)

getJavaType

public static org.springframework.roo.model.JavaType getJavaType(CompilationUnitServices compilationUnitServices,
                                                                 com.github.antlrjavaparser.api.body.TypeDeclaration typeDeclaration)

Resolves the effective JavaType a ClassOrInterfaceDeclaration represents, including any type parameters.

Parameters:

compilationUnitServices - for package management (required)

typeDeclaration - the type declaration to resolve (required)

Returns:

the effective Java type (never null)

getJavaTypeNow

public static org.springframework.roo.model.JavaType getJavaTypeNow(CompilationUnitServices compilationUnitServices,
                                                                    com.github.antlrjavaparser.api.type.ClassOrInterfaceType cit,
                                                                    Set<org.springframework.roo.model.JavaSymbolName> typeParameters)

Resolves the effective JavaType a ClassOrInterfaceType represents, including any type arguments.

Parameters:

compilationUnitServices - for package management (required)

cit - the class or interface type to resolve (required)

Returns:

the effective Java type (never null)

getJdkModifier

public static int getJdkModifier(int modifiers)

Converts a Java Parser modifier integer into a JDK Modifier integer.

Parameters:

modifiers - the Java Parser int

Returns:

the equivalent JDK int

getNameExpr

public static com.github.antlrjavaparser.api.expr.NameExpr getNameExpr(com.github.antlrjavaparser.api.expr.AnnotationExpr annotationExpr)

Obtains the name expression (NameExpr) for the passed AnnotationExpr, which is the annotation's type.

Parameters:

annotationExpr - to retrieve the type name from (required)

Returns:

the name (never null)

getNameExpr

public static com.github.antlrjavaparser.api.expr.NameExpr getNameExpr(String className)

Converts the presented class name into a name expression (either a NameExpr or QualifiedNameExpr depending on whether a package was presented).

Parameters:

className - to convert (required; can be fully qualified or simple name only)

Returns:

a compatible expression (never returns null)

getReferenceType

public static com.github.antlrjavaparser.api.type.ReferenceType getReferenceType(com.github.antlrjavaparser.api.expr.NameExpr nameExpr)

Converts the indicated JavaType into a ReferenceType.

Note that no effort is made to manage imports etc.

Parameters:

nameExpr - to convert (required)

Returns:

the corresponding ReferenceType (never null)

getResolvedName

public static com.github.antlrjavaparser.api.type.ClassOrInterfaceType getResolvedName(org.springframework.roo.model.JavaType target,
                                                                                       org.springframework.roo.model.JavaType current,
                                                                                       com.github.antlrjavaparser.api.CompilationUnit compilationUnit)

getResolvedName

public static com.github.antlrjavaparser.api.type.Type getResolvedName(org.springframework.roo.model.JavaType target,
                                                                       org.springframework.roo.model.JavaType current,
                                                                       CompilationUnitServices compilationUnit)

getType

public static com.github.antlrjavaparser.api.type.Type getType(org.springframework.roo.model.JavaType javaType)

Given a primitive type, computes the corresponding Java Parser type.

Presenting a non-primitive type to this method will throw an exception. If you have a non-primitive type, use importTypeIfRequired(JavaType, List, JavaType) and then present the NameExpr it returns to getClassOrInterfaceType(NameExpr).

Parameters:

javaType - a primitive type (required, and must be primitive)

Returns:

the equivalent Java Parser Type

importExpressionIfRequired

public static com.github.antlrjavaparser.api.expr.Expression importExpressionIfRequired(org.springframework.roo.model.JavaType targetType,
                                                                                        List<com.github.antlrjavaparser.api.ImportDeclaration> imports,
                                                                                        com.github.antlrjavaparser.api.expr.Expression value)

Recognises Expressions of type FieldAccessExpr and ClassExpr and automatically imports them if required, returning the correct Expression that should subsequently be used.

Even if an Expression is not resolved by this method into a type and/or imported, the method guarantees to always return an Expression that the caller can subsequently use in place of the passed Expression. In practical terms, the Expression passed to this method will be returned unless the type was already imported, just imported, or represented a java.lang type.

Parameters:

targetType - the compilation unit target type (required)

imports - the existing imports (required)

value - that expression, which need not necessarily be resolvable to a type (required)

Returns:

the expression to now use, as appropriately resolved (never returns null)

importParametersForType

public static com.github.antlrjavaparser.api.type.ReferenceType importParametersForType(org.springframework.roo.model.JavaType targetType,
                                                                                        List<com.github.antlrjavaparser.api.ImportDeclaration> imports,
                                                                                        org.springframework.roo.model.JavaType typeToImport)

importTypeIfRequired

public static com.github.antlrjavaparser.api.expr.NameExpr importTypeIfRequired(org.springframework.roo.model.JavaType targetType,
                                                                                List<com.github.antlrjavaparser.api.ImportDeclaration> imports,
                                                                                org.springframework.roo.model.JavaType typeToImport)

Attempts to import the presented JavaType.

Whether imported or not, the method returns a NameExpr suitable for subsequent use when referring to that type.

If an attempt is made to import a java.lang type, it is ignored.

If an attempt is made to import a type without a package, it is ignored.

We import every type usage even if the type usage is within the same package and would theoretically not require an import. This is undertaken so that there is no requirement to separately parse every unqualified type usage within the compilation unit so as to refrain from importing subsequently conflicting types.

Parameters:

targetType - the compilation unit target type (required)

imports - the compilation unit's imports (required)

typeToImport - the type to be imported (required)

Returns:

the name expression to be used when referring to that type (never null)

locateTypeDeclaration

public static com.github.antlrjavaparser.api.body.TypeDeclaration locateTypeDeclaration(com.github.antlrjavaparser.api.CompilationUnit compilationUnit,
                                                                                        org.springframework.roo.model.JavaType javaType)

Searches a compilation unit and locates the declaration with the given type's simple name.

Parameters:

compilationUnit - to scan (required)

javaType - the target to locate (required)

Returns:

the located type declaration or null if it could not be found

getClassOrInterfaceType

public static com.github.antlrjavaparser.api.type.ClassOrInterfaceType getClassOrInterfaceType(com.github.antlrjavaparser.api.type.Type type)

Returns the final ClassOrInterfaceType from a Type

Parameters:

initType -

Returns:

the final ClassOrInterfaceType or null if no ClassOrInterfaceType found