Alle Klassen und Schnittstellen
Klasse
Beschreibung
Signal that a process was aborted before completion.
Exception thrown when an incremental builder cannot find a .class file.
Basic "common"
CacheBacking implementationCommon parts of ClassFile (containing a BinaryType) and ModularClassFile (containing a BinaryModule).
Parser specialized for decoding javadoc comments
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
Useful "common" functionality for caching to files
Uses the factory pattern.
The abstract superclass of Java builders.
Uses an
index file to keep track of the cached entriesThe default index entry in the index file
AspectJ Extension - added several extension points for subclasses
Handle for an automatic module.
Implements common functions to be used across ISignaturePatterns.
Subtypes can override whatever they want...
AST node for a tag within a doc comment.
AST node for a text element within a doc comment.
Abstract subclass for type declaration, enum declaration,
and annotation type declaration AST node types.
abstract TypePattern DOM AST node.
Walks the body of around advice
Makes sure that all member accesses are to public members.
Definition of a set of access rules used to flag forbidden references to non API code.
Adds runtime visible annotations to code-style aspect declarations so that the MAP can provide aspect information at runtime.
Runtime representation of an advice declaration inside an aspect
Represents before, after and around advice in an aspect.
AdviceDeclaration DOM AST node.
The different kinds of advice in AspectJ
The five kinds of advice in AspectJ.
Used to annotated code-style advice to name it
Name is used by reflection api if present, may in future be used in adviceexecution() pcd.
After finally advice
AfterAdviceDeclaration DOM AST node.
After returning advice
AfterReturningAdviceDeclaration DOM AST node.
After throwing advice
AfterThrowingAdviceDeclaration DOM AST node.
Java 1.5 preMain agent to hook in the class pre processor
Can be used with -javaagent:aspectjweaver.jar
Adapter between the generic class pre processor interface and the AspectJ weaver Load time weaving consistency relies on
Bcel.setRepository
Internal class for converting internal compiler ASTs into public ASTs.
Factory, dynamically loaded by the TypeDeclaration class in the shadows/dom tree.
These attributes are written to and read from .class files (see the JVM spec).
Synthetic members should have NO advice put on them or on their contents.
All configuration information needed to run the AspectJ compiler.
Ajc uses this as the CompilerAdapter.
Main taskdef class for the AspectJ 1.0 compiler,
ajc.Adapt ajc to javac commands.
Ant task for the AspectJ compiler -- AJC.
A simple class with one member --
file -- that
represents an argument file.Partial implementation of CompilerAdapter for ajc task.
internal representation of declare annotation statement, used by reflect api
The AjcMemberMaker is responsible for creating the representations of methods/fields/etc that are placed in both aspects and
affected target types.
The class to be used by tools to drive a build.
Compiler options used by Eclipse integration (AJDT)
Root class for all ConstructorDeclaration objects created by the parser.
This runs the AspectJ 1.1 compiler, supporting all the command-line options.
Commandline wrapper that only permits addition of non-empty values and converts to argfile form if necessary.
Singleton class used to initialize the Ajde ui as well as the properties required to run the compiler.
Build Manager which drives the build for a given AjCompiler.
Enables the compiler/weaver progres to be related to the user via the
IBuildProgressMonitor as well as relating whether or not the user has
cancelled the build progress back to the compiler/weaver.
Enables the messages from the compiler/weaver to be passed on
to the tool's implementation so they can handle it as they wish
A task to run the ajdoc tool.
ICommand adapter for the AspectJ compiler.
Overrides the default eclipse LookupEnvironment for two purposes.
1.
Root class for all MethodDeclaration objects created by the parser.
Internal AST visitor for serializing an AST in a quick and dirty fashion.
Adapts standard JDT Compiler to add in AspectJ specific behaviours.
Extends problem reporter to support compiler-side implementation of declare soft.
Maintains state needed for incremental compilation
The runtime representation of a type (Aspect, Class, Interface, Annotation, Enum, or Array) in an AspectJ
program.
This subtype of TypeDeclaration allows for the extensions that AspectJ
has for types - they might be aspects and pointcuts may exist in
classes.
Factory, dynamically loaded by the TypeDeclaration class in the shadows/dom tree.
This is the anchor for the AspectJ runtime type system.
Implementation of the "Align items on columns" feature
AndPointcut DOM AST node.
Represents the AND of two other signature patterns.
left && right
Abstract base class of AST nodes that represent an annotatable type (added in JLS8 API).
Represents any element that may have annotations
Abstract base class of AST nodes that represent annotations.
Annotation
Default implementation of IAnnotation
Represents access to an annotation on an element, relating to some kinded pointcut.
Simple representation of an annotation that the weaver can work with.
Represents JSR 175 Annotation instances in the type-system.
Default implementation of IAnnotationComponent
Default implementation of IAnnotationComponent
This attribute is attached to a method and indicates the default
value for an annotation element.
Default implementation of AnnotationDefaultAttribute.
This class is used to visit the JDT compiler internal AST to discover annotations,
in the course of dispatching to annotation processors.
Represents adding an annotation to a type
(at)Annotation((at)Foo) or (at)Annotation(foo)
A TypeSafeEnum similar to the Java5 ElementType Enum
Annotation type declaration AST node type (added in JLS3 API).
Annotation type member declaration AST node type (added in JLS3 API).
Anonymous class declaration AST node type.
TODO: Add support for proper AnnotationPatterns instead of the annotation
expression
This type represents a type pattern of '*' but with an annotation specified, e.g.
Used as a zip file cache.
Implementation of a Java file object that corresponds to an entry in a zip/jar file
args(arguments)
Around advice
AroundAdviceDeclaration DOM AST node.
Array access expression AST node type.
Array creation expression AST node type.
Array initializer AST node type.
Represents a resolved array type
Denotes array type, such as int[][]
Type node for an array type.
Implementation of ArrayType, which represents an array of some type.
Determines if a version of asm is around that will enable us to add stack map attributes to classes that we produce.
At each iteration of
processCompilationUnit the declarations for a particular compilation unit are added to the
hierarchy passed as a a parameter.The Abstract Structure Model (ASM) represents the containment hierarchy and crosscutting structure map for AspectJ programs.
A ModelInfo object captures basic information about the structure model.
Provides utility methods for generating details for IProgramElements used when creating the model both from source (via
AsmElementFormatter.visit(..)) and when filling in the model for binary aspects (via AsmRelationshipProvider bug 145963)
Aspect declaration
Represents an aspect declaration.
AspectDeclaration DOM AST node.
Used to represent a variable reference to an aspect instance.
This is the plugin class for AspectJ.
Handles generic aspectOf method when those are not available in the aspects but added later on
thru load time weaving.
For users working on a level of Java prior to Java5, Aspects14 handles generic aspectOf methods when they
are not available in the aspects but added later on through load time weaving.
Assert statement AST node type.
Assignment expression AST node type.
Assignment operators (typesafe enumeration).
Umbrella owner and abstract syntax tree node factory.
Internal class for converting internal compiler ASTs into public ASTs.
Concrete superclass and default implementation of an AST subtree matcher.
Abstract superclass of all Abstract Syntax Tree (AST) node types.
Finds an ASTNode given an IJavaElement in a CompilationUnitDeclaration
A Java language parser for creating abstract syntax trees (ASTs).
An AST requestor handles ASTs for compilation units passed to
ASTParser.createASTs.Infrastructure for modifying code by describing changes to AST nodes.
Infrastructure to support code modifications.
A visitor for abstract syntax trees.
A visitor for iterating through the parse tree.
Uses a background thread to do the actual I/O and for caching "persistence"
so that the caching works faster on repeated activations of the application.
Represents an asynchronous command that can be sent to the
AsynchronousFileCacheBacking instance to be executed
on it asynchronouslyAsynchronousFileCacheBacking.AsynchronousFileCacheBackingCreator<T extends AsynchronousFileCacheBacking>
Base class for
AsynchronousFileCacheBacking.AbstractCommands that refer to a cache keyAnnotation defined aspect reader.
LazyResolvedPointcutDefinition lazyly resolve the pointcut so that we have time to register all pointcut referenced before
pointcut resolution happens
Abstract super class for Attribute objects.
This class is the central dispatch point for Java 6 annotation processing.
Implementation of ProcessingEnvironment that is common to batch and IDE environments.
A basic implementation of
ICompilationUnit
for use in the SourceMapper.Retrofit a
ModuleDeclaration into an ISourceModule.Search basic engine.
Denotes basic type such as int.
Java 6 annotation processor manager used when compiling from the command line
or via the javax.tools.JavaCompiler interface.
A public API for invoking the Eclipse Compiler for Java.
Implementation of Filer used when compilation is driven by command line
or by Tool interface.
Copyright (c) 2000, 2013 IBM Corporation and others.
An implementation of Messager that reports messages via the Compiler
An operation created as a result of a call to JavaCore.run(IWorkspaceRunnable, IProgressMonitor)
that encapsulates a user defined IWorkspaceRunnable.
The implementation of ProcessingEnvironment that is used when compilation is
driven by the command line or by the Tool interface.
Looks for all access to method or field that are not public within the body of the around advices and replace the invocations to
a wrapper call so that the around advice can further be inlined.
Wraps a Bcel Annotation object and uses it to answer AnnotationAJ method calls.
XXX Erik and I need to discuss this hierarchy.
This type munger will modify a given class (see the munge() method) to include a field representing a CflowCounter object.
An implementation of the constant pool reader that speaks Bcel.
XXX Erik and I need to discuss this hierarchy.
A utility class that assists in unpacking constituent parts of generic signature attributes and returning their equivalents in
UnresolvedType world.
Adds aspectOf(), hasAspect() etc to the annotation defined aspects
Wraps a reference to a classloader inside a WeakReference.
Bcel implementation of the weaving support required in a BcelWorld which will actually modify bytecode.
Exception to use inside the bcweaver.
Switch and ICompilationUnit to working copy mode
and signal the working copy addition through a delta.
Before advice
BeforeAdviceDeclaration DOM AST node.
Common functionality for Binary member handles.
Holds a lightweight identifier for an IBinaryModule, with sufficient information to either read it from
disk or read it from the index.
FIXME: this class is a stub as of now, it does not support modules in the new index.
Parent is an IClassFile.
Converter from a binary type to an AST type declaration.
Holds a lightweight identifier for an IBinaryType, with sufficient information to either read it from
disk or read it from the index.
Represents an attempt to bind the field of an annotation within a pointcut.
Utility class to decode or create a binding key.
Maps a
TypeBinding onto values.Marker interface for BindingTypePattern and BindingAnnotationTypePattern
BindingScope that knows the enclosingType, which is needed for pointcut reference resolution
Block statement AST node type.
Block comment AST node type.
Abstract base class of all AST nodes that represent body declarations
that may appear in the body of some kind of class or interface declaration,
including anonymous class declarations, enumeration declarations, and
enumeration constant declarations.
Boolean literal node.
Represents the BootstrapMethods attribute in Java 7 classes.
Default implementation of IBootstrapMethodsAttribute.
Default implementation of
IBootstrapMethodsEntryA BoundedReferenceType is the result of a generics wildcard expression ?
BranchHandle is returned by specialized InstructionList.append() whenever a BranchInstruction is appended.
Break statement AST node type.
Responsible for displaying and controlling the configuration and output of a
master and slave structure view.
Represents the configuration of a structure view of the system, rendered
by the
StructureTreeManager.An LRU cache of
IBuffers.A buffer changed event describes how a buffer has changed.
Veraltet.
The buffer manager manages the set of open buffers.
TODO: we have schitzophrenia between BuildConfigNode(s) and IProgramElement(s), fix.
Uses "typesafe enum" pattern.
Creates a popup menu that displays all the available .lst files.
The context of a build event that is notified to interested compilation
participants when
a build is starting,
to annotations processors when a source file has annotations,
or to post processors when a class has finished compiling.Adapter that implements the IBytecodeVisitor.
Utility class that implements a sequence of bytes which can be read
via the `readByte()' method.
Interface for the backing to the cache; usually a file,
but could be an in-memory backing for testing.
Represents a class which has been cached
A typed reference to a cached class entry.
Facility for overriding the default CacheKeyResolver
and CacheBacking; an implementing factory must be set
on the
WeavedClassCache before the
WeavingAdaptor is
configured.Interface to allow alternate hashing schemes for weaved and
generated classes.
Maintains some basic statistics on the class cache.
Capture-like type variable introduced during 1.8 type inference.
Case Default Literal Pattern node.
Cast expression AST node type.
Catch clause AST node type.
Richer description of a Java problem, as detected by the compiler or some of the underlying
technology reusing the compiler.
CFlowPointcut DOM AST node.
Character literal nodes.
The
CharArrayBuffer is intended as a lightweight partial implementation
of the StringBuffer class, but using char[]'s instead of Strings.This map avoids hashing.
A static utility class for char arrays.
This map uses a specialized implementation for few elements.
Taken from org.aspectj.org.eclipse.jdt.core.compiler.CharOperation
This class is a collection of helper methods to manipulate char arrays.
Representation of a shadow munger for a declare error or warning declaration.
Descriptor for a child list property of an AST node.
Descriptor for a child property of an AST node.
Represents a class file wrapper on bytes, it is aware of its actual
type name.
Default implementation of IClassFileAttribute
This class is intended to be subclassed to disassemble
classfile bytes onto a String using the proper line separator.
Abstract class that defines helpers methods for decoding .class file.
A working copy on an
IClassFile.Thrown when the BCEL attempts to read a class file and determines
that the file is malformed or otherwise cannot be interpreted as a
class file.
Exception thrown by a class file reader when encountering a error in decoding
information contained in a .class file.
Template class for building up a java class.
Thrown on internal errors.
Class instance creation expression AST node type.
Implementors should provide access to a ClassLoader instance.
The repository maintains information about which classes have been loaded.
Wrapper class that parses a given Java .class file.
Responsible for loading (class) files from the CLASSPATH.
Contains information about file/ZIP entry of the Java class.
Abstract base implementation of all classpath container initializer.
Abstract base implementation of all classpath variable initializers.
Generic class pre processor interface that allows to separate the AspectJ 5 load time weaving from Java 5 JVMTI interfaces for
further use on Java 1.3 / 1.4
Java 1.5 adapter for class pre processor
Represents a class reference in the class file.
Interface to make use of the Visitor pattern programming style.
AspectJ Extension added template method for subclasses to insert more code.
This class represents a chunk of Java byte code contained in a method.
Default implementation of ICodeAttribute.
This class represents an entry in the exception table of the Code
attribute and is used only there.
This class represents an exception handler, i.e., specifies the region where
a handler is active and an instruction where the actual handling is done.
Specification for a generic source code formatter.
Veraltet.
Implements an Eclipse Application for org.eclipse.jdt.core.JavaCodeFormatter.
Provide code generation hints to the compiler (e.g. names to use for generated members).
A compiler that compiles code snippets.
An environment that wraps the client's name environment.
A code snippet evaluator compiles and returns class file for a code snippet.
A parser for code snippets.
Utility class to parse different code snippets
A return statement inside a code snippet.
This scope is used for code snippet lookup to emulate private, protected and default access.
A single name reference inside a code snippet can denote a field of a remote
receiver object (that is, the receiver of the context in the stack frame).
The skeleton of the class 'org.eclipse.jdt.internal.eval.target.CodeSnippet'
used at compile time.
A super reference inside a code snippet denotes a reference to the super type of
the remote receiver object (that is, the receiver of the context in the stack frame).
A this reference inside a code snippet denotes a remote
receiver object (that is, the receiver of the context in the stack frame)
CombinedBinaryExpression is an implementation of BinaryExpression that
specifically attempts to mitigate the issues raised by expressions which
have a very deep leftmost branch.
Abstract base class for all AST nodes that represent comments.
Internal parser used for parsing source to create DOM AST nodes.
Commits the contents of a working copy compilation
unit to its original element and resource, bringing
the Java Model up-to-date with the current contents of the working
copy.
Used to determine if a type has structurally changed during incremental compilation.
This class is responsible for tracking progress through the various phases of compilation and weaving.
A compilation participant is notified of events occurring during the compilation process.
A compilation progress is used by the
BatchCompiler to report progress during compilation.acts as a bridge from ajde's OutputLocationManager interface to the compiler internals
Java compilation unit AST node type.
Implements a very simple version of the ICompilationUnit.
Responsible for resolving types inside a compilation unit being reconciled,
reporting the discovered problems to a given IProblemRequestor.
Operation for sorting members within a compilation unit.
A requestor for the fuzzy parser, used to compute the children of an ICompilationUnit.
Bit flags that can indicate what has changed in a configuration, see ICompilerConfiguration
Wrapper for ajdoc's use of the AspectJ compiler.
Completion context.
This class is the entry point for source completions.
Utility class for decoding additional flags in completion proposal.
Node representing a Javadoc comment including code selection.
Parser specialized for decoding javadoc comments which includes cursor location for code completion.
Detect the presence of a node in expression
This class is independent of its parent class and is in fact a dummy ExportsStatement.
Initially (https://bugs.eclipse.org/106450) this class was only used when an invocation has
actual type arguments.
Completion proposal.
Abstract base class for a completion requestor which is passed completion
proposals as they are generated in response to a code assist request.
Veraltet.
Subclass
CompletionRequestor instead.Veraltet.
Default implementation of IComponentInfo.
abstraction of DataInputStream
abstraction of DataOutputStream
A variation of a DataOutputStream that is linked to a constant pool writer.
Generates bytecode for concrete-aspect.
Conditional expression AST node type.
Record conditional initialization status during definite assignment analysis
Abstract superclass for classes to represent the different constant types in the constant pool of a class file.
This class is derived from the abstract Constant class and
represents a reference to a (external) class.
Abstract super class for Fieldref and Methodref constants.
This class is derived from the abstract Constant class and
represents a reference to a Double object.
This class is derived from the abstract Constant class and
represents a reference to the name and signature of a field or method.
This class represents a constant pool reference to a field.
This class is derived from the abstract Constant class and
represents a reference to a float object.
This class is derived from the abstract Constant class and
represents a reference to an int object.
This class represents a constant pool reference to an interface method.
This class is derived from the abstract Constant class and
represents a reference to the name and signature of a field or method.
This class is derived from the abstract Constant class and
represents a reference to a long object.
This class is derived from the abstract Constant class and
represents a reference to the name and signature of a field or method.
This class represents a constant pool reference to a method.
This class is derived from the abstract Constant class and
represents a reference to the name and signature of a field or method.
Represents a module.
This class is derived from the abstract Constant class and
represents a reference to the name and signature of a field or method.
This interface denotes those constants that have a "natural" value, such as ConstantLong, ConstantString, etc..
Represents a module.
This class represents the constant pool, i.e., a table of constants, of a parsed classfile.
This type is used to store all the constant pool entries.
Default implementation of IConstantPool.
Default implementation of IConstantPoolEntry
Default implementation of IConstantPoolEntry2 and IConstantPoolEntry3.
Used during attribute reading to decode constant pool references.
Used during attribute writing to encode common strings/etc as constant pool references.
Constants for the project, mostly defined in the JVM specification.
Some useful weaver constants.
This class is derived from the abstract Constant class and
represents a reference to a String object.
This class is derived from the abstract Constant class and
represents a reference to a Utf8 encoded string.
This class is derived from Attribute and represents a constant value, i.e., a default value for initializing a class
field.
Default implementation of IConstantValueAttribute.
Constraint formula expressing that a given expression must have an exception type.
Alternate constructor invocation statement AST node type.
Pointcut expression interface for pointcut
expressions returned by a
PointcutDesignatorHandler.
When an entry is added to the CompilationAndWeavingContext stack,
a ContextToken is returned.
Continue statement AST node type.
This operation copies/moves a collection of elements from their current
container to a new container, optionally renaming the
elements.
This operation copies/moves/renames a collection of resources from their current
container to a new container, optionally renaming the
elements.
This class is the entry point for source corrections.
Wrap an IMessageHandler to count messages handled.
This operation creates a compilation unit (CU).
This abstract class implements behavior common to
CreateElementInCUOperations.This operation creates a field declaration in a type.
This operation adds an import declaration to an existing compilation unit.
This operation creates a initializer in a type.
This operation creates an instance method.
This operation adds/replaces a package declaration in an existing compilation unit.
This operation creates a new package fragment under a given package fragment root.
This operation creates an
ITypeHierarchy for a specific type within
a specified region, or for all types within a region.Implements functionality common to
operations that create type members.
This operation creates a class or interface.
Creation reference expression AST node type (added in JLS8 API).
This holds on to all members that have an invasive effect outside of there own compilation unit.
This holds on to all CrosscuttingMembers for a world.
Abstraction to the ct.sym file access (see https://openjdk.java.net/jeps/247).
This interface is introduced to support tools like PointcutDoctor.
The AspectJ runtime representation of a declare annotation member in an aspect.
Represents a declare annotation statement, one of atField, atMethod, atConstructor or atType.
Captures type of declare annotation (method/type/field/constructor)
Abstract class for the different declare annotation
declaration AST node types.
DeclareAtConstructorDeclaration DOM AST node.
DeclareAtFieldDeclaration DOM AST node.
DeclareAtMethodDeclaration DOM AST node.
DeclareAtTypeDeclaration DOM AST node.
DeclareDeclaration DOM AST node.
Implementation of DeclaredType, which refers to a particular usage or instance of a type.
DeclareErrorDeclaration DOM AST node.
AspectJ runtime representation of a declare error or declare warning member
in an aspect.
DeclareMixin annotation - see design and usage in https://bugs.eclipse.org/bugs/show_bug.cgi?
Declare parents mixin annotation
A declare parents member defined inside an aspect
DeclareParentsDeclaration DOM AST node.
Constructed based on an @DeclareMixin being found in an aspect.
Aspect precedence declaration
AspectJ runtime representation of a declare precedence statement as
declared in an aspect.
DeclarePrecedenceDeclaration DOM AST node.
AspectJ runtime representation of a declare soft member within an aspect.
DeclareSoftDeclaration DOM AST node.
For a declare error/warning that specified a type pattern rather than a pointcut.
DeclareWarningDeclaration DOM AST node.
Utility to provide deduplication by best effort.
This dialog box is open while ajc is compiling the system and displays
a corresponding progress bar.
Default implementation of ByteCodeVisitor
Default factory for creating the backing and resolving classes.
Naive default class and classloader hashing implementation useful
for some multi-classloader environments.
Simplistic ClassLoaderReference that merely delegates to a classloader.
Constants used to set up the options of the code formatter.
This is still subject to changes before 3.0.
Internal constants related to wrapping alignment settings
This DefaultCompilerAdapter preserves the original behaviour of the
JDT compiler.
Naive File-Backed Class Cache with no expiry or application
centric invalidation.
Default implementation of MatchingContext, backed
by a Map.
DefaultPointcut DOM AST node. has: nothing
This class is a stub and should be deleted when concrete subclasses exist for all the different types of pointcuts in AspectJ.
Default implementation of IStackMapFrame
DefaultTypePattern DOM AST node. has: nothing
This class is a stub and should be deleted when concrete subclasses exist for all the different TypePattern's in AspectJ.
Use in non-OSGi environment
A working copy owner that creates internal buffers.
When a Java15ReflectionBasedDelegate gets the pointcuts for a given class it tries to resolve them before returning.
A POJO that contains raw strings from the XML (sort of XMLBean for our simple LTW DTD)
This operation deletes a collection of elements (and
all of their children).
This operation deletes a collection of resources and all of their children.
Keep the global states used during Java element delta processing.
This class is used by
JavaModelManager to convert
IResourceDeltas into IJavaElementDeltas.This class is derived from Attribute and denotes that this is a deprecated method.
AST node for an array dimension (added in JLS8 API).
Disassembler of .class files.
Discards a working copy (decrement its use count and remove its working copy info if the use count is 0)
and signal its removal through a delta.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
Do statement AST node type.
Implementation of a batch compiler that supports the jsr199
An implementation of the constant pool writer that speaks Eclipse.
Implementation of the Standard Java File Manager
Implementation of the Standard Java File Manager
Implementation of a Java file object that corresponds to a file on the file system
In the pipeline world, we can be weaving before all types have come through from compilation.
Adaptor from org.eclipse.jdt.internal.compiler.lookup.Scope to
org.aspectj.weaver.IScope
This is only used for declare soft right now.
Supports viewing eclipse TypeDeclarations/SourceTypeBindings as a ResolvedType
Compiler listeners get notified of structure model update events.
An LRU cache of
JavaElements.An element changed event describes a change to the structure or contents
of a tree of Java elements.
Element represents any defined Java language element - a package,
a method, a class or interface.
Utilities for working with java8 and earlier language elements.
Utilities for working with java9 language elements.
We want to avoid eagerly resolving of all enums that are used in annotations.
Null statement AST node type.
This attribute exists for local or
anonymous classes and ... there can be only one.
Default implementation of EnclosingMethodAttribute.
Enhanced For statement AST node type (added in JLS3 API).
Enhanced For statement AST node type with record pattern(added in JLS20 API).
Enumeration constant declaration AST node type (added in JLS3 API).
Represents a reference to a enum constant in the class file.
Enum declaration AST node type (added in JLS3 API).
Element corresponding to the Error type mirror
Implementation of the
ErrorType interface.A wrapper around the infrastructure evaluation context.
An EvaluationResult is the result of a code snippet evaluation, a global
variable evaluation or it is used to report problems against imports and
package declaration.
A evaluator builds a compilation unit and compiles it into class files.
Represents an attempt to bind the field of an annotation within a pointcut.
Matches an annotation of a given type
Default implementation of IExceptionAttribute.
Exception constants.
Reflects the context of code analysis, keeping track of enclosing
try statements, exception handlers, etc...
Reflects the context of code analysis, keeping track of enclosing
try statements, exception handlers, etc...
exceptionRanges are set initially to be low priority.
This class represents the table of exceptions that are thrown by a method.
This class describes an entry in the exception table attribute according
to the JVM specifications.
Implementation of the ExecutableType
Exports directive AST node type (added in JLS9 API).
Special kind of privileged access munger which exposes a type to be public.
Abstract base class of AST nodes that represent expressions.
Expression method reference AST node type (added in JLS8 API).
Expression statement AST node type.
A decorator for
IBinaryType that allows external annotations to be attached.Auxiliary interface for
ExternalAnnotationDecorator.getAnnotationZipFile(String, ZipFileProducer).Track changes of external annotation files and trigger closing / reloading of affected ClassFiles.
Utilities for accessing and manipulating text files that externally define annotations for a given Java type.
Strategy for merging a new signature with an existing (possibly annotated) signature.
A package fragment root that corresponds to an external class folder.
Creates javax.lang.model wrappers around JDT internal compiler bindings.
For implementing declare @type interacting with declare @parents during compilation - we need to be able to add an annotation to
'binary type binding' (this is how types are seen during incremental compilation).
Sole purpose of
FakeDefaultLiteral is to appear
in case 'default' of switch patterns (JEP 406 at the time
of writing this comment)A faked local variable declaration used for keeping track of data flows of a
special variable.
Iterator for a set of FakedTrackingVariable, which dispenses the elements
according to the priorities defined by enum
FakedTrackingVariable.IteratorForReporting.Stage.Represents a type that pointcuts may match.
This class represents the field info structure, i.e., the representation for a variable in the class.
Field access expression AST node type.
Field declaration node type.
A Java search match that represents a field declaration.
Template class for building up a field.
Super class for FieldGen and MethodGen objects, since they have some methods in common!
Default implementation of IFieldInfo.
For instances of this class,
FlowContext.getInitsForFinalBlankInitializationCheck(org.aspectj.org.eclipse.jdt.internal.compiler.lookup.TypeBinding, FlowInfo)
will returns a FlowInfo.DEAD_END, which for which
FlowInfo.isDefinitelyAssigned(org.aspectj.org.eclipse.jdt.internal.compiler.lookup.FieldBinding) returns true for all
fields.Super class for the GET/PUTxxx family of instructions.
Abstract super class for fields and methods.
Super class for InvokeInstruction and FieldInstruction, since they have some methods in common!
AspectJ Extension - support for FieldBinding.alwaysNeedsAccessMethod
A Java search match that represents a field reference.
An AST requestor handles ASTs for compilation units passed to
ASTParser.createASTs.Should only be created by the
StructureViewManager or an
equivalent factory.A
Classpath, even though an IModuleLocation, can represent a plain
classpath location too.This class is defined how to normalize the classpath entries.
A pipe when run reads from an input stream to an output stream, optionally sleeping between reads.
Reflects the context of code analysis, keeping track of enclosing
try statements, exception handlers, etc...
Utility class for decoding modifier flags in Java elements.
Uses a "flat" files model to store the cached instrumented classes
and aspects - i.e., each class/aspect is stored as a separate (binary)
file.
Internal utility for declaring with hexadecimal double and float literals.
Reflects the context of code analysis, keeping track of enclosing
try statements, exception handlers, etc...
A marker class for bindings for which we want to ignore unbound issue and consider them as implicit binding - f.e. to handle
JoinPoint in @AJ advices
For statement AST node type.
This class implements boolean that include a "maybe"
This class implements a boolean that includes a "maybe"
Handler for generated classes; such as Shadowed closures, etc.
Interface implemented by weaving class loaders to allow classes generated by
the weaving process to be defined.
A delegate that can sit in the ReferenceType instance created for an aspect generated from aop.xml.
Encapsulate generic signature parsing
structure holding a parsed class signature
structure capturing a FormalTypeParameter from the Signature grammar
This interface exists to support two different strategies for answering
generic signature related questions on Java 5 and pre-Java 5.
Parses the generic signature attribute as defined in the JVM spec.
Should only be created by the
StructureViewManager or an
equivalent factory.A global variable is a variable defined for an evaluation context and that persists
accross evaluations.
Used to ensure that a source line has been seeked to.
GuardedPattern pattern AST node type.
Creates java element handles.
Uses "typesafe enum" pattern.
This is a kind of KindedPointcut.
HashSet of Object[]
HashSet of char[][]
HashSet of Object[]
Hashtable of {Object[] --> Object }
Hashtable for non-zero int keys.
Hashtable for Integer keys.
Hashtable of {char[] --> int}
Hashtable for non-zero long keys.
Hashtable of {char[] --> Object }
Hashtable of {Object --> int }
Hashtable of {Object --> int[] }
pr354470.
Scope limited to the subtype and supertype hierarchy of a given type.
Partial implementation of an IGenericType used to
answer hierarchies.
A delegating JavaFileObject that hooks the close() methods of the Writer
or OutputStream objects that it produces, and notifies the annotation
dispatch manager when a new compilation unit is produced.
Describes an access rule to source and class files on a classpath entry.
This should contain a list of symbols unique to AspectJ grammar, but
getting jikespg to do that is too much work right now.
Common protocol for Java elements that can be annotated.
Represents an annotation on a package declaration, a type, a method, a field
or a local variable in a compilation unit or a class file.
Description of a annotation structure as described in the JVM specifications
(added in J2SE 1.5).
Represents a resolved annotation.
Description of an annotation component as described in the JVM specifications
(added in J2SE 1.5).
Description of an annotation component value as described in the JVM specifications
(added in J2SE 1.5).
Description of a annotation default attribute as described in the JVM
specifications (added in J2SE 1.5).
Represents an Attribute for a Java .class file.
Description of attribute names as described in the JVM specifications.
This represents class file information about an annotation instance.
This represents the class file information about a member value pair of an annotation.
This represents class file information about an annotation instance.
A binding represents a named entity in the Java language.
Description of a bootstrap methods attribute as described in the JVM specifications.
Description of a bootstrap method table entry as specified in the JVM specifications.
A buffer contains the text contents of a resource.
Implementors of
IBuffer can additionally implement IBuffer.ITextEditCapability.A listener, which gets notified when the contents of a specific buffer
have changed, or when the buffer is closed.
Veraltet.
Use
WorkingCopyOwner insteadInterface that handles messages sent from the compiler.
Interface that presents the user with information about the
progress of the build
Description of a Java opcodes visitor.
The
ICacheEnumeration is used to iterate over both the keys
and values in an LRUCache.Represents a single
.class file, holding the binary form
of either a type or a module:
A class file of type IOrdinaryClassFile has a single child of type IType,
a class file of type IModularClassFile has a single child of type IModuleDescription.
Class file elements need to be opened before they can be navigated.This class represents a generic class file attribute.
Veraltet.
Use
ClassFileBytesDisassembler insteadDescription of a .class file.
A classpath attribute defines a name/value pair that can be persisted with a classpath entry.
A delta which describes changes in
IClasspathAttribute of a classpath
between two discrete points in time.Interface of a classpath container.
An entry on a Java project classpath identifying one or more package fragment
roots.
An IClassWeaver is initialized with a class (a type, really, but let's ignore that for now) and a world, and has one method that
actually weaves the contents of the world into the class implementation.
Common protocol for Java elements that support source code assist and code
resolve.
Description of a code attribute as described in the JVM specifications.
Veraltet.
Use
CompletionRequestor instead.Veraltet.
Use
CodeFormatter instead (note: options have changed)A code snippet requestor implements a callback interface for installing
the class files for a code snippet on the target and running it.
Command wrapper with collecting parameter for messages.
Preprocess command-lines
Represents an entire Java compilation unit (source file with one of the
Java-like extensions).This interface denotes a compilation unit, providing its name and content.
Used to convert an IFile into an ICompilationUnit,
for clients outside of this package.
An ICompilerAdapter will be called by the compiler at strategic
points during compilation, allowing the adapter to perform additional
processing as required.
Factory for creating ICompilerAdapters according to some purpose
Interface that contains all the configuration required for the compiler to be able to perform a build
A callback interface for receiving compilation results.
Veraltet.
Use
CompletionRequestor instead.Description of a component info as described in the JVM
specifications.
Default icons.
Description of a constant pool as described in the JVM specifications.
Description of constant pool constants as described in the JVM specifications.
Description of a constant pool entry as described in the JVM specifications.
Description of the new constant pool entry as described in the JVM specifications
added for Java 7 support.
Description of a constant pool entry as described in the JVM specifications.
Description of a constant value attribute as described in the JVM
specifications.
A callback interface for receiving java problem correction.
Clients can pass a single cross-reference handler to the weaver on construction of a BcelWorld.
This represents the target file of a type dependency.
Common marker interface for AST nodes that represent fragments in doc elements.
Part of the source element parser responsible for building the output.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
An element changed listener receives notification of changes to Java elements
maintained by the Java model.
Adapter used to uniquely identify program element handles.
Additional information available for Elements that are implemented
within the Eclipse APT framework.
Description of an enclosing method attribute as described in the JVM specifications
(added in J2SE 1.5).
An evaluation context supports evaluating code snippets.
Description of a constant value attribute as described in the JVM
specifications.
The class represents an entry in the exception table of a ICodeAttribute as
specified in the JVM specifications.
Description of an extended annotation structure as described in the JVM specifications
(added in JavaSE-1.8).
Description of an extended annotation target types constants as described in the JVM specifications
(added in JavaSE-1.8).
Veraltet.
Use
CompletionRequestor insteadCommon interface for AST nodes that represent modifiers or
annotations.
Represents a field declared in a type.
Description of a field info as described in the JVM
specifications.
(formals*): ... if(expr) ...
If statement AST node type.
A global variable declared in an evaluation context.
Compiler listeners get notified of structure model update events.
Represents an import container is a child of a Java compilation unit that contains
all (and only) the import declarations.
Represents an import declaration in Java compilation unit.
IINC - Increment local variable by constant
Represents a stand-alone instance or class (static) initializer in a type.
Description of a inner class attribute as described in the JVM
specifications.
Description of a inner class info as described in the JVM
specifications.
A jar entry corresponding to a non-Java resource in an archive
IPackageFragment or IPackageFragmentRoot.Interface to allow Javadoc parser to collect both JavaSingleTypeReference and JavaQualifiedTypeReferences
Common protocol for all elements provided by the Java model.
A Java element delta describes changes in Java element between two discrete
points in time.
This interface is used by IRequestorNameLookup.
Represent the root Java element corresponding to the workspace.
Markers used by the Java model.
Represents the outcome of an Java model operation.
Status codes used with Java model status objects.
A Java project represents a view of a project resource in terms of Java
elements such as package fragments, types, methods and fields.
This interface defines the constants used by the search engine.
Veraltet.
Since 3.0, the class
SearchRequestor replaces this interface.An
IJavaSearchScope defines where search result should be found by a
SearchEngine.Interface that can be implemented by MessageHandlers that need to
perform some additional processing when a build is starting and
when it has finished.
Description of a line number attribute as described in the JVM specifications.
The ILineSeparatorFinder finds previous and next line separators
in source.
Represents a local variable declared in a method or an initializer.
Description of a local variable attribute as described in the JVM specifications.
Description of a local variable reference info table entry as specified in the JVM specifications.
Description of a local variable table entry as specified in the JVM specifications.
Description of a local variable type attribute as described in the JVM specifications
(added in J2SE 1.5).
Description of a local variable type table entry as specified in the JVM specifications
(added in J2SE 1.5).
Types implementing this interface can occupy a variable amount of space
in an LRUCache.
Exception thrown when there is an internal error in the image builder.
Common protocol for Java elements that can be members of types.
This interface is used by SourceTypeBinding to provide a delegated lookup
instance.
Represents a member-value pair of an annotation.
Represents a resolved instance of an annotation's member value pair.
Wrap message with any associated throwable or source location.
Handle messages, logging and/or aborting as appropriate.
Hold and query a collection of messages.
Represents a method (or constructor) declared in a type.
A method binding represents a method or constructor of a class or interface.
Description of a method info as described in the JVM
specifications.
Description of a method's parameters names as described in the JVM specifications.
When dumping the model out (for debugging/testing), various parts of it can be passed through this filter.
Definition of the modifier constants as specified in the JVM specifications.
Represents the class file of a module description ("module-info.class").
Description of a module's attributes as described in the JVM specifications.
A module aware name environment
Strategies for searching types Ungültige Eingabe: "&" packages in classpath locations Ungültige Eingabe: "&" modules.
A module binding represents a module (added in JLS9 API).
Represents a Java module descriptor.
Description of a Module Main Class Attribute as described in the JVMS9 4.7.27
This interface may be implemented by clients.
Description of a Module Packages as described in the JVMS9 4.7.26
This interface may be implemented by clients.
Represents an entry on the module path of a project.
Extracted slice from MethodVerifier15, which is responsible only for implicit null annotations.
Import declaration AST node type.
Handle for an import declaration.
Element info for IImportDeclaration elements.
Encapsulates an import's fully qualified name, whether it is on-demand, and whether it is static.
The
ImportRewrite helps updating imports following a import order and on-demand imports threshold as configured by a project.A
ImportRewrite.ImportRewriteContext can optionally be used in e.g.Used to determine how a type will be used, so that unwanted annotations can be filtered,
which is in particular relevant for avoiding redundant null annotations in the scope of
@NonNullByDefault.Allows the caller to specify imports to be added to or removed from a compilation unit and
creates a TextEdit which, applied to the compilation unit, effects the specified additions and
removals.
Encapsulates, for a computed import rewrite, a
TextEdit that can be applied to effect
the rewrite as well as the names of imports created by the rewrite.Used as a constructor parameter to ImportRewriteAnalyzer to configure its behavior.
Specifies which types are considered to be implicitly imported.
Specifies how to sort import declarations by their packages and/or containing types.
Represents a module path entry that represents a collection of modules
like a jimage or an exploded module directory structure
The name environment provides a callback API that the compiler
can use to look up types, compilation units, and packages in the
current environment.
The name environment provides a callback API that the compiler
can use to look up types, compilation units, and packages in the
current environment.
The name environment provides a callback API that the compiler
can use to look up types, compilation units, and packages in the
current environment.
The incremental image builder
Central point for all things incremental... - keeps track of the state recorded for each different config file - allows limited
interaction with these states
- records dependency/change info for particular classpaths > this will become what JDT keeps in its 'State' object when it's
finished
Helper class to provide String manipulation functions dealing with indentations.
An
Index maps document names to their referenced words in various categories.The location of the index files are represented as
IndexLocation
This is an abstract class to allow different implementation for a jar entry and a file
on the disk.The index qualifier which is used for represent MetaIndex qualifications which contains a category and a search key.
TODO add spec
Selects the indexes that correspond to projects in a given search scope
and that are dependent on a given focus element.
Description of a nest host attribute as described in the JVM
specifications.
Description of a nest host attribute as described in the JVM
specifications.
Description of nest members attribute as described in the JVM
specifications.
Context used during type inference for a generic method invocation
Main class for new type inference as per JLS8 sect 18.
Thrown when a definite compile error is detected deep within the type inference.
A type variable substitution strategy based on inference variables (JLS8 18.1.1)
Implementation of 18.1.1 in JLS8
Infix expression AST node type.
Infix operators (typesafe enumeration).
Reflects the context of code analysis, keeping track of enclosing
try statements, exception handlers, etc...
Static or instance initializer AST node type.
Element info for IInitializer elements.
Signature for static and instance initializers.
Used for field references within the body of an around advice
to force the use of public access methods.
This class represents a inner class attribute, i.e., the class indices of the inner and outer classes, the name and the
attributes of the inner class.
This class is derived from Attribute and denotes that this class is an Inner class of another. to the source file of
this class.
Default implementation of IInnerClassesAttribute.
Default implementation of IInnerClassesAttributeEntry
Describes one entry in the classes table of the InnerClasses attribute.
Reflects the context of code analysis, keeping track of enclosing
try statements, exception handlers, etc...
A
InstallException is thrown when installing class files on a target has failed
for any reason.Instanceof expression AST node type.
Abstract super class for all Java byte codes.
Abstract super class for branching instructions like GOTO, IFEQ, etc..
Instruction that needs one byte
A small subclass of the local variable accessing instruction class InstructionLV - this subclass does
not allow the index to be altered.
This interface contains shareable instruction objects.
Class for instructions that use an index into the constant pool such as LDC, INVOKEVIRTUAL, etc.
Instances of this class may be used, e.g., to generate typed versions of instructions.
Instances of this class give users a handle to the instructions contained in an InstructionList.
This class is a container for a list of Instruction objects.
Abstract super class for instructions dealing with local variables.
Select - Abstract super class for LOOKUPSWITCH and TABLESWITCH instructions.
Instruction that needs one short
Denote that a class targets InstructionHandles within an InstructionList.
Interface implementing the Visitor pattern programming style.
Holds a compilation result produced by the Java compilation phase, ready for weaving in the weave phase.
Internal completion context
Internal completion proposal
Query the index multiple times and do an 'and' on the results.
Type node for an intersection type in a cast expression (added in JLS8 API).
Abstraction used for intersection casts in Java 8 + and inferred types:
type inference at 1.8+
lub at 1.8+
projections for 'var' at 10+
Walks the body of inter-type declarations and replaces SuperReference with InterSuperReference
Used to represent super references inside of inter-type declarations.
An inter-type constructor declaration.
Runtime representation of an inter-type constructor member declared within an
aspect.
Base type for all inter-type declarations including methods, fields and constructors.
Represents an inter-type method, field, or constructor declared in an aspect.
An inter-type field declaration.
Represents an inter-type field declaration declared in an aspect.
InterTypeFieldDeclaration DOM AST node.
Represents an intertype member class declaration.
The member finder looks after intertype declared members on a type, there is one member finder per type that was hit by an ITD.
The member finder looks after intertype declared inner classes on a type, there is one member finder per type that was hit by an
new inner type declaration.
A special method binding representing an ITD that pretends to be a member in some target type for matching purposes.
An inter-type method declaration.
Represents an inter-type method declaration member within an aspect.
InterTypeMethodDeclaration DOM AST node.
Thrown whenever cursor location is not inside a consistent token
for example: inside a string, number, unicode, comments etc...
Exception thrown by a scanner when encountering lexical errors.
Abstraction for invocation AST nodes that can trigger overload resolution possibly involving type inference
INVOKEDYNAMIC
Super class for the INVOKExxx family of instructions.
INVOKEINTERFACE - Invoke interface method
Description of each opcode mnemonic according to the JVM specifications.
Common protocol for Java elements that must be opened before they can be
navigated or modified.
Ordinary form of a
IClassFile which holds exactly one IType.Interface that handles where the compilation output is sent.
A package binding represents a named or unnamed package.
Represents a package declaration in Java compilation unit.
A package fragment is a portion of the workspace corresponding to an entire package,
or to a portion thereof.
A package fragment root contains a set of package fragments.
Description of an exports/opens info as described in the JVM specifications 4.7.25
This interface can be used by
IJavaSearchScope, JavaSearchParticipant and SearchPattern to
mark implementors as eligible for parallel index search.Description of a parameter annotation as described in the JVM specifications
(added in J2SE 1.5).
Common protocol for Java elements that contain other Java elements.
Description of permitted subclasses attribute as described in the JVM
specifications.
Description of permitted subclasses attribute as described in the JVM
specifications.
Contract to be implemented by all poly expressions and potential poly expressions for uniform integration into overload resolution and type inference.
This interface is used by SourceTypeBinding to provide a delegated lookup instance.
Description of a Java problem, as detected by the compiler or some of the underlying
technology reusing the compiler.
A callback interface for receiving java problem as they are discovered
by some Java operation.
Implementors know how to discover annotation processors, and maintain a list of processors that
have been discovered and initialized so far.
Represents program elements in the AspectJ containment hierarchy.
Uses "typesafe enum" pattern.
Uses "typesafe enum" pattern.
Uses "typesafe enum" pattern.
Used to give progress information typically to IDEs
Description of a provides info as described in JVMS9 4.7.25.
A listener, which gets notified when a type binding has been discovered.
Description of record components attribute as described in the JVM
specifications.
A Java model region describes a hierarchical set of elements.
A relationship has a name (e.g.
Maps from a program element handles to a list of relationships between that element and other program elements.
A callback interface for receiving code snippet evaluation results.
Description of a requires info as described in JVMS9 4.7.25
A
IRestrictedAccessConstructorRequestor collects search results from a searchAllConstructorDeclarations
query to a SearchBasicEngine providing restricted access information of declaring type when a constructor is accepted.A
IRestrictedAccessMethodRequestor collects search results from a searchAllMethodDeclarations
query to a SearchBasicEngine providing restricted access information of declaring type when a method is accepted.A
IRestrictedAccessTypeRequestor collects search results from a searchAllTypeNames
query to a SearchBasicEngine providing restricted access information when a type is accepted.Represent a set of irritant flags.
Description of a runtime invisible annotations attribute as described in the JVM specifications
(added in J2SE 1.5).
Description of a runtime invisible parameter annotations attribute as described in the JVM specifications
(added in J2SE 1.5).
Description of a runtime invisible type annotations attribute as described in the JVM specifications
(added in JavaSE-1.8).
Interface to enable users to specify which class to run
Description of a runtime visible annotations attribute as described in the JVM specifications
(added in J2SE 1.5).
Description of a runtime visible parameter annotations attribute as described in the JVM specification
(added in J2SE 1.5).
Description of a runtime visible type annotations attribute as described in the JVM specifications
(added in JavaSE-1.8).
Caveat: With the introduction of "restricted keywords" in Java 9
it is impossible to classify a token without the help of a parser.
Veraltet.
Since 3.0, the class
SearchPattern replaces this interface.This is the internal requestor passed to the searchable name environment
so as to process the multiple search results as they are discovered.
A selection requestor accepts results from the selection engine.
Description of a signature attribute as described in the JVM specifications
(added in J2SE 1.5).
Description of a source attribute as described in the JVM
specifications.
Represent source location as a starting line/column and ending line in a source file.
Common protocol for Java elements that support source code manipulations such
as copy, move, rename, and delete.
A source range defines an element's source coordinates relative to
its source buffer.
Common protocol for Java elements that have associated source code.
This class represents a stack map attribute.
Description of a stack map frame as specified in the JVM specifications.
This class represents a stack map table attribute.
Implementations of this interface get told interesting information about
decisions made in AjState objects.
Abstraction of a structure model
Uses "typesafe enum" pattern.
A filter represents a mapping function from Iterator to Iterator
A getter represents a mapping function from Object to Iterator
Maps each terminal symbol in the java-grammar into a unique integer.
A tracked node position is returned when a rewrite change is
requested to be tracked.
Represents either a source type in a compilation unit (either a top-level
type, a member type, a local type, an anonymous type or a lambda expression)
or a binary type in a class file.
A TypeAnnotationWalker is initialized with all type annotations found at a given element.
A type binding represents a fully-resolved type.
This interface is used by SourceTypeBinding to provide a delegated lookup
instance.
A type hierarchy provides navigations between a type and its resolved
supertypes and subtypes for a specific type or for all types within a region.
A listener which gets notified when a particular type hierarchy object
changes.
Veraltet.
Use abstract class
TypeNameRequestor instead.Represents a type parameter defined by a type or a method
in a compilation unit or a class file.
Represents an entire Java type root (either an
ICompilationUnit
or an IClassFile).Extension to the IBuildMessageHandler to be used if only one BuildMessageHandler
is going to be used for all projects/build configuration files.
History: 246125
Interface to a module as needed to implement the updates for
--add-reads
and --add-exports command line options (or corresponding classpath attributes).The compiler first wires modules only, before then wiring packages based on the module graph.
Structure for update operations, sorted by
IUpdatableModule.UpdateKind.A variable binding represents either a field of a class or interface, or
a local variable declaration (including formal parameters, local variables,
and exception variables).
Implementors provide a 'verify()' method that is invoked at the end of type
binding completion.
Description of a verification type info as described in the JVM specifications.
This class adds support to AspectJ for an OSGi environment
Encapsulates operations that a world will need to support if it is actually going to modify bytecode rather than just match
against it.
Veraltet.
Use
ICompilationUnit insteadA jar entry that represents a non-java file found in a JAR.
A package fragment root that corresponds to a .jar or .zip.
Under JDK 1.4 or lower, we can't give generic signature info...
Uses Java 1.5 reflection APIs to determine generic signatures
Provides Java 5 behaviour in reflection based delegates (overriding 1.4 behaviour from superclass where
appropriate)
Class which handles the setting of the java options and the java options map required by
ICompilerConfiguration#getJavaOptionsMap()
Represents a Java class, i.e., the data structures, constant pool, fields, methods and commands contained in a Java .class file.
An options panel which displays the java compiler warning options.
An options panel which displays the java compiler compliance options.
Provides methods for checking Java-specific conventions such as name syntax.
The plug-in runtime class for the Java model plug-in containing the core
(UI-free) support for Java projects.
JavaCore eclipse preferences initializer.
An options panel which displays the java compiler debug options.
AST node for a Javadoc-style doc comment.
Node representing a structured Javadoc comment
Parser specialized for decoding javadoc comments
JavaDocRegion pattern AST node type.
Javadoc tag constants.
AST node for a text element within a doc comment.
Root of Java element handle hierarchy.
The delta key
A java element delta builder creates a java element delta on
a java element between the version of the java element
at the time the comparator was created and the current version
of the java element.
Holds cached structure and properties for a Java element.
An internal enumeration of all Java language features that were introduced as
standard feature or preview feature from Java 15.
JavaIndexer provides functionality to generate index files which can be used by the JDT SearchEngine.Implements an Eclipse Application for
JavaIndexer.Handles the translation of java.lang.reflect.Type objects into AspectJ UnresolvedTypes.
Implementation of
IJavaModel.Provisional API for use by JDT/UI or JDT/Debug, which may possibly be removed in a future version.
The cache of java elements to their respective info.
A checked exception representing a failure in the Java model.
Implementation of IJavaModel.
The
JavaModelManager manages instances of IJavaModel.Update the classpath variable cache
Defines behavior common to all Java Model operations
Class containing the current custom java options
An options panel which displays the character encoding java
compiler option.
Handle for a Java Project.
Java Search concrete class for a method name match.
A search participant describes a particular extension to a generic search mechanism, allowing thus to
perform combined search actions which will involve all required participants
A search scope defines which participants are involved.
A Java-specific scope for searching relative to one or more java elements.
Java Search concrete class for a type name match.
A Java-specific scope for searching the entire workspace.
Creates JDT-like handles, for example
method with string argument:
<tjp{Demo.java[Demo~main~\[QString;
method with generic argument: <pkg{MyClass.java[MyClass~myMethod~QList\<QString;>;
aspect: <pkg*A1.aj}A1
advice with Integer arg: <pkg*A8.aj}A8&afterReturning&QInteger;
method call: <pkg*A10.aj[C~m1?method-call(void pkg.C.m2())
A package fragment root that corresponds to a JMod file.
Provides reflective access to both the state available at a join point and
static information about it.
This helper object contains only the static information about a join point.
Iterates over the signatures of a join point, calculating new signatures lazily to minimize processing and to avoid unneccessary
"can't find type" errors.
A package fragment root that corresponds to a module in a JRT file system.
Labeled statement AST node type.
Reflects the context of code analysis, keeping track of enclosing
try statements, exception handlers, etc...
Lambda expression AST node type (added in JLS8 API).
Handle an external process asynchrously.
check if input contains any packages to elide.
Lazy lazy lazy.
A LazyMethodGen should be treated as a MethodGen.
End-of-line comment AST node type.
This class represents a (PC offset, line number) pair, i.e., a line number in the source that corresponds to a relative address
in the byte code.
Default implementation of ILineNumberAttribute.
This class represents a line number within a method, i.e., give an instruction
a line number corresponding to the source code line.
This class represents a table of line numbers for debugging purposes.
we don't actually target instructions, but instructions target us.
For describing manipulations to a child list property of an AST node.
This class represents a local variable within a method.
Default implementation of ILocalVariableAttribute.
A Java search match that represents a local variable declaration.
This class represents a local variable within a method.
A Java search match that represents a local variable reference.
This class represents collection of local variables in a method.
Default implementation of ILocalVariableTableEntry
Default implementation of ILocalVariableTypeAttribute.
Default implementation of ILocalVariableTypeTableEntry
AspectJ Extension - made many methods and fields more visible for extension
Also modified error checking on getType(char[][] compoundName) to allow
refering to inner types directly.
LOOKUPSWITCH - Switch with unordered set of values
Reflects the context of code analysis, keeping track of enclosing
try statements, exception handlers, etc...
The
LRUCache is a hashtable that stores a finite number of elements.This type is used internally by the LRUCache to represent entries
stored in the cache.
The
LRUCacheEnumerator returns its elements in
the order they are found in the LRUCache, with the
most recent elements first.Programmatic and command-line interface to AspectJ compiler.
This is an old implementation of ajdoc that does not use an OO style.
controller for repeatable command delays until input or file changed or removed
interceptor IMessageHandler to print as we go.
Resource bundle factory to share bundles for the same locale
Takes a method that already has the three extra parameters
thisJoinPointStaticPart, thisJoinPoint and thisEnclosingJoinPointStaticPart
Manage a MapUngültige Eingabe: "<"T1, Set>, with reverse links so that it is possible to
efficiently find all T1s that have a particular T2 associated with them.
Marker annotation node (added in JLS3 API).
When extending AspectJ's pointcut parsing and
matching with custom PointcutDesignatorHandlers,
it may be necessary to match based on context information
at a join point not exposed simply by java.lang.reflect
member information or argument values.
Test that uses MatchingContext to match (or not)
A set of matches and possible matches, which need to be resolved.
A parser that locates ast nodes that match a given search pattern.
An ast visitor that visits local type declarations.
Abstract representation of a member (field/constructor/method) within a type.
AST node for a member reference within a doc comment
(
Javadoc).Common utility methods for members.
Member value pair node (added in JLS3 API).
MemberValuePair node
Implement messages.
Error message used to report potential errors found during the AST parsing
or name resolution.
This handler accumulates messages.
AspectJ Extension - support for MethodBinding.alwaysNeedsAccessMethod
Possible mergeconflict?
Convenience API's for constructing, printing, and sending messages.
parameterize rendering behavior for messages
An IMessageHandler implementation that writes all to a PrintWriter.
This class represents the method info structure, i.e., the representation for a method in the class.
Method declaration AST node type.
A Java search match that represents a method declaration.
Type munger for annotation style ITD declare parents. with an interface AND an implementation.
Template class for building up a method.
Default implementation of IMethodInfo.
Method invocation expression AST node type.
A
MethodNameMatchRequestor collects matches from a searchAllMethodNames
query to a SearchEngine.Wrapper used to link
IRestrictedAccessMethodRequestor with MethodNameRequestor.A
MethodDeclarationRequestor collects search results from a searchAllMethodDeclarations
query to a SearchEngine.Wrapper used to linke
IRestrictedAccessMethodRequestor with MethodNameRequestor.AST node for a method or constructor reference within a doc comment
(
Javadoc).Abstract base class of all AST node types that represent a method reference
expression (added in JLS8 API).
A Java search match that represents a method reference.
AST node for a parameter within a method reference (
MethodRef).Specific block scope used for methods, constructors or clinits, representing
its outermost blockscope.
When we try to resolve a type in the world that we require to be present, and then fail to find it, we return an instance of this
class.
Exception thrown when the build should be aborted because a source file is missing/empty.
This class is used by
JavaModelManager to update the JavaModel
based on some IJavaElementDeltas.Modifier node.
Modifier keywords (typesafe enumeration).
Super class for all objects that have modifiers like private, final, ...
A handle to a modular class file.
This class is derived from Attribute and represents the module
information captured in a class file.
This class serves a dual purpose
Module declaration AST node type representing the module descriptor file (added in JLS9 API).
A Java search match that represents a module declaration.
Abstract base class of AST nodes that represent module directives (added in JLS9 API).
Implementation of
JavaCore.compileWithAttributes(IModuleDescription, Map).Copyright (c) 2017 IBM Corporation and others.
Indicates the main class of a module.
Default implementation of IModuleMainClassAttribute
Module Modifier node - represents the modifiers for the requires directive in module declaration (added in JLS9 API).
Module Modifier keywords (typesafe enumeration).
Abstract base class of AST nodes that represent exports and opens directives (added in JLS9 API).
Indicates all the packages of a module that are exported or opened by the module attribute.
Default implementation of IModulePackagesAttribute
Represents a project on the module path.
Combines an IMultiModuleEntry with further locations in order to support patch-module.
AST node for a module qualified name.
A Java search match that represents a module reference.
Just a marker class to represent statements that can occur in a module declaration
An instance of this class collects
add-exports and add-reads options from
a project's class path entries, and performs the corresponding updates when requested by the compiler.Pseudo method binding used to wrapper a real method, and expose less exceptions than original.
This operation moves elements from their current
container to a specified destination container, optionally renaming the
elements.
This operation moves resources (package fragments and compilation units) from their current
container to a specified destination container, optionally renaming the
elements.
MULTIANEWARRAY - Create new mutidimensional array of references
This class is used to perform operations on multiple
IJavaElement.Internal AST visitor for serializing an AST in a quick and dirty fashion.
Abstract base class for all AST nodes that represent names.
Common super type for Pointcuts that can bind formal parameters.
A String-based implementation of the type used to return strings in javax.lang.model.
A
NameLookup provides name resolution within a Java project.Parent class for Type and Method NameMatchRequestor classes
Node for a name-qualified type (added in JLS8 API).
Provides methods for computing Java-specific names.
https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.7.28
https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.7.29
Default implementation of INestMembersAttribute.
Code that created version one style ITD type mungers will be using direct field access from the dispatchers
Weaver representation of an intertype declared member class.
Thrown by the
aspectOf special method on aspect types
when there is no aspect of that type currently bound.Denote class to have an accept method();
For a given selection range, finds the covered node and the covering node.
The repository maintains information about which classes have been loaded.
A type annotation walker that adds missing NonNull annotations according to the current default.
Normal annotation node (added in JLS3 API).
Normal annotation node
Thrown when AjType.getDeclaredAdvice is called with an advice name and no matching
advice declaration can be found.
Thrown when AjType.getDeclaredPointcut is called with a pointcut name, and no
matching pointcut declaration can be found.
NotPointcut DOM AST node.
Represents the NOT of a signature pattern
!
An implementation of NoType, which is used to represent certain pseudo-types.
Performs matching of null type annotations.
This class represents a null buffer.
Null literal node.
Null Pattern node.
Number literal nodes.
Denotes reference such as java.lang.String.
Implementation of the "Keep braced code on one line" feature.
Description of each opcode mnemonic according to the JVM specifications.
Abstract class for implementations of java elements which are IOpenable.
Element info for IOpenable elements.
Opens directive AST node type (added in JLS9 API).
Class used to handle options in the EclipseFileManager and the EclipseCompiler
A class that hanldes LTW options.
UI for setting user-configureable options.
OrPointcut DOM AST node.
Represents the OR of two other signature patterns.
left || right
Enables the output locations detailed by the IOutputLocationManager implementation to be related to the comipler/weaver.
The
OverflowingLRUCache is an LRUCache which attempts
to maintain a size equal or less than its fSpaceLimit
by removing the least recently used elements.Package declaration AST node type.
A Java search match that represents a package declaration.
Implementation of PackageElement, which represents a package
A Java search match that represents a package reference.
Default implementation of IParameterAnnotation
Binding denoting a field after type substitution got performed.
Binding denoting a generic method after type parameter substitutions got performed.
Binding denoting a method after type parameter substitutions got performed.
Syntactic representation of a reference to a generic type.
Binding denoting a record component after type substitution got performed.
Syntactic representation of a reference to a generic type.
Type node for a parameterized type (added in JLS3 API).
A parameterized type encapsulates a type with type arguments,
Parenthesized expression AST node type.
This class implements a partial order
It includes routines for doing a topo-sort
All classes that want to be part of a partial order must implement PartialOrder.PartialComparable.
Collects the resource paths reported by a client to this search requestor.
Implementation of a Java file object that corresponds to a file on the file system
Abstract base class of AST nodes that represent patterns.
PatternInstanceof expression AST node type.
abstract TypePattern DOM AST node.
A Pointcut or TypePattern visitor
PerCflow DOM AST node.
AspectJ runtime representation of the per-clause associated with an aspect.
The different per-clauses (aspect instantiation models)
supported by AspectJ
Default implementation of IPermittedSubclassesAttribute.
OrPointcut DOM AST node.
A visitor that turns a pointcut into a type pattern equivalent for a perthis or pertarget matching: - pertarget(target(Foo)) →
Foo+ (this one is a special case..) - pertarget(execution(* Foo.do()) → Foo - perthis(call(* Foo.do()) → * - perthis(!
OrPointcut DOM AST node.
A package binding that is known not to be a
SplitPackageBinding.Pointcut declaration
AspectJ runtime representation of a pointcut member inside a class or aspect.
The lifecycle of Pointcuts is modeled by Pointcut.State.
Representation of a pointcut based per-clause associated with an aspect
(perthis/target/cflow/cflowbelow)
pointcut [declaredModifiers] [declaredName]([arguments]): [pointcutDesignator];
PointcutDeclaration DOM AST node.
abstract PointcutDesignator DOM AST node.
The PointcutDesignator interface allows extension of the
AspectJ pointcut language so that third-party tools integrating
with AspectJ can add easily their own custom
domain-specific designators and have them interoperate seamlessly
with the standard AspectJ designators.
Implementation of Pointcut that is backed by a user-extension pointcut designator handler.
Represents an anonymous pointcut expression as used in pointcuts, advice declarations,
declares, and per-clauses
Represents an AspectJ pointcut expression and provides convenience methods to determine
whether or not the pointcut matches join points specified in terms of the
java.lang.reflect interfaces.
Map from weaver.tools interface to internal Pointcut implementation...
A PointcutParser can be used to build PointcutExpressions for a user-defined subset of AspectJ's pointcut language
An enumeration of the different kinds of pointcut primitives
supported by AspectJ.
Performs term rewriting for pointcut expressions.
Walks a pointcut and determines if the synchronization related designators have been used: lock() or unlock()
Binding denoting a polymorphic method
A set of PossibleMatches that is sorted by package fragment roots.
Postfix expression AST node type.
Postfix operators (typesafe enumeration).
Prefix expression AST node type.
Prefix operators (typesafe enumeration).
Primitive type nodes.
Primitive type codes (typesafe enumeration).
A privileged access munger is for handling privileged access to a member.
Used to represent any method call to a method named
proceed.ProceedingJoinPoint exposes the proceed(..) method in order to support around advice in @AJ aspects
Takes a method that already has the three extra parameters
thisJoinPointStaticPart, thisJoinPoint and thisEnclosingJoinPointStaticPart
Cached information associated with a
Processor in the context
of annotation processor dispatch.Represents a project
Provides directive AST node type (added in JLS9 API).
This class acts as a facade to the internal Scanner implementation and delegates
all the work to the internal Scanner instance.
Collects up information about the application of ITDs and relevant declares - it can then output source code as if those ITDs had
been pushed in.
Variation on allocation, where can optionally be specified any of:
- leading enclosing instance
- trailing anonymous type
- generic type arguments for generic constructor invocation
AST node for a qualified name.
Type node for a qualified type (added in JLS3 API).
The index qualifier query which is used for searching MetaIndex qualifications in IndexManager.
Denote a raw type, i.e. a generic type referenced without any type arguments.
Monitor ensuring no more than one writer working concurrently.
The context of a reconcile event that is notified to interested compilation
participants while a reconcile operation is running.
Reconcile a working copy and signal the changes through a delta.
Default implementation of
IRecordAttribute.Record declaration AST node type (added in JLS16 API).
Use to keep track of recorded information during the parsing like comment positions,
line ends or problems.
TypePattern pattern AST node type.
Internal method structure for parsing recovery
Internal type structure for parsing recovery
Generalization over TypeBounds and ConstraintFormulas which both
can be created during reduction.
An adapter which implements the methods for handling
reference information from the parser.
An abstract Java search match that represents a reference.
ReferencePointcut DOM AST node.
Super class for object and array types.
A reference type represents some 'real' type, not a primitive, not an array -
but a real type, for example java.util.List.
Abstraction over a type - a reference type is Object or a descendant of Object, other types (int/etc) are considered primitive
types.
Subtype of ResolvedMemberImpl used in reflection world.
An implementation of FastMatchInfo that can also expose a MatchingContext.
A variable at a reflection shadow, used by the residual tests.
A ReflectionWorld is used solely for purposes of type resolution based on the runtime classpath (java.lang.reflect).
This operation renames elements.
This operation renames resources (Package fragments and compilation units).
The repository maintains informations about class interdependencies, e.g., whether a class is a sub-class of another.
Abstract definition of a class repository.
Can be specified on an aspect to ensure that particular types must be accessible before
the aspect will be 'activated'.
Requires directive AST node type (added in JLS9 API).
Carries an array of unresolved types - will resolve them on demand.
Handle representing a binary field that is resolved.
Handle representing a binary method that is resolved.
Handle representing a binary type that is resolved.
Represent a resolved member.
Handle representing a source field that is resolved.
Handle representing a source method that is resolved.
Handle representing a source type that is resolved.
This is an abstraction over method/field introduction.
An ICompilationUnit that retrieves its contents using an IFile
RET - Return from subroutine
Returnaddress, the type JSR or JSR_W instructions push upon the stack.
Return statement AST node type.
Stores all rewrite events, descriptions of events and knows which nodes
are copy or move sources or tracked.
Interface that allows to override the way how children are accessed from
a parent.
Manages context during a single round of annotation processing.
Default implementation of IRuntimeInvisibleAnnotations
Default implementation of IRuntimeInvisibleParameterAnnotations
Default implementation of IRuntimeInvisibleTypeAnnotations
Captures important runtime versions.
Default implementation of IRuntimeVisibleAnnotations
Default implementation of IRuntimeVisibleAnnotations
Default implementation of IRuntimeVisibleTypeAnnotations
A scope that also considers type variables when looking up a type.
This class provides a
SearchableBuilderEnvironment for code assist which
uses the Java model as a search tool.A search document encapsulates a content to be either indexed or searched in.
A
SearchEngine searches for Java elements following a search pattern.A search match represents the result of a search query.
A search participant describes a particular extension to a generic search
mechanism, permitting combined search actions which will involve all required
participants.
A search pattern defines how search results are found.
Collects the results from a search engine query.
The selection engine is intended to infer the nature of a selected name in some
source code.
Node representing a Javadoc comment including code selection.
Parser specialized for decoding javadoc comments which includes code selection.
Implementation of
ISelectionRequestor to assist with
code resolve in a compilation unit.This operation sets an
IJavaProject's classpath.A type-safe enum representing the kind of shadows
The result of asking a PointcutExpression to match at a shadow (method execution,
handler, constructor call, and so on).
For every shadow munger, nothing can be done with it until it is concretized.
This class is derived from Attribute and represents a reference to a Ungültige Eingabe: "<"href="http://wwwipd.ira.uka.de/~pizza/gj/">GJ
attribute.
Represents the signature at a join point.
Provides methods for encoding and decoding type and method signature strings.
AspectJ runtime representation of a signature pattern as used in various
aspect members (for example, declare @method, declare @field).
SignaturePattern DOM AST node. has: nothing
For the moment this does nothing except enable us to set a SignaturePattern for the declare annotation declarations
Basic implementation of signature pattern
This class has been created to avoid deadlocks when instrumenting SAXParser.
Copyright (c) 2012 Contributors.
A simple Java element delta that remembers the kind of changes only.
Minimal implementation of IDocument to apply text edit onto a string.
Veraltet.
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
A simple lookup table is a non-synchronized Hashtable, whose keys
and values are Objects.
AST node for a simple name.
Descriptor for a simple property of an AST node.
A simple lookup table is a non-synchronized Hashtable, whose keys
and values are Objects.
A simple lookup table is a non-synchronized Hashtable, whose keys
and values are char[].
Type node for a named class type, a named interface type, or a type variable.
Single member annotation node (added in JLS3 API).
SingleMemberAnnotation node
Single variable declaration AST node type.
Wrapper for checked exceptions matched by a 'declare soft'.
This operation is used to sort elements in a compilation unit according to
certain criteria.
Sorting utilities.
A source element parser extracts structural and reference information
from a piece of source.
Element info for IField elements.
This class is derived from Attribute and represents a reference to the source file of this class.
Default implementation of ISourceAttribute
A SourceIndexer indexes java files using a java parser.
This class is used by the JavaParserIndexer.
Immutable source location.
For defining code, the class defined and location in a source file.
A SourceMapper maps source code in a ZIP file to binary types or
binary modules in a JAR.
Element info for IMethod elements.
A source range defines an element's source coordinates relative to
its source buffer.
Abstract class for Java elements which implement ISourceReference.
Handle for a source type.
Element info for an IType element that originated from source.
This class represents a stack map attribute used for preverification of Java classes for the
Java 2 Micro Edition (J2ME).
Uses asm to add the stack map attribute to methods in a class.
Default implementation of IStackMapAttribute.
This class represents a stack map entry recording the types of
local variables and the the of stack items at a given byte code offset.
Default implementation of IStackMapFrame
Default implementation of IStackMapTableAttribute.
This class represents the type of a local variable or item on stack
used in the StackMap entries.
This type represents the weavers abstraction of an annotation - it is not tied to any underlying BCI toolkit.
Represents an AspectJ pointcut expression and provides convenience methods to determine whether or not the pointcut matches join
points specified in terms of the java.lang.reflect interfaces.
Map from weaver.tools interface to internal Pointcut implementation...
A PointcutParser can be used to build PointcutExpressions for a user-defined subset of AspectJ's pointcut language
Abstract base class of AST nodes that represent statements.
String literal nodes.
Flatten string literal
This class is a collection of helper methods to manipulate strings during search.
Abstract base class for property descriptors of AST nodes.
Utility class for building a structure model for a given compile.
Represents the configuration of a structure view of the system, rendered
by the
StructureTreeManager.Nested properties use the typesafe enum pattern.
View renderers get notified of structure view update events and should
update the display of the structure view accordingly.
Extra behavior for statements which are generating subroutines
Don't substitute any type variables.
Super constructor invocation statement AST node type.
Simple or qualified "super" field access expression AST node type.
Takes a method that already has the three extra parameters thisJoinPointStaticPart, thisJoinPoint and
thisEnclosingJoinPointStaticPart
Simple or qualified "super" method invocation expression AST node type.
Super method reference AST node type (added in JLS8 API).
Collects the super type names of a given declaring type.
Annotate members to avoid AspectJ error messages.
SWITCH - Branch depending on int value, generates either LOOKUPSWITCH or
TABLESWITCH instruction, depending on whether the match values (int[]) can be
sorted with no gaps between the numbers.
Switch case AST node type.
Switch expression AST node type (added in JEP 325).
Reflects the context of code analysis, keeping track of enclosing
try statements, exception handlers, etc...
Switch statement AST node type.
Synchronized statement AST node type.
This class is derived from Attribute and declares this class as `synthetic', i.e., it needs special handling.
Encodes a synthetic <factory> method used for resolving a diamond constructor.
This repository is used in situations where a Class is created outside the realm of a ClassLoader.
TABLESWITCH - Switch within given range of values, i.e., low..high
A tag is an instruction-targeter that does not remember its target.
AST node for a tag within a doc comment.
TagProperty pattern AST node type.
Thrown by InstructionList.remove() when one or multiple disposed instruction
are still being referenced by a InstructionTargeter object.
An object for computing adjusted source ranges for AST nodes
that are being replaced or deleted.
Reified source range.
Some methods need a temporary type munger (because ConcreteTypeMunger is abstract - dont ask...).
Maps each terminal symbol in the java-grammar into a unique integer.
TextBolck AST node type.
Creates the formatter's result TextEdit by scanning through the tokens and comparing them with the original source.
AST node for a text element within a doc comment.
AspectJ Extension- made a few changes to increase accessibility.
IMPORTANT NOTE: Internal Scanner implementation.
Simple or qualified "this" AST node type.
Takes a method that already has the three extra parameters thisJoinPointStaticPart, thisJoinPoint and
thisEnclosingJoinPointStaticPart
Corresponds to target or this pcd.
Throw statement AST node type.
Stores a token's type, position and all its properties like surrounding whitespace, wrapping behavior and so on.
A helper class that can be used to easily access source code and find tokens on any position.
Wraps a scanner and offers convenient methods for finding tokens
Helper class that can be subclassed every time an algorithm needs to swipe through all or part of the tokens and
easily keep track or previous and future tokens and whitespace.
Factory for creating various compiler tools, such as scanners, parsers and compilers.
The SortOperation takes a collection of objects and returns
a sorted collection of these objects.
UI for editing build configuration (".lst") files via a graphical tree-based
representation.
Shared implementation for try-statement-related flow contexts.
Try statement AST node type.
Abstract super class for all possible java types, namely basic types such as int, object types like String and array types, e.g.
Abstract base class of all type reference AST node types.
Used for @this() @target() @args() - represents accessing an annotated 'thing'.
The TypeAnnotationInfo class does not currently support type annotations within code
blocks (those that have a target type of 0x40 and higher) - it is not yet clear that
these need to be accessible.
Type annotation walker implementation based an actual annotations decoded from a .class file.
Implementation of 18.1.3 in JLS8
A TypeCategoryTypePattern matches on the category of a type, one of class/interface/aspect/inner/anonymous/enum/annotation, and
these are specified in the pointcut via isClass() isInterface() isAspect() isInner() isAnonymous() isEnum() isAnnotation().
Type declaration AST node type.
A Java search match that represents a type declaration.
Local type declaration statement AST node type.
A type delegate resolver is able to create type delegates for a named reference type.
Type literal AST node type.
Type method reference expression AST node type (added in JLS8 API).
Implementation of a TypeMirror.
A
TypeNameMatchRequestor collects matches from a searchAllTypeNames
query to a SearchEngine.Wrapper used to link
IRestrictedAccessTypeRequestor with TypeNameRequestor.A
TypeNameRequestor collects search results from a searchAllTypeNames
query to a SearchEngine.Wrapper used to link
IRestrictedAccessTypeRequestor with TypeNameRequestor.Type parameter declaration node (added in JLS3 API).
A Java search match that represents a type parameter declaration or reference.
Search engine locator for type parameters matches.
Pattern to search type parameters.
A Java search match that represents a type parameter declaration or reference.
AspectJ runtime representation of a type pattern as used in member
declarations such as declare parents.
TypePattern pattern AST node type.
On creation, type pattern only contains WildTypePattern nodes, not BindingType or ExactType.
AspectJ runtime representation of a type pattern based per-clause associated
with an aspect (pertypewithin).
Default impl of a type pattern.
A compiled AspectJ type pattern that can be used to
match against types at runtime.
Simplified specification of where in a (possibly complex) type reference
we are looking for type annotations.
A Java search match that represents a type reference.
Utilities for working with types (as opposed to elements).
Represents a type variable with possible bounds.
Binding for a type parameter, held by source/binary type or method.
Tag interface - methods and types can be declaring elements for type variables.
Implementation of TypeVariable
Implemented by Types that represent references to type variables
ReferenceType pointing to a type variable.
Record initialization status during definite assignment analysis
No caching of pre-allocated instances.
Exception raised when unexpected behavior is detected.
Type node for an union type (added in JLS4 API).
This class represents a reference to an unknown (i.e., application-specific) attribute of a class.
A UnresolvedType represents a type to the weaver.
Used for automatically updating build configuration files (".lst") when a
project configuration has changed.
Internal model element to represent a user library and code to serialize / deserialize.
This interface needs to be implemented by an IDE extension in order for AJDE
to store properties in a way that matches the IDE's property storing facilities.
Uses directive AST node type (added in JLS9 API).
Util class that defines helper methods to read class contents with handling of wrong encoding
Provides convenient utility methods to other types in this package.
Load classes as File from File[] dirs or URL[] jars.
Utility functions that do not really belong to any class in particular.
Abstract base class of all AST node types that declare a single
variable.
Local variable declaration expression AST node type.
Variable declaration fragment AST node type, used in field declarations,
local variable declarations,
ForStatement initializers,
and LambdaExpression parameters.Local variable declaration statement AST node type.
Implementation of VariableElement, which represents a a field, enum constant,
method or constructor parameter, local variable, or exception parameter.
A variables evaluator compiles the global variables of an evaluation context and returns
the corresponding class files.
This contains information about the installed variables such as
their names, their types, the name of the class that defines them,
the binary of the class (to be passed to the name environment when
compiling the code snippet).
release-specific version information
Lightweight subclass of DataInputStream that knows what version of the weaver was used to construct the data in it.
Check if there are illegal 'void[]' , 'void[][]' etc. occurrences anywhere in type patterns
Wraps a reference to a classloader inside a WeakReference.
A hashset whose values can be garbage collected.
A hashset of char[] whose values can be garbage collected.
Manages a cache of weaved and generated classes similar to Eclipse Equinox,
except designed to operate across multiple restarts of the JVM and with one
cache per classloader; allowing URLClassLoaders with the same set of URI
paths to share the same cache (with the default configuration).
WeaverStateInfo represents how a type was processed.
This adaptor allows the AspectJ compiler to be embedded in an existing system to facilitate load-time weaving.
An interface for weaving class loaders to provide callbacks for a
WeavingAdaptor.
While statement AST node type.
Node to represent Wildcard
Represents a wildcarded bound for a generic type, this can be unbounded '?'
Type node for a wildcard type (added in JLS3 API).
Implementation of the WildcardType
The PatternParser always creates WildTypePatterns for type patterns in pointcut expressions (apart from *, which is sometimes
directly turned into TypePattern.ANY). resolveBindings() tries to work out what we've really got and turn it into a type pattern
that we can use for matching.
The owner of an
ICompilationUnit handle in working copy mode.A World is a collection of known types and crosscutting members.
Yield statement AST node type.
Uses a ZIP file to store the instrumented classes/aspects - each one as a
separate
ZipEntry.