lombok.eclipse.handlers
Class EclipseHandlerUtil

java.lang.Object
  lombok.eclipse.handlers.EclipseHandlerUtil

public class EclipseHandlerUtil
extends Object

Container for static utility methods useful to handlers written for eclipse.

isPrimitive

public static boolean isPrimitive(org.eclipse.jdt.internal.compiler.ast.TypeReference ref)

Checks if the given type reference represents a primitive type.

toEclipseModifier

public static int toEclipseModifier(AccessLevel value)

Turns an AccessLevel instance into the flag bit used by eclipse.

nameEquals

public static boolean nameEquals(char[][] typeName,
                                 String string)

Checks if an eclipse-style array-of-array-of-characters to represent a fully qualified name ('foo.bar.baz'), matches a plain string containing the same fully qualified name with dots in the string.

filterField

public static boolean filterField(org.eclipse.jdt.internal.compiler.ast.FieldDeclaration declaration)

Checks if the field should be included in operations that work on 'all' fields: If the field is static, or starts with a '$', or is actually an enum constant, 'false' is returned, indicating you should skip it.

fieldExists

public static EclipseHandlerUtil.MemberExistsResult fieldExists(String fieldName,
                                                                EclipseNode node)

Checks if there is a field with the provided name.

Parameters:

fieldName - the field name to check for.

node - Any node that represents the Type (TypeDeclaration) to look in, or any child node thereof.

methodExists

public static EclipseHandlerUtil.MemberExistsResult methodExists(String methodName,
                                                                 EclipseNode node)

Wrapper for methodExists(String, EclipseNode, boolean) with caseSensitive = true.

methodExists

public static EclipseHandlerUtil.MemberExistsResult methodExists(String methodName,
                                                                 EclipseNode node,
                                                                 boolean caseSensitive)

Checks if there is a method with the provided name. In case of multiple methods (overloading), only the first method decides if EXISTS_BY_USER or EXISTS_BY_LOMBOK is returned.

Parameters:

methodName - the method name to check for.

node - Any node that represents the Type (TypeDeclaration) to look in, or any child node thereof.

caseSensitive - If the search should be case sensitive.

constructorExists

public static EclipseHandlerUtil.MemberExistsResult constructorExists(EclipseNode node)

Checks if there is a (non-default) constructor. In case of multiple constructors (overloading), only the first constructor decides if EXISTS_BY_USER or EXISTS_BY_LOMBOK is returned.

Parameters:

node - Any node that represents the Type (TypeDeclaration) to look in, or any child node thereof.

injectFieldSuppressWarnings

public static void injectFieldSuppressWarnings(EclipseNode type,
                                               org.eclipse.jdt.internal.compiler.ast.FieldDeclaration field)

Inserts a field into an existing type. The type must represent a TypeDeclaration. The field carries the @SuppressWarnings("all") annotation.

injectField

public static void injectField(EclipseNode type,
                               org.eclipse.jdt.internal.compiler.ast.FieldDeclaration field)

Inserts a field into an existing type. The type must represent a TypeDeclaration.

injectMethod

public static void injectMethod(EclipseNode type,
                                org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration method)

Inserts a method into an existing type. The type must represent a TypeDeclaration.

createSuppressWarningsAll

public static org.eclipse.jdt.internal.compiler.ast.Annotation[] createSuppressWarningsAll(org.eclipse.jdt.internal.compiler.ast.ASTNode source,
                                                                                           org.eclipse.jdt.internal.compiler.ast.Annotation[] originalAnnotationArray)

findAnnotations

public static org.eclipse.jdt.internal.compiler.ast.Annotation[] findAnnotations(org.eclipse.jdt.internal.compiler.ast.FieldDeclaration field,
                                                                                 Pattern namePattern)

Searches the given field node for annotations and returns each one that matches the provided regular expression pattern. Only the simple name is checked - the package and any containing class are ignored.

generateNullCheck

public static org.eclipse.jdt.internal.compiler.ast.Statement generateNullCheck(org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration variable,
                                                                                org.eclipse.jdt.internal.compiler.ast.ASTNode source)

Generates a new statement that checks if the given variable is null, and if so, throws a NullPointerException with the variable name as message.

makeMarkerAnnotation

public static org.eclipse.jdt.internal.compiler.ast.MarkerAnnotation makeMarkerAnnotation(char[][] name,
                                                                                          org.eclipse.jdt.internal.compiler.ast.ASTNode source)

Create an annotation of the given name, and is marked as being generated by the given source.

createListOfNonExistentFields

public static List<Integer> createListOfNonExistentFields(List<String> list,
                                                          EclipseNode type,
                                                          boolean excludeStandard,
                                                          boolean excludeTransient)

Given a list of field names and a node referring to a type, finds each name in the list that does not match a field within the type.

makeCastExpression

public static org.eclipse.jdt.internal.compiler.ast.CastExpression makeCastExpression(org.eclipse.jdt.internal.compiler.ast.Expression ref,
                                                                                      org.eclipse.jdt.internal.compiler.ast.TypeReference castTo,
                                                                                      org.eclipse.jdt.internal.compiler.ast.ASTNode source)

In eclipse 3.7+, the CastExpression constructor was changed from a really weird version to a less weird one. Unfortunately that means we need to use reflection as we want to be compatible with eclipse versions before 3.7 and 3.7+.

Parameters:

ref - The foo in (String)foo.

castTo - The String in (String)foo.

makeIntLiteral

public static org.eclipse.jdt.internal.compiler.ast.IntLiteral makeIntLiteral(char[] token,
                                                                              org.eclipse.jdt.internal.compiler.ast.ASTNode source)

In eclipse 3.7+, IntLiterals are created using a factory-method Unfortunately that means we need to use reflection as we want to be compatible with eclipse versions before 3.7.