Package org.jboss.jandex

Class Indexer

java.lang.Object

org.jboss.jandex.Indexer

public final class Indexer
extends Object

Analyzes and indexes the annotation and key structural information of a set of classes. The indexer will purposefully skip any class that is not Java 5 or later. It will also do a basic/quick structural scan on any class it determines does not have annotations.

The Indexer operates on input streams that point to class file data. Input streams do not need to be buffered, as the indexer already does this. There is also no limit to the number of class file streams the indexer can process, other than available memory.

The Indexer attempts to minimize the final memory state of the index, but to do this it must maintain additional in-process state (intern tables etc) until the index is complete.

Numerous optimizations are taken during indexing to attempt to minimize the CPU and I/O cost, however, the Java class file format was not designed for partial searching, which ultimately limits the efficiency of processing them.

Thread-Safety This class is not thread-safe can not be shared between threads. The index it produces however is thread-safe.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static class	Indexer.BooleanHolder
private static class	Indexer.InnerClassInfo
private static class	Indexer.IntegerHolder
private static class	Indexer.NameAndType
private static class	Indexer.PathElement
private static class	Indexer.PathElementStack
private static final class	Indexer.TmpObjects
private static class	Indexer.TypeAnnotationState

Field Summary

Fields

Modifier and Type	Field	Description
private static final byte[]	ANNOTATION_DEFAULT
private static final int	ANNOTATION_DEFAULT_LEN
private HashMap<DotName,List<AnnotationInstance>>	classAnnotations
private Map<DotName,ClassInfo>	classes
private int	classSignatureIndex
private static final byte[]	CODE
private static final int	CODE_LEN
private static final int	CONSTANT_CLASS
private static final int	CONSTANT_DOUBLE
private static final int	CONSTANT_DYNAMIC
private static final int	CONSTANT_FIELDREF
private static final int	CONSTANT_FLOAT
private static final int	CONSTANT_INTEGER
private static final int	CONSTANT_INTERFACEMETHODREF
private static final int	CONSTANT_INVOKEDYNAMIC
private static final int	CONSTANT_LONG
private static final int	CONSTANT_METHODHANDLE
private static final int	CONSTANT_METHODREF
private static final int	CONSTANT_METHODTYPE
private static final int	CONSTANT_MODULE
private static final int	CONSTANT_NAMEANDTYPE
private static final int	CONSTANT_PACKAGE
private static final int	CONSTANT_STRING
private static final int	CONSTANT_UTF8
private byte[]	constantPool
private byte[]	constantPoolAnnoAttrributes
private int[]	constantPoolOffsets
private int	constantPoolSize
private ClassInfo	currentClass
private ArrayList<AnnotationInstance>	elementAnnotations
private static final byte[]	ENCLOSING_METHOD
private static final int	ENCLOSING_METHOD_LEN
private static final byte[]	EXCEPTIONS
private static final int	EXCEPTIONS_LEN
private List<FieldInfo>	fields
private static final int	HAS_ANNOTATION_DEFAULT
private static final int	HAS_CODE
private static final int	HAS_ENCLOSING_METHOD
private static final int	HAS_EXCEPTIONS
private static final int	HAS_INNER_CLASSES
private static final int	HAS_LOCAL_VARIABLE_TABLE
private static final int	HAS_METHOD_PARAMETERS
private static final int	HAS_MODULE
private static final int	HAS_MODULE_MAIN_CLASS
private static final int	HAS_MODULE_PACKAGES
private static final int	HAS_PERMITTED_SUBCLASSES
private static final int	HAS_RECORD
private static final int	HAS_RUNTIME_ANNOTATION
private static final int	HAS_RUNTIME_INVISIBLE_ANNOTATION
private static final int	HAS_RUNTIME_INVISIBLE_PARAM_ANNOTATION
private static final int	HAS_RUNTIME_INVISIBLE_TYPE_ANNOTATION
private static final int	HAS_RUNTIME_PARAM_ANNOTATION
private static final int	HAS_RUNTIME_TYPE_ANNOTATION
private static final int	HAS_SIGNATURE
private Map<DotName,List<ClassInfo>>	implementors
private static final byte[]	INNER_CLASSES
private static final int	INNER_CLASSES_LEN
private Map<DotName,Indexer.InnerClassInfo>	innerClasses
private static final byte[]	LOCAL_VARIABLE_TABLE
private static final int	LOCAL_VARIABLE_TABLE_LEN
private Map<DotName,List<AnnotationInstance>>	masterAnnotations
private static final byte[]	METHOD_PARAMETERS
private static final int	METHOD_PARAMETERS_LEN
private IdentityHashMap<MethodInfo,MethodParamList>	methodParams
private List<MethodInfo>	methods
private static final byte[]	MODULE
private static final int	MODULE_LEN
private static final byte[]	MODULE_MAIN_CLASS
private static final int	MODULE_MAIN_CLASS_LEN
private static final byte[]	MODULE_PACKAGES
private static final int	MODULE_PACKAGES_LEN
private DotName	moduleMainClass
private List<DotName>	modulePackages
private Map<DotName,ModuleInfo>	modules
private NameTable	names
private static final byte[]	PERMITTED_SUBCLASSES
private static final int	PERMITTED_SUBCLASSES_LEN
private static final byte[]	RECORD
private static final int	RECORD_LEN
private List<RecordComponentInfo>	recordComponents
private static final byte[]	RUNTIME_ANNOTATIONS
private static final int	RUNTIME_ANNOTATIONS_LEN
private static final byte[]	RUNTIME_INVISIBLE_ANNOTATIONS
private static final int	RUNTIME_INVISIBLE_ANNOTATIONS_LEN
private static final byte[]	RUNTIME_INVISIBLE_PARAM_ANNOTATIONS
private static final int	RUNTIME_INVISIBLE_PARAM_ANNOTATIONS_LEN
private static final byte[]	RUNTIME_INVISIBLE_TYPE_ANNOTATIONS
private static final int	RUNTIME_INVISIBLE_TYPE_ANNOTATIONS_LEN
private static final byte[]	RUNTIME_PARAM_ANNOTATIONS
private static final int	RUNTIME_PARAM_ANNOTATIONS_LEN
private static final byte[]	RUNTIME_TYPE_ANNOTATIONS
private static final int	RUNTIME_TYPE_ANNOTATIONS_LEN
private static final byte[]	SIGNATURE
private static final int	SIGNATURE_LEN
private GenericSignatureParser	signatureParser
private IdentityHashMap<AnnotationTarget,Object>	signaturePresent
private List<Object>	signatures
private Map<DotName,List<ClassInfo>>	subclasses
private Map<DotName,List<ClassInfo>>	subinterfaces
private final Indexer.TmpObjects	tmpObjects
private IdentityHashMap<AnnotationTarget,List<Indexer.TypeAnnotationState>>	typeAnnotations
private Map<DotName,Set<ClassInfo>>	users

Constructor Summary

Constructors

Constructor	Description
Indexer()

Method Summary

Modifier and Type	Method	Description
private void	addImplementor(DotName interfaceName, ClassInfo currentClass)
private void	addSubclass(DotName superName, ClassInfo currentClass)
private void	addSubinterface(DotName superName, ClassInfo currentClass)
private void	adjustMethodParameters()
private void	applySignatures()
private int	bitsToInt(byte[] pool, int pos)
private long	bitsToLong(byte[] pool, int pos)
private ArrayDeque<Indexer.InnerClassInfo>	buildClassesQueue(Type type)	Returns a list of Indexer.InnerClassInfos representing types enclosing given type.
private Map<DotName,Type>	buildOwnerMap(Type type)
Index	complete()	Completes, finalizes, and returns the index after zero or more calls to index().
private static String	convertClassFieldDescriptor(String descriptor)
private ParameterizedType	convertParameterized(Type oType)
private static Type[]	copyTypeParameters(AnnotationTarget target)
private DotName	decodeClassEntry(int index)
private DotName	decodeDotNameEntry(int index, int constantType, String typeName, char delim)
private double	decodeDoubleEntry(int index)
private float	decodeFloatEntry(int index)
private int	decodeIntegerEntry(int index)
private long	decodeLongEntry(int index)
private DotName	decodeModuleEntry(int index)
private Indexer.NameAndType	decodeNameAndTypeEntry(int index)
private String	decodeOptionalUtf8Entry(int index)
private DotName	decodePackageEntry(int index)
private String	decodeUtf8Entry(int index)
private byte[]	decodeUtf8EntryAsBytes(int index)
private Type	deepCopyTypeIfNeeded(Type type)	When type contains no type variable references, returns type.
private TypeVariable	findTypeParameter(Type[] typeParameters, String identifier)	Finds and returns a type variable with given identifier among given typeParameters.
private static Type[]	getTypeParameters(AnnotationTarget target)
private String	getTypeVariableIdentifier(Type typeVariable)
private boolean	hasAnonymousEncloser(Indexer.TypeAnnotationState typeAnnotationState)
private boolean	hasLocalEncloser(Indexer.TypeAnnotationState typeAnnotationState)
void	index(InputStream stream)	Analyze and index the class file data present in given input stream.
ClassInfo	index$$bridge(InputStream stream)
void	indexClass(Class<?> clazz)	Analyze and index the class file data of given clazz.
ClassInfo	indexClass$$bridge(Class<?> clazz)
ClassSummary	indexWithSummary(InputStream stream)	Analyze and index the class file data present in given input stream.
private void	initClassFields()
private void	initIndexMaps()
private byte[]	intern(byte[] bytes)
private String	intern(String string)
private Type	intern(Type type)
private Type[]	intern(Type[] type)
private boolean	isBridge(MethodInfo methodInfo)
private static boolean	isEnumConstructor(MethodInfo method)
private boolean	isInnerConstructor(MethodInfo method)
private boolean	isJDK11OrNewer(DataInputStream stream)
private static boolean	match(byte[] target, int offset, byte[] expected)
private static int	minLength(int oldLength, int minGrowth)
private static int	newLength(int oldLength, int minGrowth, int prefGrowth)
private DotName	outermostAnnotableTypeName(Type type)	Returns the name of the outermost type that encloses given type and on which type annotations are admissible.
private void	parseClassSignature(String signature, ClassInfo clazz)
private void	parseFieldSignature(String signature, FieldInfo field)
private Type[]	parseMethodArgs(String descriptor, Indexer.IntegerHolder pos)
private void	parseMethodSignature(String signature, MethodInfo method)
private void	parseRecordComponentSignature(String signature, RecordComponentInfo recordComponent)
private Type	parseType(String descriptor)
private Type	parseType(String descriptor, Indexer.IntegerHolder pos)
private void	patchTypeVariableReferences(Type type, Deque<TypeVariable> typeVarStack, AnnotationTarget parametricEncloser)	Patches all type variable references contained in given type.
private int	popNestedDepth(Indexer.PathElementStack elements)
private AnnotationInstance	processAnnotation(DataInputStream data, AnnotationTarget target, boolean visible)
private void	processAnnotationDefault(DataInputStream data, MethodInfo target)
private AnnotationValue	processAnnotationElementValue(String name, DataInputStream data)
private void	processAnnotations(DataInputStream data, AnnotationTarget target, boolean visible)
private void	processAttributes(DataInputStream data, AnnotationTarget target)
private void	processClassInfo(DataInputStream data)
private void	processCode(DataInputStream data, MethodInfo target)
private boolean	processConstantPool(DataInputStream stream)
private void	processEnclosingMethod(DataInputStream data, ClassInfo target)
private void	processExceptions(DataInputStream data, MethodInfo target)
private void	processFieldInfo(DataInputStream data)
private void	processInnerClasses(DataInputStream data, ClassInfo target)
private void	processLocalVariableTable(DataInputStream data, MethodInfo target)
private void	processMethodInfo(DataInputStream data)
private void	processMethodParameters(DataInputStream data, MethodInfo target)
private void	processModule(DataInputStream data, ClassInfo target)
private List<ModuleInfo.ExportedPackageInfo>	processModuleExports(DataInputStream data)
private void	processModuleMainClass(DataInputStream data, ClassInfo target)
private List<ModuleInfo.OpenedPackageInfo>	processModuleOpens(DataInputStream data)
private void	processModulePackages(DataInputStream data, ClassInfo target)
private List<ModuleInfo.ProvidedServiceInfo>	processModuleProvides(DataInputStream data)
private List<ModuleInfo.RequiredModuleInfo>	processModuleRequires(DataInputStream data)
private List<DotName>	processModuleUses(DataInputStream data)
private void	processPermittedSubclasses(DataInputStream data, ClassInfo target)
private void	processRecordComponents(DataInputStream data)
private void	processSignature(DataInputStream data, AnnotationTarget target)
private ArrayList<Indexer.PathElement>	processTargetPath(DataInputStream data, Indexer.BooleanHolder genericsRequired, Indexer.BooleanHolder bridgeIncompatible)
private Indexer.TypeAnnotationState	processTypeAnnotation(DataInputStream data, AnnotationTarget target, boolean visible)
private void	processTypeAnnotations(DataInputStream data, AnnotationTarget target, boolean visible)
private Type	propagateOneTypeParameterBound(Type type, Type[] allTypeParams, AnnotationTarget target)
private void	propagateTypeParameterBounds()
private void	propagateTypeParameterBounds(AnnotationTarget target, Deque<TypeVariable> sharedTypeVarStack)
private void	propagateTypeVariables()
private Type	propagateTypeVariables(Type type, AnnotationTarget parametricEncloser)
private Type	rebuildNestedType(Type last, ArrayDeque<Indexer.InnerClassInfo> classes, Type type, int depth, Indexer.TypeAnnotationState typeAnnotationState)
private void	recordAnnotation(Map<DotName,List<AnnotationInstance>> classAnnotations, DotName annotation, AnnotationInstance instance)
private void	recordUsedClass(DotName usedClass)
private void	recordUsedType(Type type)
private void	resolveTypeAnnotation(AnnotationTarget target, Indexer.TypeAnnotationState typeAnnotationState)
private void	resolveTypeAnnotations()
private TypeVariable	resolveTypeParameter(AnnotationTarget target, String identifier)	Resolves a given type variable identifier against given parametric target (either a method or a class).
private Type	resolveTypePath(Type type, Indexer.TypeAnnotationState typeAnnotationState)
private void	resolveUsers()
private void	retargetTypeAnnotations(AnnotationTarget parametricEncloser, Type oldType, Type newType)
private Type	searchNestedType(Type type, int depth, Indexer.TypeAnnotationState typeAnnotationState)
private Type	searchTypePath(Type type, Indexer.TypeAnnotationState typeAnnotationState)
private static void	setTypeParameters(AnnotationTarget target, Type[] typeParameters)
private static byte[]	sizeToFit(byte[] buf, int needed, int offset, int remainingEntries)
private boolean	skipBridge(Indexer.TypeAnnotationState typeAnnotationState, MethodInfo method)
private static void	skipFully(InputStream s, long n)
private void	skipTargetPath(DataInputStream data)
private boolean	targetsArray(Indexer.TypeAnnotationState typeAnnotationState)
private void	updateTypeTarget(AnnotationTarget enclosingTarget, Indexer.TypeAnnotationState typeAnnotationState)
private void	updateTypeTargets()
private void	verifyMagic(DataInputStream stream)

Methods inherited from class java.lang.Object

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

Field Details

CONSTANT_CLASS

private static final int CONSTANT_CLASS

See Also:

• Constant Field Values

CONSTANT_FIELDREF

private static final int CONSTANT_FIELDREF

See Also:

• Constant Field Values

CONSTANT_METHODREF

private static final int CONSTANT_METHODREF

See Also:

• Constant Field Values

CONSTANT_INTERFACEMETHODREF

private static final int CONSTANT_INTERFACEMETHODREF

See Also:

• Constant Field Values

CONSTANT_STRING

private static final int CONSTANT_STRING

See Also:

• Constant Field Values

CONSTANT_INTEGER

private static final int CONSTANT_INTEGER

See Also:

• Constant Field Values

CONSTANT_FLOAT

private static final int CONSTANT_FLOAT

See Also:

• Constant Field Values

CONSTANT_LONG

private static final int CONSTANT_LONG

See Also:

• Constant Field Values

CONSTANT_DOUBLE

private static final int CONSTANT_DOUBLE

See Also:

• Constant Field Values

CONSTANT_NAMEANDTYPE

private static final int CONSTANT_NAMEANDTYPE

See Also:

• Constant Field Values

CONSTANT_UTF8

private static final int CONSTANT_UTF8

See Also:

• Constant Field Values

CONSTANT_INVOKEDYNAMIC

private static final int CONSTANT_INVOKEDYNAMIC

See Also:

• Constant Field Values

CONSTANT_METHODHANDLE

private static final int CONSTANT_METHODHANDLE

See Also:

• Constant Field Values

CONSTANT_METHODTYPE

private static final int CONSTANT_METHODTYPE

See Also:

• Constant Field Values

CONSTANT_MODULE

private static final int CONSTANT_MODULE

See Also:

• Constant Field Values

CONSTANT_PACKAGE

private static final int CONSTANT_PACKAGE

See Also:

• Constant Field Values

CONSTANT_DYNAMIC

private static final int CONSTANT_DYNAMIC

See Also:

• Constant Field Values

RUNTIME_ANNOTATIONS

private static final byte[] RUNTIME_ANNOTATIONS

RUNTIME_PARAM_ANNOTATIONS

private static final byte[] RUNTIME_PARAM_ANNOTATIONS

RUNTIME_TYPE_ANNOTATIONS

private static final byte[] RUNTIME_TYPE_ANNOTATIONS

ANNOTATION_DEFAULT

private static final byte[] ANNOTATION_DEFAULT

SIGNATURE

private static final byte[] SIGNATURE

EXCEPTIONS

private static final byte[] EXCEPTIONS

INNER_CLASSES

private static final byte[] INNER_CLASSES

ENCLOSING_METHOD

private static final byte[] ENCLOSING_METHOD

METHOD_PARAMETERS

private static final byte[] METHOD_PARAMETERS

LOCAL_VARIABLE_TABLE

private static final byte[] LOCAL_VARIABLE_TABLE

CODE

private static final byte[] CODE

MODULE

private static final byte[] MODULE

MODULE_PACKAGES

private static final byte[] MODULE_PACKAGES

MODULE_MAIN_CLASS

private static final byte[] MODULE_MAIN_CLASS

RECORD

private static final byte[] RECORD

RUNTIME_INVISIBLE_ANNOTATIONS

private static final byte[] RUNTIME_INVISIBLE_ANNOTATIONS

RUNTIME_INVISIBLE_PARAM_ANNOTATIONS

private static final byte[] RUNTIME_INVISIBLE_PARAM_ANNOTATIONS

RUNTIME_INVISIBLE_TYPE_ANNOTATIONS

private static final byte[] RUNTIME_INVISIBLE_TYPE_ANNOTATIONS

PERMITTED_SUBCLASSES

private static final byte[] PERMITTED_SUBCLASSES

RUNTIME_ANNOTATIONS_LEN

private static final int RUNTIME_ANNOTATIONS_LEN

RUNTIME_PARAM_ANNOTATIONS_LEN

private static final int RUNTIME_PARAM_ANNOTATIONS_LEN

RUNTIME_TYPE_ANNOTATIONS_LEN

private static final int RUNTIME_TYPE_ANNOTATIONS_LEN

ANNOTATION_DEFAULT_LEN

private static final int ANNOTATION_DEFAULT_LEN

SIGNATURE_LEN

private static final int SIGNATURE_LEN

EXCEPTIONS_LEN

private static final int EXCEPTIONS_LEN

INNER_CLASSES_LEN

private static final int INNER_CLASSES_LEN

ENCLOSING_METHOD_LEN

private static final int ENCLOSING_METHOD_LEN

METHOD_PARAMETERS_LEN

private static final int METHOD_PARAMETERS_LEN

LOCAL_VARIABLE_TABLE_LEN

private static final int LOCAL_VARIABLE_TABLE_LEN

CODE_LEN

private static final int CODE_LEN

MODULE_LEN

private static final int MODULE_LEN

MODULE_PACKAGES_LEN

private static final int MODULE_PACKAGES_LEN

MODULE_MAIN_CLASS_LEN

private static final int MODULE_MAIN_CLASS_LEN

RECORD_LEN

private static final int RECORD_LEN

RUNTIME_INVISIBLE_ANNOTATIONS_LEN

private static final int RUNTIME_INVISIBLE_ANNOTATIONS_LEN

RUNTIME_INVISIBLE_PARAM_ANNOTATIONS_LEN

private static final int RUNTIME_INVISIBLE_PARAM_ANNOTATIONS_LEN

RUNTIME_INVISIBLE_TYPE_ANNOTATIONS_LEN

private static final int RUNTIME_INVISIBLE_TYPE_ANNOTATIONS_LEN

PERMITTED_SUBCLASSES_LEN

private static final int PERMITTED_SUBCLASSES_LEN

HAS_RUNTIME_ANNOTATION

private static final int HAS_RUNTIME_ANNOTATION

See Also:

• Constant Field Values

HAS_RUNTIME_PARAM_ANNOTATION

private static final int HAS_RUNTIME_PARAM_ANNOTATION

See Also:

• Constant Field Values

HAS_RUNTIME_TYPE_ANNOTATION

private static final int HAS_RUNTIME_TYPE_ANNOTATION

See Also:

• Constant Field Values

HAS_SIGNATURE

private static final int HAS_SIGNATURE

See Also:

• Constant Field Values

HAS_EXCEPTIONS

private static final int HAS_EXCEPTIONS

See Also:

• Constant Field Values

HAS_INNER_CLASSES

private static final int HAS_INNER_CLASSES

See Also:

• Constant Field Values

HAS_ENCLOSING_METHOD

private static final int HAS_ENCLOSING_METHOD

See Also:

• Constant Field Values

HAS_ANNOTATION_DEFAULT

private static final int HAS_ANNOTATION_DEFAULT

See Also:

• Constant Field Values

HAS_METHOD_PARAMETERS

private static final int HAS_METHOD_PARAMETERS

See Also:

• Constant Field Values

HAS_LOCAL_VARIABLE_TABLE

private static final int HAS_LOCAL_VARIABLE_TABLE

See Also:

• Constant Field Values

HAS_CODE

private static final int HAS_CODE

See Also:

• Constant Field Values

HAS_MODULE

private static final int HAS_MODULE

See Also:

• Constant Field Values

HAS_MODULE_PACKAGES

private static final int HAS_MODULE_PACKAGES

See Also:

• Constant Field Values

HAS_MODULE_MAIN_CLASS

private static final int HAS_MODULE_MAIN_CLASS

See Also:

• Constant Field Values

HAS_RECORD

private static final int HAS_RECORD

See Also:

• Constant Field Values

HAS_RUNTIME_INVISIBLE_ANNOTATION

private static final int HAS_RUNTIME_INVISIBLE_ANNOTATION

See Also:

• Constant Field Values

HAS_RUNTIME_INVISIBLE_PARAM_ANNOTATION

private static final int HAS_RUNTIME_INVISIBLE_PARAM_ANNOTATION

See Also:

• Constant Field Values

HAS_RUNTIME_INVISIBLE_TYPE_ANNOTATION

private static final int HAS_RUNTIME_INVISIBLE_TYPE_ANNOTATION

See Also:

• Constant Field Values

HAS_PERMITTED_SUBCLASSES

private static final int HAS_PERMITTED_SUBCLASSES

See Also:

• Constant Field Values

constantPoolSize

private int constantPoolSize

constantPool

private byte[] constantPool

constantPoolOffsets

private int[] constantPoolOffsets

constantPoolAnnoAttrributes

private byte[] constantPoolAnnoAttrributes

currentClass

private ClassInfo currentClass

classAnnotations

private HashMap<DotName,List<AnnotationInstance>> classAnnotations

elementAnnotations

private ArrayList<AnnotationInstance> elementAnnotations

signaturePresent

private IdentityHashMap<AnnotationTarget,Object> signaturePresent

signatures

private List<Object> signatures

classSignatureIndex

private int classSignatureIndex

innerClasses

private Map<DotName,Indexer.InnerClassInfo> innerClasses

typeAnnotations

private IdentityHashMap<AnnotationTarget,List<Indexer.TypeAnnotationState>> typeAnnotations

methods

private List<MethodInfo> methods

fields

private List<FieldInfo> fields

recordComponents

private List<RecordComponentInfo> recordComponents

methodParams

private IdentityHashMap<MethodInfo,MethodParamList> methodParams

modulePackages

private List<DotName> modulePackages

moduleMainClass

private DotName moduleMainClass

masterAnnotations

private Map<DotName,List<AnnotationInstance>> masterAnnotations

subclasses

private Map<DotName,List<ClassInfo>> subclasses

subinterfaces

private Map<DotName,List<ClassInfo>> subinterfaces

implementors

private Map<DotName,List<ClassInfo>> implementors

classes

private Map<DotName,ClassInfo> classes

modules

private Map<DotName,ModuleInfo> modules

users

private Map<DotName,Set<ClassInfo>> users

names

private NameTable names

signatureParser

private GenericSignatureParser signatureParser

tmpObjects

private final Indexer.TmpObjects tmpObjects

Constructor Details

Indexer

public Indexer()

Method Details

match

private static boolean match(byte[] target,
 int offset,
 byte[] expected)

sizeToFit

private static byte[] sizeToFit(byte[] buf,
 int needed,
 int offset,
 int remainingEntries)

newLength

private static int newLength(int oldLength,
 int minGrowth,
 int prefGrowth)

minLength

private static int minLength(int oldLength,
 int minGrowth)

skipFully

private static void skipFully(InputStream s,
 long n)
                       throws IOException

Throws:

IOException

initIndexMaps

private void initIndexMaps()

initClassFields

private void initClassFields()

processMethodInfo

private void processMethodInfo(DataInputStream data)
                        throws IOException

Throws:

IOException

processFieldInfo

private void processFieldInfo(DataInputStream data)
                       throws IOException

Throws:

IOException

processRecordComponents

private void processRecordComponents(DataInputStream data)
                              throws IOException

Throws:

IOException

processPermittedSubclasses

private void processPermittedSubclasses(DataInputStream data,
 ClassInfo target)
                                 throws IOException

Throws:

IOException

processAttributes

private void processAttributes(DataInputStream data,
 AnnotationTarget target)
                        throws IOException

Throws:

IOException

processModule

private void processModule(DataInputStream data,
 ClassInfo target)
                    throws IOException

Throws:

IOException

processModuleRequires

private List<ModuleInfo.RequiredModuleInfo> processModuleRequires(DataInputStream data)
                                                           throws IOException

Throws:

IOException

processModuleExports

private List<ModuleInfo.ExportedPackageInfo> processModuleExports(DataInputStream data)
                                                           throws IOException

Throws:

IOException

processModuleOpens

private List<ModuleInfo.OpenedPackageInfo> processModuleOpens(DataInputStream data)
                                                       throws IOException

Throws:

IOException

processModuleUses

private List<DotName> processModuleUses(DataInputStream data)
                                 throws IOException

Throws:

IOException

processModuleProvides

private List<ModuleInfo.ProvidedServiceInfo> processModuleProvides(DataInputStream data)
                                                            throws IOException

Throws:

IOException

processModulePackages

private void processModulePackages(DataInputStream data,
 ClassInfo target)
                            throws IOException

Throws:

IOException

processModuleMainClass

private void processModuleMainClass(DataInputStream data,
 ClassInfo target)
                             throws IOException

Throws:

IOException

processCode

private void processCode(DataInputStream data,
 MethodInfo target)
                  throws IOException

Throws:

IOException

processAnnotationDefault

private void processAnnotationDefault(DataInputStream data,
 MethodInfo target)
                               throws IOException

Throws:

IOException

processAnnotations

private void processAnnotations(DataInputStream data,
 AnnotationTarget target,
 boolean visible)
                         throws IOException

Throws:

IOException

processInnerClasses

private void processInnerClasses(DataInputStream data,
 ClassInfo target)
                          throws IOException

Throws:

IOException

processMethodParameters

private void processMethodParameters(DataInputStream data,
 MethodInfo target)
                              throws IOException

Throws:

IOException

processLocalVariableTable

private void processLocalVariableTable(DataInputStream data,
 MethodInfo target)
                                throws IOException

Throws:

IOException

processEnclosingMethod

private void processEnclosingMethod(DataInputStream data,
 ClassInfo target)
                             throws IOException

Throws:

IOException

processTypeAnnotations

private void processTypeAnnotations(DataInputStream data,
 AnnotationTarget target,
 boolean visible)
                             throws IOException

Throws:

IOException

processTypeAnnotation

private Indexer.TypeAnnotationState processTypeAnnotation(DataInputStream data,
 AnnotationTarget target,
 boolean visible)
                                                   throws IOException

Throws:

IOException

adjustMethodParameters

private void adjustMethodParameters()

isInnerConstructor

private boolean isInnerConstructor(MethodInfo method)

isEnumConstructor

private static boolean isEnumConstructor(MethodInfo method)

resolveTypeAnnotations

private void resolveTypeAnnotations()

resolveUsers

private void resolveUsers()
                   throws IOException

Throws:

IOException

recordUsedType

private void recordUsedType(Type type)

recordUsedClass

private void recordUsedClass(DotName usedClass)

updateTypeTargets

private void updateTypeTargets()

getTypeParameters

private static Type[] getTypeParameters(AnnotationTarget target)

copyTypeParameters

private static Type[] copyTypeParameters(AnnotationTarget target)

setTypeParameters

private static void setTypeParameters(AnnotationTarget target,
 Type[] typeParameters)

resolveTypeAnnotation

private void resolveTypeAnnotation(AnnotationTarget target,
 Indexer.TypeAnnotationState typeAnnotationState)

skipBridge

private boolean skipBridge(Indexer.TypeAnnotationState typeAnnotationState,
 MethodInfo method)

isBridge

private boolean isBridge(MethodInfo methodInfo)

targetsArray

private boolean targetsArray(Indexer.TypeAnnotationState typeAnnotationState)

resolveTypePath

private Type resolveTypePath(Type type,
 Indexer.TypeAnnotationState typeAnnotationState)

popNestedDepth

private int popNestedDepth(Indexer.PathElementStack elements)

updateTypeTarget

private void updateTypeTarget(AnnotationTarget enclosingTarget,
 Indexer.TypeAnnotationState typeAnnotationState)

searchTypePath

private Type searchTypePath(Type type,
 Indexer.TypeAnnotationState typeAnnotationState)

rebuildNestedType

private Type rebuildNestedType(Type last,
 ArrayDeque<Indexer.InnerClassInfo> classes,
 Type type,
 int depth,
 Indexer.TypeAnnotationState typeAnnotationState)

convertParameterized

private ParameterizedType convertParameterized(Type oType)

searchNestedType

private Type searchNestedType(Type type,
 int depth,
 Indexer.TypeAnnotationState typeAnnotationState)

hasAnonymousEncloser

private boolean hasAnonymousEncloser(Indexer.TypeAnnotationState typeAnnotationState)

hasLocalEncloser

private boolean hasLocalEncloser(Indexer.TypeAnnotationState typeAnnotationState)

outermostAnnotableTypeName

private DotName outermostAnnotableTypeName(Type type)

Returns the name of the outermost type that encloses given type and on which type annotations are admissible. This is either the nearest enclosing static nested class, or the enclosing top-level class. If type is not a nested type, returs its name.

This could easily be implemented by calling buildClassesQueue(Type) and looking at the first element. The only difference is that the present implementation doesn't allocate and is probably a little faster.

buildClassesQueue

private ArrayDeque<Indexer.InnerClassInfo> buildClassesQueue(Type type)

Returns a list of Indexer.InnerClassInfos representing types enclosing given type. Only types on which type annotations are admissible are present in the result. That is, the first element of the list represents the outermost type on which type annotations are admissible, and the last element of the list is an InnerClassInfo representing type itself. Returns an empty list if type is not a nested type.

buildOwnerMap

private Map<DotName,Type> buildOwnerMap(Type type)

processTargetPath

private ArrayList<Indexer.PathElement> processTargetPath(DataInputStream data,
 Indexer.BooleanHolder genericsRequired,
 Indexer.BooleanHolder bridgeIncompatible)
                                                  throws IOException

Throws:

IOException

skipTargetPath

private void skipTargetPath(DataInputStream data)
                     throws IOException

Throws:

IOException

processExceptions

private void processExceptions(DataInputStream data,
 MethodInfo target)
                        throws IOException

Throws:

IOException

processSignature

private void processSignature(DataInputStream data,
 AnnotationTarget target)
                       throws IOException

Throws:

IOException

applySignatures

private void applySignatures()

parseClassSignature

private void parseClassSignature(String signature,
 ClassInfo clazz)

parseFieldSignature

private void parseFieldSignature(String signature,
 FieldInfo field)

parseMethodSignature

private void parseMethodSignature(String signature,
 MethodInfo method)

parseRecordComponentSignature

private void parseRecordComponentSignature(String signature,
 RecordComponentInfo recordComponent)

processAnnotation

private AnnotationInstance processAnnotation(DataInputStream data,
 AnnotationTarget target,
 boolean visible)
                                      throws IOException

Throws:

IOException

recordAnnotation

private void recordAnnotation(Map<DotName,List<AnnotationInstance>> classAnnotations,
 DotName annotation,
 AnnotationInstance instance)

intern

private String intern(String string)

intern

private byte[] intern(byte[] bytes)

intern

private Type intern(Type type)

intern

private Type[] intern(Type[] type)

processAnnotationElementValue

private AnnotationValue processAnnotationElementValue(String name,
 DataInputStream data)
                                               throws IOException

Throws:

IOException

processClassInfo

private void processClassInfo(DataInputStream data)
                       throws IOException

Throws:

IOException

addSubclass

private void addSubclass(DotName superName,
 ClassInfo currentClass)

addSubinterface

private void addSubinterface(DotName superName,
 ClassInfo currentClass)

addImplementor

private void addImplementor(DotName interfaceName,
 ClassInfo currentClass)

isJDK11OrNewer

private boolean isJDK11OrNewer(DataInputStream stream)
                        throws IOException

Throws:

IOException

verifyMagic

private void verifyMagic(DataInputStream stream)
                  throws IOException

Throws:

IOException

decodeClassEntry

private DotName decodeClassEntry(int index)
                          throws IOException

Throws:

IOException

decodeModuleEntry

private DotName decodeModuleEntry(int index)
                           throws IOException

Throws:

IOException

decodePackageEntry

private DotName decodePackageEntry(int index)
                            throws IOException

Throws:

IOException

decodeDotNameEntry

private DotName decodeDotNameEntry(int index,
 int constantType,
 String typeName,
 char delim)
                            throws IOException

Throws:

IOException

decodeOptionalUtf8Entry

private String decodeOptionalUtf8Entry(int index)
                                throws IOException

Throws:

IOException

decodeUtf8Entry

private String decodeUtf8Entry(int index)
                        throws IOException

Throws:

IOException

decodeUtf8EntryAsBytes

private byte[] decodeUtf8EntryAsBytes(int index)

decodeNameAndTypeEntry

private Indexer.NameAndType decodeNameAndTypeEntry(int index)
                                            throws IOException

Throws:

IOException

bitsToInt

private int bitsToInt(byte[] pool,
 int pos)

bitsToLong

private long bitsToLong(byte[] pool,
 int pos)

decodeIntegerEntry

private int decodeIntegerEntry(int index)

decodeLongEntry

private long decodeLongEntry(int index)

decodeFloatEntry

private float decodeFloatEntry(int index)

decodeDoubleEntry

private double decodeDoubleEntry(int index)

convertClassFieldDescriptor

private static String convertClassFieldDescriptor(String descriptor)

parseMethodArgs

private Type[] parseMethodArgs(String descriptor,
 Indexer.IntegerHolder pos)

parseType

private Type parseType(String descriptor)

parseType

private Type parseType(String descriptor,
 Indexer.IntegerHolder pos)

processConstantPool

private boolean processConstantPool(DataInputStream stream)
                             throws IOException

Throws:

IOException

indexClass

public void indexClass(Class<?> clazz)
                throws IOException

Analyze and index the class file data of given clazz. Each call adds information to the final complete index.

Parameters:

clazz - a previously-loaded class

Throws:

IOException - if the class file data is corrupt or the underlying stream fails

IllegalArgumentException - if clazz is null

indexClass$$bridge

public ClassInfo indexClass$$bridge(Class<?> clazz)
                             throws IOException

Throws:

IOException

index

public void index(InputStream stream)
           throws IOException

Analyze and index the class file data present in given input stream. Each call adds information to the final complete index. Closing the input stream is the caller's responsibility.

Parameters:

stream - the class bytecode to index, must not be null

Throws:

IOException - if the class file data is corrupt or the stream fails

IllegalArgumentException - if stream is null

index$$bridge

public ClassInfo index$$bridge(InputStream stream)
                        throws IOException

Throws:

IOException

indexWithSummary

public ClassSummary indexWithSummary(InputStream stream)
                              throws IOException

Analyze and index the class file data present in given input stream. Each call adds information to the final complete index. Closing the input stream is the caller's responsibility.

For reporting progress in batch indexers, this variant of index returns a summary of the just-indexed class.

Parameters:

stream - the class bytecode to index, must not be null

Returns:

a summary of the just-indexed class

Throws:

IOException - if the class file data is corrupt or the stream fails

IllegalArgumentException - if stream is null

complete

public Index complete()

Completes, finalizes, and returns the index after zero or more calls to index(). Future calls to index() will result in a new index.

Returns:

the master index for all scanned class streams

propagateTypeParameterBounds

private void propagateTypeParameterBounds()

propagateTypeParameterBounds

private void propagateTypeParameterBounds(AnnotationTarget target,
 Deque<TypeVariable> sharedTypeVarStack)

propagateOneTypeParameterBound

private Type propagateOneTypeParameterBound(Type type,
 Type[] allTypeParams,
 AnnotationTarget target)

deepCopyTypeIfNeeded

private Type deepCopyTypeIfNeeded(Type type)

When type contains no type variable references, returns type. When type does contain type variable references, returns a deep copy with each reference replaced by a new one. In that case, the newly created references must be patched by the caller.

When called from outside, type must be a type variable.

patchTypeVariableReferences

private void patchTypeVariableReferences(Type type,
 Deque<TypeVariable> typeVarStack,
 AnnotationTarget parametricEncloser)

Patches all type variable references contained in given type. The typeVarStack is used to track enclosing type variables when traversing the structure of the type; when called from outside, it must be empty and must not be used anywhere else. The parametricEncloser is the type's nearest enclosing annotation target that may have type parameters, that is, the nearest enclosing method or class.

findTypeParameter

private TypeVariable findTypeParameter(Type[] typeParameters,
 String identifier)

Finds and returns a type variable with given identifier among given typeParameters. Returns null when none exists.

resolveTypeParameter

private TypeVariable resolveTypeParameter(AnnotationTarget target,
 String identifier)

Resolves a given type variable identifier against given parametric target (either a method or a class). That is, if the target has a type parameter with matching identifier, returns it; otherwise, resolves identifier against target's nearest enclosing method or class. Returns null if the identifier can't be resolved.

getTypeVariableIdentifier

private String getTypeVariableIdentifier(Type typeVariable)

propagateTypeVariables

private void propagateTypeVariables()

propagateTypeVariables

private Type propagateTypeVariables(Type type,
 AnnotationTarget parametricEncloser)

retargetTypeAnnotations

private void retargetTypeAnnotations(AnnotationTarget parametricEncloser,
 Type oldType,
 Type newType)