org.eclipse.wst.jsdt.core

## Interface IType

All Superinterfaces:
  IFunctionContainer, IJavaScriptElement, ILookupScope, IMember, IParent, ISourceManipulation, ISourceReference

    public interface IType
    extends IMember, IFunctionContainer

Represents a source type in a JavaScript file (either a top-level type, a member type, or a local type)

The children are of type `IMember`, which includes `IField`, `IFunction`, `IInitializer` and `IType`. The children are listed in the order in which they appear in the source file.

This interface is not intended to be implemented by clients.

Provisional API: This class/interface is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made available at this early stage to solicit feedback from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken (repeatedly) as the API evolves.

Provisional API: This class/interface is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made available at this early stage to solicit feedback from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken (repeatedly) as the API evolves.

### Field Summary

### Fields inherited from interface org.eclipse.wst.jsdt.core.IJavaScriptElement

`CLASS_FILE, EXPORT_CONTAINER, EXPORT_DECLARATION, FIELD, IMPORT_CONTAINER, IMPORT_DECLARATION, INITIALIZER, JAVASCRIPT_MODEL, JAVASCRIPT_PROJECT, JAVASCRIPT_UNIT, LOCAL_VARIABLE, METHOD, PACKAGE_FRAGMENT, PACKAGE_FRAGMENT_ROOT, TYPE`

### Method Summary

All Methods Instance Methods Abstract Methods
`void` `codeComplete(char[] snippet, int insertion, int position, char[][] localVariableTypeNames, char[][] localVariableNames, int[] localVariableModifiers, boolean isStatic, CompletionRequestor requestor)` Do code completion inside a code snippet in the context of the current type.
`void` `codeComplete(char[] snippet, int insertion, int position, char[][] localVariableTypeNames, char[][] localVariableNames, int[] localVariableModifiers, boolean isStatic, CompletionRequestor requestor, WorkingCopyOwner owner)` Do code completion inside a code snippet in the context of the current type.
`IField` `createField(java.lang.String contents, IJavaScriptElement sibling, boolean force, IProgressMonitor monitor)` Creates and returns a field in this type with the given contents.
`IFunction` `createMethod(java.lang.String contents, IJavaScriptElement sibling, boolean force, IProgressMonitor monitor)` Creates and returns a method or constructor in this type with the given contents.
`IType` `createType(java.lang.String contents, IJavaScriptElement sibling, boolean force, IProgressMonitor monitor)` Creates and returns a type in this type with the given contents.
`IFunction[]` `findMethods(IFunction method)` Finds the methods in this type that correspond to the given method.
`IJavaScriptElement[]` `getChildrenForCategory(java.lang.String category)` Returns the children of this type that have the given category as a `@category` tag.
`java.lang.String` `getElementName()` Returns the simple name of this type, unqualified by package or enclosing type.
`IField` `getField(java.lang.String name)` Returns the field with the specified name in this type (for example, `"bar"`).
`IField[]` `getFields()` Returns the fields declared by this type.
`java.lang.String` `getFullyQualifiedName()` Returns the fully qualified name of this type, including qualification for any containing types and packages.
`java.lang.String` `getFullyQualifiedName(char enclosingTypeSeparator)` Returns the fully qualified name of this type, including qualification for any containing types and packages.
`java.lang.String` `getFullyQualifiedParameterizedName()` Returns this type's fully qualified name
`IFunction` `getFunction(java.lang.String name, java.lang.String[] parameterTypeSignatures)` Returns the method with the specified name and parameter types in this type (for example, `"foo", {"I", "QString;"}`).
`IFunction[]` `getFunctions()` Returns the methods and constructors declared by this type.
`IInitializer` `getInitializer(int occurrenceCount)` Returns the initializer with the specified position relative to the order they are defined in the source.
`IInitializer[]` `getInitializers()` Returns the initializers declared by this type.
`java.lang.String` `getKey()` Returns the binding key for this type.
`IPackageFragment` `getPackageFragment()` Returns the source folder (package fragment) in which this element is defined.
`java.lang.String` `getSuperclassName()` Returns the name of this type's superclass, or `null` for source types that do not specify a superclass.
`java.lang.String` `getSuperclassTypeSignature()` Returns the type signature of this type's superclass, or `null` if none.
`IType` `getType(java.lang.String name)` Returns the member type declared in this type with the given simple name.
`java.lang.String` `getTypeQualifiedName()` Returns the type-qualified name of this type, including qualification for any enclosing types, but not including package qualification.
`java.lang.String` `getTypeQualifiedName(char enclosingTypeSeparator)` Returns the type-qualified name of this type, including qualification for any enclosing types, but not including package qualification.
`IType[]` `getTypes()` Returns the immediate member types declared by this type.
`boolean` `isAnonymous()` Returns whether this type represents an anonymous type.
`boolean` `isClass()` Returns whether this type is read-only.
`boolean` `isLocal()` Returns whether this type represents a local type.
`boolean` `isMember()` Returns whether this type represents a member type.
`boolean` `isResolved()` Returns whether this type represents a resolved type.
`ITypeHierarchy` `loadTypeHierachy(java.io.InputStream input, IProgressMonitor monitor)` Loads a previously saved ITypeHierarchy from an input stream.
`ITypeHierarchy` `newSupertypeHierarchy(IJavaScriptUnit[] workingCopies, IProgressMonitor monitor)` Creates and returns a type hierarchy for this type containing this type and all of its supertypes, considering types in the given working copies.
`ITypeHierarchy` `newSupertypeHierarchy(IProgressMonitor monitor)` Creates and returns a type hierarchy for this type containing this type and all of its supertypes.
`ITypeHierarchy` `newSupertypeHierarchy(WorkingCopyOwner owner, IProgressMonitor monitor)` Creates and returns a type hierarchy for this type containing this type and all of its supertypes, considering types in the working copies with the given owner.
`ITypeHierarchy` `newTypeHierarchy(IJavaScriptProject project, IProgressMonitor monitor)` Creates and returns a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the context of the given project.
`ITypeHierarchy` `newTypeHierarchy(IJavaScriptProject project, WorkingCopyOwner owner, IProgressMonitor monitor)` Creates and returns a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the context of the given project, considering types in the working copies with the given owner.
`ITypeHierarchy` `newTypeHierarchy(IJavaScriptUnit[] workingCopies, IProgressMonitor monitor)` Creates and returns a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the workspace, considering types in the given working copies.
`ITypeHierarchy` `newTypeHierarchy(IProgressMonitor monitor)` Creates and returns a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the workspace.
`ITypeHierarchy` `newTypeHierarchy(WorkingCopyOwner owner, IProgressMonitor monitor)` Creates and returns a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the workspace, considering types in the working copies with the given owner.
`java.lang.String[][]` `resolveType(java.lang.String typeName)` Resolves the given type name within the context of this type (depending on the type hierarchy and its imports).
`java.lang.String[][]` `resolveType(java.lang.String typeName, WorkingCopyOwner owner)` Resolves the given type name within the context of this type (depending on the type hierarchy and its imports) and using the given owner's working copies, considering types in the working copies with the given owner.

### Methods inherited from interface org.eclipse.wst.jsdt.core.IMember

`getCategories, getClassFile, getDeclaringType, getFlags, getJavaScriptUnit, getJSdocRange, getNameRange, getOccurrenceCount, getType, getTypeRoot, isBinary`

### Methods inherited from interface org.eclipse.wst.jsdt.core.IJavaScriptElement

`exists, getAncestor, getAttachedJavadoc, getCommonSuperType, getCorrespondingResource, getDisplayName, getElementType, getHandleIdentifier, getHostPath, getJavaScriptModel, getJavaScriptProject, getOpenable, getParent, getPath, getPrimaryElement, getResource, getSchedulingRule, getUnderlyingResource, isReadOnly, isStructureKnown, isVirtual`

### Methods inherited from interface org.eclipse.wst.jsdt.core.ILookupScope

`newNameLookup, newNameLookup, newSearchableNameEnvironment, newSearchableNameEnvironment`

### Methods inherited from interface org.eclipse.wst.jsdt.core.ISourceReference

`exists, getSource, getSourceRange`

### Methods inherited from interface org.eclipse.wst.jsdt.core.ISourceManipulation

`copy, delete, move, rename`

### Methods inherited from interface org.eclipse.wst.jsdt.core.IParent

`getChildren, hasChildren`

### Method Detail

#### codeComplete

    void codeComplete(char[] snippet,
                      int insertion,
                      int position,
                      char[][] localVariableTypeNames,
                      char[][] localVariableNames,
                      int[] localVariableModifiers,
                      boolean isStatic,
                      CompletionRequestor requestor)
               throws JavaScriptModelException

Do code completion inside a code snippet in the context of the current type. If the type can access to his source code and the insertion position is valid, then completion is performed against source. Otherwise the completion is performed against type structure and given locals variables.

Parameters:
  `snippet` - the code snippet
  `insertion` - the position with in source where the snippet is inserted. This position must not be in comments. A possible value is -1, if the position is not known.
  `position` - the position within snippet where the user is performing code assist.
  `localVariableTypeNames` - an array (possibly empty) of fully qualified type names of local variables visible at the current scope
  `localVariableNames` - an array (possibly empty) of local variable names that are visible at the current scope
  `localVariableModifiers` - an array (possible empty) of modifiers for local variables
  `isStatic` - whether the current scope is in a static context
  `requestor` - the completion requestor
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### codeComplete

    void codeComplete(char[] snippet,
                      int insertion,
                      int position,
                      char[][] localVariableTypeNames,
                      char[][] localVariableNames,
                      int[] localVariableModifiers,
                      boolean isStatic,
                      CompletionRequestor requestor,
                      WorkingCopyOwner owner)
               throws JavaScriptModelException

Do code completion inside a code snippet in the context of the current type. It considers types in the working copies with the given owner first. In other words, the owner's working copies will take precedence over their original compilation units in the workspace.

Note that if a working copy is empty, it will be as if the original compilation unit had been deleted.

If the type can access to his source code and the insertion position is valid, then completion is performed against source. Otherwise the completion is performed against type structure and given locals variables.

Parameters:
  `snippet` - the code snippet
  `insertion` - the position with in source where the snippet is inserted. This position must not be in comments. A possible value is -1, if the position is not known.
  `position` - the position with in snippet where the user is performing code assist.
  `localVariableTypeNames` - an array (possibly empty) of fully qualified type names of local variables visible at the current scope
  `localVariableNames` - an array (possibly empty) of local variable names that are visible at the current scope
  `localVariableModifiers` - an array (possible empty) of modifiers for local variables
  `isStatic` - whether the current scope is in a static context
  `requestor` - the completion requestor
  `owner` - the owner of working copies that take precedence over their original compilation units
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### createField

    IField createField(java.lang.String contents,
                       IJavaScriptElement sibling,
                       boolean force,
                       IProgressMonitor monitor)
                throws JavaScriptModelException

Creates and returns a field in this type with the given contents.

Optionally, the new element can be positioned before the specified sibling. If no sibling is specified, the element will be inserted as the last field declaration in this type.

It is possible that a field with the same name already exists in this type. The value of the `force` parameter effects the resolution of such a conflict:

- `true` - in this case the field is created with the new contents
- `false` - in this case a `JavaScriptModelException` is thrown

Parameters:
  `contents` - the given contents
  `sibling` - the given sibling
  `force` - a flag in case the same name already exists in this type
  `monitor` - the given progress monitor
Returns:
  a field in this type with the given contents
Throws:
  `JavaScriptModelException` - if the element could not be created. Reasons include:
  - This JavaScript element does not exist (ELEMENT_DOES_NOT_EXIST)
  - A `CoreException` occurred while updating an underlying resource
  - The specified sibling is not a child of this type (INVALID_SIBLING)
  - The contents could not be recognized as a field declaration (INVALID_CONTENTS)
  - This type is read-only (binary) (READ_ONLY)
  - There was a naming collision with an existing field (NAME_COLLISION)

#### createMethod

    IFunction createMethod(java.lang.String contents,
                           IJavaScriptElement sibling,
                           boolean force,
                           IProgressMonitor monitor)
                    throws JavaScriptModelException

Creates and returns a method or constructor in this type with the given contents.

Optionally, the new element can be positioned before the specified sibling. If no sibling is specified, the element will be appended to this type.

It is possible that a method with the same signature already exists in this type. The value of the `force` parameter effects the resolution of such a conflict:

- `true` - in this case the method is created with the new contents
- `false` - in this case a `JavaScriptModelException` is thrown

Parameters:
  `contents` - the given contents
  `sibling` - the given sibling
  `force` - a flag in case the same name already exists in this type
  `monitor` - the given progress monitor
Returns:
  a method or constructor in this type with the given contents
Throws:
  `JavaScriptModelException` - if the element could not be created. Reasons include:
  - This JavaScript element does not exist (ELEMENT_DOES_NOT_EXIST)
  - A `CoreException` occurred while updating an underlying resource
  - The specified sibling is not a child of this type (INVALID_SIBLING)
  - The contents could not be recognized as a method or constructor declaration (INVALID_CONTENTS)
  - This type is read-only (binary) (READ_ONLY)
  - There was a naming collision with an existing method (NAME_COLLISION)

#### createType

    IType createType(java.lang.String contents,
                     IJavaScriptElement sibling,
                     boolean force,
                     IProgressMonitor monitor)
              throws JavaScriptModelException

Creates and returns a type in this type with the given contents.

Optionally, the new type can be positioned before the specified sibling. If no sibling is specified, the type will be appended to this type.

It is possible that a type with the same name already exists in this type. The value of the `force` parameter effects the resolution of such a conflict:

- `true` - in this case the type is created with the new contents
- `false` - in this case a `JavaScriptModelException` is thrown

Parameters:
  `contents` - the given contents
  `sibling` - the given sibling
  `force` - a flag in case the same name already exists in this type
  `monitor` - the given progress monitor
Returns:
  a type in this type with the given contents
Throws:
  `JavaScriptModelException` - if the element could not be created. Reasons include:
  - This JavaScript element does not exist (ELEMENT_DOES_NOT_EXIST)
  - A `CoreException` occurred while updating an underlying resource
  - The specified sibling is not a child of this type (INVALID_SIBLING)
  - The contents could not be recognized as a type declaration (INVALID_CONTENTS)
  - This type is read-only (binary) (READ_ONLY)
  - There was a naming collision with an existing field (NAME_COLLISION)

#### findMethods

    IFunction[] findMethods(IFunction method)

Finds the methods in this type that correspond to the given method. A method m1 corresponds to another method m2 if:

- m1 has the same element name as m2.
- m1 has the same number of arguments as m2 and the simple names of the argument types must be equals.
- m1 exists.

Parameters:
  `method` - the given method
Returns:
  the found method or `null` if no such methods can be found.

#### getChildrenForCategory

    IJavaScriptElement[] getChildrenForCategory(java.lang.String category)
                                         throws JavaScriptModelException

Returns the children of this type that have the given category as a `@category` tag. Returns an empty array if no children with this category exist.

Returns:
  the children for the given category.
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### getElementName

    java.lang.String getElementName()

Returns the simple name of this type, unqualified by package or enclosing type. This is a handle-only method.

Specified by:
  `getElementName` in interface `IJavaScriptElement`
Returns:
  the simple name of this type

#### getField

    IField getField(java.lang.String name)

Returns the field with the specified name in this type (for example, `"bar"`). This is a handle-only method. The field may or may not exist.

Specified by:
  `getField` in interface `IFunctionContainer`
Parameters:
  `name` - the given name
Returns:
  the field with the specified name in this type

#### getFields

    IField[] getFields()
                throws JavaScriptModelException

Returns the fields declared by this type. If this is a source type, the results are listed in the order in which they appear in the source, otherwise, the results are in no particular order. For binary types, this includes synthetic fields.

Specified by:
  `getFields` in interface `IFunctionContainer`
Returns:
  the fields declared by this type
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### getFullyQualifiedName

    java.lang.String getFullyQualifiedName()

Returns the fully qualified name of this type, including qualification for any containing types and packages. This is the name of the package, followed by `'.'`, followed by the type-qualified name. This is a handle-only method.

Returns:
  the fully qualified name of this type
See Also:
  `getTypeQualifiedName()`

#### getFullyQualifiedName

    java.lang.String getFullyQualifiedName(char enclosingTypeSeparator)

Returns the fully qualified name of this type, including qualification for any containing types and packages. This is the name of the package, followed by `'.'`, followed by the type-qualified name using the `enclosingTypeSeparator`. This is a handle-only method.

Parameters:
  `enclosingTypeSeparator` - the given enclosing type separator
Returns:
  the fully qualified name of this type, including qualification for any containing types and packages
See Also:
  `getTypeQualifiedName(char)`

#### getFullyQualifiedParameterizedName

    java.lang.String getFullyQualifiedParameterizedName()
                                                 throws JavaScriptModelException

Returns this type's fully qualified name

Returns:
  the fully qualified parameterized representation of this type
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### getInitializer

    IInitializer getInitializer(int occurrenceCount)

Returns the initializer with the specified position relative to the order they are defined in the source. Numbering starts at 1 (thus the first occurrence is occurrence 1, not occurrence 0). This is a handle-only method. The initializer may or may not be present.

Parameters:
  `occurrenceCount` - the specified position
Returns:
  the initializer with the specified position relative to the order they are defined in the source

#### getInitializers

    IInitializer[] getInitializers()
                            throws JavaScriptModelException

Returns the initializers declared by this type. For binary types this is an empty collection. If this is a source type, the results are listed in the order in which they appear in the source.

Returns:
  the initializers declared by this type
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### getKey

    java.lang.String getKey()

Returns the binding key for this type. A binding key is a key that uniquely identifies this type. It allows access to generic info for parameterized types.

Returns:
  the binding key for this type
See Also:
  `IBinding.getKey()`, `BindingKey`

#### getFunction

    IFunction getFunction(java.lang.String name,
                          java.lang.String[] parameterTypeSignatures)

Returns the method with the specified name and parameter types in this type (for example, `"foo", {"I", "QString;"}`). To get the handle for a constructor, the name specified must be the simple name of the enclosing type. This is a handle-only method. The method may or may not be present.

The type signatures may be either unresolved (for source types) or resolved (for binary types), and either basic (for basic types) or rich (for parameterized types). See `Signature` for details.

Specified by:
  `getFunction` in interface `IFunctionContainer`
Parameters:
  `name` - the given name
  `parameterTypeSignatures` - the given parameter types
Returns:
  the method with the specified name and parameter types in this type

#### getFunctions

    IFunction[] getFunctions()
                      throws JavaScriptModelException

Returns the methods and constructors declared by this type. For binary types, this may include the special `<clinit>`; method and synthetic methods. If this is a source type, the results are listed in the order in which they appear in the source, otherwise, the results are in no particular order.

Specified by:
  `getFunctions` in interface `IFunctionContainer`
Returns:
  the methods and constructors declared by this type
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### getPackageFragment

    IPackageFragment getPackageFragment()

Returns the source folder (package fragment) in which this element is defined. This is a handle-only method.

Returns:
  the package fragment in which this element is defined

#### getSuperclassName

    java.lang.String getSuperclassName()
                                throws JavaScriptModelException

Returns the name of this type's superclass, or `null` for source types that do not specify a superclass.

For interfaces, the superclass name is always `"java.lang.Object"`. For source types, the name as declared is returned, for binary types, the resolved, qualified name is returned. For anonymous types, the superclass name is the name appearing after the 'new' keyword'. If the superclass is a parameterized type, the string may include its type arguments enclosed in "<>". If the returned string is needed for anything other than display purposes, use `getSuperclassTypeSignature()` which returns a structured type signature string containing more precise information.

Returns:
  the name of this type's superclass, or `null` for source types that do not specify a superclass
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### getSuperclassTypeSignature

    java.lang.String getSuperclassTypeSignature()
                                         throws JavaScriptModelException

Returns the type signature of this type's superclass, or `null` if none.

The type signature may be either unresolved (for source types) or resolved (for binary types), and either basic (for basic types) or rich (for parameterized types). See `Signature` for details.

Returns:
  the type signature of this type's superclass, or `null` if none
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### getType

    IType getType(java.lang.String name)

Returns the member type declared in this type with the given simple name. This is a handle-only method. The type may or may not exist.

Specified by:
  `getType` in interface `IFunctionContainer`
Parameters:
  `name` - the given simple name
Returns:
  the member type declared in this type with the given simple name

#### getTypeQualifiedName

    java.lang.String getTypeQualifiedName()

Returns the type-qualified name of this type, including qualification for any enclosing types, but not including package qualification. This is a handle-only method.

Returns:
  the type-qualified name of this type

#### getTypeQualifiedName

    java.lang.String getTypeQualifiedName(char enclosingTypeSeparator)

Returns the type-qualified name of this type, including qualification for any enclosing types, but not including package qualification. This is a handle-only method.

Parameters:
  `enclosingTypeSeparator` - the specified enclosing type separator
Returns:
  the type-qualified name of this type

#### getTypes

    IType[] getTypes()
              throws JavaScriptModelException

Returns the immediate member types declared by this type. The results are listed in the order in which they appear in the source or class file.

Returns:
  the immediate member types declared by this type
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### isAnonymous

    boolean isAnonymous()
                 throws JavaScriptModelException

Returns whether this type represents an anonymous type.

Returns:
  true if this type represents an anonymous type, false otherwise
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### isClass

    boolean isClass()
             throws JavaScriptModelException

Returns whether this type is read-only.

Note that a class can neither be an interface, an enumeration class, nor an annotation type.

Returns:
  true if this type represents a class, false otherwise
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### isLocal

    boolean isLocal()
             throws JavaScriptModelException

Returns whether this type represents a local type.

Returns:
  true if this type represents a local type, false otherwise
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### isMember

    boolean isMember()
              throws JavaScriptModelException

Returns whether this type represents a member type.

Returns:
  true if this type represents a member type, false otherwise
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### isResolved

    boolean isResolved()

Returns whether this type represents a resolved type. If a type is resolved, its key contains resolved information.

Returns:
  whether this type represents a resolved type.

#### loadTypeHierachy

    ITypeHierarchy loadTypeHierachy(java.io.InputStream input,
                                    IProgressMonitor monitor)
                             throws JavaScriptModelException

Loads a previously saved ITypeHierarchy from an input stream. A type hierarchy can be stored using ITypeHierachy#store(OutputStream). Only hierarchies originally created by the following methods can be loaded:

- IType#newSupertypeHierarchy(IProgressMonitor)
- IType#newTypeHierarchy(IJavaScriptProject, IProgressMonitor)
- IType#newTypeHierarchy(IProgressMonitor)

Parameters:
  `input` - stream where hierarchy will be read
  `monitor` - the given progress monitor
Returns:
  the stored hierarchy
Throws:
  `JavaScriptModelException` - if the hierarchy could not be restored, reasons include: - type is not the focus of the hierarchy or - unable to read the input stream (wrong format, IOException during reading, ...)
See Also:
  `ITypeHierarchy.store(java.io.OutputStream, IProgressMonitor)`

#### newSupertypeHierarchy

    ITypeHierarchy newSupertypeHierarchy(IProgressMonitor monitor)
                                  throws JavaScriptModelException

Creates and returns a type hierarchy for this type containing this type and all of its supertypes.

Parameters:
  `monitor` - the given progress monitor
Returns:
  a type hierarchy for this type containing this type and all of its supertypes
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### newSupertypeHierarchy

    ITypeHierarchy newSupertypeHierarchy(IJavaScriptUnit[] workingCopies,
                                         IProgressMonitor monitor)
                                  throws JavaScriptModelException

Creates and returns a type hierarchy for this type containing this type and all of its supertypes, considering types in the given working copies. In other words, the list of working copies will take precedence over their original compilation units in the workspace.

Note that passing an empty working copy will be as if the original compilation unit had been deleted.

Parameters:
  `workingCopies` - the working copies that take precedence over their original compilation units
  `monitor` - the given progress monitor
Returns:
  a type hierarchy for this type containing this type and all of its supertypes
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### newSupertypeHierarchy

    ITypeHierarchy newSupertypeHierarchy(WorkingCopyOwner owner,
                                         IProgressMonitor monitor)
                                  throws JavaScriptModelException

Creates and returns a type hierarchy for this type containing this type and all of its supertypes, considering types in the working copies with the given owner. In other words, the owner's working copies will take precedence over their original compilation units in the workspace.

Note that if a working copy is empty, it will be as if the original compilation unit had been deleted.

Parameters:
  `owner` - the owner of working copies that take precedence over their original compilation units
  `monitor` - the given progress monitor
Returns:
  a type hierarchy for this type containing this type and all of its supertypes
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### newTypeHierarchy

    ITypeHierarchy newTypeHierarchy(IJavaScriptProject project,
                                    IProgressMonitor monitor)
                             throws JavaScriptModelException

Creates and returns a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the context of the given project.

Parameters:
  `project` - the given project
  `monitor` - the given progress monitor
Returns:
  a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the context of the given project
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### newTypeHierarchy

    ITypeHierarchy newTypeHierarchy(IJavaScriptProject project,
                                    WorkingCopyOwner owner,
                                    IProgressMonitor monitor)
                             throws JavaScriptModelException

Creates and returns a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the context of the given project, considering types in the working copies with the given owner. In other words, the owner's working copies will take precedence over their original compilation units in the workspace.

Note that if a working copy is empty, it will be as if the original compilation unit had been deleted.

Parameters:
  `project` - the given project
  `owner` - the owner of working copies that take precedence over their original compilation units
  `monitor` - the given progress monitor
Returns:
  a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the context of the given project
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### newTypeHierarchy

    ITypeHierarchy newTypeHierarchy(IProgressMonitor monitor)
                             throws JavaScriptModelException

Creates and returns a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the workspace.

Parameters:
  `monitor` - the given progress monitor
Returns:
  a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the workspace
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### newTypeHierarchy

    ITypeHierarchy newTypeHierarchy(IJavaScriptUnit[] workingCopies,
                                    IProgressMonitor monitor)
                             throws JavaScriptModelException

Creates and returns a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the workspace, considering types in the given working copies. In other words, the list of working copies that will take precedence over their original compilation units in the workspace.

Note that passing an empty working copy will be as if the original compilation unit had been deleted.

Parameters:
  `workingCopies` - the working copies that take precedence over their original compilation units
  `monitor` - the given progress monitor
Returns:
  a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the workspace
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### newTypeHierarchy

    ITypeHierarchy newTypeHierarchy(WorkingCopyOwner owner,
                                    IProgressMonitor monitor)
                             throws JavaScriptModelException

Creates and returns a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the workspace, considering types in the working copies with the given owner. In other words, the owner's working copies will take precedence over their original compilation units in the workspace.

Note that if a working copy is empty, it will be as if the original compilation unit had been deleted.

Parameters:
  `owner` - the owner of working copies that take precedence over their original compilation units
  `monitor` - the given progress monitor
Returns:
  a type hierarchy for this type containing this type, all of its supertypes, and all its subtypes in the workspace
Throws:
  `JavaScriptModelException` - if this element does not exist or if an exception occurs while accessing its corresponding resource.

#### resolveType

    java.lang.String[][] resolveType(java.lang.String typeName)
                              throws JavaScriptModelException

Resolves the given type name within the context of this type (depending on the type hierarchy and its imports).

Multiple answers might be found in case there are ambiguous matches.

Each matching type name is decomposed as an array of two strings, the first denoting the package name (dot-separated) and the second being the type name. The package name is empty if it is the default package. The type name is the type qualified name using a '.' enclosing type separator.

Returns `null` if unable to find any matching type.

Parameters:
  `typeName` - the given type name
Returns:
  the resolved type names or `null` if unable to find any matching type
Throws:
  `JavaScriptModelException` - if code resolve could not be performed.
See Also:
  `getTypeQualifiedName(char)`

#### resolveType

    java.lang.String[][] resolveType(java.lang.String typeName,
                                     WorkingCopyOwner owner)
                              throws JavaScriptModelException

Resolves the given type name within the context of this type (depending on the type hierarchy and its imports) and using the given owner's working copies, considering types in the working copies with the given owner. In other words, the owner's working copies will take precedence over their original compilation units in the workspace.

Note that if a working copy is empty, it will be as if the original compilation unit had been deleted.

Multiple answers might be found in case there are ambiguous matches.

Each matching type name is decomposed as an array of two strings, the first denoting the package name (dot-separated) and the second being the type name. The package name is empty if it is the default package. The type name is the type qualified name using a '.' enclosing type separator.

Returns `null` if unable to find any matching type.

Parameters:
  `typeName` - the given type name
  `owner` - the owner of working copies that take precedence over their original compilation units
Returns:
  the resolved type names or `null` if unable to find any matching type
Throws:
  `JavaScriptModelException` - if code resolve could not be performed.
See Also:
  `getTypeQualifiedName(char)`