Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2013 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html Contributors: IBM Corporation - initial API and implementation Stephan Herrmann - Contributions for bug 349326 - [1.7] new warning for missing try-with-resources bug 186342 - [compiler][null] Using annotations for null checking bug 365519 - editorial cleanup after bug 186342 and bug 365387 bug 358903 - Filter practically unimportant resource leak warnings bug 365531 - [compiler][null] investigate alternative strategy for internally encoding nullness defaults bug 388281 - [compiler][null] inheritance of null annotations as an option bug 395002 - Self bound generic class doesn't resolve bounds properly for wildcards for certain parametrisation. bug 400421 - [compiler] Null analysis for fields does not take

Com.google.inject.Inject:
into account bug 382069 - [null] Make the null analysis consider JUnit's assertNotNull similarly to assertions /
  
  package org.eclipse.jdt.internal.compiler.lookup;
  
  import java.util.Arrays;
  
  
  /*
  Not all fields defined by this type (& its subclasses) are initialized when it is created.
  Some are initialized only when needed.
  
  Accessors have been provided for some public fields so all TypeBindings have the same API...
  but access public fields directly whenever possible.
  Non-public fields have accessors which should be used everywhere you expect the field to be initialized.
  
  null is NOT a valid value for a non-public field... it just means the field is not initialized.
  */
  
  abstract public class ReferenceBinding extends TypeBinding {
  
  	public char[][] compoundName;
  	public char[] sourceName;
  	public int modifiers;
  	public PackageBinding fPackage;
  	char[] fileName;
  	char[] constantPoolName;
  	char[] signature;
  
  
  	int typeBits// additional bits characterizing this type
  
  	public static final ReferenceBinding LUB_GENERIC = new ReferenceBinding() { /* used for lub computation */
  		public boolean hasTypeBit(int bit) { return false; }
  	};
  
  	private static final Comparator FIELD_COMPARATOR = new Comparator() {
  		public int compare(Object o1Object o2) {
  			char[] n1 = ((FieldBindingo1).;
  			char[] n2 = ((FieldBindingo2).;
  			return ReferenceBinding.compare(n1n2n1.lengthn2.length);
  		}
  	};
  	private static final Comparator METHOD_COMPARATOR = new Comparator() {
  		public int compare(Object o1Object o2) {
  			MethodBinding m1 = (MethodBindingo1;
  			MethodBinding m2 = (MethodBindingo2;
  			char[] s1 = m1.selector;
  			char[] s2 = m2.selector;
  			int c = ReferenceBinding.compare(s1s2s1.lengths2.length);
  			return c == 0 ? m1.parameters.length - m2.parameters.length : c;
  		}
  	};
  
  public static FieldBinding binarySearch(char[] nameFieldBinding[] sortedFields) {
  	if (sortedFields == null)
  		return null;
  	int max = sortedFields.length;
  	if (max == 0)
  		return null;
  	int left = 0, right = max - 1, nameLength = name.length;
  	int mid = 0;
  	char[] midName;
  	while (left <= right) {
  		mid = left + (right - left) /2;
  		int compare = compare(namemidName = sortedFields[mid].nameLengthmidName.length);
  		if (compare < 0) {
  			right = mid-1;
  		} else if (compare > 0) {
  			left = mid+1;
  		} else {
  			return sortedFields[mid];
  		}
  	}
  	return null;
  }

Returns a combined range value representing: (start + (end<<32)), where start is the index of the first matching method (remember methods are sorted alphabetically on selectors), and end is the index of last contiguous methods with same selector. -1 means no method got found

Parameters:
selector
sortedMethods
Returns:
(start + (end<<32)) or -1 if no method found
 
 public static long binarySearch(char[] selectorMethodBinding[] sortedMethods) {
 	if (sortedMethods == null)
 		return -1;
 	int max = sortedMethods.length;
 	if (max == 0)
 		return -1;
 	int left = 0, right = max - 1, selectorLength = selector.length;
 	int mid = 0;
 	char[] midSelector;
 	while (left <= right) {
 		mid = left + (right - left) /2;
 		int compare = compare(selectormidSelector = sortedMethods[mid].selectorLengthmidSelector.length);
 		if (compare < 0) {
 			right = mid-1;
 		} else if (compare > 0) {
 			left = mid+1;
 		} else {
 			int start = midend = mid;
 			// find first method with same selector
 			while (start > left && CharOperation.equals(sortedMethods[start-1].selector)){ start--; }
 			// find last method with same selector
 			while (end < right && CharOperation.equals(sortedMethods[end+1].selector)){ end++; }
 			return start + ((long)end<< 32);
 		}
 	}
 	return -1;
 }

Compares two strings lexicographically. The comparison is based on the Unicode value of each character in the strings.

Returns:
the value 0 if the str1 is equal to str2; a value less than 0 if str1 is lexicographically less than str2; and a value greater than 0 if str1 is lexicographically greater than str2.
 
 static int compare(char[] str1char[] str2int len1int len2) {
 	int n= Math.min(len1len2);
 	int i= 0;
 	while (n-- != 0) {
 		char c1str1[i];
 		char c2str2[i++];
 		if (c1 != c2) {
 			return c1 - c2;
 		}
 	}
 	return len1 - len2;
 }

Sort the field array using a quicksort
 
 public static void sortFields(FieldBinding[] sortedFieldsint leftint right) {
 	Arrays.sort(sortedFieldsleftright);
 }

Sort the field array using a quicksort
 
 public static void sortMethods(MethodBinding[] sortedMethodsint leftint right) {
 	Arrays.sort(sortedMethodsleftright);
 }

Return the array of resolvable fields (resilience)
 
 	return fields();
 }

Return the array of resolvable methods (resilience)
 
 	return methods();
 }

Answer true if the receiver can be instantiated
 
 public boolean canBeInstantiated() {
 }

Answer true if the receiver is visible to the invocationPackage.
 
 public final boolean canBeSeenBy(PackageBinding invocationPackage) {
 	if (isPublic()) return true;
 	if (isPrivate()) return false;
 
 	// isProtected() or isDefault()
 	return invocationPackage == this.;
 }

Answer true if the receiver is visible to the receiverType and the invocationType.
 
 public final boolean canBeSeenBy(ReferenceBinding receiverTypeReferenceBinding invocationType) {
 	if (isPublic()) return true;
 
 	if (invocationType == this && invocationType == receiverTypereturn true;
 
 	if (isProtected()) {
 		// answer true if the invocationType is the declaringClass or they are in the same package
 		// OR the invocationType is a subclass of the declaringClass
 		//    AND the invocationType is the invocationType or its subclass
 		//    OR the type is a static method accessed directly through a type
 		//    OR previous assertions are true for one of the enclosing type
 		if (invocationType == thisreturn true;
 		if (invocationType.fPackage == this.return true;
 
 		TypeBinding currentType = invocationType.erasure();
 		TypeBinding declaringClass = enclosingType().erasure(); // protected types always have an enclosing one
 		if (declaringClass == invocationTypereturn true;
 		if (declaringClass == nullreturn false// could be null if incorrect top-level protected type
 		//int depth = 0;
 		do {
 			if (currentType.findSuperTypeOriginatingFrom(declaringClass) != nullreturn true;
 			//depth++;
 			currentType = currentType.enclosingType();
 		} while (currentType != null);
 		return false;
 	}
 
 	if (isPrivate()) {
 		// answer true if the receiverType is the receiver or its enclosingType
 		// AND the invocationType and the receiver have a common enclosingType
 		receiverCheck: {
 			if (!(receiverType == this || receiverType == enclosingType())) {
 				// special tolerance for type variable direct bounds, but only if compliance <= 1.6, see: https://bugs.eclipse.org/bugs/show_bug.cgi?id=334622
 				if (receiverType.isTypeVariable()) {
 					TypeVariableBinding typeVariable = (TypeVariableBindingreceiverType;
 					if (typeVariable.environment.globalOptions.complianceLevel <= . && (typeVariable.isErasureBoundTo(erasure()) || typeVariable.isErasureBoundTo(enclosingType().erasure())))
 						break receiverCheck;
 				}
 				return false;
 			}
 		}
 
 		if (invocationType != this) {
 			ReferenceBinding outerInvocationType = invocationType;
 			ReferenceBinding temp = outerInvocationType.enclosingType();
 			while (temp != null) {
 				outerInvocationType = temp;
 				temp = temp.enclosingType();
 			}
 
 			ReferenceBinding outerDeclaringClass = (ReferenceBinding)erasure();
 			temp = outerDeclaringClass.enclosingType();
 			while (temp != null) {
 				outerDeclaringClass = temp;
 				temp = temp.enclosingType();
 			}
 			if (outerInvocationType != outerDeclaringClassreturn false;
 		}
 		return true;
 	}
 
 	// isDefault()
 	if (invocationType.fPackage != this.return false;
 
 	ReferenceBinding currentType = receiverType;
 	TypeBinding originalDeclaringClass = (enclosingType() == null ? this : enclosingType()).original();
 	do {
 		if (currentType.isCapture()) {  // https://bugs.eclipse.org/bugs/show_bug.cgi?id=285002
 			if (originalDeclaringClass == currentType.erasure().original()) return true;
 		} else { 
 			if (originalDeclaringClass == currentType.original()) return true;
 		}
 		PackageBinding currentPackage = currentType.fPackage;
 		// package could be null for wildcards/intersection types, ignore and recurse in superclass
 		if (currentPackage != null && currentPackage != this.return false;
 	} while ((currentType = currentType.superclass()) != null);
 	return false;
 }

Answer true if the receiver is visible to the type provided by the scope.
 
 public final boolean canBeSeenBy(Scope scope) {
 	if (isPublic()) return true;
 
 	SourceTypeBinding invocationType = scope.enclosingSourceType();
 	if (invocationType == thisreturn true;
 
 	if (invocationType == null// static import call
 		return !isPrivate() && scope.getCurrentPackage() == this.;
 
 	if (isProtected()) {
 		// answer true if the invocationType is the declaringClass or they are in the same package
 		// OR the invocationType is a subclass of the declaringClass
 		//    AND the invocationType is the invocationType or its subclass
 		//    OR the type is a static method accessed directly through a type
 		//    OR previous assertions are true for one of the enclosing type
 		if (invocationType.fPackage == this.return true;
 
 		TypeBinding declaringClass = enclosingType(); // protected types always have an enclosing one
 		if (declaringClass == nullreturn false// could be null if incorrect top-level protected type
 		declaringClass = declaringClass.erasure();// erasure cannot be null
 		TypeBinding currentType = invocationType.erasure();
 		// int depth = 0;
 		do {
 			if (declaringClass == invocationTypereturn true;
 			if (currentType.findSuperTypeOriginatingFrom(declaringClass) != nullreturn true;
 			// depth++;
 			currentType = currentType.enclosingType();
 		} while (currentType != null);
 		return false;
 	}
 	if (isPrivate()) {
 		// answer true if the receiver and the invocationType have a common enclosingType
 		// already know they are not the identical type
 		ReferenceBinding outerInvocationType = invocationType;
 		ReferenceBinding temp = outerInvocationType.enclosingType();
 		while (temp != null) {
 			outerInvocationType = temp;
 			temp = temp.enclosingType();
 		}
 
 		ReferenceBinding outerDeclaringClass = (ReferenceBinding)erasure();
 		temp = outerDeclaringClass.enclosingType();
 		while (temp != null) {
 			outerDeclaringClass = temp;
 			temp = temp.enclosingType();
 		}
 		return outerInvocationType == outerDeclaringClass;
 	}
 
 	// isDefault()
 	return invocationType.fPackage == this.;
 }
 
 public char[] computeGenericTypeSignature(TypeVariableBinding[] typeVariables) {
 
 	boolean isMemberOfGeneric = isMemberType() && (enclosingType(). & .) != 0;
 	if (typeVariables == . && !isMemberOfGeneric) {
 		return signature();
 	}
 	StringBuffer sig = new StringBuffer(10);
 	if (isMemberOfGeneric) {
 	    char[] typeSig = enclosingType().genericTypeSignature();
 	    sig.append(typeSig, 0, typeSig.length-1); // copy all but trailing semicolon
 	    sig.append('.'); // NOTE: cannot override trailing ';' with '.' in enclosing signature, since shared char[]
 	    sig.append(this.);
 	}	else {
 	    char[] typeSig = signature();
 	    sig.append(typeSig, 0, typeSig.length-1); // copy all but trailing semicolon
 	}
 	if (typeVariables == .) {
 	    sig.append(';');
 	} else {
 	    sig.append('<');
 	    for (int i = 0, length = typeVariables.lengthi < lengthi++) {
 	        sig.append(typeVariables[i].genericTypeSignature());
 	    }
 	    sig.append(">;"); //$NON-NLS-1$
 	}
 	int sigLength = sig.length();
 	char[] result = new char[sigLength];
 	sig.getChars(0, sigLengthresult, 0);
 	return result;
 }
 
 public void computeId() {
 	// note that more (configurable) ids are assigned from PackageBinding#checkIfNullAnnotationType() 
 
 	// try to avoid multiple checks against a package/type name
 	switch (this..length) {
 
 		case 3 :
 			char[] packageName = this.[0];
 			// expect only java.*.* and javax.*.* and junit.*.* and org.junit.*
 			switch (packageName.length) {
 				case 3: // only one type in this group, yet:
 					if (CharOperation.equals(.this.))
 					return;						
 				case 4:
 					if (!CharOperation.equals(.packageName))
 						return;
 					break// continue below ...
 				case 5:
 					switch (packageName[1]) {
 						case 'a':
 							return;
 						case 'u':
 							return;
 					}
 					return;
 				defaultreturn;
 			}
 			// ... at this point we know it's java.*.*
 			
 			packageName = this.[1];
 			if (packageName.length == 0) return// just to be safe
 			char[] typeName = this.[2];
 			if (typeName.length == 0) return// just to be safe
 			// remaining types MUST be in java.*.*
 			if (!CharOperation.equals(.this.[1])) {
 				switch (packageName[0]) {
 					case 'i' :
 						if (CharOperation.equals(packageName.)) {
 							switch (typeName[0]) {
 								case 'C' :
 									if (CharOperation.equals(typeName.[2]))
 										this. |= .// don't assign id, only typeBit (for analysis of resource leaks) 
 									return;
 								case 'E' :
 									if (CharOperation.equals(typeName.[2]))
 									return;
 								case 'I' :
 									if (CharOperation.equals(typeName.[2]))
 									return;
 								case 'O' :
 									if (CharOperation.equals(typeName.[2]))
 									return;
 								case 'P' :
 									if (CharOperation.equals(typeName.[2]))
 									return;
 								case 'S' :
 									if (CharOperation.equals(typeName.[2]))
 									return;
 							}
 						}
 						return;
 					case 'u' :
 						if (CharOperation.equals(packageName.)) {
 							switch (typeName[0]) {
 								case 'C' :
 									if (CharOperation.equals(typeName.[2]))
 									return;
 								case 'I' :
 									if (CharOperation.equals(typeName.[2]))
 									return;
 								case 'O' :
 									if (CharOperation.equals(typeName.[2]))
 									return;
 							}
 						}
 						return;
 				}
 				return;
 			}
 
 			// remaining types MUST be in java.lang.*
 			switch (typeName[0]) {
 				case 'A' :
 					switch(typeName.length) {
 						case 13 :
 							if (CharOperation.equals(typeName.[2])) {
 							}
 							return;
 						case 14:
 							if (CharOperation.equals(typeName.[2]))
 							return;
 					}
 					return;
 				case 'B' :
 					switch (typeName.length) {
 						case 4 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 						case 7 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 					}
 					return;
 				case 'C' :
 					switch (typeName.length) {
 						case 5 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 						case 9 :
 							if (CharOperation.equals(typeName.[2]))
 							else if (CharOperation.equals(typeName.[2]))
 							    this. = .;
 							return;
 						case 22 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 					}
 					return;
 				case 'D' :
 					switch (typeName.length) {
 						case 6 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 						case 10 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 					}
 					return;
 				case 'E' :
 					switch (typeName.length) {
 						case 4 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 						case 5 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 						case 9 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 					}
 					return;
 				case 'F' :
 					if (CharOperation.equals(typeName.[2]))
 					return;
 				case 'I' :
 					switch (typeName.length) {
 						case 7 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 						case 8 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 						case 24 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 					}
 					return;
 				case 'L' :
 					if (CharOperation.equals(typeName.[2]))
 					return;
 				case 'N' :
 					if (CharOperation.equals(typeName.[2]))
 					return;
 				case 'O' :
 					switch (typeName.length) {
 						case 6 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 						case 8 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 					}
 					return;
 				case 'R' :
 					if (CharOperation.equals(typeName.[2]))
 					break;
 				case 'S' :
 					switch (typeName.length) {
 						case 5 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 						case 6 :
 							if (CharOperation.equals(typeName.[2]))
 							else if (CharOperation.equals(typeName.[2]))
 							return;
 						case 11 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 						case 12 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 						case 13 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 						case 16 :
 							if (CharOperation.equals(typeName.[2]))
 							return;
 					}
 					return;
 				case 'T' :
 					if (CharOperation.equals(typeName.[2]))
 					return;
 				case 'V' :
 					if (CharOperation.equals(typeName.[2]))
 					return;
 			}
 		break;
 
 		case 4:
 			// expect one type from com.*.*.*:
 				return;
 			}
 			// otherwise only expect java.*.*.*
 			if (!CharOperation.equals(.this.[0]))
 				return;
 			packageName = this.[1];
 			if (packageName.length == 0) return// just to be safe
 
 			packageName = this.[2];
 			if (packageName.length == 0) return// just to be safe
 			typeName = this.[3];
 			if (typeName.length == 0) return// just to be safe
 			switch (packageName[0]) {
 				case 'a' :
 					if (CharOperation.equals(packageName.)) {
 						switch (typeName[0]) {
 							case 'A' :
 								if (CharOperation.equals(typeName.[3]))
 								return;
 							case 'D' :
 								if (CharOperation.equals(typeName.[3]))
 								return;
 							case 'E' :
 								if (CharOperation.equals(typeName.[3]))
 								return;
 							case 'I' :
 								if (CharOperation.equals(typeName.[3]))
 								return;
 							case 'R' :
 								switch (typeName.length) {
 									case 9 :
 										if (CharOperation.equals(typeName.[3]))
 										return;
 									case 15 :
 										if (CharOperation.equals(typeName.[3]))
 										return;
 								}
 								return;
 							case 'T' :
 								if (CharOperation.equals(typeName.[3]))
 								return;
 						}
 					}
 					return;
 				case 'i':
 					if (CharOperation.equals(packageName.)) {
 						if (typeName.length == 0) return// just to be safe
 						switch (typeName[0]) {
 							case 'M' :
 								return;
 						}
 					}
 					return;
 				case 'r' :
 					if (CharOperation.equals(packageName.)) {
 						switch (typeName[0]) {
 							case 'C' :
 								if (CharOperation.equals(typeName.[2]))
 								return;
 							case 'F' :
 								if (CharOperation.equals(typeName.[2]))
 								return;
 							case 'M' :
 								if (CharOperation.equals(typeName.[2]))
 								return;
 						}
 					}
 					return;
 			}
 			break;
 		case 5 :
 			packageName = this.[0];
 			switch (packageName[0]) {
 				case 'j' :
 					if (!CharOperation.equals(.this.[0]))
 						return;
 					packageName = this.[1];
 					if (packageName.length == 0) return// just to be safe
 					
 					if (CharOperation.equals(.packageName)) {
 						packageName = this.[2];
 						if (packageName.length == 0) return// just to be safe
 						switch (packageName[0]) {
 							case 'i' :
 								if (CharOperation.equals(packageName.)) { 
 									typeName = this.[3];
 									if (typeName.length == 0) return// just to be safe
 									switch (typeName[0]) {
 										case 'M' :
 											char[] memberTypeName = this.[4];
 											if (memberTypeName.length == 0) return// just to be safe
 											return;
 									}
 								}
 								return;
 						}
 						return;
 					}
 					return;
 				case 'o':
 					if (!CharOperation.equals(.this.[0]))
 						return;
 					packageName = this.[1];
 					if (packageName.length == 0) return// just to be safe
 
 					switch (packageName[0]) {
 						case 'e':
 							if (CharOperation.equals(.packageName)) {
 								packageName = this.[2];
 								if (packageName.length == 0) return// just to be safe
 								switch (packageName[0]) {
 									case 'c' :
 										if (CharOperation.equals(packageName.)) { 
 											typeName = this.[3];
 											if (typeName.length == 0) return// just to be safe
 											switch (typeName[0]) {
 												case 'r' :
 													char[] memberTypeName = this.[4];
 													if (memberTypeName.length == 0) return// just to be safe
 													if (CharOperation.equals(typeName.[3])
 															&& CharOperation.equals(memberTypeName.[4]))
 													return;
 											}
 										}
 										return;
 								}
 								return;
 							}
 							return;
 						case 'a':
 							if (CharOperation.equals(.packageName)) {
 								if (CharOperation.equals(.this.[2])) {
 								}
 							}
 							return;
 					}
 					return;
 				case 'c':
 					if (!CharOperation.equals(.this.[0]))
 						return;
 					return;
 			}
 			break;
 	}
 }

p.X<T extends Y & I, U extends Y> {} -> Lp/X;
 
 public char[] computeUniqueKey(boolean isLeaf) {
 	if (!isLeafreturn signature();
 }

Answer the receiver's constant pool name. NOTE: This method should only be used during/after code gen.
 
 public char[] constantPoolName() /* java/lang/Object */ {
 	if (this. != nullreturn this.;
 	return this. = CharOperation.concatWith(this.'/');
 }
 
 public String debugName() {
 	return (this. != null) ? new String(readableName()) : "UNNAMED TYPE"//$NON-NLS-1$
 }
 
 public final int depth() {
 	int depth = 0;
 	ReferenceBinding current = this;
 	while ((current = current.enclosingType()) != null)
 		depth++;
 	return depth;
 }
 
 public boolean detectAnnotationCycle() {
 	if ((this. & .) != 0) return false// already checked
 	if ((this. & .) != 0) return true// in the middle of checking its methods
 
 	MethodBinding[] currentMethods = methods();
 	boolean inCycle = false// check each method before failing
 	for (int i = 0, l = currentMethods.lengthi < li++) {
 		TypeBinding returnType = currentMethods[i]..leafComponentType().erasure();
 		if (this == returnType) {
 			if (this instanceof SourceTypeBinding) {
 				MethodDeclaration decl = (MethodDeclarationcurrentMethods[i].sourceMethod();
 				((SourceTypeBindingthis)..problemReporter().annotationCircularity(thisthisdecl != null ? decl.returnType : null);
 			}
 		} else if (returnType.isAnnotationType() && ((ReferenceBindingreturnType).detectAnnotationCycle()) {
 			if (this instanceof SourceTypeBinding) {
 				MethodDeclaration decl = (MethodDeclarationcurrentMethods[i].sourceMethod();
 				((SourceTypeBindingthis)..problemReporter().annotationCircularity(thisreturnTypedecl != null ? decl.returnType : null);
 			}
 			inCycle = true;
 		}
 	}
 	if (inCycle)
 		return true;
 	return false;
 }
 
 public final ReferenceBinding enclosingTypeAt(int relativeDepth) {
 	ReferenceBinding current = this;
 	while (relativeDepth-- > 0 && current != null)
 		current = current.enclosingType();
 	return current;
 }
 
 public int enumConstantCount() {
 	int count = 0;
 	FieldBinding[] fields = fields();
 	for (int i = 0, length = fields.lengthi < lengthi++) {
 		if ((fields[i]. & .) != 0) count++;
 	}
 	return count;
 }
 
 public int fieldCount() {
 	return fields().length;
 }
 
 public FieldBinding[] fields() {
 	return .;
 }
 
 public final int getAccessFlags() {
 }

Returns:
the JSR 175 annotations for this type.
 
 	return retrieveAnnotations(this);
 }

 
 public long getAnnotationTagBits() {
 	return this.;
 }

Returns:
the enclosingInstancesSlotSize
 
 	if (isStatic()) return 0;
 	return enclosingType() == null ? 0 : 1;
 }
 
 public MethodBinding getExactConstructor(TypeBinding[] argumentTypes) {
 	return null;
 }
 
 public MethodBinding getExactMethod(char[] selectorTypeBinding[] argumentTypesCompilationUnitScope refScope) {
 	return null;
 }
 public FieldBinding getField(char[] fieldNameboolean needResolve) {
 	return null;
 }
 
 public char[] getFileName() {
 	return this.;
 }
 
 public ReferenceBinding getMemberType(char[] typeName) {
 	ReferenceBinding[] memberTypes = memberTypes();
 	for (int i = memberTypes.length; --i >= 0;)
 		if (CharOperation.equals(memberTypes[i].typeName))
 			return memberTypes[i];
 	return null;
 }
 
 public MethodBinding[] getMethods(char[] selector) {
 }
 
 // Answer methods named selector, which take no more than the suggestedParameterLength.
 // The suggested parameter length is optional and may not be guaranteed by every type.
 public MethodBinding[] getMethods(char[] selectorint suggestedParameterLength) {
 	return getMethods(selector);
 }

Returns:
the outerLocalVariablesSlotSize
 
 	return 0;
 }
 
 	return this.;
 }
 
 public TypeVariableBinding getTypeVariable(char[] variableName) {
 	TypeVariableBinding[] typeVariables = typeVariables();
 	for (int i = typeVariables.length; --i >= 0;)
 		if (CharOperation.equals(typeVariables[i].variableName))
 			return typeVariables[i];
 	return null;
 }
 
 public int hashCode() {
 	// ensure ReferenceBindings hash to the same position as UnresolvedReferenceBindings so they can be replaced without rehashing
 	// ALL ReferenceBindings are unique when created so equals() is the same as ==
 	return (this. == null || this..length == 0)
 		? super.hashCode()
 		: CharOperation.hashCode(this.[this..length - 1]);
 }

Returns true if the two types have an incompatible common supertype, e.g. List<String> and List<Integer>
 
 public boolean hasIncompatibleSuperType(ReferenceBinding otherType) {
 
     if (this == otherTypereturn false;
 
 	ReferenceBinding[] interfacesToVisit = null;
 	int nextPosition = 0;
     ReferenceBinding currentType = this;
 	TypeBinding match;
 	do {
 		match = otherType.findSuperTypeOriginatingFrom(currentType);
 		if (match != null && match.isProvablyDistinct(currentType))
 			return true;
 
 		ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
 		if (itsInterfaces != null && itsInterfaces != .) {
 			if (interfacesToVisit == null) {
 				interfacesToVisit = itsInterfaces;
 				nextPosition = interfacesToVisit.length;
 			} else {
 				int itsLength = itsInterfaces.length;
 				if (nextPosition + itsLength >= interfacesToVisit.length)
 					System.arraycopy(interfacesToVisit, 0, interfacesToVisit = new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
 				nextInterface : for (int a = 0; a < itsLengtha++) {
 					ReferenceBinding next = itsInterfaces[a];
 					for (int b = 0; b < nextPositionb++)
						if (next == interfacesToVisit[b]) continue nextInterface;
					interfacesToVisit[nextPosition++] = next;
while ((currentType = currentType.superclass()) != null);
	for (int i = 0; i < nextPositioni++) {
		currentType = interfacesToVisit[i];
		if (currentType == otherTypereturn false;
		match = otherType.findSuperTypeOriginatingFrom(currentType);
		if (match != null && match.isProvablyDistinct(currentType))
			return true;
		ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
		if (itsInterfaces != null && itsInterfaces != .) {
			int itsLength = itsInterfaces.length;
			if (nextPosition + itsLength >= interfacesToVisit.length)
				System.arraycopy(interfacesToVisit, 0, interfacesToVisit = new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
			nextInterface : for (int a = 0; a < itsLengtha++) {
				ReferenceBinding next = itsInterfaces[a];
				for (int b = 0; b < nextPositionb++)
					if (next == interfacesToVisit[b]) continue nextInterface;
				interfacesToVisit[nextPosition++] = next;
	return false;
public boolean hasMemberTypes() {
    return false;
Answer whether a

NonNullByDefault:
is applicable at the given method binding.
boolean hasNonNullDefault() {
	// Note, STB overrides for correctly handling local types
	ReferenceBinding currentType = this;
	while (currentType != null) {
		if ((currentType.tagBits & .) != 0)
			return true;
		if ((currentType.tagBits & .) != 0)
			return false;
		currentType = currentType.enclosingType();
	// package
public final boolean hasRestrictedAccess() {
Answer an additional bit characterizing this type, like TypeIds.BitAutoCloseable.
abstract public boolean hasTypeBit(int bit);

Answer true if the receiver implements anInterface or is identical to anInterface. If searchHierarchy is true, then also search the receiver's superclasses. NOTE: Assume that anInterface is an interface.
public boolean implementsInterface(ReferenceBinding anInterfaceboolean searchHierarchy) {
	if (this == anInterface)
		return true;
	ReferenceBinding[] interfacesToVisit = null;
	int nextPosition = 0;
	ReferenceBinding currentType = this;
	do {
		ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
		if (itsInterfaces != null && itsInterfaces != .) { // in code assist cases when source types are added late, may not be finished connecting hierarchy
			if (interfacesToVisit == null) {
				interfacesToVisit = itsInterfaces;
				nextPosition = interfacesToVisit.length;
else {
				int itsLength = itsInterfaces.length;
				if (nextPosition + itsLength >= interfacesToVisit.length)
					System.arraycopy(interfacesToVisit, 0, interfacesToVisit = new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
				nextInterface : for (int a = 0; a < itsLengtha++) {
					ReferenceBinding next = itsInterfaces[a];
					for (int b = 0; b < nextPositionb++)
						if (next == interfacesToVisit[b]) continue nextInterface;
					interfacesToVisit[nextPosition++] = next;
while (searchHierarchy && (currentType = currentType.superclass()) != null);
	for (int i = 0; i < nextPositioni++) {
		currentType = interfacesToVisit[i];
		if (currentType.isEquivalentTo(anInterface))
			return true;
		ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
		if (itsInterfaces != null && itsInterfaces != .) { // in code assist cases when source types are added late, may not be finished connecting hierarchy
			int itsLength = itsInterfaces.length;
			if (nextPosition + itsLength >= interfacesToVisit.length)
				System.arraycopy(interfacesToVisit, 0, interfacesToVisit = new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
			nextInterface : for (int a = 0; a < itsLengtha++) {
				ReferenceBinding next = itsInterfaces[a];