Packages

package br

In this representation of Java bytecode references to a Java class file's constant pool and to attributes are replaced by direct references to the corresponding constant pool entries. This facilitates developing analyses and fosters comprehension.

Based on the fact that indirect reference to constant pool entries are resolved and replaced by direct reference this representation is called the resolved representation.

This representation of Java bytecode is considered as OPAL's standard representation for writing Scala based analyses. This representation is engineered such that it facilitates writing analyses that use pattern matching.

Source
package.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. br
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. sealed abstract class AllocationSite extends AnyRef

    An allocation site (a (multi(a))new(array) instruction) in a method's bytecode.

    An allocation site (a (multi(a))new(array) instruction) in a method's bytecode. (Please see org.opalj.br.analyses.AllocationSitesKey for further details regarding the default set of allocation sites.)

    Note

    Information about a program's allocation sites can be made available using the respective key.

  2. sealed abstract class AllocationType extends AnyRef

    Enumeration of all allocation types.

  3. case class Annotation(annotationType: FieldType, elementValuePairs: ElementValuePairs = IndexedSeq.empty) extends AnnotationLike with Product with Serializable

    An annotation of a class, field, method or method parameter.

    An annotation of a class, field, method or method parameter.

    Annotations are associated with a class, field, or method using the attribute org.opalj.br.RuntimeInvisibleAnnotationTable or org.opalj.br.RuntimeVisibleAnnotationTable.

    Annotations are associated with a method parameter using the attribute org.opalj.br.RuntimeInvisibleParameterAnnotationTable or a org.opalj.br.RuntimeVisibleParameterAnnotationTable.

  4. abstract class AnnotationLike extends AnyRef

    An annotation of a code entity.

    An annotation of a code entity.

    Annotations are associated with a class, field, method, type etc. using the respective attributes.

  5. trait AnnotationTable extends Attribute

    The runtime (in)visible annotations of a class, method, or field.

    The runtime (in)visible annotations of a class, method, or field.

    Note

    At the JVM level, repeating annotations (as supported by Java 8) (http://docs.oracle.com/javase/tutorial/java/annotations/repeating.html) have no explicit support.

  6. case class AnnotationValue(annotation: Annotation) extends ElementValue with Product with Serializable
  7. type Annotations = IndexedSeq[Annotation]
  8. final case class AppendFrame(frameType: Int, offsetDelta: Int, verificationTypeInfoLocals: VerificationTypeInfoLocals) extends StackMapFrame with Product with Serializable
  9. final class ArrayAllocationSite extends AllocationSite
  10. final class ArrayType extends ReferenceType

    Represents an array type.

    Represents an array type.

    Comparing ArrayTypes

    To facilitate comparisons of (array) types, each array type is represented at any given time, by exactly one instance of ArrayType.

    General Information

    From the JVM specification

    An array type consists of a component type with a single dimension (whose length is not given by the type). The component type of an array type may itself be an array type. If, starting from any array type, one considers its component type, and then (if that is also an array type) the component type of that type, and so on, eventually one must reach a component type that is not an array type; this is called the element type of the array type. The element type of an array type is necessarily either a primitive type, or a class type, or an interface type.

  11. case class ArrayTypeSignature(typeSignature: TypeSignature) extends Signature with FieldTypeSignature with Product with Serializable

    See also

    For matching signatures see Signature.

  12. case class ArrayValue(values: IndexedSeq[ElementValue]) extends ElementValue with Product with Serializable
  13. trait Attribute extends AnyRef

    A class file attribute.

    A class file attribute.

    Note

    Some class file attributes are skipped or resolved while loading the class file and hence, are no longer represented at runtime.

  14. type Attributes = Seq[Attribute]
  15. sealed trait BaseType extends FieldType with TypeSignature
  16. sealed trait BaseTypeElementValue extends ElementValue

    Common super trait of all element values with a primitive base type.

  17. sealed abstract class BooleanType extends CTIntType

    The type of boolean values (true=1, false=0).

    The type of boolean values (true=1, false=0).

    Though the JVM internally uses an int value to store a boolean value the VM offers no special further support for handling booleans. In particular the conversion of some "byte|short|char|int" value to an int value is not directly supported.

  18. case class BooleanValue(value: Boolean) extends BaseTypeElementValue with Product with Serializable
  19. trait BootstrapArgument extends AnyRef

    A marker trait to identify those constant pool values that can be arguments of boot strap methods.

  20. type BootstrapArguments = IndexedSeq[BootstrapArgument]
  21. case class BootstrapMethod(handle: MethodHandle, arguments: BootstrapArguments) extends Product with Serializable

    Java 7's 'BootstrapMethod'.

  22. case class BootstrapMethodTable(methods: BootstrapMethods) extends Attribute with Product with Serializable

    Java 7's BootstrapMethods_attribute.

  23. type BootstrapMethods = IndexedSeq[BootstrapMethod]
  24. sealed abstract class ByteType extends IntLikeType
  25. case class ByteValue(value: Byte) extends BaseTypeElementValue with Product with Serializable
  26. sealed trait CTIntType extends BaseType

    All values which are stored in a value with computational type integer.

  27. sealed abstract class CharType extends IntLikeType
  28. case class CharValue(value: Char) extends BaseTypeElementValue with Product with Serializable
  29. sealed trait ChopFrame extends StackMapFrame
  30. final case class ChopFrame248(offsetDelta: Int) extends StackMapFrame with ChopFrame with Product with Serializable
  31. final case class ChopFrame249(offsetDelta: Int) extends StackMapFrame with ChopFrame with Product with Serializable
  32. final case class ChopFrame250(offsetDelta: Int) extends StackMapFrame with ChopFrame with Product with Serializable
  33. final class ClassFile extends ConcreteSourceElement

    Represents a single class file which either defines a class type or an interface type.

    Represents a single class file which either defines a class type or an interface type. (Annotation types are also interface types and Enums are class types.)

    Note

    Equality of ClassFile objects is reference based and a class file's hash code is the same as the underlying ObjectType's hash code; i.e., ' thisType's hash code.

  34. trait ClassFileAttributeBuilder extends AnyRef

    Given a class files's main elements the attribute is build.

    Given a class files's main elements the attribute is build.

    See also

    The BytecodeAssember framework for an example usage.

  35. trait ClassFileRepository extends AnyRef

    Enables the lookup of ClassFiles.

  36. class ClassHierarchy extends AnyRef

    Represents a project's class hierarchy.

    Represents a project's class hierarchy. The class hierarchy only contains information about those classes that were explicitly added to it except of java.lang.Object; the type java.lang.Object is always part of the class hierarchy. Hence, the class hierarchy may contain holes.

    Thread safety

    This class is effectively immutable; concurrent access to the class hierarchy is supported.

    Note

    Unless explicitly documented, it is an error to pass an instance of ObjectType to any method if the ObjectType was not previously added. If in doubt, first check if the type is known (isKnown/ifKnown).

    ,

    Java 9 module definitions are completely ignored.

  37. trait ClassMember extends ConcreteSourceElement

    Abstractions over the common properties of class members (Methods and Fields).

  38. case class ClassSignature(formalTypeParameters: List[FormalTypeParameter], superClassSignature: ClassTypeSignature, superInterfacesSignature: List[ClassTypeSignature]) extends Signature with Product with Serializable

    See also

    For matching signatures see Signature.

  39. case class ClassTypeSignature(packageIdentifier: Option[String], simpleClassTypeSignature: SimpleClassTypeSignature, classTypeSignatureSuffix: List[SimpleClassTypeSignature]) extends Signature with FieldTypeSignature with ThrowsSignature with Product with Serializable

    See also

    For matching signatures see Signature.

  40. case class ClassValue(value: Type) extends ElementValue with Product with Serializable
  41. final class Code extends Attribute with CommonAttributes with InstructionsContainer with FilterMonadic[(PC, Instruction), Nothing]

    Representation of a method's code attribute, that is, representation of a method's implementation.

  42. case class CodeAnalysisFailedException(message: String, code: Code, pc: PC) extends RuntimeException with Product with Serializable

    Exception that is thrown when an analysis of a method's implementation has failed.

    Exception that is thrown when an analysis of a method's implementation has failed.

    message

    The message that describes the reason.

    code

    The code block for which the analysis failed.

    pc

    The program counter of the last instruction that was tried to analyze.

  43. trait CodeAttributeBuilder[T] extends AnyRef

    Given a method's signature and access flags the code attribute is build and some meta information - depending on the type of the code attribute builder - is collected.

    Given a method's signature and access flags the code attribute is build and some meta information - depending on the type of the code attribute builder - is collected.

    See also

    The BytecodeAssember framework for an example usage.

  44. trait CommonAttributes extends AnyRef

    Defines methods to return common attributes from the attributes table of ClassFile, Field, Method and Code declarations.

  45. trait CommonSourceElementAttributes extends CommonAttributes

    Defines methods to return common attributes from the attributes table of ClassFile, Field and Method declarations.

  46. case class CompactLineNumberTable(rawLineNumbers: Array[Byte]) extends LineNumberTable with Product with Serializable

    A method's line number table.

  47. class CompareAllConfiguration extends SimilarityTestConfiguration
  48. sealed abstract class ComputationalType extends AnyRef

    The computational type of a value on the operand stack.

    The computational type of a value on the operand stack.

    (cf. JVM Spec. 2.11.1 Types and the Java Virtual Machine).

  49. sealed abstract class ComputationalTypeCategory extends AnyRef

    The computational type category of a value on the operand stack.

    The computational type category of a value on the operand stack.

    (cf. JVM Spec. 2.11.1 Types and the Java Virtual Machine).

  50. trait ConcreteSourceElement extends SourceElement

    We treat as a source element every entity that can be referred to by other class files.

  51. final case class ConstantClass(value: ReferenceType) extends ConstantValue[ReferenceType] with Product with Serializable

    Represents a class or interface.

    Represents a class or interface.

    ConstantClass is, e.g., used by anewarray and multianewarray instructions. A ConstantClass value is never a Field value. I.e., it is never used to set the value of a static final field.

  52. final case class ConstantDouble(value: Double) extends ConstantFieldValue[Double] with Product with Serializable
  53. sealed abstract class ConstantFieldValue[T] extends Attribute with ConstantValue[T]

    A representation of the constant value of a field.

  54. final case class ConstantFloat(value: Float) extends ConstantFieldValue[Float] with Product with Serializable
  55. final case class ConstantInteger(value: Int) extends ConstantFieldValue[Int] with Product with Serializable
  56. final case class ConstantLong(value: Long) extends ConstantFieldValue[Long] with Product with Serializable
  57. final case class ConstantString(value: String) extends ConstantFieldValue[String] with Product with Serializable
  58. trait ConstantValue[T] extends BootstrapArgument

    Represents constant values; that is, values pushed onto the stack by the ldc(2)(_w) instructions or type information required by the instructions to create arrays.

    Represents constant values; that is, values pushed onto the stack by the ldc(2)(_w) instructions or type information required by the instructions to create arrays.

    Note

    A MethodHandle or MethodType (i.e., a MethodDescriptor) is also a ConstantValue.

  59. sealed abstract class ContravariantIndicator extends VarianceIndicator

    A declaration such as <? super Entry> is represented in class file signatures by the ContravariantIndicator ("? super") and a FieldTypeSignature.

    A declaration such as <? super Entry> is represented in class file signatures by the ContravariantIndicator ("? super") and a FieldTypeSignature.

    See also

    For matching signatures see Signature.

  60. sealed abstract class CovariantIndicator extends VarianceIndicator

    If you have a declaration such as <? extends Entry> then the "? extends" part is represented by the CovariantIndicator.

    If you have a declaration such as <? extends Entry> then the "? extends" part is represented by the CovariantIndicator.

    See also

    For matching signatures see Signature.

  61. sealed abstract class DoubleType extends NumericType
  62. case class DoubleValue(value: Double) extends BaseTypeElementValue with Product with Serializable
  63. sealed trait ElementValue extends Attribute

    An element value represents an annotation's value or an annonation's default value; depending on the context in which it is used.

  64. case class ElementValuePair(name: String, value: ElementValue) extends Product with Serializable

    An annotation's name-value pair.

  65. type ElementValuePairs = IndexedSeq[ElementValuePair]
  66. case class EnclosingMethod(clazz: ObjectType, name: Option[String], descriptor: Option[MethodDescriptor]) extends Attribute with Product with Serializable

    The optional enclosing method attribute of a class.

    The optional enclosing method attribute of a class.

    name

    The name of the enclosing method. The name is optional, but if defined the descriptor also has to be defined.

    descriptor

    The method descriptor of the enclosing method. The descriptor is optional, but if defined the name also has to be defined.

  67. case class EnumValue(enumType: ObjectType, constName: String) extends ElementValue with Product with Serializable
  68. case class ExceptionHandler(startPC: Int, endPC: Int, handlerPC: Int, catchType: Option[ObjectType]) extends Product with Serializable

    An entry in the exceptions table of a org.opalj.br.Code block.

    An entry in the exceptions table of a org.opalj.br.Code block.

    startPC

    A valid index into the code array. It points to the first instruction in the "try-block" (inclusive).

    endPC

    An index into the code array that points to the instruction after the "try-block" (exclusive).

    handlerPC

    Points to the first instruction of the exception handler.

    catchType

    The type of the exception that is catched. None in case of a finally block.

  69. type ExceptionHandlers = IndexedSeq[ExceptionHandler]
  70. case class ExceptionTable(exceptions: Exceptions) extends Attribute with Product with Serializable

    Attribute in a method's attributes table that declares the (checked) exceptions that may be thrown by the method.

  71. type Exceptions = Seq[ObjectType]
  72. case class Exports(exports: String, exportsTo: IndexedSeq[String]) extends Product with Serializable

    exports

    Name of an exported package in internal form.

    exportsTo

    List of names of modules whose code can access the public types in this exported package (in internal form).

  73. final class Field extends JVMField
  74. sealed abstract class FieldAccessMethodHandle extends MethodHandle
  75. trait FieldAttributeBuilder extends AnyRef

    Given a field's information a (final) attribute related to the field is build.

  76. case class FieldIdentifier(declaringObjectType: ObjectType, fieldName: String) extends StructureIdentifier with Product with Serializable
  77. sealed abstract class FieldReadAccessMethodHandle extends FieldAccessMethodHandle
  78. final class FieldTemplate extends JVMField
  79. sealed trait FieldType extends Type

    Supertype of all types except VoidType.

  80. sealed trait FieldTypeSignature extends Signature with TypeSignature

    See also

    For matching signatures see Signature.

  81. sealed abstract class FieldWriteAccessMethodHandle extends FieldAccessMethodHandle
  82. type Fields = IndexedSeq[Field]
  83. sealed abstract class FloatType extends NumericType
  84. case class FloatValue(value: Float) extends BaseTypeElementValue with Product with Serializable
  85. case class FormalTypeParameter(identifier: String, classBound: Option[FieldTypeSignature], interfaceBound: List[FieldTypeSignature]) extends Product with Serializable

    See also

    For matching signatures see Signature.

  86. final case class FullFrame(offsetDelta: Int, verificationTypeInfoLocals: VerificationTypeInfoLocals, verificationTypeInfoStack: VerificationTypeInfoStack) extends StackMapFrame with Product with Serializable
  87. case class GetFieldMethodHandle(declaringClassType: ObjectType, name: String, fieldType: FieldType) extends FieldReadAccessMethodHandle with Product with Serializable
  88. case class GetStaticMethodHandle(declaringClassType: ObjectType, name: String, fieldType: FieldType) extends FieldReadAccessMethodHandle with Product with Serializable
  89. case class InnerClass(innerClassType: ObjectType, outerClassType: Option[ObjectType], innerName: Option[String], innerClassAccessFlags: Int) extends Product with Serializable
  90. case class InnerClassTable(innerClasses: InnerClasses) extends Attribute with Product with Serializable

    Attribute in a class' attribute table the encodes information about inner classes.

  91. type InnerClasses = IndexedSeq[InnerClass]
  92. type Instructions = Array[Instruction]
  93. trait InstructionsContainer extends AnyRef

    Common interface of all elements that have (at most one) sequence of instructions.

  94. sealed abstract class IntLikeType extends NumericType with CTIntType

    An IntLikeType is every type (byte, char, short and int) that uses a primtive int to store the current value and which has explicit support in the JVM.

    An IntLikeType is every type (byte, char, short and int) that uses a primtive int to store the current value and which has explicit support in the JVM.

    Note

    Boolean values are (at least conceptually) also stored in ints. However, the JVM has basically no explicit support for booleans (e.g., a conversion of an int value to a boolean is not directly supported).

  95. case class IntValue(value: Int) extends BaseTypeElementValue with Product with Serializable
  96. sealed abstract class IntegerType extends IntLikeType
  97. case class InvokeInterfaceMethodHandle(receiverType: ReferenceType, name: String, methodDescriptor: MethodDescriptor) extends MethodCallMethodHandle with Product with Serializable
  98. case class InvokeSpecialMethodHandle(receiverType: ReferenceType, isInterface: Boolean, name: String, methodDescriptor: MethodDescriptor) extends MethodCallMethodHandle with Product with Serializable
  99. case class InvokeStaticMethodHandle(receiverType: ReferenceType, isInterface: Boolean, name: String, methodDescriptor: MethodDescriptor) extends MethodCallMethodHandle with Product with Serializable
  100. case class InvokeVirtualMethodHandle(receiverType: ReferenceType, name: String, methodDescriptor: MethodDescriptor) extends MethodCallMethodHandle with Product with Serializable
  101. sealed abstract class JVMField extends ClassMember with Ordered[JVMField]

    Represents a single field declaration/definition.

    Represents a single field declaration/definition.

    Note

    Identity (w.r.t. equals/hashCode) is intentionally by reference (default behavior).

    ,

    Fields, which are directly created, have no link to "their defining" ClassFile. This link is implicitly established when a method is added to a ClassFile. This operation also updates the field object.

  102. sealed abstract class JVMMethod extends ClassMember with Ordered[JVMMethod] with InstructionsContainer

    Represents a single method.

    Represents a single method.

    Method objects are constructed using the companion object's factory methods.

    Note

    Equality of methods is – by purpose – reference based.

    ,

    Methods, which are directly created, have no link to "their defining" ClassFile. This link is implicitly established when a method is added to a ClassFile. This operation also updates the method object. Hence, an empty method/constructor which is identical across multiple classes can be reused.

  103. case class LineNumber(startPC: Int, lineNumber: Int) extends Product with Serializable

    An entry in a line number table.

  104. trait LineNumberTable extends Attribute

    A method's line number table.

  105. type LineNumbers = Seq[LineNumber]
  106. type LiveVariables = Array[BitSet]
  107. case class LocalVariable(startPC: PC, length: Int, name: String, fieldType: FieldType, index: Int) extends Product with Serializable

    An entry in a local variable table.

  108. case class LocalVariableTable(localVariables: LocalVariables) extends Attribute with Product with Serializable

    Representation of the local variable table.

  109. case class LocalVariableType(startPC: Int, length: Int, name: String, signature: FieldTypeSignature, index: Int) extends Product with Serializable
  110. case class LocalVariableTypeTable(localVariableTypes: LocalVariableTypes) extends Attribute with Product with Serializable

    Representation of the local variable type table.

  111. type LocalVariableTypes = IndexedSeq[LocalVariableType]
  112. type LocalVariables = IndexedSeq[LocalVariable]
  113. case class LocalvarTableEntry(startPC: Int, length: Int, index: Int) extends Product with Serializable
  114. sealed abstract class LongType extends NumericType
  115. case class LongValue(value: Long) extends BaseTypeElementValue with Product with Serializable
  116. final class Method extends JVMMethod

    A method belonging to a class file.

    A method belonging to a class file. Method objects are created by creating a class file using MethodTemplates.

  117. trait MethodAttributeBuilder extends AnyRef

    Given a method's signature and access flags the attribute related to the method is build.

    Given a method's signature and access flags the attribute related to the method is build.

    See also

    The BytecodeAssember framework for an example usage.

  118. sealed abstract class MethodCallMethodHandle extends MethodHandle
  119. sealed abstract class MethodDescriptor extends ConstantValue[MethodDescriptor] with (Int) ⇒ FieldType with Ordered[MethodDescriptor]

    A method descriptor represents the parameters that the method takes and the value that it returns.

    A method descriptor represents the parameters that the method takes and the value that it returns.

    Note

    The equals(Any):Boolean method takes the number of parameters and types into account. I.e., two method descriptor objects are equal if they have the same number of parameters and each parameter has the same Type.

  120. sealed abstract class MethodHandle extends ConstantValue[MethodHandle]

    A method handle.

  121. case class MethodIdentifier(declaringReferenceType: ReferenceType, methodName: String, methodDescriptor: MethodDescriptor) extends StructureIdentifier with Product with Serializable
  122. case class MethodParameter(name: Option[String], accessFlags: Int) extends Product with Serializable

    The description of a method parameter.

    The description of a method parameter. If name is None a formal parameter is described.

  123. case class MethodParameterTable(parameters: MethodParameters) extends (Int) ⇒ MethodParameter with Attribute with Product with Serializable

    Representation of a method's information about the method parameters.

  124. type MethodParameters = IndexedSeq[MethodParameter]
  125. final case class MethodSignature(name: String, descriptor: MethodDescriptor) extends Product with Serializable

    Represents a method signature which consists of the name and descriptor of a method; the signatures of all methods of a class file has to be different.

  126. final class MethodTemplate extends JVMMethod

    A method which is not (yet) associated with a class file.

  127. case class MethodTypeSignature(formalTypeParameters: List[FormalTypeParameter], parametersTypeSignatures: List[TypeSignature], returnTypeSignature: ReturnTypeSignature, throwsSignature: List[ThrowsSignature]) extends Signature with Product with Serializable

    See also

    For matching signatures see Signature.

  128. type Methods = IndexedSeq[Method]
  129. case class Module(requires: IndexedSeq[Requires], exports: IndexedSeq[Exports], uses: IndexedSeq[ObjectType], provides: IndexedSeq[Provides]) extends Attribute with Product with Serializable

    Definition of a Java 9 module.

  130. case class NewInvokeSpecialMethodHandle(receiverType: ReferenceType, name: String, methodDescriptor: MethodDescriptor) extends MethodCallMethodHandle with Product with Serializable
  131. trait NoSourceElementsVisitor extends SourceElementsVisitor[Unit]

    Simple implementation of the SourceElementsVisitor trait where all methods do nothing.

  132. sealed abstract class NumericType extends BaseType
  133. final class ObjectAllocationSite extends AllocationSite
  134. final class ObjectType extends ReferenceType

    Represents an ObjectType.

  135. case class ObjectVariableInfo(clazz: ReferenceType) extends VerificationTypeInfo with Product with Serializable
  136. type Opcode = Int
  137. type PC = Int

    A program counter identifies an instruction in a code array.

    A program counter identifies an instruction in a code array.

    A program counter is a value in the range [0/*UShort.min*/, 65535/*UShort.max*/].

    Note

    This type alias serves comprehension purposes.

  138. type PCs = IntArraySet

    A collection of program counters using an IntArraySet as its backing collection.

    A collection of program counters using an IntArraySet as its backing collection.

    Using PCs is in particular well suited for small(er) collections.

    Note

    This type alias serves comprehension purposes.

  139. trait ParameterAnnotationTable extends Attribute

    Parameter annotations.

  140. type ParameterAnnotations = IndexedSeq[Annotations]
  141. case class ProperTypeArgument(varianceIndicator: Option[VarianceIndicator], fieldTypeSignature: FieldTypeSignature) extends TypeArgument with Product with Serializable

    See also

    For matching signatures see Signature.

  142. case class Provides(provides: ObjectType, withInterface: ObjectType) extends Product with Serializable
  143. case class PutFieldMethodHandle(declaringClassType: ObjectType, name: String, fieldType: FieldType) extends FieldWriteAccessMethodHandle with Product with Serializable
  144. case class PutStaticMethodHandle(declaringClassType: ObjectType, name: String, fieldType: FieldType) extends FieldWriteAccessMethodHandle with Product with Serializable
  145. sealed abstract class ReferenceType extends FieldType
  146. case class Requires(requires: String, requiresFlags: Int) extends Product with Serializable

    requires

    The name of a required module.

  147. trait ReturnTypeSignature extends SignatureElement
  148. case class RuntimeInvisibleAnnotationTable(annotations: Annotations) extends AnnotationTable with Product with Serializable

    The runtime invisible class, method, or field annotations.

  149. case class RuntimeInvisibleParameterAnnotationTable(parameterAnnotations: ParameterAnnotations) extends ParameterAnnotationTable with Product with Serializable

    Parameter annotations.

  150. case class RuntimeInvisibleTypeAnnotationTable(typeAnnotations: TypeAnnotations) extends TypeAnnotationTable with Product with Serializable

    The runtime invisible type annotations.

  151. case class RuntimeVisibleAnnotationTable(annotations: Annotations) extends AnnotationTable with Product with Serializable

    A class, method, or field annotation.

  152. case class RuntimeVisibleParameterAnnotationTable(parameterAnnotations: ParameterAnnotations) extends ParameterAnnotationTable with Product with Serializable

    Parameter annotations.

  153. case class RuntimeVisibleTypeAnnotationTable(typeAnnotations: TypeAnnotations) extends TypeAnnotationTable with Product with Serializable

    A runtime visible type annotation.

  154. final case class SameFrame(frameType: Int) extends StackMapFrame with Product with Serializable
  155. final case class SameFrameExtended(offsetDelta: Int) extends StackMapFrame with Product with Serializable
  156. final case class SameLocals1StackItemFrame(frameType: Int, verificationTypeInfoStackItem: br.VerificationTypeInfo) extends StackMapFrame with Product with Serializable
  157. final case class SameLocals1StackItemFrameExtended(offsetDelta: Int, verificationTypeInfoStackItem: br.VerificationTypeInfo) extends StackMapFrame with Product with Serializable
  158. sealed abstract class ShortType extends IntLikeType
  159. case class ShortValue(value: Short) extends BaseTypeElementValue with Product with Serializable
  160. sealed abstract class Signature extends SignatureElement with Attribute

    An attribute-level signature as defined in the JVM specification.

    An attribute-level signature as defined in the JVM specification.

    To match Signature objects the predefined matchers/extractors can be used. * @example

    Example 1

    interface Processor extends Function<Object, Void> { /*empty*/ }

    ClassSignature: Ljava/lang/Object;Ljava/util/function/Function<Ljava/lang/Object;Ljava/lang/Void;>;

    ClassSignature(
      typeParameters=List(),
      superClass=ClassTypeSignature(Some(java/lang/),SimpleClassTypeSignature(Object,List()),List()),
      superInterfaces=List(
          ClassTypeSignature(
              Some(java/util/function/),
              SimpleClassTypeSignature(Function,
                    List(ProperTypeArgument(
                           None,
                           ClassTypeSignature(
                              Some(java/lang/),
                              SimpleClassTypeSignature(Object,List()),
                              List())),
                       ProperTypeArgument(
                          None,
                          ClassTypeSignature(
                              Some(java/lang/),
                              SimpleClassTypeSignature(Void,List()),
                              List())))),
              List())))

    Example 2

    interface Col<C> { /*empty*/ }

    ClassSignature: <C:Ljava/lang/Object;>Ljava/lang/Object;

    ClassSignature(
        typeParameters=
            List(
                FormalTypeParameter(
                    C,
                    Some(ClassTypeSignature(
                            Some(java/lang/),SimpleClassTypeSignature(Object,List()),List())),
                    List())),
         superClass=ClassTypeSignature(
                Some(java/lang/),SimpleClassTypeSignature(Object,List()),List()),
         superInterfaces=List())

    Example 3

    interface ColObject extends Col<Object> { /*empty*/ }

    ClassSignature: Ljava/lang/Object;LCol<Ljava/lang/Object;>;

    ClassSignature(
        typeParameters=List(),
        superClass=ClassTypeSignature(Some(java/lang/),SimpleClassTypeSignature(Object,List()),List()),
        superInterfaces=List(
                ClassTypeSignature(
                    None,
                    SimpleClassTypeSignature(
                        Col,
                        List(ProperTypeArgument(
                                variance=None,
                                signature=ClassTypeSignature(Some(java/lang/),SimpleClassTypeSignature(Object,List()),List()))
                     )),
                     List())))

    Example 4

    interface ColError<E extends Error> extends Col<E>{/*empty*/}

    ClassSignature: <E:Ljava/lang/Error;>Ljava/lang/Object;LCol<TE;>;

    ClassSignature(
        typeParameters=List(
                FormalTypeParameter(
                    E,
                    Some(ClassTypeSignature(Some(java/lang/),SimpleClassTypeSignature(Error,List()),List())),List())),
        superClass=ClassTypeSignature(Some(java/lang/),SimpleClassTypeSignature(Object,List()),List()),
        superInterfaces=List(
                ClassTypeSignature(
                    None,
                    SimpleClassTypeSignature(
                        Col,
                        List(ProperTypeArgument(variance=None,signature=TypeVariableSignature(E)))),
                    List())))

    Example 5

    class Use {
      // The following fields all have "ClassTypeSignatures"
      Col<?> ce = null; // Signature: LCol<*>;
      Col<Object> co = null; // Signature: LCol;
      Col<? super Serializable> cs = null; // Signature: LCol<-Ljava/io/Serializable;>;
      Col<? extends Comparable<?>> cc = null; // Signature: LCol<+Ljava/lang/Comparable<*>;>;
    
      MyCol<java.util.List<Object>> mco = new MyCol<>();
      MyCol<java.util.List<Object>>.MyInnerCol<Comparable<java.util.List<Object>>> mico = this.mco.new MyInnerCol<Comparable<java.util.List<Object>>>();
      // Signature: LMyCol;>.MyInnerCol;>;>;
    }

    AST of mico:

    ClassSignature(
        typeParameters=List(),
        superClass=ClassTypeSignature(
                None,
                SimpleClassTypeSignature(
                    MyCol,
                    List(ProperTypeArgument(
                            variance=None,
                            signature=ClassTypeSignature(
                                    Some(java/util/),
                                    SimpleClassTypeSignature(
                                        List,
                                        List(ProperTypeArgument(
                                                variance=None,
                                                signature=ClassTypeSignature(
                                                        Some(java/lang/),
                                                        SimpleClassTypeSignature(Object,List()),
                                                        List())))),
                                     List())))),
                /*suffic=*/List(SimpleClassTypeSignature(
                        MyInnerCol,
                        List(ProperTypeArgument(
                                variance=None,
                                signature=ClassTypeSignature(
                                    Some(java/lang/),
                                    SimpleClassTypeSignature(
                                        Comparable,
                                        List(ProperTypeArgument(
                                                variance=None,
                                                signature=ClassTypeSignature(
                                                        Some(java/util/),
                                                        SimpleClassTypeSignature(
                                                            List,
                                                            List(ProperTypeArgument(
                                                                    variance=None,
                                                                    signature=ClassTypeSignature(
                                                                            Some(java/lang/),
                                                                            SimpleClassTypeSignature(Object,List()),
                                                                            List())))),
                                                        List())))),
                                    List())))))),
        superInterfaces=List())

    Matching Signatures

    Scala REPL:

    val SignatureParser = org.opalj.br.reader.SignatureParser
    val GenericType = org.opalj.br.GenericType
    val SimpleGenericType = org.opalj.br.SimpleGenericType
    val BasicClassTypeSignature = org.opalj.br.BasicClassTypeSignature
    
    SignatureParser.parseClassSignature("Ljava/lang/Object;LCol;").superInterfacesSignature.head match { case BasicClassTypeSignature(ot) => ot.toJava; case _ => null}
    // res: String = Col
    
    SignatureParser.parseClassSignature("Ljava/lang/Object;LCol;").superInterfacesSignature.head match { case SimpleGenericType(bt,gt) => bt.toJava+"<"+gt.toJava+">"; case _ => null}
    //res11: String = null
    
    scala> SignatureParser.parseFieldTypeSignature("LCol;") match { case SimpleGenericType(bt,ta) => bt.toJava+"<"+ta+">"; case _ => null}
    res1: String = Col<ObjectType(java/lang/Object)>
    
    scala> SignatureParser.parseFieldTypeSignature("LCol;") match { case GenericType(bt,ta) => bt.toJava+"<"+ta+">"; case _ => null}
    res2: String = Col<List(ProperTypeArgument(variance=None,signature=ClassTypeSignature(Some(java/lang/),SimpleClassTypeSignature(Object,List()),List())))>
  161. trait SignatureElement extends AnyRef

    An element of a Signature used to encode generic type information.

  162. trait SignatureVisitor[T] extends AnyRef

    Implements a visitor for type signatures.

  163. abstract class SimilarityTestConfiguration extends AnyRef

    Specifies which parts of a class file should be compared with another one.

  164. case class SimpleClassTypeSignature(simpleName: String, typeArguments: List[TypeArgument]) extends Product with Serializable

    See also

    For matching signatures see Signature.

  165. case class SourceDebugExtension(debug_extension: Array[Byte]) extends Attribute with Product with Serializable

    Attribute to associate additional debug information with a class.

    Attribute to associate additional debug information with a class. The source debug extension attribute is an optional attribute of a class declaration (org.opalj.br.ClassFile).

  166. trait SourceElement extends CommonSourceElementAttributes

    We treat as a source element every entity that can be referred to by other class files.

  167. type SourceElementID = Int
  168. trait SourceElementsVisitor[T] extends AnyRef

    Classes that traverse a class file can extend this trait to facilitate reporting the traversed source file elements.

  169. case class SourceFile(sourceFile: String) extends Attribute with Product with Serializable

    The source file attribute is an optional attribute in the attributes table of org.opalj.br.ClassFile objects.

    The source file attribute is an optional attribute in the attributes table of org.opalj.br.ClassFile objects.

    sourceFile

    The name of the source file from which this class file was compiled; it will not contain any path information.

  170. sealed abstract class StackMapFrame extends AnyRef

    Part of the Java 6 stack map table attribute.

  171. type StackMapFrames = IndexedSeq[StackMapFrame]
  172. case class StackMapTable(stackMapFrames: StackMapFrames) extends Attribute with Product with Serializable

    Java 6's stack map table attribute.

  173. case class StringValue(value: String) extends ElementValue with Product with Serializable
  174. trait StructureIdentifier extends AnyRef

    Uniquely identifies a specific element that can (by definition) only exist once in a project.

    Uniquely identifies a specific element that can (by definition) only exist once in a project. For example, in the context of OPAL a type declaration is unique or the combination of a type declaration and a field name or the combination of a type declaration, method name and method descriptor.

  175. sealed abstract class SubtypeInformation extends TypeHierarchyInformation

    Represents a type's subtype information.

  176. sealed abstract class SupertypeInformation extends TypeHierarchyInformation

    Represents a type's supertype information.

  177. case class SynthesizedClassFiles(classFiles: List[(ClassFile, Option[AnyRef])]) extends Attribute with Product with Serializable

    This attribute stores references to ClassFile objects that have been generated while parsing the annotated ClassFile.

    This attribute stores references to ClassFile objects that have been generated while parsing the annotated ClassFile.

    For example, to represent proxy types that have been created by Java8 lambda or method reference expressions.

    This attribute may only be present while the class file is processed/read and will be removed from the attributes table before any analysis sees the "final" class file.

    This attribute may occur multiple times in the attributes table of a class file structure.

    classFiles

    A sequence consisting of class file objects and "reasons" why the respective class file was created.

  178. case class TAOfCastExpression(offset: Int, type_argument_index: Int) extends TypeAnnotationTarget with Product with Serializable
  179. case class TAOfCatch(exception_table_index: Int) extends TypeAnnotationTarget with Product with Serializable
  180. case class TAOfConstructorInMethodReferenceExpression(offset: Int, type_argument_index: Int) extends TypeAnnotationTarget with Product with Serializable
  181. case class TAOfConstructorInvocation(offset: Int, type_argument_index: Int) extends TypeAnnotationTarget with Product with Serializable
  182. case class TAOfFormalParameter(formal_parameter_index: Int) extends TypeAnnotationTarget with Product with Serializable
  183. case class TAOfInstanceOf(offset: Int) extends TypeAnnotationTarget with Product with Serializable
  184. case class TAOfLocalvarDecl(localVarTable: IndexedSeq[LocalvarTableEntry]) extends TypeAnnotationTarget with Product with Serializable
  185. case class TAOfMethodInMethodReferenceExpression(offset: Int, type_argument_index: Int) extends TypeAnnotationTarget with Product with Serializable
  186. case class TAOfMethodInvocation(offset: Int, type_argument_index: Int) extends TypeAnnotationTarget with Product with Serializable
  187. case class TAOfMethodReferenceExpressionIdentifier(offset: Int) extends TypeAnnotationTarget with Product with Serializable
  188. case class TAOfMethodReferenceExpressionNew(offset: Int) extends TypeAnnotationTarget with Product with Serializable
  189. case class TAOfNew(offset: Int) extends TypeAnnotationTarget with Product with Serializable
  190. case class TAOfParameterDeclarationOfClassOrInterface(type_parameter_index: Int) extends TypeAnnotationTarget with Product with Serializable
  191. case class TAOfParameterDeclarationOfMethodOrConstructor(type_parameter_index: Int) extends TypeAnnotationTarget with Product with Serializable
  192. case class TAOfResourcevarDecl(localVarTable: IndexedSeq[LocalvarTableEntry]) extends TypeAnnotationTarget with Product with Serializable
  193. case class TAOfSupertype(supertype_index: Int) extends TypeAnnotationTarget with Product with Serializable
  194. case class TAOfThrows(throws_type_index: Int) extends TypeAnnotationTarget with Product with Serializable
  195. case class TAOfTypeBoundOfParameterDeclarationOfClassOrInterface(type_parameter_index: Int, bound_index: Int) extends TypeAnnotationTarget with Product with Serializable
  196. case class TAOfTypeBoundOfParameterDeclarationOfMethodOrConstructor(type_parameter_index: Int, bound_index: Int) extends TypeAnnotationTarget with Product with Serializable
  197. case class TAOnNestedType(path: IndexedSeq[TypeAnnotationPathElement]) extends TypeAnnotationPath with Product with Serializable
  198. case class TAOnTypeArgument(index: Int) extends TypeAnnotationPathElement with Product with Serializable
  199. sealed trait ThrowsSignature extends SignatureElement
  200. trait TraversingVisitor extends SignatureVisitor[Unit]

    This visitor's visit methods completely traverse all elements of a type signature.

  201. sealed trait Type extends UIDValue with Ordered[Type]

    Represents a JVM type.

    Represents a JVM type.

    Programmatically, we distinguish three major kinds of types:

    • base types/primitive types
    • reference types
    • the type void.

    General Information

    From the JVM specification

    There are three kinds of reference types: class types, array types, and interface types. Their values are references to dynamically created class instances, arrays, or class instances or arrays that implement interfaces, respectively.

    A reference value may also be the special null reference, a reference to no object, which will be denoted here by null. The null reference initially has no runtime type, but may be cast to any type. The default value of a reference type is null. The Java virtual machine specification does not mandate a concrete value encoding null.

    Comparing Types/Performance

    Given that the comparison of types is a standard operation in static analysis that is usually done over and over again great care was taken to enable an efficient comparison of types. It is - without exception - always possible to compare types using reference equality (i.e., the eq/ne operators). For each type there will always be at most one object that represents that specific type.

    Additionally, a stable order is defined between types that is based on a type's kind and the unique id of the types in case of reference types. The order is: void type < primitive types < array types < class/interface types

  202. case class TypeAnnotation(target: TypeAnnotationTarget, path: TypeAnnotationPath, annotationType: FieldType, elementValuePairs: ElementValuePairs) extends AnnotationLike with Product with Serializable

    A type annotation (*TA*).

    A type annotation (*TA*).

    TypeAnnotations were introduced with Java 8 and are associated with a ClassFile, Field, Method or Code using a org.opalj.br.RuntimeInvisibleTypeAnnotationTable or a org.opalj.br.RuntimeVisibleTypeAnnotationTable attribute.

  203. sealed abstract class TypeAnnotationPath extends AnyRef

    The path that describes which type is actually annotated using a TypeAnnotation.

  204. sealed abstract class TypeAnnotationPathElement extends AnyRef

    An element of the path that describes which type is actually annotated using a TypeAnnotation.

  205. trait TypeAnnotationTable extends Attribute

    The runtime (in)visible type annotations of a class, method, field or code block.

    The runtime (in)visible type annotations of a class, method, field or code block.

    Note

    For further information about type-level annotations go to: http://cr.openjdk.java.net/~abuckley/8misc.pdf.

  206. sealed abstract class TypeAnnotationTarget extends AnyRef

    Describes the kind of the target of a TypeAnnotation.

  207. type TypeAnnotations = IndexedSeq[TypeAnnotation]
  208. sealed abstract class TypeArgument extends SignatureElement

    See also

    For matching signatures see Signature.

  209. trait TypeConversionFactory[T] extends AnyRef

    A factory to create instruction sequences to convert one primitive type into another one.

  210. case class TypeDeclaration(objectType: ObjectType, isInterfaceType: Boolean, theSuperclassType: Option[ObjectType], theSuperinterfaceTypes: UIDSet[ObjectType]) extends Product with Serializable

    Stores information about a type's supertypes.

  211. sealed abstract class TypeHierarchyInformation extends AnyRef

    Represents the results of a type hierarchy related query.

  212. case class TypeIdentifier(t: Type) extends StructureIdentifier with Product with Serializable
  213. trait TypeSignature extends ReturnTypeSignature
  214. case class TypeVariableSignature(identifier: String) extends Signature with FieldTypeSignature with ThrowsSignature with Product with Serializable

    See also

    For matching signatures see Signature.

  215. class TypesVisitor extends TraversingVisitor

    Traverses a signature and calls for each Type the given method.

    Traverses a signature and calls for each Type the given method.

    Thread Safety

    This class is thread-safe and reusable. I.e., you can use one instance of this visitor to simultaneously process multiple signatures. In this case, however, the given function f also has to be thread safe or you have to use different functions.

  216. case class UninitializedVariableInfo(offset: Int) extends VerificationTypeInfo with Product with Serializable
  217. case class UnknownAttribute(attributeName: String, info: Array[Byte]) extends Attribute with Product with Serializable

    Represents (as a byte array) attributes that are not directly supported by OPAL.

  218. case class UnpackedLineNumberTable(lineNumbers: LineNumbers) extends LineNumberTable with Product with Serializable

    A method's line number table.

  219. type UpperTypeBound = UIDSet[ReferenceType]

    An upper type bound represents the available type information about a reference value.

    An upper type bound represents the available type information about a reference value. It is always "just" an upper bound for a concrete type; i.e., we know that the runtime type has to be a subtype (reflexive) of the type identified by the upper bound. Furthermore, an upper bound can identify multiple independent types. E.g., a type bound for array objects could be: java.io.Serializable and java.lang.Cloneable. Here, independent means that no two types of the bound are in a subtype relationship. Hence, an upper bound is always a special set where the values are not equal and are not in an inheritance relation. However, identifying independent types is a class hierarchy's responsibility.

    In general, an upper bound identifies a single class type and a set of independent interface types that are known to be implemented by the current object. Even if the type contains a class type it may just be a super class of the concrete type and, hence, just represent an abstraction.

  220. sealed abstract class VarianceIndicator extends SignatureElement

    Indicates a TypeArgument's variance.

  221. sealed abstract class VerificationTypeInfo extends AnyRef

    Part of the Java 6 stack map table attribute.

  222. type VerificationTypeInfoLocals = IndexedSeq[VerificationTypeInfo]
  223. type VerificationTypeInfoStack = IndexedSeq[VerificationTypeInfo]
  224. final case class VirtualClass(thisType: ObjectType) extends VirtualSourceElement with Product with Serializable

    Represents a class for which we have found some references but have not analyzed any class file or do not want to keep the reference to the underlying class file.

  225. sealed abstract class VirtualClassMember extends VirtualSourceElement

  226. final case class VirtualField(declaringClassType: ObjectType, name: String, fieldType: FieldType) extends VirtualClassMember with Product with Serializable

    Represents a field of a virtual class.

  227. final class VirtualForwardingMethod extends VirtualMethod
  228. sealed class VirtualMethod extends VirtualClassMember

    Represents a method of a virtual class.

  229. sealed abstract class VirtualSourceElement extends SourceElement with Ordered[VirtualSourceElement]

    A VirtualSourceElement is the representation of some source element that is always detached from the concrete source element that represents the implementation.

  230. sealed abstract class VoidType extends Type with ReturnTypeSignature

    Represents the Java type/keyword void.

  231. sealed abstract class Wildcard extends TypeArgument

    If a type argument is not further specified (e.g.

    If a type argument is not further specified (e.g. List<?> l = …) then the type argument "?" is represented by this object.

    See also

    For matching signatures see Signature.

Value Members

  1. val BaseConfig: Config
  2. final val ConfigKeyPrefix: String("org.opalj.br.")
  3. final val FrameworkName: String("OPAL Bytecode Representation")
  4. final def NoPCs: EmptyIntArraySet.type
  5. def annotationsToJava(annotations: Annotations, before: String = "", after: String = ""): String

    Converts a given list of annotations into a Java-like representation.

  6. def classAccessFlagsToString(accessFlags: Int): String
  7. def classAccessFlagsToXHTML(accessFlags: Int): Node
  8. def methodAccessFlagsToString(accessFlags: Int): String
  9. def methodToXHTML(accessFlags: Int, name: String, descriptor: MethodDescriptor, abbreviateTypes: Boolean): Node
  10. def methodToXHTML(name: String, descriptor: MethodDescriptor, abbreviateTypes: Boolean = true): Node

    Creates an (X)HTML5 representation that resembles Java source code method signature.

  11. def typeToXHTML(accessFlags: Int, t: Type, abbreviateTypes: Boolean): Node
  12. def typeToXHTML(t: Type, abbreviateType: Boolean = true): Node

    Creates an (X)HTML5 representation of the given Java type declaration.

  13. object AllocationSite
  14. object Annotation extends Serializable

    Factory object to create Annotation objects.

  15. object AnnotationTable

    Functionality common to annotation tables.

  16. object AnnotationValue extends Serializable
  17. object ArrayAllocation extends AllocationType with Product with Serializable
  18. object ArrayAllocationSite
  19. object ArrayElementType

    Facilitates matching against an array's element type.

  20. object ArrayType

    Defines factory and extractor methods for ArrayTypes.

  21. object ArrayTypeSignature extends Serializable
  22. object ArrayValue extends Serializable
  23. object BaseType

    Common constants related to base types (aka.

    Common constants related to base types (aka. primitive types).

  24. object BasicClassTypeSignature

    Extractor/Matcher of the (potentially erased) ObjectType that is defined by a ClassTypeSignature; ignores all further potential type parameters.

    Extractor/Matcher of the (potentially erased) ObjectType that is defined by a ClassTypeSignature; ignores all further potential type parameters.

    See also

    For matching signatures see Signature.

  25. object BooleanType extends BooleanType with Product with Serializable
  26. object BooleanValue extends Serializable
  27. object BootstrapMethodTable extends Serializable
  28. object ByteType extends ByteType with Product with Serializable
  29. object ByteValue extends Serializable
  30. object Category1ComputationalTypeCategory extends ComputationalTypeCategory with Product with Serializable
  31. object Category2ComputationalTypeCategory extends ComputationalTypeCategory with Product with Serializable
  32. object CharType extends CharType with Product with Serializable
  33. object CharValue extends Serializable
  34. object ChopFrame
  35. object ClassFile

    Defines factory and extractor methods for ClassFile objects as well as related constants.

  36. object ClassFileInformation

    Loads class files form a JAR archive and prints the signature and module related information of the classes.

  37. object ClassHierarchy

    Factory methods for creating ClassHierarchy objects.

  38. object ClassMember

    Defines an extractor method for class members.

  39. object ClassSignature extends Serializable
  40. object ClassTypeSignature extends Serializable
  41. object ClassValue extends Serializable
  42. object ClassesWithoutConcreteSubclasses extends DefaultOneStepAnalysis

    Lists all abstract classes and interfaces that have no concrete subclasses in the given set of jars.

  43. object Code

    Defines constants useful when analyzing a method's code.

  44. object CompareAllConfiguration extends CompareAllConfiguration
  45. object ComputationalTypeDouble extends ComputationalType with Product with Serializable
  46. object ComputationalTypeFloat extends ComputationalType with Product with Serializable
  47. object ComputationalTypeInt extends ComputationalType with Product with Serializable
  48. object ComputationalTypeLong extends ComputationalType with Product with Serializable
  49. object ComputationalTypeReference extends ComputationalType with Product with Serializable
  50. object ComputationalTypeReturnAddress extends ComputationalType with Product with Serializable
  51. object ConcreteType

    Matches a ClassTypeSignature with a SimpleClassTypeSignature that does not define a generic type.

    Matches a ClassTypeSignature with a SimpleClassTypeSignature that does not define a generic type. For example, java.lang.Object.

    See also

    For matching signatures see Signature.

  52. object ConcreteTypeArgument

    Facilitates matching ProperTypeArguments that define a single concrete/invariant type that is not a generic type on its own.

    Facilitates matching ProperTypeArguments that define a single concrete/invariant type that is not a generic type on its own. E.g., it can be used to match the type argument of List<Integer> and to extract the concrete type Integer. It cannot be used to match, e.g., List<List<Integer>>.

    See also

    For matching signatures see Signature.

  53. object ConstantDouble extends Serializable
  54. object ConstantFloat extends Serializable
  55. object ConstantInteger extends Serializable
  56. object ConstantLong extends Serializable
  57. object ConstantString extends Serializable
  58. object ConstantValue

    Facilitates matching constant values.

  59. object ContravariantIndicator extends ContravariantIndicator with Product with Serializable
  60. object CountClassForNameCalls extends DefaultOneStepAnalysis

    Counts the number of Class.forName calls.

  61. object CountOverridingMethods extends AnalysisExecutor

    Counts the number of methods that override/implement an instance method.

  62. object CovariantIndicator extends CovariantIndicator with Product with Serializable
  63. object Deprecated extends Attribute with Product with Serializable

    The deprecated attribute.

  64. object DoubleType extends DoubleType with Product with Serializable
  65. object DoubleValue extends Serializable
  66. object DoubleVariableInfo extends VerificationTypeInfo with Product with Serializable
  67. object ElementValue
  68. object ElementValuePair extends Serializable
  69. object EnclosingMethod extends Serializable
  70. object EnumValue extends Serializable
  71. object ExceptionTable extends Serializable
  72. object Field

    Defines factory and extractor methods for Field objects.

  73. object FieldAccessInformationAnalysis extends DefaultOneStepAnalysis

    Basic field access information.

    Basic field access information.

    Example Usage

    run -cp=/Library/Java/JavaVirtualMachines/jdk1.8.0_25.jdk/Contents/Home/jre/lib/ -field="java.util.HashMap entrySet"
  74. object FieldType

    Factory to parse field type (descriptors) to get field type objects.

  75. object FieldTypeJVMSignature
  76. object FieldTypeSignature
  77. object FloatType extends FloatType with Product with Serializable
  78. object FloatValue extends Serializable
  79. object FloatVariableInfo extends VerificationTypeInfo with Product with Serializable
  80. object GenericType

    Matches all ClassTypeSignatures which consists of a SimpleClassTypeSignature with a non-empty List of TypeArguments ( which consists of Wildcards or ProperTypeArguments)

    Matches all ClassTypeSignatures which consists of a SimpleClassTypeSignature with a non-empty List of TypeArguments ( which consists of Wildcards or ProperTypeArguments)

    See also

    For matching signatures see Signature.

  81. object GenericTypeArgument

    Facilitates matching the (VarianceIndicator, ObjectType) that is defined within a ProperTypeArgument.

    Facilitates matching the (VarianceIndicator, ObjectType) that is defined within a ProperTypeArgument. It matches ProperTypeArguments which define TypeArguments in the inner ClassTypeSignature.

    Example:
    1. matches e.g.: List<List<Integer>>

      val scts : SimpleClassTypeSignature = ...
      scts.typeArguments match {
          case GenericTypeArgument(varInd, objectType) => ...
          case _ => ...
      }
    See also

    For matching signatures see Signature.

  82. object GenericTypeWithClassSuffix

    Matches all ClassTypeSignatures which consists of a SimpleClassTypeSignature with an optional list of TypeArguments ( which consists of Wildcards or ProperTypeArguments) and a non-empty list of SimpleClassTypeSignature (which encodes the suffix of the ClassTypeSignature for inner classes)

    Matches all ClassTypeSignatures which consists of a SimpleClassTypeSignature with an optional list of TypeArguments ( which consists of Wildcards or ProperTypeArguments) and a non-empty list of SimpleClassTypeSignature (which encodes the suffix of the ClassTypeSignature for inner classes)

    See also

    For matching signatures see Signature.

  83. object HasNoArgsAndReturnsVoid
  84. object InnerClassTable extends Serializable
  85. object IntValue extends Serializable
  86. object IntegerType extends IntegerType with Product with Serializable
  87. object IntegerVariableInfo extends VerificationTypeInfo with Product with Serializable
  88. object InvokedynamicPrinter extends DefaultOneStepAnalysis

    Prints out the immediately available information about invokedynamic instructions.

  89. object JVMMethodDescriptor

    Extractor for JVM method descriptors (for example, "(I[Ljava/lang/Object;])V").

  90. object LineNumberTable
  91. object LoadMethodHandleOrMethodType extends DefaultOneStepAnalysis

  92. object LocalVariableTable extends Serializable
  93. object LocalVariableTypeTable extends Serializable
  94. object LongType extends LongType with Product with Serializable
  95. object LongValue extends Serializable
  96. object LongVariableInfo extends VerificationTypeInfo with Product with Serializable
  97. object LowerTypeBound

    Facilitates matching ProperTypeArguments that define a lower type bound.

    Facilitates matching ProperTypeArguments that define a lower type bound. E.g., a type bound which uses a ContravarianceIndicator (? super) such as in List<? super Number>.

    Example:
    1. matches, e.g., List<? super Integer>

      val scts : SimpleClassTypeSignature = ...
      scts.typeArguments.head match {
          case LowerTypeBound(objectType) => ...
          case _ => ...
      }
    See also

    For matching signatures see Signature.

  98. object MaxLocalsEvaluation extends DefaultOneStepAnalysis

    Computes some statistics related to the number of parameters and locals (Local Variables/Registers) defined/specified by each method.

  99. object Method

    Defines factory and extractor methods for Method objects.

  100. object MethodAnnotationsPrinter extends AnalysisExecutor

    Prints out the method-level annotations of all methods.

    Prints out the method-level annotations of all methods. (I.e., class, field and parameter annotations are not printed.)

  101. object MethodCallMethodHandle
  102. object MethodDescriptor

    Defines extractor and factory methods for MethodDescriptors.

  103. object MethodParameterTable extends Serializable
  104. object MethodTypeSignature extends Serializable
  105. object MethodWithBody

    Provides efficient pattern matching facilities for methods with bodies.

    Provides efficient pattern matching facilities for methods with bodies.

    Example:
    1. Matching all methods that have a method body:

      for {
           classFile ← project.classFiles
           method @ MethodWithBody(code) ← classFile.methods
      } {
           // the type of method is "..resolved.Method"
           // the type of code is "..resolved.Code"
      }
  106. object Module extends Serializable
  107. object NativeMethodsCounter extends DefaultOneStepAnalysis

    Counts the number of native methods.

  108. object NoArgumentMethodDescriptor
  109. object NotJavaLangObject

    Defines an extractor to match a type against any ObjectType except java.lang.Object.

    Defines an extractor to match a type against any ObjectType except java.lang.Object.

    Example:
    1. val t : Type = ...
      t match {
       case ot @ NotJavaLangObject() => ot
       case _ =>
      }
  110. object NotVoid

    Defines an extractor to match against any Type except void.

    Defines an extractor to match against any Type except void. Can be useful, e.g., when matching MethodDescriptors to select all methods that return something.

  111. object NullVariableInfo extends VerificationTypeInfo with Product with Serializable
  112. object ObjectAllocation extends AllocationType with Product with Serializable
  113. object ObjectAllocationSite
  114. object ObjectType

    Defines factory and extractor methods for ObjectTypes.

  115. object ParameterAnnotationTable
  116. object PrintBaseCFG

    Prints the CFG of a method using a data-flow independent analysis.

  117. object PrivateMethodsWithObjectTypeParameterCounter extends DefaultOneStepAnalysis

    Counts the number of private methods that have at least one parameter with a reference type.

  118. object PublicMethodsInNonRestrictedPackagesCounter extends AnalysisExecutor

    Counts the number of native methods.

  119. object ReferenceType

    Factory to create instances of ReferenceType.

  120. object ReturnType
  121. object RuntimeInvisibleAnnotationTable extends Serializable
  122. object RuntimeInvisibleParameterAnnotationTable extends Serializable
  123. object RuntimeInvisibleTypeAnnotationTable extends Serializable
  124. object RuntimeVisibleAnnotationTable extends Serializable
  125. object RuntimeVisibleParameterAnnotationTable extends Serializable
  126. object RuntimeVisibleTypeAnnotationTable extends Serializable
  127. object ShortType extends ShortType with Product with Serializable
  128. object ShortValue extends Serializable
  129. object ShowInnerClassesInformation extends DefaultOneStepAnalysis

    Shows the inner classes attributes of given class files.

  130. object ShowLocalVariableTypeTables extends DefaultOneStepAnalysis

    Shows the local variable type tables of given class files.

  131. object Signature
  132. object SimpleGenericType

    Facilitates matching ClassTypeSignatures that define a simple generic type that has a single type argument with a concrete type.

    Facilitates matching ClassTypeSignatures that define a simple generic type that has a single type argument with a concrete type.

    Example:
    1. The following can be used to match, e.g., List<Object>.

      val f : Field = ...
      f.fieldTypeSignature match {
          case SimpleGenericType(ContainerType,ElementType) => ...
          case _ => ...
      }
  133. object SingleArgumentMethodDescriptor

    Extractor for method descriptors defining a single parameter type and some return type.

  134. object SourceDebugExtension extends Serializable
  135. object SourceFile extends Serializable
  136. object StackMapTable extends Serializable
  137. object StringConstants extends DefaultOneStepAnalysis

    Prints out all string constants found in the bytecode.

  138. object StringValue extends Serializable
  139. object SubtypeInformation
  140. object SupertypeInformation
  141. object SynthesizedClassFiles extends Serializable
  142. object Synthetic extends Attribute with Product with Serializable

    The synthetic attribute.

  143. object TADeeperInArrayType extends TypeAnnotationPathElement with Product with Serializable
  144. object TADeeperInNestedType extends TypeAnnotationPathElement with Product with Serializable
  145. object TADirectlyOnType extends TypeAnnotationPath with Product with Serializable
  146. object TAOfFieldDeclaration extends TypeAnnotationTarget with Product with Serializable
  147. object TAOfReceiverType extends TypeAnnotationTarget with Product with Serializable
  148. object TAOfReturnType extends TypeAnnotationTarget with Product with Serializable
  149. object TAOnBoundOfWildcardType extends TypeAnnotationPathElement with Product with Serializable
  150. object TAOnTypeArgument extends Serializable
  151. object TheArgument

    Extractor for method descriptors defining a single parameter type.

  152. object ThrownExceptions extends DefaultOneStepAnalysis

    Prints out the information about the exceptions thrown by methods.

  153. object TopVariableInfo extends VerificationTypeInfo with Product with Serializable
  154. object TransitiveUsage extends AnalysisExecutor

    Calculates the transitive closure of all classes referred to by a given class.

    Calculates the transitive closure of all classes referred to by a given class. Here, "referred to" means that the type is explicitly used in the implementation of the class.

  155. object TwoArgumentsMethodDescriptor
  156. object Type
  157. object TypeAnnotationTable

    Functionality common to annotation tables.

  158. object TypeVariableSignature extends Serializable
  159. object UIDSetDemo extends App
  160. object UninitializedThisVariableInfo extends VerificationTypeInfo with Product with Serializable
  161. object UnknownAttribute extends Serializable
  162. object UpperTypeBound

    Facilitates matching ProperTypeArguments that define an upper type bound.

    Facilitates matching ProperTypeArguments that define an upper type bound. E.g., a type bound which uses a CovarianceIndicator (? extends) such as in List<? extends Number>.

    Example:
    1. val scts : SimpleClassTypeSignature = ...
      scts.typeArguments.head match {
          case UpperTypeBound(objectType) => ...
          case _ => ...
      }
    See also

    For matching signatures see Signature.

  163. object VirtualAndStaticMethodCalls extends DefaultOneStepAnalysis

    Counts the number of static and virtual method calls.

  164. object VirtualForwardingMethod
  165. object VirtualMethod
  166. object VirtualSourceElement

    Defines common helper functions related to VirtualSourceElements.

  167. object VirtualTypeFlag extends Attribute with Product with Serializable

    This class file level attribute identifies ClassFile objects that have no direct representation in the bytecode of a project.

    This class file level attribute identifies ClassFile objects that have no direct representation in the bytecode of a project.

    Instead, the class file annotated with this attribute was generated to represent a class file object that is either explicitly generated at runtime and then used by the program or is conceptually generated at runtime by the JavaVM, but not exposed to the program. An example of the later case are the call site objects that are generated for invokedynamic instructions.

    However, such classes are generally required to facilitate subsequent analyses.

  168. object VoidType extends VoidType with Product with Serializable
  169. object Wildcard extends Wildcard with Product with Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped