5e9e93c4a09e2b8ce84abde5783ad71824206ef0
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / core / dom / ITypeBinding.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2008 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Eclipse Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/epl-v10.html
7  *
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11
12 package net.sourceforge.phpdt.core.dom;
13
14 /**
15  * A type binding represents fully-resolved type. There are a number of
16  * different kinds of type bindings:
17  * <ul>
18  * <li>a class - represents the class declaration;
19  * possibly with type parameters</li>
20  * <li>an interface - represents the class declaration;
21  * possibly with type parameters</li>
22  * <li>an enum - represents the enum declaration (enum types do not have
23  * have type parameters)</li>
24  * <li>an annotation - represents the annotation type declaration
25  * (annotation types do not have have type parameters)</li>
26  * <li>an array type - array types are referenced but not explicitly
27  * declared</li>
28  * <li>a primitive type (including the special return type <code>void</code>)
29  * - primitive types are referenced but not explicitly declared</li>
30  * <li>the null type - this is the special type of <code>null</code></li>
31  * <li>a type variable - represents the declaration of a type variable;
32  * possibly with type bounds</li>
33  * <li>a wildcard type - represents a wild card used as a type argument in
34  * a parameterized type reference</li>
35  * <li>a raw type - represents a legacy non-parameterized reference to
36  * a generic type</li>
37  * <li>a parameterized type - represents an copy of a type declaration
38  * with substitutions for its type parameters</li>
39  * <li>a capture - represents a capture binding</li>
40  * </ul>
41  *
42  * @see ITypeBinding#getDeclaredTypes()
43  * @since 2.0
44  * @noimplement This interface is not intended to be implemented by clients.
45  */
46 public interface ITypeBinding extends IBinding {
47
48
49         /**
50          * Answer an array type binding using the receiver and the given dimension.
51          *
52          * <p>If the receiver is an array binding, then the resulting dimension is the given dimension
53          * plus the dimension of the receiver. Otherwise the resulting dimension is the given
54          * dimension.</p>
55          *
56          * @param dimension the given dimension
57          * @return an array type binding
58          * @throws IllegalArgumentException:<ul>
59          * <li>if the receiver represents the void type</li>
60          * <li>if the resulting dimensions is lower than one or greater than 255</li>
61          * </ul>
62          * @since 3.3
63          */
64         public ITypeBinding createArrayType(int dimension);
65
66         /**
67          * Returns the binary name of this type binding.
68          * The binary name of a class is defined in the Java Language
69          * Specification 3rd edition, section 13.1.
70          * <p>
71          * Note that in some cases, the binary name may be unavailable.
72          * This may happen, for example, for a local type declared in
73          * unreachable code.
74          * </p>
75          *
76          * @return the binary name of this type, or <code>null</code>
77          * if the binary name is unknown
78          * @since 3.0
79          */
80         public String getBinaryName();
81
82         /**
83          * Returns the bound of this wildcard type if it has one.
84          * Returns <code>null</code> if this is not a wildcard type.
85          *
86          * @return the bound of this wildcard type, or <code>null</code> if none
87          * @see #isWildcardType()
88          * @see #isUpperbound()
89          * @since 3.1
90          */
91         public ITypeBinding getBound();
92
93         /**
94          * Returns the binding representing the component type of this array type,
95          * or <code>null</code> if this is not an array type binding. The component
96          * type of an array might be an array type.
97          * <p>This is subject to change before 3.2 release.</p>
98          *
99          * @return the component type binding, or <code>null</code> if this is
100          *   not an array type
101          * @since 3.2
102          */
103         public ITypeBinding getComponentType();
104
105         /**
106          * Returns a list of bindings representing all the fields declared
107          * as members of this class, interface, or enum type.
108          * 
109          * <p>These include public, protected, default (package-private) access,
110          * and private fields declared by the class, but excludes inherited fields.
111          * Synthetic fields may or may not be included. Fields from binary types that
112          * reference unresolvable types may not be included.</p>
113          *
114          * <p>Returns an empty list if the class, interface, or enum declares no fields,
115          * and for other kinds of type bindings that do not directly have members.</p>
116          *
117          * <p>The resulting bindings are in no particular order.</p>
118          *
119          * @return the list of bindings for the field members of this type,
120          *   or the empty list if this type does not have field members
121          */
122         public IVariableBinding[] getDeclaredFields();
123
124         /**
125          * Returns a list of method bindings representing all the methods and
126          * constructors declared for this class, interface, enum, or annotation
127          * type.
128          * <p>These include public, protected, default (package-private) access,
129          * and private methods Synthetic methods and constructors may or may not be
130          * included. Returns an empty list if the class, interface, or enum,
131          * type declares no methods or constructors, if the annotation type declares
132          * no members, or if this type binding represents some other kind of type
133          * binding. Methods from binary types that reference unresolvable types may
134          * not be included.</p>
135          * <p>The resulting bindings are in no particular order.</p>
136          *
137          * @return the list of method bindings for the methods and constructors
138          *   declared by this class, interface, enum type, or annotation type,
139          *   or the empty list if this type does not declare any methods or constructors
140          */
141         public IMethodBinding[] getDeclaredMethods();
142
143         /**
144          * Returns the declared modifiers for this class or interface binding
145          * as specified in the original source declaration of the class or
146          * interface. The result may not correspond to the modifiers in the compiled
147          * binary, since the compiler may change them (in particular, for inner
148          * class emulation). The <code>getModifiers</code> method should be used if
149          * the compiled modifiers are needed. Returns -1 if this type does not
150          * represent a class or interface.
151          *
152          * @return the bit-wise or of <code>Modifier</code> constants
153          * @see #getModifiers()
154          * @see Modifier
155          */
156         public int getDeclaredModifiers();
157
158         /**
159          * Returns a list of type bindings representing all the types declared as
160          * members of this class, interface, or enum type.
161          * These include public, protected, default (package-private) access,
162          * and private classes, interfaces, enum types, and annotation types
163          * declared by the type, but excludes inherited types. Returns an empty
164          * list if the type declares no type members, or if this type
165          * binding represents an array type, a primitive type, a type variable,
166          * a wildcard type, a capture, or the null type.
167          * The resulting bindings are in no particular order.
168          *
169          * @return the list of type bindings for the member types of this type,
170          *   or the empty list if this type does not have member types
171          */
172         public ITypeBinding[] getDeclaredTypes();
173
174         /**
175          * Returns the type binding representing the class, interface, or enum
176          * that declares this binding.
177          * <p>
178          * The declaring class of a member class, interface, enum, annotation
179          * type is the class, interface, or enum type of which it is a member.
180          * The declaring class of a local class or interface (including anonymous
181          * classes) is the innermost class or interface containing the expression
182          * or statement in which this type is declared.
183          * </p>
184          * <p>The declaring class of a type variable is the class in which the type
185          * variable is declared if it is declared on a type. It returns
186          * <code>null</code> otherwise.
187          * </p>
188          * <p>The declaring class of a capture binding is the innermost class or
189          * interface containing the expression or statement in which this capture is
190          * declared.
191          * </p>
192          * <p>Array types, primitive types, the null type, top-level types,
193          * wildcard types, recovered binding have no declaring class.
194          * </p>
195          *
196          * @return the binding of the type that declares this type, or
197          * <code>null</code> if none
198          */
199         public ITypeBinding getDeclaringClass();
200
201         /**
202          * Returns the method binding representing the method that declares this binding
203          * of a local type or type variable.
204          * <p>
205          * The declaring method of a local class or interface (including anonymous
206          * classes) is the innermost method containing the expression or statement in
207          * which this type is declared. Returns <code>null</code> if the type
208          * is declared in an initializer.
209          * </p>
210          * <p>
211          * The declaring method of a type variable is the method in which the type
212          * variable is declared if it is declared on a method. It
213          * returns <code>null</code> otherwise.
214          * </p>
215          * <p>Array types, primitive types, the null type, top-level types,
216          * wildcard types, capture bindings, and recovered binding have no
217          * declaring method.
218          * </p>
219          *
220          * @return the binding of the method that declares this type, or
221          * <code>null</code> if none
222          * @since 3.1
223          */
224         public IMethodBinding getDeclaringMethod();
225
226         /**
227          * Returns the dimensionality of this array type, or <code>0</code> if this
228          * is not an array type binding.
229          *
230          * @return the number of dimension of this array type binding, or
231          *   <code>0</code> if this is not an array type
232          */
233         public int getDimensions();
234
235         /**
236          * Returns the binding representing the element type of this array type,
237          * or <code>null</code> if this is not an array type binding. The element
238          * type of an array is never itself an array type.
239          *
240          * @return the element type binding, or <code>null</code> if this is
241          *   not an array type
242          */
243         public ITypeBinding getElementType();
244
245         /**
246          * Returns the erasure of this type binding.
247          * <ul>
248          * <li>For parameterized types ({@link #isParameterizedType()})
249          * - returns the binding for the corresponding generic type.</li>
250          * <li>For raw types ({@link #isRawType()})
251          * - returns the binding for the corresponding generic type.</li>
252          * <li>For wildcard types ({@link #isWildcardType()})
253          * - returns the binding for the upper bound if it has one and
254          * java.lang.Object in other cases.</li>
255          * <li>For type variables ({@link #isTypeVariable()})
256          * - returns the binding for the erasure of the leftmost bound
257          * if it has bounds and java.lang.Object if it does not.</li>
258          * <li>For captures ({@link #isCapture()})
259          * - returns the binding for the erasure of the leftmost bound
260          * if it has bounds and java.lang.Object if it does not.</li>
261          * <li>For array types ({@link #isArray()}) - returns an array type of
262          * the same dimension ({@link #getDimensions()}) as this type
263          * binding for which the element type is the erasure of the element type
264          * ({@link #getElementType()}) of this type binding.</li>
265          * <li>For all other type bindings - returns the identical binding.</li>
266          * </ul>
267          *
268          * @return the erasure type binding
269          * @since 3.1
270          */
271         public ITypeBinding getErasure();
272
273         /**
274          * Returns a list of type bindings representing the direct superinterfaces
275          * of the class, interface, or enum type represented by this type binding.
276          * <p>
277          * If this type binding represents a class or enum type, the return value
278          * is an array containing type bindings representing all interfaces
279          * directly implemented by this class. The number and order of the interface
280          * objects in the array corresponds to the number and order of the interface
281          * names in the <code>implements</code> clause of the original declaration
282          * of this type.
283          * </p>
284          * <p>
285          * If this type binding represents an interface, the array contains
286          * type bindings representing all interfaces directly extended by this
287          * interface. The number and order of the interface objects in the array
288          * corresponds to the number and order of the interface names in the
289          * <code>extends</code> clause of the original declaration of this interface.
290          * </p>
291          * <p>
292          * If the class or enum implements no interfaces, or the interface extends
293          * no interfaces, or if this type binding represents an array type, a
294          * primitive type, the null type, a type variable, an annotation type,
295          * a wildcard type, or a capture binding, this method returns an array of
296      * length 0.
297          * </p>
298          *
299          * @return the list of type bindings for the interfaces extended by this
300          *   class or enum, or interfaces extended by this interface, or otherwise
301          *   the empty list
302          */
303         public ITypeBinding[] getInterfaces();
304
305         /**
306          * Returns the compiled modifiers for this class, interface, enum,
307          * or annotation type binding.
308          * The result may not correspond to the modifiers as declared in the
309          * original source, since the compiler may change them (in particular,
310          * for inner class emulation). The <code>getDeclaredModifiers</code> method
311          * should be used if the original modifiers are needed.
312          * Returns 0 if this type does not represent a class, an interface, an enum, an annotation
313          * type or a recovered type.
314          *
315          * @return the compiled modifiers for this type binding or 0
316          * if this type does not represent a class, an interface, an enum, an annotation
317          * type or a recovered type.
318          * @see #getDeclaredModifiers()
319          */
320         public int getModifiers();
321
322         /**
323          * Returns the unqualified name of the type represented by this binding
324          * if it has one.
325          * <ul>
326          * <li>For top-level types, member types, and local types,
327          * the name is the simple name of the type.
328          * Example: <code>"String"</code> or <code>"Collection"</code>.
329          * Note that the type parameters of a generic type are not included.</li>
330          * <li>For primitive types, the name is the keyword for the primitive type.
331          * Example: <code>"int"</code>.</li>
332          * <li>For the null type, the name is the string "null".</li>
333          * <li>For anonymous classes, which do not have a name,
334          * this method returns an empty string.</li>
335          * <li>For array types, the name is the unqualified name of the component
336          * type (as computed by this method) followed by "[]".
337          * Example: <code>"String[]"</code>. Note that the component type is never an
338          * an anonymous class.</li>
339          * <li>For type variables, the name is just the simple name of the
340          * type variable (type bounds are not included).
341          * Example: <code>"X"</code>.</li>
342          * <li>For type bindings that correspond to particular instances of a generic
343          * type arising from a parameterized type reference,
344          * the name is the unqualified name of the erasure type (as computed by this method)
345          * followed by the names (again, as computed by this method) of the type arguments
346          * surrounded by "&lt;&gt;" and separated by ",".
347          * Example: <code>"Collection&lt;String&gt;"</code>.
348          * </li>
349          * <li>For type bindings that correspond to particular instances of a generic
350          * type arising from a raw type reference, the name is the unqualified name of
351          * the erasure type (as computed by this method).
352          * Example: <code>"Collection"</code>.</li>
353          * <li>For wildcard types, the name is "?" optionally followed by
354          * a single space followed by the keyword "extends" or "super"
355          * followed a single space followed by the name of the bound (as computed by
356          * this method) when present.
357          * Example: <code>"? extends InputStream"</code>.
358          * </li>
359      * <li>Capture types do not have a name. For these types,
360      * and array types thereof, this method returns an empty string.</li>
361          * </ul>
362          *
363          * @return the unqualified name of the type represented by this binding,
364          * or the empty string if it has none
365          * @see #getQualifiedName()
366          */
367         public String getName();
368
369         /**
370          * Returns the binding for the package in which this type is declared.
371          *
372          * <p>The package of a recovered type reference binding is either
373          * the package of the enclosing type, or, if the type name is the name of a
374          * {@linkplain AST#resolveWellKnownType(String) well-known type},
375          * the package of the matching well-known type.</p>
376          * 
377          * @return the binding for the package in which this class, interface,
378          * enum, or annotation type is declared, or <code>null</code> if this type
379          * binding represents a primitive type, an array type, the null type,
380          * a type variable, a wildcard type, a capture binding.
381          */
382         public IPackageBinding getPackage();
383
384         /**
385          * Returns the fully qualified name of the type represented by this
386          * binding if it has one.
387          * <ul>
388          * <li>For top-level types, the fully qualified name is the simple name of
389          * the type preceded by the package name (or unqualified if in a default package)
390          * and a ".".
391          * Example: <code>"java.lang.String"</code> or <code>"java.util.Collection"</code>.
392          * Note that the type parameters of a generic type are not included.</li>
393          * <li>For members of top-level types, the fully qualified name is the
394          * simple name of the type preceded by the fully qualified name of the
395          * enclosing type (as computed by this method) and a ".".
396          * Example: <code>"java.io.ObjectInputStream.GetField"</code>.
397          * If the binding is for a member type that corresponds to a particular instance
398          * of a generic type arising from a parameterized type reference, the simple
399          * name of the type is followed by the fully qualified names of the type arguments
400          * (as computed by this method) surrounded by "&lt;&gt;" and separated by ",".
401          * Example: <code>"pkg.Outer.Inner&lt;java.lang.String&gt;"</code>.
402          * </li>
403          * <li>For primitive types, the fully qualified name is the keyword for
404          * the primitive type.
405          * Example: <code>"int"</code>.</li>
406          * <li>For the null type, the fully qualified name is the string
407          * "null".</li>
408          * <li>Local types (including anonymous classes) and members of local
409          * types do not have a fully qualified name. For these types, and array
410          * types thereof, this method returns an empty string.</li>
411          * <li>For array types whose component type has a fully qualified name,
412          * the fully qualified name is the fully qualified name of the component
413          * type (as computed by this method) followed by "[]".
414          * Example: <code>"java.lang.String[]"</code>.</li>
415          * <li>For type variables, the fully qualified name is just the name of the
416          * type variable (type bounds are not included).
417          * Example: <code>"X"</code>.</li>
418          * <li>For type bindings that correspond to particular instances of a generic
419          * type arising from a parameterized type reference,
420          * the fully qualified name is the fully qualified name of the erasure
421          * type followed by the fully qualified names of the type arguments surrounded by "&lt;&gt;" and separated by ",".
422          * Example: <code>"java.util.Collection&lt;java.lang.String&gt;"</code>.
423          * </li>
424          * <li>For type bindings that correspond to particular instances of a generic
425          * type arising from a raw type reference,
426          * the fully qualified name is the fully qualified name of the erasure type.
427          * Example: <code>"java.util.Collection"</code>. Note that the
428          * the type parameters are omitted.</li>
429          * <li>For wildcard types, the fully qualified name is "?" optionally followed by
430          * a single space followed by the keyword "extends" or "super"
431          * followed a single space followed by the fully qualified name of the bound
432          * (as computed by this method) when present.
433          * Example: <code>"? extends java.io.InputStream"</code>.
434          * </li>
435     * <li>Capture types do not have a fully qualified name. For these types,
436     * and array types thereof, this method returns an empty string.</li>
437          * </ul>
438          *
439          * @return the fully qualified name of the type represented by this
440          *    binding, or the empty string if it has none
441          * @see #getName()
442          * @since 2.1
443          */
444         public String getQualifiedName();
445
446         /**
447          * Returns the type binding for the superclass of the type represented
448          * by this class binding.
449          * <p>
450          * If this type binding represents any class other than the class
451          * <code>java.lang.Object</code>, then the type binding for the direct
452          * superclass of this class is returned. If this type binding represents
453          * the class <code>java.lang.Object</code>, then <code>null</code> is
454          * returned.
455          * <p>
456          * Loops that ascend the class hierarchy need a suitable termination test.
457          * Rather than test the superclass for <code>null</code>, it is more
458          * transparent to check whether the class is <code>Object</code>, by
459          * comparing whether the class binding is identical to
460          * <code>ast.resolveWellKnownType("java.lang.Object")</code>.
461          * </p>
462          * <p>
463          * If this type binding represents an interface, an array type, a
464          * primitive type, the null type, a type variable, an enum type,
465          * an annotation type, a wildcard type, or a capture binding then
466          * <code>null</code> is returned.
467          * </p>
468          *
469          * @return the superclass of the class represented by this type binding,
470          *    or <code>null</code> if none
471          * @see AST#resolveWellKnownType(String)
472          */
473         public ITypeBinding getSuperclass();
474
475         /**
476          * Returns the type arguments of this generic type instance, or the
477          * empty list for other type bindings.
478          * <p>
479          * Note that type arguments only occur on a type binding that represents
480          * an instance of a generic type corresponding to a parameterized type
481          * reference (e.g., <code>Collection&lt;String&gt;</code>).
482          * Do not confuse these with type parameters which only occur on the
483          * type binding corresponding directly to the declaration of the
484          * generic class or interface (e.g., <code>Collection&lt;T&gt;</code>).
485          * </p>
486          *
487          * @return the list of type bindings for the type arguments used to
488          * instantiate the corresponding generic type, or otherwise the empty list
489          * @see #getTypeDeclaration()
490          * @see #isGenericType()
491          * @see #isParameterizedType()
492          * @see #isRawType()
493          * @since 3.1
494          */
495         public ITypeBinding[] getTypeArguments();
496
497         /**
498          * Returns the declared type bounds of this type variable or capture. If the
499          * variable or the capture had no explicit bound, then it returns an empty list.
500      * <p>
501      * Note that per construction, it can only contain one class or array type,
502      * at most, and then it is located in first position.
503      * </p>
504      * <p>
505      * Also note that array type bound may only occur in the case of a capture
506      * binding, e.g. <code>capture-of ? extends Object[]</code>
507      * </p>
508          *
509          * @return the list of type bindings for this type variable or capture,
510      * or otherwise the empty list
511          * @see #isCapture()
512          * @see #isTypeVariable()
513          * @since 3.1
514          */
515         public ITypeBinding[] getTypeBounds();
516
517         /**
518          * Returns the binding for the type declaration corresponding to this type
519          * binding.
520          * <p>For parameterized types ({@link #isParameterizedType()})
521          * and most raw types ({@link #isRawType()}), this method returns the binding
522          * for the corresponding generic type.</p>
523          * <p>For raw member types ({@link #isRawType()}, {@link #isMember()})
524          * of a raw declaring class, the type declaration is a generic or a non-generic
525          * type.</p>
526          * <p>A different non-generic binding will be returned when one of the declaring
527          * types/methods was parameterized.</p>
528          * <p>For other type bindings, this returns the same binding.</p>
529          *
530          * @return the type binding
531          * @since 3.1
532          */
533         public ITypeBinding getTypeDeclaration();
534
535         /**
536          * Returns the type parameters of this class or interface type binding.
537          * <p>
538          * Note that type parameters only occur on the binding of the
539          * declaring generic class or interface; e.g., <code>Collection&lt;T&gt;</code>.
540          * Type bindings corresponding to a raw or parameterized reference to a generic
541          * type do not carry type parameters (they instead have non-empty type arguments
542          * and non-trivial erasure).
543          * </p>
544          *
545          * @return the list of binding for the type variables for the type
546          * parameters of this type, or otherwise the empty list
547          * @see #isTypeVariable()
548          * @since 3.1
549          */
550         // TODO (jeem) - clarify whether binding for a generic type instance carries a copy of the generic type's type parameters as well as type arguments
551         public ITypeBinding[] getTypeParameters();
552
553         /**
554          * Returns the corresponding wildcard binding of this capture binding.
555      * Returns <code>null</code> if this type bindings does not represent
556      * a capture binding.
557          *
558          * @return the corresponding wildcard binding for a capture
559          * binding, <code>null</code> otherwise
560          * @since 3.1
561          */
562         public ITypeBinding getWildcard();
563
564         /**
565          * Returns whether this type binding represents an annotation type.
566          * <p>
567          * Note that an annotation type is always an interface.
568          * </p>
569          *
570          * @return <code>true</code> if this object represents an annotation type,
571          *    and <code>false</code> otherwise
572          * @since 3.1
573          */
574         public boolean isAnnotation();
575
576         /**
577          * Returns whether this type binding represents an anonymous class.
578          * <p>
579          * An anonymous class is a subspecies of local class, and therefore mutually
580          * exclusive with member types. Note that anonymous classes have no name
581          * (<code>getName</code> returns the empty string).
582          * </p>
583          *
584          * @return <code>true</code> if this type binding is for an anonymous class,
585          *   and <code>false</code> otherwise
586          */
587         public boolean isAnonymous();
588
589         /**
590          * Returns whether this type binding represents an array type.
591          *
592          * @return <code>true</code> if this type binding is for an array type,
593          *   and <code>false</code> otherwise
594          * @see #getElementType()
595          * @see #getDimensions()
596          */
597         public boolean isArray();
598
599         /**
600          * Returns whether an expression of this type can be assigned to a variable
601          * of the given type, as specified in section 5.2 of <em>The Java Language
602          * Specification, Third Edition</em> (JLS3).
603          *
604          * <p>If the receiver or the argument is a recovered type, the answer is always false,
605          * unless the two types are identical or the argument is <code>java.lang.Object</code>.</p>
606          *
607          * @param variableType the type of a variable to check compatibility against
608          * @return <code>true</code> if an expression of this type can be assigned to a
609          *   variable of the given type, and <code>false</code> otherwise
610          * @since 3.1
611          */
612         public boolean isAssignmentCompatible(ITypeBinding variableType);
613
614         /**
615          * Returns whether this type binding represents a capture binding.
616          * <p>
617          * Capture bindings result from capture conversion as specified
618          * in section 5.1.10 of <em>The Java Language Specification,
619          * Third Edition</em> (JLS3).
620          * </p>
621          * <p>
622          * A capture binding may have upper bounds and a lower bound.
623          * Upper bounds may be accessed using {@link #getTypeBounds()},
624          * the lower bound must be accessed indirectly through the associated
625          * wildcard {@link #getWildcard()} when it is a lower bound wildcard.
626          * </p>
627          * <p>
628          * Note that capture bindings are distinct from type variables
629      * (even though they are often depicted as synthetic type
630      * variables); as such, {@link #isTypeVariable()} answers
631      * <code>false</code> for capture bindings, and
632      * {@link #isCapture()} answers <code>false</code> for type variables.
633          * </p>
634      *
635          * @return <code>true</code> if this type binding is a capture,
636          *   and <code>false</code> otherwise
637          * @see #getTypeBounds()
638          * @see #getWildcard()
639          * @since 3.1
640          */
641         public boolean isCapture();
642
643         /**
644          * Returns whether this type is cast compatible with the given type,
645          * as specified in section 5.5 of <em>The Java Language
646          * Specification, Third Edition</em> (JLS3).
647          * <p>
648          * NOTE: The cast compatibility check performs backwards.
649          * When testing whether type B can be cast to type A, one would use:
650          * <code>A.isCastCompatible(B)</code>
651          * </p>
652          *
653          * <p>If the receiver or the argument is a recovered type, the answer is always false,
654          * unless the two types are identical or the argument is <code>java.lang.Object</code>.</p>
655          *
656          * @param type the type to check compatibility against
657          * @return <code>true</code> if this type is cast compatible with the
658          * given type, and <code>false</code> otherwise
659          * @since 3.1
660          */
661         public boolean isCastCompatible(ITypeBinding type);
662
663         /**
664          * Returns whether this type binding represents a class type or a recovered binding.
665          *
666          * @return <code>true</code> if this object represents a class or a recovered binding,
667          *    and <code>false</code> otherwise
668          */
669         public boolean isClass();
670
671         /**
672          * Returns whether this type binding represents an enum type.
673          *
674          * @return <code>true</code> if this object represents an enum type,
675          *    and <code>false</code> otherwise
676          * @since 3.1
677          */
678         public boolean isEnum();
679
680         /**
681          * Returns whether this type binding originated in source code.
682          * Returns <code>false</code> for all primitive types, the null type,
683          * array types, and for all classes, interfaces, enums, annotation
684          * types, type variables, parameterized type references,
685          * raw type references, wildcard types, and capture bindings
686      * whose information came from a pre-compiled binary class file.
687          *
688          * @return <code>true</code> if the type is in source code,
689          *    and <code>false</code> otherwise
690          */
691         public boolean isFromSource();
692
693         /**
694          * Returns whether this type binding represents a declaration of
695          * a generic class or interface.
696          * <p>
697          * Note that type parameters only occur on the binding of the
698          * declaring generic class or interface; e.g., <code>Collection&lt;T&gt;</code>.
699          * Type bindings corresponding to a raw or parameterized reference to a generic
700          * type do not carry type parameters (they instead have non-empty type arguments
701          * and non-trivial erasure).
702          * This method is fully equivalent to <code>getTypeParameters().length &gt; 0)</code>.
703          * </p>
704          * <p>
705          * Note that {@link #isGenericType()},
706          * {@link #isParameterizedType()},
707          * and {@link #isRawType()} are mutually exclusive.
708          * </p>
709          *
710          * @return <code>true</code> if this type binding represents a
711          * declaration of a generic class or interface, and <code>false</code> otherwise
712          * @see #getTypeParameters()
713          * @since 3.1
714          */
715         public boolean isGenericType();
716
717         /**
718          * Returns whether this type binding represents an interface type.
719          * <p>
720          * Note that an interface can also be an annotation type.
721          * </p>
722          *
723          * @return <code>true</code> if this object represents an interface,
724          *    and <code>false</code> otherwise
725          */
726         public boolean isInterface();
727
728         /**
729          * Returns whether this type binding represents a local class.
730          * <p>
731          * A local class is any nested class or enum type not declared as a member
732          * of another class or interface. A local class is a subspecies of nested
733          * type, and mutually exclusive with member types. Note that anonymous
734          * classes are a subspecies of local classes.
735          * </p>
736          * <p>
737          * Also note that interfaces and annotation types cannot be local.
738          * </p>
739          *
740          * @return <code>true</code> if this type binding is for a local class or
741          * enum type, and <code>false</code> otherwise
742          */
743         public boolean isLocal();
744
745         /**
746          * Returns whether this type binding represents a member class or
747          * interface.
748          * <p>
749          * A member type is any type declared as a member of
750          * another type. A member type is a subspecies of nested
751          * type, and mutually exclusive with local types.
752          * </p>
753          *
754          * @return <code>true</code> if this type binding is for a member class,
755          *   interface, enum, or annotation type, and <code>false</code> otherwise
756          */
757         public boolean isMember();
758
759         /**
760          * Returns whether this type binding represents a nested class, interface,
761          * enum, or annotation type.
762          * <p>
763          * A nested type is any type whose declaration occurs within
764          * the body of another. The set of nested types is disjoint from the set of
765          * top-level types. Nested types further subdivide into member types, local
766          * types, and anonymous types.
767          * </p>
768          *
769          * @return <code>true</code> if this type binding is for a nested class,
770          *   interface, enum, or annotation type, and <code>false</code> otherwise
771          */
772         public boolean isNested();
773
774         /**
775          * Returns whether this type binding represents the null type.
776          * <p>
777          * The null type is the type of a <code>NullLiteral</code> node.
778          * </p>
779          *
780          * @return <code>true</code> if this type binding is for the null type,
781          *   and <code>false</code> otherwise
782          */
783         public boolean isNullType();
784
785         /**
786          * Returns whether this type binding represents an instance of
787          * a generic type corresponding to a parameterized type reference.
788          * <p>
789          * For example, an AST type like
790          * <code>Collection&lt;String&gt;</code> typically resolves to a
791          * type binding whose type argument is the type binding for the
792          * class <code>java.lang.String</code> and whose erasure is the type
793          * binding for the generic type <code>java.util.Collection</code>.
794          * </p>
795          * <p>
796          * Note that {@link #isGenericType()},
797          * {@link #isParameterizedType()},
798          * and {@link #isRawType()} are mutually exclusive.
799          * </p>
800          *
801          * @return <code>true</code> if this type binding represents a
802          * an instance of a generic type corresponding to a parameterized
803          * type reference, and <code>false</code> otherwise
804          * @see #getTypeArguments()
805          * @see #getTypeDeclaration()
806          * @since 3.1
807          */
808         public boolean isParameterizedType();
809
810         /**
811          * Returns whether this type binding represents a primitive type.
812          * <p>
813          * There are nine predefined type bindings to represent the eight primitive
814          * types and <code>void</code>. These have the same names as the primitive
815          * types that they represent, namely boolean, byte, char, short, int,
816          * long, float, and double, and void.
817          * </p>
818          *
819          * @return <code>true</code> if this type binding is for a primitive type,
820          *   and <code>false</code> otherwise
821          */
822         public boolean isPrimitive();
823
824         /**
825          * Returns whether this type binding represents an instance of
826          * a generic type corresponding to a raw type reference.
827          * <p>
828          * For example, an AST type like
829          * <code>Collection</code> typically resolves to a
830          * type binding whose type argument is the type binding for
831          * the class <code>java.lang.Object</code> (the
832          * default bound for the single type parameter of
833          * <code>java.util.Collection</code>) and whose erasure is the
834          * type binding for the generic type
835          * <code>java.util.Collection</code>.
836          * </p>
837          * <p>
838          * Note that {@link #isGenericType()},
839          * {@link #isParameterizedType()},
840          * and {@link #isRawType()} are mutually exclusive.
841          * </p>
842          *
843          * @return <code>true</code> if this type binding represents a
844          * an instance of a generic type corresponding to a raw
845          * type reference, and <code>false</code> otherwise
846          * @see #getTypeDeclaration()
847          * @see #getTypeArguments()
848          * @since 3.1
849          */
850         public boolean isRawType();
851
852         /**
853          * Returns whether this type is subtype compatible with the given type,
854          * as specified in section 4.10 of <em>The Java Language
855          * Specification, Third Edition</em> (JLS3).
856          *
857          * <p>If the receiver or the argument is a recovered type, the answer is always false,
858          * unless the two types are identical or the argument is <code>java.lang.Object</code>.</p>
859          *
860          * @param type the type to check compatibility against
861          * @return <code>true</code> if this type is subtype compatible with the
862          * given type, and <code>false</code> otherwise
863          * @since 3.1
864          */
865         public boolean isSubTypeCompatible(ITypeBinding type);
866
867         /**
868          * Returns whether this type binding represents a top-level class,
869          * interface, enum, or annotation type.
870          * <p>
871          * A top-level type is any type whose declaration does not occur within the
872          * body of another type declaration. The set of top level types is disjoint
873          * from the set of nested types.
874          * </p>
875          *
876          * @return <code>true</code> if this type binding is for a top-level class,
877          *   interface, enum, or annotation type, and <code>false</code> otherwise
878          */
879         public boolean isTopLevel();
880
881         /**
882          * Returns whether this type binding represents a type variable.
883          * Type variables bindings carry the type variable's bounds.
884      * <p>
885      * Note that type variables are distinct from capture bindings
886      * (even though capture bindings are often depicted as synthetic
887      * type variables); as such, {@link #isTypeVariable()} answers
888      * <code>false</code> for capture bindings, and
889      * {@link #isCapture()} answers <code>false</code> for type variables.
890      * </p>
891          *
892          * @return <code>true</code> if this type binding is for a type variable,
893          *   and <code>false</code> otherwise
894          * @see #getName()
895          * @see #getTypeBounds()
896          * @since 3.1
897          */
898         public boolean isTypeVariable();
899
900         /**
901          * Returns whether this wildcard type is an upper bound
902          * ("extends") as opposed to a lower bound ("super").
903          * Note that this property is only relevant for wildcards
904          * that have a bound.
905          *
906          * @return <code>true</code> if this wildcard type has a bound that is
907          * an upper bound, and <code>false</code> in all other cases
908          * @see #isWildcardType()
909          * @see #getBound()
910          * @since 3.1
911          */
912         public boolean isUpperbound();
913
914         /**
915          * Returns whether this type binding represents a wildcard type. A wildcard
916          * type occus only as an argument to a parameterized type reference.
917          * <p>
918          * For example, a AST type like
919          * <code>Collection&lt;? extends Object&gt;</code> typically resolves to a
920          * parameterized type binding whose type argument is a wildcard type
921          * with upper type bound <code>java.util.Object</code>.
922          * </p>
923          *
924          * @return <code>true</code> if this object represents a wildcard type,
925          *    and <code>false</code> otherwise
926          * @since 3.1
927          * @see #getBound()
928          * @see #isUpperbound()
929          */
930         public boolean isWildcardType();
931 }