TypeBinding

java.lang.Object
- org.aspectj.org.eclipse.jdt.internal.compiler.lookup.Binding
- - org.aspectj.org.eclipse.jdt.internal.compiler.lookup.TypeBinding

Direct Known Subclasses:

ArrayBinding, BaseTypeBinding, PolyTypeBinding, ReferenceBinding
```
public abstract class TypeBinding
extends Binding
```

Field Summary

Fields
Modifier and Type	Field and Description
`static BaseTypeBinding`	`BOOLEAN`
`static BaseTypeBinding`	`BYTE`
`static BaseTypeBinding`	`CHAR`
`static BaseTypeBinding`	`DOUBLE`
`static BaseTypeBinding`	`FLOAT`
`int`	`id`
`static BaseTypeBinding`	`INT` Base type definitions
`static BaseTypeBinding`	`LONG`
`static NullTypeBinding`	`NULL`
`static BaseTypeBinding`	`SHORT`
`long`	`tagBits`
`static ReferenceBinding`	`TYPE_USE_BINDING`
`protected AnnotationBinding[]`	`typeAnnotations`
`static VoidTypeBinding`	`VOID`

Fields inherited from class org.aspectj.org.eclipse.jdt.internal.compiler.lookup.Binding
ANY_EXCEPTION, ARRAY_TYPE, BASE_TYPE, DefaultLocationArrayContents, DefaultLocationField, DefaultLocationParameter, DefaultLocationReturnType, DefaultLocationTypeArgument, DefaultLocationTypeBound, DefaultLocationTypeParameter, FIELD, GENERIC_TYPE, IMPORT, INTERSECTION_TYPE, INTERSECTION_TYPE18, LOCAL, METHOD, NO_ANNOTATIONS, NO_ELEMENT_VALUE_PAIRS, NO_EXCEPTIONS, NO_FIELDS, NO_MEMBER_TYPES, NO_METHODS, NO_NULL_DEFAULT, NO_PARAMETER_NAMES, NO_PARAMETERS, NO_REFERENCE_TYPES, NO_SUPERINTERFACES, NO_TYPE_VARIABLES, NO_TYPES, NONNULL_BY_DEFAULT, NULL_UNSPECIFIED_BY_DEFAULT, NullnessDefaultMASK, PACKAGE, PARAMETERIZED_TYPE, POLY_TYPE, RAW_TYPE, TYPE, TYPE_PARAMETER, TYPE_USE, UNINITIALIZED_FIELDS, UNINITIALIZED_METHODS, UNINITIALIZED_REFERENCE_TYPES, VARIABLE, WILDCARD_TYPE

Constructor Summary

Constructors
Constructor and Description

TypeBinding()

TypeBinding(TypeBinding prototype)

Constructors
Constructor and Description
`TypeBinding()`
`TypeBinding(TypeBinding prototype)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`acceptsNonNullDefault()` Used to implement this sentence from o.e.j.annotation.DefaultLocation: "Wildcards and the use of type variables are always excluded from NonNullByDefault."
`ReferenceBinding`	`actualType()`
`java.lang.String`	`annotatedDebugName()`
`boolean`	`canBeInstantiated()`
`boolean`	`canBeSeenBy(Scope scope)`
`TypeBinding`	`capture(Scope scope, int start, int end)` Perform capture conversion on a given type (only effective on parameterized type with wildcards)
`TypeBinding`	`clone(TypeBinding enclosingType)` Virtual copy constructor: a copy is made of the receiver's entire instance state and then suitably parameterized by the arguments to the clone operation as seen fit by each type.
`TypeBinding`	`closestMatch()` In case of problems, returns the closest match found.
`java.util.List<TypeBinding>`	`collectMissingTypes(java.util.List<TypeBinding> missingTypes)` Iterate through the type components to collect instances of leaf missing types
`void`	`collectSubstitutes(Scope scope, TypeBinding actualType, InferenceContext inferenceContext, int constraint)` Collect the substitutes into a map for certain type variables inside the receiver type e.g.
`abstract char[]`	`constantPoolName()` Answer the receiver's constant pool name.
`ReferenceBinding`	`containerAnnotationType()`
`java.lang.String`	`debugName()`
`int`	`depth()`
`int`	`dimensions()`
`MethodBinding`	`enclosingMethod()`
`ReferenceBinding`	`enclosingType()`
`boolean`	`enterRecursiveFunction()` Call this before descending into type details to prevent infinite recursion.
`static boolean`	`equalsEquals(TypeBinding that, TypeBinding other)`
`TypeBinding`	`erasure()`
`void`	`exitRecursiveFunction()` Exit the context of a potentially recursive function.
`ReferenceBinding`	`findSuperTypeOriginatingFrom(int wellKnownOriginalID, boolean originalIsClass)` Find supertype which originates from a given well-known type, or null if not found (using id avoids triggering the load of well-known type: 73740) NOTE: only works for erasures of well-known types, as random other types may share same id though being distincts.
`TypeBinding`	`findSuperTypeOriginatingFrom(TypeBinding otherType)` Find supertype which originates from a given type, or null if not found
`TypeBinding`	`genericCast(TypeBinding targetType)` Returns the type to use for generic cast, or null if none required
`char[]`	`genericTypeSignature()` Answer the receiver classfile signature.
`TypeBinding`	`getErasureCompatibleType(TypeBinding declaringClass)` Return the supertype which would erase as a subtype of a given declaring class.
`ReferenceBinding[]`	`getIntersectingTypes()`
`MethodBinding[]`	`getMethods(char[] selector)`
`abstract PackageBinding`	`getPackage()`
`MethodBinding`	`getSingleAbstractMethod(Scope scope, boolean replaceWildcards)` Return the single abstract method of a functional interface, or one of `null` or `ReferenceBinding.samProblemBinding`, if the receiver is not a functional interface as defined in JLS 9.8.
`AnnotationBinding[]`	`getTypeAnnotations()`
`boolean`	`hasNullTypeAnnotations()` Does this type or any of its details (array dimensions, type arguments) have a null type annotation?
`boolean`	`hasTypeAnnotations()`
`boolean`	`hasTypeBit(int bit)` Answer an additional bit characterizing this type, like `TypeIds.BitAutoCloseable`.
`boolean`	`isAnonymousType()`
`boolean`	`isArrayType()`
`boolean`	`isBaseType()`
`boolean`	`isBoundParameterizedType()` Returns true if parameterized type AND not of the form List
`boolean`	`isBoxedPrimitiveType()`
`boolean`	`isBoxingCompatibleWith(TypeBinding right, Scope scope)`
`boolean`	`isCapture()` Returns true if the type is the capture of some wildcard
`boolean`	`isClass()`
`boolean`	`isCompatibleWith(TypeBinding right)`
`abstract boolean`	`isCompatibleWith(TypeBinding right, Scope scope)`
`boolean`	`isEnum()`
`boolean`	`isEquivalentTo(TypeBinding otherType)` Returns true if a type is identical to another one, or for generic types, true if compared to its raw type.
`boolean`	`isFreeTypeVariable()`
`boolean`	`isFunctionalInterface(Scope scope)`
`boolean`	`isFunctionalType()`
`boolean`	`isGenericType()`
`boolean`	`isHierarchyInconsistent()`
`boolean`	`isInterface()`
`boolean`	`isIntersectionType()` Returns true if the current type denotes an intersection type: Number & Comparable
`boolean`	`isIntersectionType18()`
`boolean`	`isLocalType()`
`boolean`	`isMemberType()`
`boolean`	`isNestedType()`
`boolean`	`isNumericType()`
`boolean`	`isParameterizedType()` Returns true if the type is parameterized, e.g.
`boolean`	`isParameterizedTypeWithActualArguments()` Returns true if the type is parameterized, e.g.
`boolean`	`isParameterizedWithOwnVariables()` Returns true if the type is parameterized using its own type variables as arguments
`boolean`	`isPolyType()`
`boolean`	`isPotentiallyCompatibleWith(TypeBinding right, Scope scope)`
`boolean`	`isPrimitiveOrBoxedPrimitiveType()`
`boolean`	`isPrimitiveType()`
`boolean`	`isProperType(boolean admitCapture18)` JLS8 Sect 18.1.1
`boolean`	`isProvablyDistinct(TypeBinding otherType)` Returns true if a type is provably distinct from another one,
`boolean`	`isRawType()`
`boolean`	`isReifiable()` JLS(3) 4.7.
`boolean`	`isRepeatableAnnotationType()` Answer true if the receiver is an annotation which may be repeatable.
`boolean`	`isStatic()` Answer true if the receiver is a static member type (or toplevel)
`boolean`	`isSubtypeOf(TypeBinding right)`
`boolean`	`isThrowable()` Returns true if a given type may be thrown
`boolean`	`isTypeArgumentContainedBy(TypeBinding otherType)`
`boolean`	`isTypeVariable()` Returns true if the type was declared as a type variable
`boolean`	`isUnboundWildcard()` Returns true if wildcard type of the form '?' (no bound)
`boolean`	`isUncheckedException(boolean includeSupertype)` Returns true if the type is a subclass of java.lang.Error or java.lang.RuntimeException
`boolean`	`isUnresolvedType()`
`boolean`	`isWildcard()` Returns true if the type is a wildcard
`int`	`kind()`
`TypeBinding`	`leafComponentType()`
`boolean`	`mentionsAny(TypeBinding[] parameters, int idx)` Does this type mention any of the given type parameters, except the one at position 'idx'?
`boolean`	`needsUncheckedConversion(TypeBinding targetType)` Meant to be invoked on compatible types, to figure if unchecked conversion is necessary
`static boolean`	`notEquals(TypeBinding that, TypeBinding other)`
`char[]`	`nullAnnotatedReadableName(CompilerOptions options, boolean shortNames)` Answer a readable name (for error reporting) that includes nullness type annotations.
`TypeBinding`	`original()` Returns the orignal generic type instantiated by the receiver type, or itself if not.
`TypeBinding`	`prototype()` Return the primordial type from which the receiver was cloned.
`char[]`	`qualifiedPackageName()` Answer the qualified name of the receiver's package separated by periods or an empty string if its the default package.
`abstract char[]`	`qualifiedSourceName()` Answer the source name for the type.
`void`	`setTypeAnnotations(AnnotationBinding[] annotations, boolean evalNullAnnotations)`
`char[]`	`signableName()`
`char[]`	`signature()` Answer the receiver classfile signature.
`boolean`	`sIsMoreSpecific(TypeBinding s, TypeBinding t, Scope scope)`
`abstract char[]`	`sourceName()`
`ReferenceBinding`	`superclass()`
`ReferenceBinding[]`	`superInterfaces()`
`void`	`swapUnresolved(UnresolvedReferenceBinding unresolvedType, ReferenceBinding resolvedType, LookupEnvironment environment)`
`SyntheticArgumentBinding[]`	`syntheticOuterLocalVariables()`
`TypeVariableBinding[]`	`typeVariables()`
`TypeBinding`	`unannotated()` Return this type minus its type annotations
`TypeBinding`	`uncapture(Scope scope)` Perform capture "deconversion" on a given type
`long`	`updateTagBits()` Refresh some tagBits from details into the main type.
`static TypeBinding`	`wellKnownType(Scope scope, int id)` Match a well-known type id to its binding
`TypeBinding`	`withoutToplevelNullAnnotation()` Return this type minus its toplevel null annotations.

Methods inherited from class org.aspectj.org.eclipse.jdt.internal.compiler.lookup.Binding
computeUniqueKey, computeUniqueKey, getAnnotations, getAnnotationTagBits, initializeDeprecatedAnnotationTagBits, isAnnotationType, isParameter, isTaggedRepeatable, isValidBinding, isVolatile, problemId, readableName, setAnnotations, setAnnotations, shortReadableName

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - id
```
public int id
```
  - tagBits
```
public long tagBits
```
  - typeAnnotations
```
protected AnnotationBinding[] typeAnnotations
```
  - TYPE_USE_BINDING
```
public static final ReferenceBinding TYPE_USE_BINDING
```
  - INT
```
public static final BaseTypeBinding INT
```
    Base type definitions
  - BYTE
```
public static final BaseTypeBinding BYTE
```
  - SHORT
```
public static final BaseTypeBinding SHORT
```
  - CHAR
```
public static final BaseTypeBinding CHAR
```
  - LONG
```
public static final BaseTypeBinding LONG
```
  - FLOAT
```
public static final BaseTypeBinding FLOAT
```
  - DOUBLE
```
public static final BaseTypeBinding DOUBLE
```
  - BOOLEAN
```
public static final BaseTypeBinding BOOLEAN
```
  - NULL
```
public static final NullTypeBinding NULL
```
  - VOID
```
public static final VoidTypeBinding VOID
```
- Constructor Detail
  - TypeBinding
```
public TypeBinding()
```
  - TypeBinding
```
public TypeBinding(TypeBinding prototype)
```
- Method Detail
  - wellKnownType
```
public static final TypeBinding wellKnownType(Scope scope,
                                              int id)
```
    Match a well-known type id to its binding
  - actualType
```
public ReferenceBinding actualType()
```
  - annotatedDebugName
```
public java.lang.String annotatedDebugName()
```
  - containerAnnotationType
```
public ReferenceBinding containerAnnotationType()
```
  - canBeInstantiated
```
public boolean canBeInstantiated()
```
  - capture
```
public TypeBinding capture(Scope scope,
                           int start,
                           int end)
```
    Perform capture conversion on a given type (only effective on parameterized type with wildcards)
  - uncapture
```
public TypeBinding uncapture(Scope scope)
```
    Perform capture "deconversion" on a given type
  - closestMatch
```
public TypeBinding closestMatch()
```
    In case of problems, returns the closest match found. It may not be perfect match, but the result of a best effort to improve fault-tolerance.
  - collectMissingTypes
```
public java.util.List<TypeBinding> collectMissingTypes(java.util.List<TypeBinding> missingTypes)
```
    Iterate through the type components to collect instances of leaf missing types
    
    Parameters:
    
    missingTypes -
    
    Returns:
    
    missing types
  - collectSubstitutes
```
public void collectSubstitutes(Scope scope,
                               TypeBinding actualType,
                               InferenceContext inferenceContext,
                               int constraint)
```
    Collect the substitutes into a map for certain type variables inside the receiver type e.g. Collection.findSubstitute(T, Collection>): T --> List Constraints: A << F corresponds to: F.collectSubstitutes(..., A, ..., CONSTRAINT_EXTENDS (1)) A = F corresponds to: F.collectSubstitutes(..., A, ..., CONSTRAINT_EQUAL (0)) A >> F corresponds to: F.collectSubstitutes(..., A, ..., CONSTRAINT_SUPER (2))
  - clone
```
public TypeBinding clone(TypeBinding enclosingType)
```
    Virtual copy constructor: a copy is made of the receiver's entire instance state and then suitably parameterized by the arguments to the clone operation as seen fit by each type. Parameters may not make sense for every type in the hierarchy, in which case they are silently ignored. A type may choose to retain a copy of the prototype for reference.
  - constantPoolName
```
public abstract char[] constantPoolName()
```
    Answer the receiver's constant pool name. NOTE: This method should only be used during/after code gen. e.g. 'java/lang/Object'
  - debugName
```
public java.lang.String debugName()
```
  - dimensions
```
public int dimensions()
```
  - depth
```
public int depth()
```
  - enclosingMethod
```
public MethodBinding enclosingMethod()
```
  - enclosingType
```
public ReferenceBinding enclosingType()
```
  - erasure
```
public TypeBinding erasure()
```
  - findSuperTypeOriginatingFrom
```
public ReferenceBinding findSuperTypeOriginatingFrom(int wellKnownOriginalID,
                                                     boolean originalIsClass)
```
    Find supertype which originates from a given well-known type, or null if not found (using id avoids triggering the load of well-known type: 73740) NOTE: only works for erasures of well-known types, as random other types may share same id though being distincts.
    
    See Also:
    
    TypeIds
  - findSuperTypeOriginatingFrom
```
public TypeBinding findSuperTypeOriginatingFrom(TypeBinding otherType)
```
    Find supertype which originates from a given type, or null if not found
  - genericCast
```
public TypeBinding genericCast(TypeBinding targetType)
```
    Returns the type to use for generic cast, or null if none required
  - genericTypeSignature
```
public char[] genericTypeSignature()
```
    Answer the receiver classfile signature. Arrays & base types do not distinguish between signature() & constantPoolName(). NOTE: This method should only be used during/after code gen.
  - getErasureCompatibleType
```
public TypeBinding getErasureCompatibleType(TypeBinding declaringClass)
```
    Return the supertype which would erase as a subtype of a given declaring class. If the receiver is already erasure compatible, then it will returned. If not, then will return the alternate lowest upper bound compatible with declaring class. NOTE: the declaringClass is already know to be compatible with the receiver
    
    Parameters:
    
    declaringClass - to look for
    
    Returns:
    
    the lowest erasure compatible type (considering alternate bounds)
  - getPackage
```
public abstract PackageBinding getPackage()
```
  - isAnonymousType
```
public final boolean isAnonymousType()
```
  - isArrayType
```
public final boolean isArrayType()
```
  - isBaseType
```
public final boolean isBaseType()
```
  - isPrimitiveType
```
public final boolean isPrimitiveType()
```
  - isPrimitiveOrBoxedPrimitiveType
```
public final boolean isPrimitiveOrBoxedPrimitiveType()
```
  - isBoxedPrimitiveType
```
public boolean isBoxedPrimitiveType()
```
  - isBoundParameterizedType
```
public boolean isBoundParameterizedType()
```
    Returns true if parameterized type AND not of the form List
  - isCapture
```
public boolean isCapture()
```
    Returns true if the type is the capture of some wildcard
  - isClass
```
public boolean isClass()
```
  - isCompatibleWith
```
public boolean isCompatibleWith(TypeBinding right)
```
  - isCompatibleWith
```
public abstract boolean isCompatibleWith(TypeBinding right,
                                         Scope scope)
```
  - isPotentiallyCompatibleWith
```
public boolean isPotentiallyCompatibleWith(TypeBinding right,
                                           Scope scope)
```
  - isBoxingCompatibleWith
```
public boolean isBoxingCompatibleWith(TypeBinding right,
                                      Scope scope)
```
  - isEnum
```
public boolean isEnum()
```
  - isEquivalentTo
```
public boolean isEquivalentTo(TypeBinding otherType)
```
    Returns true if a type is identical to another one, or for generic types, true if compared to its raw type.
  - isGenericType
```
public boolean isGenericType()
```
  - isHierarchyInconsistent
```
public final boolean isHierarchyInconsistent()
```
  - isInterface
```
public boolean isInterface()
```
  - isFunctionalInterface
```
public boolean isFunctionalInterface(Scope scope)
```
  - isIntersectionType
```
public boolean isIntersectionType()
```
    Returns true if the current type denotes an intersection type: Number & Comparable
  - isLocalType
```
public final boolean isLocalType()
```
  - isMemberType
```
public final boolean isMemberType()
```
  - isNestedType
```
public final boolean isNestedType()
```
  - isNumericType
```
public final boolean isNumericType()
```
  - isParameterizedType
```
public boolean isParameterizedType()
```
    Returns true if the type is parameterized, e.g. List. Note that some instances of ParameterizedTypeBinding have no arguments, like for non-generic members of a parameterized type. Use isParameterizedTypeWithActualArguments() instead to find out.
  - hasNullTypeAnnotations
```
public boolean hasNullTypeAnnotations()
```
    Does this type or any of its details (array dimensions, type arguments) have a null type annotation?
  - acceptsNonNullDefault
```
public boolean acceptsNonNullDefault()
```
    Used to implement this sentence from o.e.j.annotation.DefaultLocation: "Wildcards and the use of type variables are always excluded from NonNullByDefault."
  - isIntersectionType18
```
public boolean isIntersectionType18()
```
  - isParameterizedTypeWithActualArguments
```
public final boolean isParameterizedTypeWithActualArguments()
```
    Returns true if the type is parameterized, e.g. List Note that some instances of ParameterizedTypeBinding do answer false to isParameterizedType() in case they have no arguments, like for non-generic members of a parameterized type. i.e. isParameterizedType() is not equivalent to testing type.kind() == Binding.PARAMETERIZED_TYPE
  - isParameterizedWithOwnVariables
```
public boolean isParameterizedWithOwnVariables()
```
    Returns true if the type is parameterized using its own type variables as arguments
  - isProperType
```
public boolean isProperType(boolean admitCapture18)
```
    JLS8 Sect 18.1.1
    
    Parameters:
    
    admitCapture18 - request if CaptureBinding18 shuld be considered as a proper type. If unsure say 'true', only in Scope.greaterLowerBound(TypeBinding[], Scope, LookupEnvironment) CaptureBinding18 has to be excluded to prevent an NPE on a branch that heuristically tries to avoid inconsistent intersections.
  - isPolyType
```
public boolean isPolyType()
```
  - isProvablyDistinct
```
public boolean isProvablyDistinct(TypeBinding otherType)
```
    Returns true if a type is provably distinct from another one,
  - isRepeatableAnnotationType
```
public boolean isRepeatableAnnotationType()
```
    Answer true if the receiver is an annotation which may be repeatable. Overridden as appropriate.
  - isRawType
```
public final boolean isRawType()
```
  - isReifiable
```
public boolean isReifiable()
```
    JLS(3) 4.7. Note: Foo.Bar is also reifiable
  - isStatic
```
public boolean isStatic()
```
    Answer true if the receiver is a static member type (or toplevel)
  - isThrowable
```
public boolean isThrowable()
```
    Returns true if a given type may be thrown
  - isTypeArgumentContainedBy
```
public boolean isTypeArgumentContainedBy(TypeBinding otherType)
```
  - isTypeVariable
```
public boolean isTypeVariable()
```
    Returns true if the type was declared as a type variable
  - isUnboundWildcard
```
public boolean isUnboundWildcard()
```
    Returns true if wildcard type of the form '?' (no bound)
  - isUncheckedException
```
public boolean isUncheckedException(boolean includeSupertype)
```
    Returns true if the type is a subclass of java.lang.Error or java.lang.RuntimeException
  - isWildcard
```
public boolean isWildcard()
```
    Returns true if the type is a wildcard
  - kind
```
public int kind()
```
    Specified by:
    
    kind in class Binding
  - leafComponentType
```
public TypeBinding leafComponentType()
```
  - needsUncheckedConversion
```
public boolean needsUncheckedConversion(TypeBinding targetType)
```
    Meant to be invoked on compatible types, to figure if unchecked conversion is necessary
  - nullAnnotatedReadableName
```
public char[] nullAnnotatedReadableName(CompilerOptions options,
                                        boolean shortNames)
```
    Answer a readable name (for error reporting) that includes nullness type annotations.
  - original
```
public TypeBinding original()
```
    Returns the orignal generic type instantiated by the receiver type, or itself if not. This is similar to erasure process, except it doesn't erase type variable, wildcard, intersection types etc...
  - unannotated
```
public TypeBinding unannotated()
```
    Return this type minus its type annotations
  - withoutToplevelNullAnnotation
```
public TypeBinding withoutToplevelNullAnnotation()
```
    Return this type minus its toplevel null annotations. Any annotations on type arguments or bounds are retained.
  - hasTypeAnnotations
```
public final boolean hasTypeAnnotations()
```
  - qualifiedPackageName
```
public char[] qualifiedPackageName()
```
    Answer the qualified name of the receiver's package separated by periods or an empty string if its the default package. For example, {java.util}.
  - qualifiedSourceName
```
public abstract char[] qualifiedSourceName()
```
    Answer the source name for the type. In the case of member types, as the qualified name from its top level type. For example, for a member type N defined inside M & A: "A.M.N".
  - getTypeAnnotations
```
public final AnnotationBinding[] getTypeAnnotations()
```
    Returns:
    
    the JSR 308 annotations for this type.
  - setTypeAnnotations
```
public void setTypeAnnotations(AnnotationBinding[] annotations,
                               boolean evalNullAnnotations)
```
  - signableName
```
public char[] signableName()
```
  - signature
```
public char[] signature()
```
    Answer the receiver classfile signature. Arrays & base types do not distinguish between signature() & constantPoolName(). NOTE: This method should only be used during/after code gen.
  - sourceName
```
public abstract char[] sourceName()
```
  - swapUnresolved
```
public void swapUnresolved(UnresolvedReferenceBinding unresolvedType,
                           ReferenceBinding resolvedType,
                           LookupEnvironment environment)
```
  - typeVariables
```
public TypeVariableBinding[] typeVariables()
```
  - getSingleAbstractMethod
```
public MethodBinding getSingleAbstractMethod(Scope scope,
                                             boolean replaceWildcards)
```
    Return the single abstract method of a functional interface, or one of null or ReferenceBinding.samProblemBinding, if the receiver is not a functional interface as defined in JLS 9.8. In particular null is answered if the receiver is not a reference type, or is a problem type.
    
    Parameters:
    
    scope - scope
    
    replaceWildcards - Should wildcards be replaced following JLS 9.8? Say false for lambdas with explicit argument types which should apply 18.5.3
    
    Returns:
    
    The single abstract method of a functional interface, or one of null or ReferenceBinding.samProblemBinding, if the receiver is not a functional interface.
  - getIntersectingTypes
```
public ReferenceBinding[] getIntersectingTypes()
```
  - equalsEquals
```
public static boolean equalsEquals(TypeBinding that,
                                   TypeBinding other)
```
  - notEquals
```
public static boolean notEquals(TypeBinding that,
                                TypeBinding other)
```
  - prototype
```
public TypeBinding prototype()
```
    Return the primordial type from which the receiver was cloned. Not all types track a prototype, only SourceTypeBinding, BinaryTypeBinding and UnresolvedReferenceBinding do so as of now. In fact some types e.g ParameterizedTypeBinding should not do so. Deflecting a query to a prototype would lead to wrong results in the case of ParameterizedTypeBinding
  - isUnresolvedType
```
public boolean isUnresolvedType()
```
  - mentionsAny
```
public boolean mentionsAny(TypeBinding[] parameters,
                           int idx)
```
    Does this type mention any of the given type parameters, except the one at position 'idx'?
  - hasTypeBit
```
public boolean hasTypeBit(int bit)
```
    Answer an additional bit characterizing this type, like TypeIds.BitAutoCloseable.
  - sIsMoreSpecific
```
public boolean sIsMoreSpecific(TypeBinding s,
                               TypeBinding t,
                               Scope scope)
```
  - isSubtypeOf
```
public boolean isSubtypeOf(TypeBinding right)
```
  - getMethods
```
public MethodBinding[] getMethods(char[] selector)
```
  - canBeSeenBy
```
public boolean canBeSeenBy(Scope scope)
```
  - superclass
```
public ReferenceBinding superclass()
```
  - superInterfaces
```
public ReferenceBinding[] superInterfaces()
```
  - syntheticOuterLocalVariables
```
public SyntheticArgumentBinding[] syntheticOuterLocalVariables()
```
  - enterRecursiveFunction
```
public boolean enterRecursiveFunction()
```
    Call this before descending into type details to prevent infinite recursion.
    
    Returns:
    
    true if a recursion has already been started.
  - exitRecursiveFunction
```
public void exitRecursiveFunction()
```
    Exit the context of a potentially recursive function.
  - isFunctionalType
```
public boolean isFunctionalType()
```
  - updateTagBits
```
public long updateTagBits()
```
    Refresh some tagBits from details into the main type. Currently handled: TagBits.HasNullTypeAnnotation
  - isFreeTypeVariable
```
public boolean isFreeTypeVariable()
```

Class TypeBinding

Field Summary

Fields inherited from class org.aspectj.org.eclipse.jdt.internal.compiler.lookup.Binding

Constructor Summary

Method Summary

Methods inherited from class org.aspectj.org.eclipse.jdt.internal.compiler.lookup.Binding

Methods inherited from class java.lang.Object

Field Detail

id

tagBits

typeAnnotations

TYPE_USE_BINDING

INT

BYTE

SHORT

CHAR

LONG

FLOAT

DOUBLE

BOOLEAN

NULL

VOID

Constructor Detail

TypeBinding

TypeBinding

Method Detail

wellKnownType

actualType

annotatedDebugName

containerAnnotationType

canBeInstantiated

capture

uncapture

closestMatch

collectMissingTypes

collectSubstitutes

clone

constantPoolName

debugName

dimensions

depth

enclosingMethod

enclosingType

erasure

findSuperTypeOriginatingFrom

findSuperTypeOriginatingFrom

genericCast

genericTypeSignature

getErasureCompatibleType

getPackage

isAnonymousType

isArrayType

isBaseType

isPrimitiveType

isPrimitiveOrBoxedPrimitiveType

isBoxedPrimitiveType

isBoundParameterizedType

isCapture

isClass

isCompatibleWith

isCompatibleWith

isPotentiallyCompatibleWith

isBoxingCompatibleWith

isEnum

isEquivalentTo

isGenericType

isHierarchyInconsistent

isInterface

isFunctionalInterface

isIntersectionType

isLocalType

isMemberType

isNestedType

isNumericType

isParameterizedType

hasNullTypeAnnotations

acceptsNonNullDefault

isIntersectionType18

isParameterizedTypeWithActualArguments

isParameterizedWithOwnVariables