# All Classes

All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
AbstractJavaLaunchConfigurationDelegate: Abstract implementation of a Java launch configuration delegate.
AbstractOpenWizardAction: Abstract base classed used for the open wizard actions.
AbstractProposalSorter: Abstract base class for sorters contributed to the `org.eclipse.jdt.ui.javaCompletionProposalSorters` extension point.
AbstractTypeDeclaration: Abstract subclass for type declaration, enum declaration, and annotation type declaration AST node types.
AbstractVMInstall: Abstract implementation of a VM install.
AbstractVMInstallPage: A wizard page used to edit the attributes of an installed JRE.
AbstractVMInstallType: Abstract implementation of a VM install type.
AbstractVMRunner: Abstract implementation of a VM runner.
AddDelegateMethodsAction: Creates delegate methods for a type's fields.
AddGetterSetterAction: Creates getter and setter methods for a type's fields.
AddJavaDocStubAction: Create Javadoc comment stubs for the selected members.
AddToClasspathAction: Action to add a JAR to the classpath of its parent project.
AddUnimplementedConstructorsAction: Creates unimplemented constructors for a type.
AdvancedJavaLaunchDelegate: A launch delegate for launching local Java applications with advanced source lookup support.
AdvancedJUnitLaunchConfigurationDelegate: Launch configuration delegate for a JUnit test as a Java application with advanced source lookup support.
AdvancedSourceLookup: Static methods for implementing advanced source lookup.
AdvancedSourceLookupParticipant
AnnotatableType: Abstract base class of AST nodes that represent an annotatable type (added in JLS8 API).
Annotation: Abstract base class of AST nodes that represent annotations.
AnnotationMirror: Represents an annotation.
AnnotationProcessor: An annotation processor, used to examine and process the annotations of program elements.
AnnotationProcessorEnvironment: The environment encapsulating the state needed by an annotation processor.
AnnotationProcessorFactory: A factory for creating annotation processors.
AnnotationProcessorListener: Superinterface for all annotation processor event listeners.
AnnotationProcessors: Utilities to create specialized annotation processors.
AnnotationType: Represents an annotation type.
AnnotationTypeDeclaration: Represents the declaration of an annotation type.
AnnotationTypeDeclaration: Annotation type declaration AST node type (added in JLS3 API).
AnnotationTypeElementDeclaration: Represents an element of an annotation type.
AnnotationTypeMemberDeclaration: Annotation type member declaration AST node type (added in JLS3 API).
AnnotationValue: Represents a value of an annotation type element.
AnonymousClassDeclaration: Anonymous class declaration AST node type.
AppletArgumentsTab: A launch configuration tab that displays and edits program arguments, VM arguments, and working directory launch configuration attributes, for an applet.
AppletMainTab: This tab appears for Java applet launch configurations and allows the user to edit attributes such as the applet class to launch and its owning project, if any.
AppletParametersTab: This tab appears for java applet launch configurations and allows the user to edit applet-specific attributes such as width, height, name & applet parameters.
AptBuilder: Commandline entry point for building a workspace using APT.
AptConfig: Accesses configuration data for APT.
AptPreferenceConstants: String constants used to access APT preference store This class is not intended to be subclassed or instantiated.
AptUtil
ArchiveSourceLocation: Deprecated. In 3.0, the debug platform provides source lookup facilities that should be used in place of the Java source lookup support provided in 2.0.
ArrayAccess: Array access expression AST node type.
ArrayCreation: Array creation expression AST node type.
ArrayInitializer: Array initializer AST node type.
ArrayType: Represents an array type.
ArrayType: Type node for an array type.
AssertStatement: Assert statement AST node type.
Assignment: Assignment expression AST node type.
Assignment.Operator: Assignment operators (typesafe enumeration).
AST: Umbrella owner and abstract syntax tree node factory.
ASTMatcher: Concrete superclass and default implementation of an AST subtree matcher.
ASTNode: Abstract superclass of all Abstract Syntax Tree (AST) node types.
ASTParser: A Java language parser for creating abstract syntax trees (ASTs).
ASTRequestor: An AST requestor handles ASTs for compilation units passed to `ASTParser.createASTs`.
ASTRewrite: Infrastructure for modifying code by describing changes to AST nodes.
ASTRewriteCorrectionProposal: A proposal for quick fixes and quick assists that works on an AST rewrite.
ASTVisitor: A visitor for abstract syntax trees.
BatchCompiler: A public API for invoking the Eclipse Compiler for Java.
BindingKey: Utility class to decode or create a binding key.
Block: Block statement AST node type.
BlockComment: Block comment AST node type.
BodyDeclaration: 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.
BooleanLiteral: Boolean literal node.
BreakStatement: Break statement AST node type.
BufferChangedEvent: A buffer changed event describes how a buffer has changed.
BuildActionGroup: Contributes all build related actions to the context menu and installs handlers for the corresponding global menu actions.
BuildContext: The context of a build event that is notified to interested compilation participants when `a build is starting`, or to annotations processors when `a source file has annotations`.
BuildJarIndex: An Ant task to generate the index file for the given jar path.
BuildPathDialogAccess: Class that gives access to dialogs used by the Java build path page to configure classpath entries and properties of classpath entries.
ByteCodeVisitorAdapter: Adapter that implements the IBytecodeVisitor.
CastExpression: Cast expression AST node type.
CatchClause: Catch clause AST node type.
CategorizedProblem: Richer description of a Java problem, as detected by the compiler or some of the underlying technology reusing the compiler.
CCPActionGroup: Action group that adds copy, cut, paste, and delete actions to a view part's context menu and installs handlers for the corresponding global menu actions.
ChangeCorrectionProposal: Implementation of a Java completion proposal to be used for quick fix and quick assist proposals that are based on a `Change`.
ChangeCorrectionProposalCore
ChangeMethodSignatureArguments: Change method signature arguments describe the data that a processor provides to its change signature participants
ChangeMethodSignatureArguments.Parameter: Instances of `ChangeMethodSignatureArguments.Parameter` are used to describe the new parameters after a change method signature refactoring.
ChangeMethodSignatureArguments.ThrownException: Instances of `ChangeMethodSignatureArguments.ThrownException` are used to describe the new thrown exceptions after a change method signature refactoring.
ChangeMethodSignatureDescriptor: Refactoring descriptor for the change method signature refactoring.
ChangeMethodSignatureParticipant: A participant to participate in refactorings that change method signatures.
ChangeTypeAction: Action to generalize the type of a local or field declaration or the return type of a method declaration.
CharacterLiteral: Character literal nodes.
CharOperation: This class is a collection of helper methods to manipulate char arrays.
CheckDebugAttributes: An Ant task to find out if a class file or a jar contains debug attributes.
Checks: Utility functions intended for use with the null annotations defined in this package.
ChildListPropertyDescriptor: Descriptor for a child list property of an AST node.
ChildPropertyDescriptor: Descriptor for a child property of an AST node.
ClassDeclaration: Represents the declaration of a class.
ClassFileBytesDisassembler: This class is intended to be subclassed to disassemble classfile bytes onto a String using the proper line separator.
ClassFormatException: Exception thrown by a class file reader when encountering a error in decoding information contained in a .class file.
ClassInstanceCreation: Class instance creation expression AST node type.
ClasspathAttributeConfiguration: A `ClasspathAttributeConfiguration` specifies how a `class path attribute` is presented and configured in the Java build path dialog.
ClasspathAttributeConfiguration.ClasspathAttributeAccess: This class provides information about the attribute to be rendered or configured.
ClasspathContainerInitializer: Abstract base implementation of all classpath container initializer.
ClasspathContainerSourceContainer: A source container for a classpath container.
ClasspathFixProcessor: Class to be implemented by contributors to the extension point `org.eclipse.jdt.ui.classpathFixProcessors`.
ClasspathFixProcessor.ClasspathFixProposal: A proposal to fix a class path issue.
ClasspathVariableInitializer: Abstract base implementation of all classpath variable initializers.
ClasspathVariableSourceContainer: A classpath variable source container contains a source container that is the resolved value of the associated variable.
ClassType: Represents a class type.
CleanUpContext: The context that contains all information required by a clean up to create a fix.
CleanUpContextCore: The context that contains all information required by a clean up to create a fix.
CleanUpOptions: Allows to set and retrieve clean up settings for given options keys.
CleanUpOptionsCore: Allows to set and retrieve clean up settings for given options keys.
CleanUpRequirements: Specifies the requirements of a clean up.
CleanUpRequirementsCore: Specifies the requirements of a clean up.
CodeFormatter: Specification for a generic source code formatter.
CodeFormatterApplication: Implements an Eclipse Application for org.eclipse.jdt.core.JavaCodeFormatter.
CodeGeneration: Class that offers access to the templates contained in the 'code templates' preference page.
CodeGeneration: Deprecated. See `CodeGeneration`
CodeStyleConfiguration: Gives access to the import rewrite configured with the settings as specified in the user interface.
CodeStyleConfiguration: Gives access to the import rewrite configured with the settings as specified in the user interface.
Comment: Abstract base class for all AST nodes that represent comments.
CompatibleEnvironment: The result of analyzing a vm install for compatibility with an execution environment.
CompilationParticipant: A compilation participant is notified of events occurring during the compilation process.
CompilationProgress: A compilation progress is used by the `BatchCompiler` to report progress during compilation.
CompilationUnit: Java compilation unit AST node type.
CompilationUnitChange: A `TextFileChange` that operates on an `ICompilationUnit` in the workspace.
CompilationUnitSorter: Operation for sorting members within a compilation unit.
CompletionContext: Completion context.
CompletionFlags: Utility class for decoding additional flags in completion proposal.
CompletionProposal: Completion proposal.
CompletionProposalCollector: Java UI implementation of `CompletionRequestor`.
CompletionProposalComparator: Comparator for java completion proposals.
CompletionProposalLabelProvider: Provides labels for java content assist proposals.
CompletionRequestor: Abstract base class for a completion requestor which is passed completion proposals as they are generated in response to a code assist request.
CompletionRequestorAdapter: Deprecated. Subclass `CompletionRequestor` instead.
ConditionalExpression: Conditional expression AST node type.
ConstructorDeclaration: Represents a constructor of a class or interface.
ConstructorInvocation: Alternate constructor invocation statement AST node type.
ContentAssistInvocationContext: Describes the context of an invocation of content assist in a text viewer.
ContinueStatement: Continue statement AST node type.
ConvertAnonymousDescriptor: Refactoring descriptor for the convert anonymous to nested refactoring.
ConvertAnonymousToNestedAction: Action to convert an anonymous inner class to a nested class.
ConvertingSelectionProvider: A converting selection provider is a special selection provider which converts a selection before notifying any listeners.
ConvertLocalToFieldAction: Action to convert a local variable to a field.
ConvertLocalVariableDescriptor: Refactoring descriptor for the convert local variable refactoring.
ConvertMemberTypeDescriptor: Refactoring descriptor for the convert member type refactoring.
ConvertNestedToTopAction: Action to convert a nested class to a top level class.
CopyDescriptor: Refactoring descriptor for the copy refactoring.
CoreASTProvider: The `CoreASTProvider` provides access to the `AST root` used by the current active Java editor.
CoreASTProvider.WAIT_FLAG: Wait flag class.
CorrectionEngine: This class is the entry point for source corrections.
CreationReference: Creation reference expression AST node type (added in JLS8 API).
CUCorrectionProposal: A proposal for quick fixes and quick assists that work on a single compilation unit.
CUCorrectionProposalCore: A proposal for quick fixes and quick assists that work on a single compilation unit.
CustomFiltersActionGroup: Action group to add the filter action to a view part's tool bar menu.
Declaration: Represents the declaration of a program element such as a package, class, or method.
DeclarationFilter: A filter for selecting just the items of interest from a collection of declarations.
Declarations: Utility methods for operating on declarations.
DeclarationsSearchGroup: Action group that adds the search for declarations actions to a context menu and the global menu bar.
DeclarationVisitor: A visitor for declarations, in the style of the standard visitor design pattern.
DeclarationVisitors: Utilities to create specialized `DeclarationVisitor` instances.
DeclaredType: Represents a declared type, either a class type or an interface type.
DefaultCodeFormatterConstants: Constants used to set up the options of the code formatter.
DefaultJavaFoldingStructureProvider: Updates the projection model of a class file or compilation unit.
DefaultJavaFoldingStructureProvider.JavaProjectionAnnotation: A `ProjectionAnnotation` for java code.
DefaultLocation: Locations that can be affected by a `NonNullByDefault` annotation.
DeleteDescriptor: Refactoring descriptor for the delete refactoring.
Dimension: AST node for an array dimension (added in JLS8 API).
DirectorySourceLocation: Deprecated. In 3.0, the debug platform provides source lookup facilities that should be used in place of the Java source lookup support provided in 2.0.
DOMException: Deprecated. 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.
DOMFactory: Deprecated. 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.
DoStatement: Do statement AST node type.
EclipseAnnotationProcessorEnvironment: Extended the APT `AnnotationProcessorEnvironment` to expose extra API.
EclipseAnnotationProcessorFactory: Extend the APT annotation processor factory API to provide extra features.
EclipseMessager: Extend the APT `Messager` to allow the registrating of diagnostics on ast nodes.
ElementChangedEvent: An element changed event describes a change to the structure or contents of a tree of Java elements.
ElementQuerySpecification: Describes a search query by giving the `IJavaElement` to search for.
EmptyStatement: Null statement AST node type.
EncapsulateFieldDescriptor: Refactoring descriptor for the encapsulate field refactoring.
EnhancedForStatement: Enhanced For statement AST node type (added in JLS3 API).
EnumConstantDeclaration: Represents an enum constant declaration.
EnumConstantDeclaration: Enumeration constant declaration AST node type (added in JLS3 API).
EnumDeclaration: Represents the declaration of an enum type.
EnumDeclaration: Enum declaration AST node type (added in JLS3 API).
EnumType: Represents an enum type.
EnvironmentFactory
EvaluationManager: The evaluation manager provides factory methods for creating evaluation engines.
ExecutableDeclaration: Represents a method or constructor of a class or interface.
ExecutionArguments: The execution arguments for running a Java VM.
ExecutionEnvironmentDescription: Helper class to parse and retrieve properties from execution environment description files.
ExportsDirective: Exports directive AST node type (added in JLS9 API).
Expression: Abstract base class of AST nodes that represent expressions.
ExpressionMethodReference: Expression method reference AST node type (added in JLS8 API).
ExpressionStatement: Expression statement AST node type.
ExternalAnnotationUtil: Utilities for accessing and manipulating text files that externally define annotations for a given Java type.
ExternalAnnotationUtil.MergeStrategy: Strategy for merging a new signature with an existing (possibly annotated) signature.
ExternalizeStringsAction: Externalizes the strings of a compilation unit or find all strings in a package or project that are not externalized yet.
ExtractClassAction: Extracts selected fields into a new class and replaces the fields with a new field to the new class
ExtractClassDescriptor: Refactoring descriptor for the extract class refactoring.
ExtractClassDescriptor.Field: Instances of `ExtractClassDescriptor.Field` describe which fields will be moved to the extracted class and their new name there.
ExtractConstantAction: Extracts an expression into a constant field and replaces all occurrences of the expression with the new constant.
ExtractConstantDescriptor: Refactoring descriptor for the extract constant refactoring.
ExtractInterfaceAction: Extract a new interface from a class and tries to use the interface instead of the concrete class where possible.
ExtractInterfaceDescriptor: Refactoring descriptor for the extract interface refactoring.
ExtractLocalDescriptor: Refactoring descriptor for the extract local variable refactoring.
ExtractMethodAction: Extracts the code selected inside a compilation unit editor into a new method.
ExtractMethodDescriptor: Refactoring descriptor for the extract method refactoring.
ExtractSuperclassDescriptor: Refactoring descriptor for the extract superclass refactoring.
ExtractTempAction: Extracts an expression into a new local variable and replaces all occurrences of the expression with the local variable.
FieldAccess: Field access expression AST node type.
FieldDeclaration: Represents a field of a type declaration.
FieldDeclaration: Field declaration node type.
FieldDeclarationMatch: A Java search match that represents a field declaration.
FieldReferenceMatch: A Java search match that represents a field reference.
FileASTRequestor: An AST requestor handles ASTs for compilation units passed to `ASTParser.createASTs`.
Filer: This interface supports the creation of new files by an annotation processor.
Filer.Location: Locations (subtrees within the file system) where new files are created.
FindAction: Abstract class for Java search actions.
FindBreakContinueTargetOccurrencesAction: Action to find all break/continue targets for a given break or continue statement.
FindDeclarationsAction: Finds declarations of the selected element in the workspace.
FindDeclarationsInHierarchyAction: Finds declarations of the selected element in its hierarchy.
FindDeclarationsInProjectAction: Finds declarations of the selected element in the enclosing project of the selected element.
FindDeclarationsInWorkingSetAction: Finds declarations of the selected element in working sets.
FindExceptionOccurrencesAction: Action to find all originators of a exception (e.g. method invocations, class casts, ...) for a given exception.
FindImplementOccurrencesAction: Action to find all implement occurrences of an extended class or an implemented interface.
FindImplementorsAction: Finds implementors of the selected element in the workspace.
FindImplementorsInProjectAction: Finds implementors of the selected element in the enclosing project.
FindImplementorsInWorkingSetAction: Finds implementors of the selected element in working sets.
FindMethodExitOccurrencesAction: Action to find all method exits for a given method.
FindOccurrencesInFileAction: Action to find all occurrences of a compilation unit member (e.g.
FindReadReferencesAction: Finds field read accesses of the selected element in the workspace.
FindReadReferencesInHierarchyAction: Finds field read accesses of the selected element in its hierarchy.
FindReadReferencesInProjectAction: Finds field read accesses of the selected element in the enclosing project.
FindReadReferencesInWorkingSetAction: Finds field read accesses of the selected element in working sets.
FindReferencesAction: Finds references of the selected element in the workspace.
FindReferencesInHierarchyAction: Finds references of the selected element in its hierarchy.
FindReferencesInProjectAction: Finds references to the selected element in the enclosing project of the selected element.
FindReferencesInWorkingSetAction: Finds references of the selected element in working sets.
FindStringsToExternalizeAction: Deprecated. use `ExternalizeStringsAction` instead
FindWriteReferencesAction: Finds field write accesses of the selected element in the workspace.
FindWriteReferencesInHierarchyAction: Finds field write accesses of the selected element in its hierarchy.
FindWriteReferencesInProjectAction: Finds field write accesses of the selected element in the enclosing project.
FindWriteReferencesInWorkingSetAction: Finds field write accesses of the selected element in working sets.
Flags: Utility class for decoding modifier flags in Java elements.
FormatAllAction: Formats the code of the compilation units contained in the selection.
FormatAllAction.ObjectDelegate
ForStatement: For statement AST node type.
GeneralizeTypeDescriptor: Refactoring descriptor for the generalize declared type refactoring.
GenerateActionGroup: Action group that adds the source and generate actions to a part's context menu and installs handlers for the corresponding global menu actions.
GenerateHashCodeEqualsAction: Adds method implementations for ``Object.equals(java.lang.Object)`` and ``Object.hashCode()``.
GenerateNewConstructorUsingFieldsAction: Creates constructors for a type based on existing fields.
GenerateToStringAction: Adds method implementations for ``Object.toString()`` The action opens a dialog from which the user can choose the fields and methods to be considered.
IAccessRule: Describes an access rule to source and class files on a classpath entry.
IAccessRuleParticipant: Contributes access rules for an execution environment.
IAnnotatable: Common protocol for Java elements that can be annotated.
IAnnotation: 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.
IAnnotation: Description of a annotation structure as described in the JVM specifications (added in J2SE 1.5).
IAnnotationBinding: Represents a resolved annotation.
IAnnotationComponent: Description of an annotation component as described in the JVM specifications (added in J2SE 1.5).
IAnnotationComponentValue: Description of an annotation component value as described in the JVM specifications (added in J2SE 1.5).
IAnnotationDefaultAttribute: Description of a annotation default attribute as described in the JVM specifications (added in J2SE 1.5).
IAntLaunchConfigurationConstants: Deprecated. use `IAntLaunchConstants`
IAntLaunchConstants: Constant definitions for Ant launch configurations.
IAstEvaluationEngine: An evaluation engine that performs evaluations by interpreting abstract syntax trees.
IAttributeNamesConstants: Description of attribute names as described in the JVM specifications.
IBinding: A binding represents a named entity in the Java language.
IBootstrapMethodsAttribute: Description of a bootstrap methods attribute as described in the JVM specifications.
IBootstrapMethodsEntry: Description of a bootstrap method table entry as specified in the JVM specifications.
IBuffer: A buffer contains the text contents of a resource.
IBuffer.ITextEditCapability: Implementors of `IBuffer` can additionally implement `IBuffer.ITextEditCapability`.
IBufferChangedListener: A listener, which gets notified when the contents of a specific buffer have changed, or when the buffer is closed.
IBufferFactory: Deprecated. Use `WorkingCopyOwner` instead
IBytecodeVisitor: Description of a Java opcodes visitor.
IClassFile: 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.
IClassFileAttribute: This class represents a generic class file attribute.
IClassFileDisassembler: Deprecated. Use `ClassFileBytesDisassembler` instead
IClassFileEvaluationEngine: An evaluation engine that performs evaluations by deploying and executing class files locally.
IClassFileReader: Description of a .class file.
IClasspathAttribute: A classpath attribute defines a name/value pair that can be persisted with a classpath entry.
IClasspathContainer: Interface of a classpath container.
IClasspathContainerPage: A classpath container page allows the user to create a new or edit an existing classpath container entry.
IClasspathContainerPageExtension: Classpath container pages that implement `IClasspathContainerPage` can optionally implement `IClasspathContainerPageExtension` to get additional information about the context when the page is opened.
IClasspathContainerPageExtension2: Classpath container pages that implement `IClasspathContainerPage` can optionally implement `IClasspathContainerPageExtension2` to return more than one element when creating new containers.
IClasspathEntry: An entry on a Java project classpath identifying one or more package fragment roots.
ICleanUp: A clean up solves problems in a compilation unit.
ICleanUpConfigurationUI: Provides the UI to configure a clean up.
ICleanUpFix: A clean up fix calculates a `CompilationUnitChange` which can be applied on a document to fix one or more problems in a compilation unit.
ICleanUpFixCore: A clean up fix calculates a `CompilationUnitChange` which can be applied on a document to fix one or more problems in a compilation unit.
ICleanUpOptionsInitializer: Initializes the default options for a clean up kind.
ICodeAssist: Common protocol for Java elements that support source code assist and code resolve.
ICodeAttribute: Description of a code attribute as described in the JVM specifications.
ICodeCompletionRequestor: Deprecated. Use `CompletionRequestor` instead.
ICodeFormatter: Deprecated. Use `CodeFormatter` instead (note: options have changed)
ICodeSnippetRequestor: A code snippet requestor implements a callback interface for installing the class files for a code snippet on the target and running it.
IColorManager: Manages SWT color objects for the given color keys and given `RGB` objects.
IColorManagerExtension: Extends `IColorManager` with the ability to bind and un-bind colors.
ICommandAccess: Correction proposals can implement this interface to be invokable by a command (which can be bound to a keyboard shortcut).
ICompilationUnit: Represents an entire Java compilation unit (source file with one of the `Java-like extensions`).
ICompiledExpression: A compiled expression can be compiled once and evaluated multiple times in a runtime context.
ICompletionRequestor: Deprecated. Use `CompletionRequestor` instead.
IComponentInfo: Description of a component info as described in the JVM specifications.
IConstantPool: Description of a constant pool as described in the JVM specifications.
IConstantPoolConstant: Description of constant pool constants as described in the JVM specifications.
IConstantPoolEntry: Description of a constant pool entry as described in the JVM specifications.
IConstantPoolEntry2: Description of the new constant pool entry as described in the JVM specifications added for Java 7 support.
IConstantPoolEntry3: Description of a constant pool entry as described in the JVM specifications.
IConstantValueAttribute: Description of a constant value attribute as described in the JVM specifications.
IContextMenuConstants: Constants for menu groups used in context menus for Java views and editors.
ICorrectionRequestor: A callback interface for receiving java problem correction.
ICUCorrectionProposal
IDocElement: Common marker interface for AST nodes that represent fragments in doc elements.
IDOMCompilationUnit: Deprecated. 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.
IDOMFactory: Deprecated. 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.
IDOMField: Deprecated. 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.
IDOMImport: Deprecated. 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.
IDOMInitializer: Deprecated. 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.
IDOMMember: Deprecated. 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.
IDOMMethod: Deprecated. 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.
IDOMNode: Deprecated. 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.
IDOMPackage: Deprecated. 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.
IDOMType: Deprecated. 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.
IElementChangedListener: An element changed listener receives notification of changes to Java elements maintained by the Java model.
IEnclosingMethodAttribute: Description of an enclosing method attribute as described in the JVM specifications (added in J2SE 1.5).
IEvaluationContext: An evaluation context supports evaluating code snippets.
IEvaluationEngine: An evaluation engine performs an evaluation of a code snippet or expression in a specified thread of a debug target.
IEvaluationListener: Evaluation results are reported to evaluation listeners on the completion of an evaluation.
IEvaluationResult: The result of an evaluation.
IEvaluationRunnable: A runnable that represents one logical evaluation to be run in a target thread.
IExceptionAttribute: Description of a constant value attribute as described in the JVM specifications.
IExceptionTableEntry: The class represents an entry in the exception table of a ICodeAttribute as specified in the JVM specifications.
IExecutionEnvironment: An execution environment describes capabilities of a Java runtime environment (`IVMInstall`).
IExecutionEnvironmentAnalyzerDelegate: Analyzes vm installs for compatibility with execution environments.
IExecutionEnvironmentsManager: Manager for execution environments.
IExtendedAnnotation: Description of an extended annotation structure as described in the JVM specifications (added in JavaSE-1.8).
IExtendedAnnotationConstants: Description of an extended annotation target types constants as described in the JVM specifications (added in JavaSE-1.8).
IExtendedModifier: Common interface for AST nodes that represent modifiers or annotations.
IFactoryPath: A minimal API for manipulating the annotation processor factory path.
IField: Represents a field declared in a type.
IFieldInfo: Description of a field info as described in the JVM specifications.
IfStatement: If statement AST node type.
IGlobalVariable: A global variable declared in an evaluation context.
IImportContainer: Represents an import container is a child of a Java compilation unit that contains all (and only) the import declarations.
IImportDeclaration: Represents an import declaration in Java compilation unit.
IInitializer: Represents a stand-alone instance or class (static) initializer in a type.
IInnerClassesAttribute: Description of a inner class attribute as described in the JVM specifications.
IInnerClassesAttributeEntry: Description of a inner class info as described in the JVM specifications.
IInvocationContext: Context information for quick fix and quick assist processors.
IJarBuilder: A JAR builder can be used to add elements to a JAR file which is about to be build.
IJarBuilderExtension: Extends `IJarBuilder` with the following functions: Write a file to the JAR to build
IJarDescriptionReader: Reads the description file of a JAR package data object into such an object.
IJarDescriptionWriter: Writes the description file of a JAR package data object.
IJarEntryResource: A jar entry corresponding to a non-Java resource in an archive `IPackageFragment` or `IPackageFragmentRoot`.
IJarExportRunnable: A runnable which executes a JAR export operation within the workspace.
IJavaArray: A value referencing an array on a target VM.
IJavaArrayType: The type of an array on a Java debug target.
IJavaBreakpoint: A breakpoint specific to the Java debug model.
IJavaBreakpointListener: Provides event and error notification for Java breakpoints.
IJavaClassObject: An object referencing an instance of `java.lang.Class` on a target VM.
IJavaClassPrepareBreakpoint: A breakpoint that suspends execution when a class is prepared in a target VM.
IJavaClassType: The class of an object on a Java debug target.
IJavaColorConstants: Color keys used for syntax highlighting Java code and Javadoc compliant comments.
IJavaCompletionProposal: A completion proposal with a relevance value.
IJavaCompletionProposalComputer: Computes completions and context information displayed by the Java editor content assistant.
IJavaDebugTarget: A Java virtual machine.
IJavaDebugUIConstants: Constant definitions for Java debug UI plug-in.
IJavadocCompletionProcessor: Deprecated. As of 3.2, replaced by `org.eclipse.jdt.ui.javaCompletionProposalComputer` extension-point.
IJavaEditorActionDefinitionIds: Defines the definition IDs for the Java editor actions.
IJavaEditorTextHover: Provides a hover popup which appears on top of an editor with relevant display information.
IJavaElement: Common protocol for all elements provided by the Java model.
IJavaElementDelta: A Java element delta describes changes in Java element between two discrete points in time.
IJavaElementMapper: An `IJavaElementMapper` provides methods to map an original elements to its refactored counterparts.
IJavaElementSearchConstants: Search scope constants for Java selection dialogs.
IJavaExceptionBreakpoint: A breakpoint that suspends execution when a corresponding exception is thrown in a target VM.
IJavaExceptionBreakpoint.SuspendOnRecurrenceStrategy: Constants for telling the debugger for each exception breakpoint how to handle multiple occurrences of the same exception instance, which can happen via re-throwing or multiple finally clauses in the call stack.
IJavaFieldVariable: A variable that contains the value of an instance or class variable.
IJavaFoldingPreferenceBlock: Contributors to the `org.eclipse.jdt.ui.foldingStructureProvider` extension point can specify an implementation of this interface to be displayed on the Java > Editor > Folding preference page.
IJavaFoldingStructureProvider: Contributors to the `org.eclipse.jdt.ui.foldingStructureProvider` extension point must specify an implementation of this interface which will create and maintain `ProjectionAnnotation` objects that define folded regions in the `ProjectionViewer`.
IJavaFoldingStructureProviderExtension: Extends `IJavaFoldingStructureProvider` with the following functions: collapsing of comments and members expanding and collapsing of certain java elements
IJavaHotCodeReplaceListener: Notification of hot code replace failure and success.
IJavaInterfaceType: An interface an object implements on a Java debug target.
IJavaLaunchConfigurationConstants: Constant definitions for Java launch configurations.
IJavaLineBreakpoint: A breakpoint that suspends execution when a particular line of code is reached.
IJavaMethodBreakpoint: A method breakpoint suspends execution when a method is entered or exited.
IJavaMethodEntryBreakpoint: A method entry breakpoint suspends execution on the first executable line of a method when entered.
IJavaModel: Represent the root Java element corresponding to the workspace.
IJavaModelMarker: Markers used by the Java model.
IJavaModelStatus: Represents the outcome of an Java model operation.
IJavaModelStatusConstants: Status codes used with Java model status objects.
IJavaModifiers: Modifiers common to Java debug elements that have associated Java member declarations.
IJavaObject: A value referencing an object on a target VM.
IJavaPartitionerManager: This IDocumentPartitioner Manager manages the creation of the IDocumentPartitioner and the corresponding IPartitionTokenScanner.
IJavaPartitions: Definition of Java partitioning and its partitions.
IJavaPatternBreakpoint: Deprecated. use `IJavaStratumLineBreakpoint` instead
IJavaPrimitiveValue: A primitive value on a Java debug target.
IJavaProject: A Java project represents a view of a project resource in terms of Java elements such as package fragments, types, methods and fields.
IJavaRefactorings: Interface for refactoring ids offered by the JDT tooling.
IJavaReferenceType: Represents the type of an object in a virtual machine - including classes, interfaces and array types.
IJavaSearchConstants: This interface defines the constants used by the search engine.
IJavaSearchResultCollector: Deprecated. Since 3.0, the class `SearchRequestor` replaces this interface.
IJavaSearchScope: An `IJavaSearchScope` defines where search result should be found by a `SearchEngine`.
IJavaSourceLocation: Deprecated. In 3.0, the debug platform provides source lookup facilities that should be used in place of the Java source lookup support provided in 2.0.
IJavaStackFrame: A stack frame in a thread on a Java virtual machine.
IJavaStratumLineBreakpoint: A line breakpoint identified by its source file name and/or path, and stratum that it is relative to.
IJavaTargetPatternBreakpoint: A line breakpoint installed in types associated with a specific source file (based on source file name debug attribute) and whose fully qualified name matches a specified pattern per target.
IJavaThread: A thread in a Java virtual machine.
IJavaThreadGroup: Represents a thread group in the target VM.
IJavaType: The type of a value on a Java debug target - a primitive data type, class, interface, or array.
IJavaValue: An object, primitive data type, or array, on a Java virtual machine.
IJavaVariable: A local variable, field slot, or receiver (this) in a Java virtual machine.
IJavaWatchpoint: A breakpoint on a field.
ILibraryLocationResolver: This resolver allows contributors to provide `LibraryLocation` information for non-standard JRE / JDK libraries.
ILineNumberAttribute: Description of a line number attribute as described in the JVM specifications.
ILocalVariable: Represents a local variable declared in a method or an initializer.
ILocalVariableAttribute: Description of a local variable attribute as described in the JVM specifications.
ILocalVariableReferenceInfo: Description of a local variable reference info table entry as specified in the JVM specifications.
ILocalVariableTableEntry: Description of a local variable table entry as specified in the JVM specifications.
ILocalVariableTypeTableAttribute: Description of a local variable type attribute as described in the JVM specifications (added in J2SE 1.5).
ILocalVariableTypeTableEntry: Description of a local variable type table entry as specified in the JVM specifications (added in J2SE 1.5).
IManifestProvider: A manifest provider creates manifest files.
IMatchPresentation: This interface serves to display elements that a search participant has contributed to a search result.
IMember: Common protocol for Java elements that can be members of types.
IMemberValuePair: Represents a member-value pair of an annotation.
IMemberValuePairBinding: Represents a resolved instance of an annotation's member value pair.
IMethod: Represents a method (or constructor) declared in a type.
IMethodBinding: A method binding represents a method or constructor of a class or interface.
IMethodInfo: Description of a method info as described in the JVM specifications.
IMethodParametersAttribute: Description of a method's parameters names as described in the JVM specifications.
IModifierConstants: Definition of the modifier constants as specified in the JVM specifications.
IModularClassFile: Represents the class file of a module description ("module-info.class").
IModuleAttribute: Description of a module's attributes as described in the JVM specifications.
IModuleBinding: A module binding represents a module (added in JLS9 API).
IModuleDescription: Represents a Java module descriptor.
IModuleMainClassAttribute: Description of a Module Main Class Attribute as described in the JVMS9 4.7.27 This interface may be implemented by clients.
IModulePackagesAttribute: Description of a Module Packages as described in the JVMS9 4.7.26 This interface may be implemented by clients.
ImplementorsSearchGroup: Action group that adds the search for implementors actions to a context menu and the global menu bar.
ImportActionGroup: Action group to add the Import and Export action to a view part's context menu.
ImportDeclaration: Import declaration AST node type.
ImportReferencesCollector
ImportRewrite: The `ImportRewrite` helps updating imports following a import order and on-demand imports threshold as configured by a project.
ImportRewrite.ImportRewriteContext: A `ImportRewrite.ImportRewriteContext` can optionally be used in e.g.
ImportRewrite.TypeLocation: 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`.
IndentManipulation: Helper class to provide String manipulation functions dealing with indentations.
INestHostAttribute: Description of a nest host attribute as described in the JVM specifications.
INestMemberAttributeEntry: Description of a nest host attribute as described in the JVM specifications.
INestMembersAttribute: Description of nest members attribute as described in the JVM specifications.
InferTypeArgumentsAction: Infers type arguments for raw references to generic types.
InferTypeArgumentsDescriptor: Refactoring descriptor for the infer type arguments refactoring.
InfixExpression: Infix expression AST node type.
InfixExpression.Operator: Infix operators (typesafe enumeration).
Initializer: Static or instance initializer AST node type.
InlineAction: Inlines a method, local variable or a static final field.
InlineConstantDescriptor: Refactoring descriptor for the inline constant refactoring.
InlineLocalVariableDescriptor: Refactoring descriptor for the inline local variable refactoring.
InlineMethodDescriptor: Refactoring descriptor for the inline method refactoring.
InlineTempAction: Inlines the value of a local variable at all places where a read reference is used.
InstanceofExpression: Instanceof expression AST node type.
InterfaceDeclaration: Represents the declaration of an interface.
InterfaceType: Represents an interface type.
IntersectionType: Type node for an intersection type in a cast expression (added in JLS8 API).
IntroduceFactoryAction: Action that encapsulates the a constructor call with a factory method.
IntroduceFactoryDescriptor: Refactoring descriptor for the introduce factory refactoring.
IntroduceIndirectionAction: Action that introduces an indirection for a certain method.
IntroduceIndirectionDescriptor: Refactoring descriptor for the introduce indirection refactoring.
IntroduceParameterAction: Introduces a new method parameter from a selected expression.
IntroduceParameterDescriptor: Refactoring descriptor for the introduce parameter refactoring.
IntroduceParameterObjectDescriptor: Refactoring descriptor for the introduce parameter object refactoring.
IntroduceParameterObjectDescriptor.Parameter: Instances of Parameter are used to describe the position of parameter and fields.
InvalidInputException: Exception thrown by a scanner when encountering lexical errors.
IOpcodeMnemonics: Description of each opcode mnemonic according to the JVM specifications.
IOpenable: Common protocol for Java elements that must be opened before they can be navigated or modified.
IOrdinaryClassFile: Ordinary form of a `IClassFile` which holds exactly one `IType`.
IPackageBinding: A package binding represents a named or unnamed package.
IPackageDeclaration: Represents a package declaration in Java compilation unit.
IPackageFragment: A package fragment is a portion of the workspace corresponding to an entire package, or to a portion thereof.
IPackageFragmentRoot: A package fragment root contains a set of package fragments.
IPackagesViewPart: The standard Packages view presents a Java-centric view of the workspace.
IPackageVisibilityInfo: Description of an exports/opens info as described in the JVM specifications 4.7.25
IParameterAnnotation: Description of a parameter annotation as described in the JVM specifications (added in J2SE 1.5).
IParent: Common protocol for Java elements that contain other Java elements.
IProblem: Description of a Java problem, as detected by the compiler or some of the underlying technology reusing the compiler.
IProblemLocation: Problem information for quick fix and quick assist processors.
IProblemRequestor: A callback interface for receiving java problem as they are discovered by some Java operation.
IProvidesInfo: Description of a provides info as described in JVMS9 4.7.25.
IQueryParticipant: This is the interface expected of extensions to the extension point `org.eclipse.jdt.ui.queryParticipants`.
IQuickAssistProcessor: Interface to be implemented by contributors to the extension point `org.eclipse.jdt.ui.quickAssistProcessors`.
IQuickFixProcessor: Interface to be implemented by contributors to the extension point `org.eclipse.jdt.ui.quickFixProcessors`.
IRecordAttribute: Description of record components attribute as described in the JVM specifications.
IRefactoringProcessorIds: Interface to define the processor IDs provided by JDT refactorings.
IRefactoringProcessorIds: Interface to define the processor IDs provided by the JDT refactoring.
IRegion: A Java model region describes a hierarchical set of elements.
IRequiresInfo: Description of a requires info as described in JVMS9 4.7.25
IRuntimeClasspathEntry: Represents an entry on a runtime classpath.
IRuntimeClasspathEntry2: Enhancements to `IRuntimeClasspathEntry` to support extensible runtime classpath entries.
IRuntimeClasspathEntryResolver: Resolves variable and/or container runtime classpath entries in the context of a launch configuration or Java project.
IRuntimeClasspathEntryResolver2: Optional enhancements to `IRuntimeClasspathEntryResolver`.
IRuntimeClasspathProvider: A classpath provider computes an unresolved classpath for a launch configuration, and resolves classpath entries for a launch configuration.
IRuntimeContainerComparator: Deprecated. support has been added to `ClasspathContainerInitializer` to handle comparison of classpath containers.
IRuntimeInvisibleAnnotationsAttribute: Description of a runtime invisible annotations attribute as described in the JVM specifications (added in J2SE 1.5).
IRuntimeInvisibleParameterAnnotationsAttribute: Description of a runtime invisible parameter annotations attribute as described in the JVM specifications (added in J2SE 1.5).
IRuntimeInvisibleTypeAnnotationsAttribute: Description of a runtime invisible type annotations attribute as described in the JVM specifications (added in JavaSE-1.8).
IRuntimeVisibleAnnotationsAttribute: Description of a runtime visible annotations attribute as described in the JVM specifications (added in J2SE 1.5).
IRuntimeVisibleParameterAnnotationsAttribute: Description of a runtime visible parameter annotations attribute as described in the JVM specification (added in J2SE 1.5).
IRuntimeVisibleTypeAnnotationsAttribute: Description of a runtime visible type annotations attribute as described in the JVM specifications (added in JavaSE-1.8).
IScanner: Caveat: With the introduction of "restricted keywords" in Java 9 it is impossible to classify a token without the help of a parser.
ISearchPattern: Deprecated. Since 3.0, the class `SearchPattern` replaces this interface.
ISearchRequestor: A callback interface to report matches against.
ISharedImages: Standard images provided by the Java UI plug-in.
ISignatureAttribute: Description of a signature attribute as described in the JVM specifications (added in J2SE 1.5).
ISourceAttribute: Description of a source attribute as described in the JVM specifications.
ISourceContainerResolver: Implementations of this interface identify runtime classes locations and download (or "resolve") corresponding sources from external sources repositories like Maven or P2 artifact repositories and PDE target platform.
ISourceManipulation: Common protocol for Java elements that support source code manipulations such as copy, move, rename, and delete.
ISourceRange: A source range defines an element's source coordinates relative to its source buffer.
ISourceReference: Common protocol for Java elements that have associated source code.
IStackMapAttribute: This class represents a stack map attribute.
IStackMapFrame: Description of a stack map frame as specified in the JVM specifications.
IStackMapTableAttribute: This class represents a stack map table attribute.
ITerminalSymbols: Maps each terminal symbol in the java-grammar into a unique integer.
ITestCaseElement: Represents a test case element.
ITestElement: Common protocol for test elements.
ITestElement.FailureTrace: A failure trace of a test.
ITestElement.ProgressState: Running states of a test.
ITestElement.Result: Result states of a test.
ITestElementContainer: Common protocol for test elements containers.
ITestRunListener: Deprecated. As of 3.3, replaced by `TestRunListener`
ITestRunSession: Represents a test run session.
ITestSuiteElement: Represents a test suite element.
ITrackedNodePosition: A tracked node position is returned when a rewrite change is requested to be tracked.
IType: 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.
ITypeBinding: A type binding represents a fully-resolved type.
ITypeHierarchy: 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.
ITypeHierarchyChangedListener: A listener which gets notified when a particular type hierarchy object changes.
ITypeHierarchyViewPart: The standard type hierarchy view presents a type hierarchy for a given input class or interface.
ITypeInfoFilterExtension: A filter to select `ITypeInfoRequestor` objects.
ITypeInfoImageProvider: A special image descriptor provider for `ITypeInfoRequestor`.
ITypeInfoRequestor: An interfaces to give access to the type presented in type selection dialogs like the open type dialog.
ITypeNameRequestor: Deprecated. Use abstract class `TypeNameRequestor` instead.
ITypeParameter: Represents a type parameter defined by a type or a method in a compilation unit or a class file.
ITypeRoot: Represents an entire Java type root (either an `ICompilationUnit` or an `IClassFile`).
ITypeSelectionComponent: Interface to access the type selection component hosting a type selection extension.
IVariableBinding: 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).
IVerificationTypeInfo: Description of a verification type info as described in the JVM specifications.
IVMConnector: A VM connector establishes a JDI connection with a debuggable virtual machine.
IVMInstall: Represents a particular installation of a VM.
IVMInstall2: Optional extensions that may be implemented by an `IVMInstall`.
IVMInstall3: Optional extensions that may be implemented by an `IVMInstall`, providing access to a JRE's system properties.
IVMInstallChangedListener: A VM install changed listener is notified when the workspace default VM install changes, or when an attribute of a specific VM install changes.
IVMInstallType: Represents a particular type of VM for which there may be any number of VM installations.
IVMRunner: A VM runner starts a Java VM running a Java program.
IWorkingCopy: Deprecated. Use `ICompilationUnit` instead
IWorkingCopyManager: Interface for accessing working copies of `ICompilationUnit` objects.
IWorkingCopyManagerExtension: Extension interface for `IWorkingCopyManager`.
IWorkingCopyProvider: Interface used for Java element content providers to indicate that the content provider can return working copy elements for members below compilation units.
IWorkspaceProjectDescriber: Implementations of this interface describe workspace projects for the purpose of source lookup.
IWorkspaceProjectDescriber.IJavaProjectSourceDescription
JarPackageData: Model for a JAR package which stores information used during JAR export and import.
JarWriter: Deprecated. use `JarWriter3` instead.
JarWriter2: Deprecated. Use `JarWriter3` instead which leverages new `EFS` support
JarWriter3: Creates a JAR file for the given JAR package data.
JavaAppletLaunchShortcut: Launch shortcut for Java applets.
JavaApplicationLaunchShortcut: Launch shortcut for local Java applications.
JavaArgumentsTab: A launch configuration tab that displays and edits program arguments, VM arguments, and working directory launch configuration attributes.
JavaBreakpointConditionEditor: Controls to edit a breakpoint's conditional expression, condition enabled state, and suspend policy (suspend when condition is `true` or when the value of the conditional expression changes).
JavaBreakpointPropertiesRulerActionDelegate: Action to open a properties dialog on a Java breakpoint from a ruler context menu.
JavaCapabilityConfigurationPage: Basic wizard page for creating new Java projects.
JavaClasspathTab: A launch configuration tab that displays and edits the user and bootstrap classes comprising the classpath launch configuration attribute.
JavaConnectTab: A launch configuration tab that displays and edits the project associated with a remote connection and the connector used to connect to a remote VM.
JavaContentAssistInvocationContext: Describes the context of a content assist invocation in a Java editor.
JavaConventions: Provides methods for checking Java-specific conventions such as name syntax.
JavaCore: The plug-in runtime class for the Java model plug-in containing the core (UI-free) support for Java projects.
JavaDebugUtils: Utilities for the Java debugger.
JavaDependenciesTab: A launch configuration tab that displays and edits the user and bootstrap classes comprising the classpath launch configuration attribute.
Javadoc: AST node for a Javadoc-style doc comment.
JavadocContentAccess: Helper needed to get the content of a Javadoc comment.
JavadocExportWizardPage: A Javadoc export wizard page allows the user to add an additional page to the Javadoc wizard.
JavadocExportWizardPage.IJavadocExportWizardPageContainer: The page container.
JavaElementComparator: Viewer comparator for Java elements.
JavaElementContentProvider: Deprecated. use the StandardJavaElementContentProvider instead
JavaElementImageDescriptor: A `JavaElementImageDescriptor` consists of a base image and several adornments.
JavaElementLabelProvider: Standard label provider for Java elements.
JavaElementLabels: `JavaElementLabels` provides helper methods to render names of Java elements.
JavaElementSorter: Deprecated. use `JavaElementComparator` instead.
JavaIndexer: `JavaIndexer` provides functionality to generate index files which can be used by the JDT `SearchEngine`.
JavaIndexerApplication: Implements an Eclipse Application for `JavaIndexer`.
JavaJRETab: A launch configuration tab that displays and edits the VM install launch configuration attributes.
JavaLaunchDelegate: A launch delegate for launching local Java applications.
JavaLaunchShortcut: Common behavior for Java launch shortcuts
JavaLaunchTab: Common function for Java launch configuration tabs.
JavaMainTab: A launch configuration tab that displays and edits project and main type name launch configuration attributes.
JavaManipulation: Central access point for the Java Manipulation plug-in (id `"org.eclipse.jdt.core.manipulation"`).
JavaModelException: A checked exception representing a failure in the Java model.
JavaParticipantManager: Facade to access participants to the participant extension points provided by the org.eclipse.jdt.core.manipulation plug-in.
JavaProjectSourceContainer: Java project source container.
JavaProjectSourceLocation: Deprecated. In 3.0, the debug platform provides source lookup facilities that should be used in place of the Java source lookup support provided in 2.0.
JavaRefactoringContribution: Partial implementation of a Java refactoring contribution.
JavaRefactoringDescriptor: Partial implementation of a java refactoring descriptor.
JavaRuntime: The central access point for launching support.
JavaSearchActionGroup: Action group that adds the Java search actions to a context menu and the global menu bar.
JavaSourceLocator: Deprecated. In 3.0, the debug platform provides source lookup facilities that should be used in place of the Java source lookup support provided in 2.0.
JavaSourceLookupDialog: Deprecated. In 3.0, the debug platform provides source lookup facilities that should be used in place of the Java source lookup support provided in 2.0.
JavaSourceLookupParticipant: A source lookup participant that searches for Java source code.
JavaSourceLookupTab: Deprecated. In 3.0, the debug platform provides source lookup facilities that should be used in place of the Java source lookup support provided in 2.0.
JavaSourcePathComputer: Computes a default source lookup path for Java applications.
JavaSourceViewerConfiguration: Configuration for a source viewer which shows Java code.
JavaTextTools: Tools required to configure a Java text viewer.
JavaUI: Central access point for the Java UI plug-in (id `"org.eclipse.jdt.ui"`).
JavaUISourceLocator: Deprecated. In 3.0, the debug platform provides source lookup facilities that should be used in place of the Java source lookup support provided in 2.0.
JDIDebugModel: Provides utility methods for creating debug targets and breakpoints specific to the JDI debug model.
JdtActionConstants: Action ids for standard actions, for groups in the menu bar, and for actions in context menus of JDT views.
JdtApt: Ant task for invoking the commandline apt builder Sample build.xml: <project name="test_eclipse" default="build" basedir="."
JDTCompilerAdapter: Ant 1.5 compiler adapter for the Eclipse Java compiler.
JUnitCore: Class for accessing JUnit support; all functionality is provided by static methods.
JUnitLaunchConfigurationDelegate: Launch configuration delegate for a JUnit test as a Java application.
JUnitLaunchConfigurationTab: The launch configuration tab for JUnit.
JUnitLaunchShortcut: The launch shortcut to launch JUnit tests.
LabeledStatement: Labeled statement AST node type.
LambdaExpression: Lambda expression AST node type (added in JLS8 API).
LibraryLocation: The location of a library (for example rt.jar).
LineComment: End-of-line comment AST node type.
ListRewrite: For describing manipulations to a child list property of an AST node.
LocalFileStorage: Deprecated. In 3.0 this class is now provided by the debug platform.
LocalVariableDeclarationMatch: A Java search match that represents a local variable declaration.
LocalVariableReferenceMatch: A Java search match that represents a local variable reference.
MarkerAnnotation: Marker annotation node (added in JLS3 API).
MemberDeclaration: Represents a declaration that may be a member or constructor of a declared type.
MemberFilterActionGroup: Action Group that contributes filter buttons for a view parts showing methods and fields.
MemberRef: AST node for a member reference within a doc comment (`Javadoc`).
MemberValuePair: Member value pair node (added in JLS3 API).
Message: Error message used to report potential errors found during the AST parsing or name resolution.
Messager: A `Messager` provides the way for an annotation processor to report error messages, warnings, and other notices.
MethodDeclaration: Represents a method of a class or interface.
MethodDeclaration: Method declaration AST node type.
MethodDeclarationMatch: A Java search match that represents a method declaration.
MethodInvocation: Method invocation expression AST node type.
MethodNameMatch: A match collected while `searching` for all type names methods using a `requestor`.
MethodNameMatchRequestor: A `MethodNameMatchRequestor` collects matches from a `searchAllMethodNames` query to a `SearchEngine`.
MethodNameRequestor: A `MethodDeclarationRequestor` collects search results from a `searchAllMethodDeclarations` query to a `SearchEngine`.
MethodRef: AST node for a method or constructor reference within a doc comment (`Javadoc`).
MethodReference: Abstract base class of all AST node types that represent a method reference expression (added in JLS8 API).
MethodReferenceMatch: A Java search match that represents a method reference.
MethodRefParameter: AST node for a parameter within a method reference (`MethodRef`).
MirroredTypeException: Thrown when an application attempts to access the `Class` object corresponding to a `TypeMirror`.
MirroredTypesException: Thrown when an application attempts to access a sequence of `Class` objects each corresponding to a `TypeMirror`.
Modifier: Represents a modifier on the declaration of a program element such as a class, method, or field.
Modifier: Modifier node.
Modifier.ModifierKeyword: Modifier keywords (typesafe enumeration).
ModifyParametersAction: Action to start the modify parameters refactoring.
ModuleDeclaration: Module declaration AST node type representing the module descriptor file (added in JLS9 API).
ModuleDeclarationMatch: A Java search match that represents a module declaration.
ModuleDirective: Abstract base class of AST nodes that represent module directives (added in JLS9 API).
ModuleModifier: Module Modifier node - represents the modifiers for the requires directive in module declaration (added in JLS9 API).
ModuleModifier.ModuleModifierKeyword: Module Modifier keywords (typesafe enumeration).
ModulePackageAccess: Abstract base class of AST nodes that represent exports and opens directives (added in JLS9 API).
ModuleReferenceMatch: A Java search match that represents a module reference.
MoveAction: This action moves Java elements to a new location.
MoveDescriptor: Refactoring descriptor for the move refactoring.
MoveMethodDescriptor: Refactoring descriptor for the move method refactoring.
MoveStaticMembersDescriptor: Refactoring descriptor for the move static members refactoring.
Name: Abstract base class for all AST nodes that represent names.
NameQualifiedType: Node for a name-qualified type (added in JLS8 API).
NamingConventions: Provides methods for computing Java-specific names.
NavigateActionGroup: Action group that adds the open and show actions to a context menu and the action bar's navigate menu.
NewAnnotationWizardPage: Wizard page to create a new annotation type.
NewClassWizardPage: Wizard page to create a new class.
NewContainerWizardPage: Wizard page that acts as a base class for wizard pages that create new Java elements.
NewElementWizardPage: Base class for wizard page responsible to create Java elements.
NewEnumWizardPage: Wizard page to create a new enum type.
NewInterfaceWizardPage: Wizard page to create a new interface.
NewJavaProjectWizardPage: Deprecated. Use `NewJavaProjectWizardPageTwo` or `JavaCapabilityConfigurationPage`.
NewJavaProjectWizardPageOne: The first page of the New Java Project wizard.
NewJavaProjectWizardPageTwo: The second page of the New Java project wizard.
NewModuleInfoWizardPage: Wizard page to create a new module-info file.
NewPackageWizardPage: Wizard page to create a new package.
NewRecordWizardPage: Wizard page to create a new record.
NewTestCaseWizardPageOne: The class `NewTestCaseWizardPageOne` contains controls and validation routines for the first page of the 'New JUnit TestCase Wizard'.
NewTestCaseWizardPageOne.JUnitVersion: Available JUnit versions.
NewTestCaseWizardPageTwo: The class `NewTestCaseWizardPageTwo` contains controls and validation routines for the second page of the 'New JUnit TestCase Wizard'.
NewTestSuiteWizardPage: The class `NewTestSuiteWizardPage` contains controls and validation routines for the single page in the 'New JUnit TestSuite Wizard'.
NewTypeWizardPage: The class `NewTypeWizardPage` contains controls and validation routines for a 'New Type WizardPage'.
NewTypeWizardPage.ImportsManager: Class used in stub creation routines to add needed imports to a compilation unit.
NodeFinder: For a given selection range, finds the covered node and the covering node.
NonNull: Qualifier for a reference type in a `TYPE_USE` position: The type that has this annotation is intended to not include the value `null`.
NonNullByDefault: Applying this annotation to a declaration has the effect that type references, which are contained in the declaration, and for which a null annotation is otherwise lacking, should be considered as `@NonNull`.
NormalAnnotation: Normal annotation node (added in JLS3 API).
Nullable: Qualifier for a reference type in a `TYPE_USE` position: The type that has this annotation explicitly includes the value `null`.
NullLiteral: Null literal node.
NumberLiteral: Number literal nodes.
OccurrencesSearchGroup: Action group that adds the occurrences in file actions to a context menu and the global menu bar.
OpcodeStringValues: Description of each opcode mnemonic according to the JVM specifications.
OpenAction: This action opens a Java editor on a Java element or file.
OpenAttachedJavadocAction: This action opens the selected element's Javadoc in a browser as defined by the preferences.
OpenEditorActionGroup: Action group that adds the actions opening a new editor to the context menu and the action bar's navigate menu.
OpenExternalJavadocAction: Deprecated. As of 3.6, replaced by `OpenAttachedJavadocAction`
OpenImplementationAction: The action allows to open the implementation for a method or a type in its hierarchy.
OpenJavaBrowsingPerspectiveAction: Action to programmatically open a Java perspective.
OpenJavaPerspectiveAction: Action to programmatically open a Java perspective.
OpenNewAnnotationWizardAction: Action that opens the new annotation wizard.The action initialized the wizard with either the selection as configured by `AbstractOpenWizardAction.setSelection(IStructuredSelection)` or takes a preconfigured new annotation wizard page, see `OpenNewAnnotationWizardAction.setConfiguredWizardPage(NewAnnotationWizardPage)`.
OpenNewClassWizardAction: Action that opens the new class wizard.
OpenNewEnumWizardAction: Action that opens the new enum wizard.
OpenNewInterfaceWizardAction: Action that opens the new interface wizard.
OpenNewJavaProjectWizardAction: Action that opens the new Java project wizard.
OpenNewPackageWizardAction: Action that opens the new package wizard.
OpenNewRecordWizardAction: Action that opens the new enum wizard.
OpenNewSourceFolderWizardAction: Action that opens the new source folder wizard.
OpenProjectAction: Action to open a closed project.
OpensDirective: Opens directive AST node type (added in JLS9 API).
OpenSuperImplementationAction: The action opens a Java editor on the selected method's super implementation.
OpenTypeHierarchyAction: This action opens a type hierarchy on the selected type.
OpenViewActionGroup: Action group that adds actions to open a new JDT view part or an external viewer to a context menu and the global menu bar.
OrganizeImportsAction: Organizes the imports of a compilation unit.
OrganizeImportsAction.ObjectDelegate
OrganizeImportsOperation
OrganizeImportsOperation.IChooseImportQuery
OverrideIndicatorLabelDecorator: LabelDecorator that decorates an method's image with override or implements overlays.
OverrideMethodsAction: Adds unimplemented methods of a type.
PackageDeclaration: Represents the declaration of a package.
PackageDeclaration: Package declaration AST node type.
PackageDeclarationMatch: A Java search match that represents a package declaration.
PackageFragmentRootSourceContainer: Package fragment root source container.
PackageFragmentRootSourceLocation: Deprecated. In 3.0, the debug platform provides source lookup facilities that should be used in place of the Java source lookup support provided in 2.0.
PackageReferenceMatch: A Java search match that represents a package reference.
ParameterDeclaration: Represents a formal parameter of a method or constructor.
ParameterizedType: Type node for a parameterized type (added in JLS3 API).
ParenthesizedExpression: Parenthesized expression AST node type.
PatternQuerySpecification: Describes a search query by giving a textual pattern to search for.
Phase: Enum for APT related operation phase.
PostfixExpression: Postfix expression AST node type.
PostfixExpression.Operator: Postfix operators (typesafe enumeration).
PreferenceConstants: Preference constants used in the JDT-UI preference store.
PrefixExpression: Prefix expression AST node type.
PrefixExpression.Operator: Prefix operators (typesafe enumeration).
PrimitiveType: Represents a primitive type.
PrimitiveType: Primitive type nodes.
PrimitiveType.Code: Primitive type codes (typesafe enumeration).
PrimitiveType.Kind: An enumeration of the different kinds of primitive types.
ProblemsLabelDecorator: LabelDecorator that decorates an element's image with error and warning overlays that represent the severity of markers attached to the element's underlying resource.
ProblemsLabelDecorator.ProblemsLabelChangedEvent: This is a special `LabelProviderChangedEvent` carrying additional information whether the event origins from a maker change.
ProjectActionGroup: Adds actions to open and close a project to the global menu bar.
PropertyChangeEvent: An event object describing a change to a named property.
ProvidesDirective: Provides directive AST node type (added in JLS9 API).
PullUpAction: Action to pull up method and fields into a superclass.
PullUpDescriptor: Refactoring descriptor for the pull up refactoring.
PushDownAction: Action to push down methods and fields into subclasses.
PushDownDescriptor: Refactoring descriptor for the push down refactoring.
QualifiedName: AST node for a qualified name.
QualifiedType: Type node for a qualified type (added in JLS3 API).
QuerySpecification: Describes a Java search query.
ReadReferencesSearchGroup: Action group that adds the search for read references actions to a context menu and the global menu bar.
ReconcileContext: The context of a reconcile event that is notified to interested compilation participants while a reconcile operation is running.
RecordDeclaration: Record declaration AST node type (added in JLS14 API).
RefactorActionGroup: Action group that adds refactor actions (for example 'Rename', 'Move') to a context menu and the global menu bar.
RefactoringSaveHelper: Helper to save dirty editors prior to starting a refactoring.
ReferenceMatch: An abstract Java search match that represents a reference.
ReferencesSearchGroup: Action group that adds the search for references actions to a context menu and the global menu bar.
ReferenceType: Represents a reference type.
RefreshAction: Action for refreshing the workspace from the local file system for the selected resources and all of their descendants.
RemoveFromClasspathAction: Action to remove package fragment roots from the classpath of its parent project.
RenameAction: Renames a Java element or workbench resource.
RenameJavaElementDescriptor: Refactoring descriptor for the rename java element refactoring.
RenameLocalVariableDescriptor: Deprecated. since 1.2 merged into `RenameJavaElementDescriptor`
RenameResourceDescriptor: Deprecated. since 1.2, use `RenameResourceDescriptor` from `org.eclipse.ltk.core.refactoring` instead.
RenameSupport: Central access point to execute rename refactorings.
RenameTypeArguments: Rename type arguments describe the data that a rename type processor provides to its rename type participants.
ReplaceInvocationsAction: Action that replaces method invocations.
RequiresDirective: Requires directive AST node type (added in JLS9 API).
ReturnStatement: Return statement AST node type.
RoundCompleteEvent: Event for the completion of a round of annotation processing.
RoundCompleteListener: Listener for the completion of a round of annotation processing.
RoundState: Represents the status of a completed round of annotation processing.
SearchDocument: A search document encapsulates a content to be either indexed or searched in.
SearchEngine: A `SearchEngine` searches for Java elements following a search pattern.
SearchMatch: A search match represents the result of a search query.
SearchParticipant: A search participant describes a particular extension to a generic search mechanism, permitting combined search actions which will involve all required participants.
SearchPattern: A search pattern defines how search results are found.
SearchRequestor: Collects the results from a search engine query.
SelectionDispatchAction: Action that dispatches the `IAction#run()` and the `ISelectionChangedListener#selectionChanged` according to the type of the selection.
SelfEncapsulateFieldAction: Action to run the self encapsulate field refactoring.
SharedASTProvider: Deprecated. Use `SharedASTProviderCore` instead.
SharedASTProvider.WAIT_FLAG: Wait flag class.
SharedASTProviderCore: The `SharedASTProviderCore` provides access to the `AST root` used by the current active Java editor.
SharedASTProviderCore.WAIT_FLAG: Wait flag class.
ShowActionGroup: Deprecated. As of 3.5, got replaced by generic Navigate > Show In >
ShowInNavigatorViewAction: Deprecated. As of 3.5, got replaced by generic Navigate > Show In >
ShowInPackageViewAction: Deprecated. As of 3.5, got replaced by generic Navigate > Show In >
Signature: Provides methods for encoding and decoding type and method signature strings.
SimpleDeclarationVisitor: A simple visitor for declarations.
SimpleName: AST node for a simple name.
SimplePropertyDescriptor: Descriptor for a simple property of an AST node.
SimpleType: Type node for a named class type, a named interface type, or a type variable.
SimpleTypeVisitor: A simple visitor for types.
SingleMemberAnnotation: Single member annotation node (added in JLS3 API).
SingleVariableDeclaration: Single variable declaration AST node type.
SocketUtil: Utility class to find a port to debug on.
SortMembersAction: Sorts the members of a compilation unit with the sort order as specified in the Sort Order preference page.
SourcePosition: Represents a position in a source file.
SourceRange: A source range defines an element's source coordinates relative to its source buffer.
StandardClasspathProvider: Default implementation for classpath provider.
StandardJavaElementContentProvider: A base content provider for Java elements.
StandardSourcePathProvider: Default implementation of source lookup path computation and resolution.
Statement: Abstract base class of AST nodes that represent statements.
StringLiteral: String literal nodes.
StructuralPropertyDescriptor: Abstract base class for property descriptors of AST nodes.
SuperConstructorInvocation: Super constructor invocation statement AST node type.
SuperFieldAccess: Simple or qualified "super" field access expression AST node type.
SuperMethodInvocation: Simple or qualified "super" method invocation expression AST node type.
SuperMethodReference: Super method reference AST node type (added in JLS8 API).
SurroundWithTryCatchAction: Action to surround a set of statements with a try/catch block.
SurroundWithTryMultiCatchAction: Action to surround a set of statements with a try/multi-catch block.
SurroundWithTryWithResourcesAction: Action to surround a set of statements with a try-with-resources/catch block.
SwitchCase: Switch case AST node type.
SwitchExpression: Switch expression AST node type (added in JEP 325).
SwitchStatement: Switch statement AST node type.
SynchronizedStatement: Synchronized statement AST node type.
TagElement: AST node for a tag within a doc comment.
TargetSourceRangeComputer: An object for computing adjusted source ranges for AST nodes that are being replaced or deleted.
TargetSourceRangeComputer.SourceRange: Reified source range.
TestRunListener: A test run listener that can be registered at `JUnitCore.addTestRunListener(TestRunListener)` or as a contribution to the `org.eclipse.jdt.junit.testRunListeners` extension point.
TextBlock: TextBolck AST node type.
TextElement: AST node for a text element within a doc comment.
ThisExpression: Simple or qualified "this" AST node type.
ThrowStatement: Throw statement AST node type.
ToolFactory: Factory for creating various compiler tools, such as scanners, parsers and compilers.
TryStatement: Try statement AST node type.
Type: Abstract base class of all type reference AST node types.
TypeDeclaration: Represents the declaration of a class or interface.
TypeDeclaration: Type declaration AST node type.
TypeDeclarationMatch: A Java search match that represents a type declaration.
TypeDeclarationStatement: Local type declaration statement AST node type.
TypeKinds: Contains various properties for a Java element.
TypeLiteral: Type literal AST node type.
TypeMethodReference: Type method reference expression AST node type (added in JLS8 API).
TypeMirror: Represents a type in the Java programming language.
TypeNameMatch: A match collected while `searching` for all type names methods using a `requestor`.
TypeNameMatchCollector
TypeNameMatchRequestor: A `TypeNameMatchRequestor` collects matches from a `searchAllTypeNames` query to a `SearchEngine`.
TypeNameRequestor: A `TypeNameRequestor` collects search results from a `searchAllTypeNames` query to a `SearchEngine`.
TypeParameter: Type parameter declaration node (added in JLS3 API).
TypeParameterDeclaration: Represents a formal type parameter of a generic type, method, or constructor declaration.
TypeParameterDeclarationMatch: A Java search match that represents a type parameter declaration or reference.
TypeParameterReferenceMatch: A Java search match that represents a type parameter declaration or reference.
TypeReferenceMatch: A Java search match that represents a type reference.
Types: Utility methods for operating on types.
TypeSelectionExtension: The class provides API to extend type selection dialogs like the open type dialog.
TypeVariable: Represents a type variable.
TypeVisitor: A visitor for types, in the style of the standard visitor design pattern.
UnionType: Type node for an union type (added in JLS4 API).
UsesDirective: Uses directive AST node type (added in JLS9 API).
UseSupertypeAction: Tries to use a super type of a class where possible.
UseSupertypeDescriptor: Refactoring descriptor for the use supertype refactoring.
VariableDeclaration: Abstract base class of all AST node types that declare a single variable.
VariableDeclarationExpression: Local variable declaration expression AST node type.
VariableDeclarationFragment: Variable declaration fragment AST node type, used in field declarations, local variable declarations, `ForStatement` initializers, and `LambdaExpression` parameters.
VariableDeclarationStatement: Local variable declaration statement AST node type.
VMRunnerConfiguration: Holder for various arguments passed to a VM runner.
VMStandin: An implementation of IVMInstall that is used for manipulating VMs without necessarily committing changes.
VoidType: A pseudo-type representing the type of `void`.
WhileStatement: While statement AST node type.
WildcardType: Represents a wildcard type argument.
WildcardType: Type node for a wildcard type (added in JLS3 API).
WorkingCopyOwner: The owner of an `ICompilationUnit` handle in working copy mode.
WorkingSetFindAction: Wraps a `JavaElementSearchActions` to find its results in the specified working set.
WriteReferencesSearchGroup: Action group that adds the search for write references actions to a context menu and the global menu bar.
YieldStatement: Yield statement AST node type.
ZipEntryStorage: Deprecated. In 3.0 this class is provided by the debug platform and clients should use the replacement class `org.eclipse.debug.core.sourcelookup.containers.ZipEntryStorage`.