Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2012 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 186342 - [compiler][null] Using annotations for null checking bug 367203 - [compiler][null] detect assigning null to nonnull argument bug 365519 - editorial cleanup after bug 186342 and bug 365387 bug 365662 - [compiler][null] warn on contradictory and redundant null annotations bug 365531 - [compiler][null] investigate alternative strategy for internally encoding nullness defaults bug 388281 - [compiler][null] inheritance of null annotations as an option /
  
  package org.eclipse.jdt.internal.compiler.lookup;
  
  import java.util.List;
  
  
  public class MethodBinding extends Binding {
  
  	public int modifiers;
  	public char[] selector;
  	public TypeBinding returnType;
  	public TypeBinding[] parameters;
  	char[] signature;
  	public long tagBits;

Store nullness information from annotation (incl. applicable default).
  
  	public Boolean[] parameterNonNullness;  // TRUE means @NonNull declared, FALSE means @Nullable declared, null means nothing declared
  
  protected MethodBinding() {
  	// for creating problem or synthetic method
  }
  public MethodBinding(int modifierschar[] selectorTypeBinding returnTypeTypeBinding[] parametersReferenceBinding[] thrownExceptionsReferenceBinding declaringClass) {
  	this. = modifiers;
  	this. = selector;
  	this. = returnType;
  	this. = (parameters == null || parameters.length == 0) ? . : parameters;
  	this. = (thrownExceptions == null || thrownExceptions.length == 0) ? . : thrownExceptions;
  	this. = declaringClass;
  
  	// propagate the strictfp & deprecated modifiers
  	if (this. != null) {
  		if (this..isStrictfp())
  			if (!(isNative() || isAbstract()))
  	}
  }
  public MethodBinding(int modifiersTypeBinding[] parametersReferenceBinding[] thrownExceptionsReferenceBinding declaringClass) {
  	this(modifiers..parametersthrownExceptionsdeclaringClass);
  }
  // special API used to change method declaring class for runtime visibility check
  public MethodBinding(MethodBinding initialMethodBindingReferenceBinding declaringClass) {
  	this. = initialMethodBinding.modifiers;
  	this. = initialMethodBinding.selector;
  	this. = initialMethodBinding.returnType;
  	this. = initialMethodBinding.parameters;
  	this. = initialMethodBinding.thrownExceptions;
  	this. = declaringClass;
  	declaringClass.storeAnnotationHolder(thisinitialMethodBinding.declaringClass.retrieveAnnotationHolder(initialMethodBindingtrue));
  }
  /* Answer true if the argument types & the receiver's parameters have the same erasure
  */
  public final boolean areParameterErasuresEqual(MethodBinding method) {
  	TypeBinding[] args = method.parameters;
  	if (this. == args)
  		return true;
  
  	int length = this..length;
  	if (length != args.length)
  		return false;
  
  	for (int i = 0; i < lengthi++)
  		if (this.[i] != args[i] && this.[i].erasure() != args[i].erasure())
  			return false;
  	return true;
  }
  /*
   * Returns true if given parameters are compatible with this method parameters.
   * Callers to this method should first check that the number of TypeBindings
   * passed as argument matches this MethodBinding number of parameters
   */
  public final boolean areParametersCompatibleWith(TypeBinding[] arguments) {
 	int paramLength = this..length;
 	int argLength = arguments.length;
 	int lastIndex = argLength;
 	if (isVarargs()) {
 		lastIndex = paramLength - 1;
 		if (paramLength == argLength) { // accept X[] but not X or X[][]
 			TypeBinding varArgType = this.[lastIndex]; // is an ArrayBinding by definition
 			TypeBinding lastArgument = arguments[lastIndex];
 			if (varArgType != lastArgument && !lastArgument.isCompatibleWith(varArgType))
 				return false;
 		} else if (paramLength < argLength) { // all remainig argument types must be compatible with the elementsType of varArgType
 			TypeBinding varArgType = ((ArrayBindingthis.[lastIndex]).elementsType();
 			for (int i = lastIndexi < argLengthi++)
 				if (varArgType != arguments[i] && !arguments[i].isCompatibleWith(varArgType))
 					return false;
 		} else if (lastIndex != argLength) { // can call foo(int i, X ... x) with foo(1) but NOT foo();
 			return false;
 		}
 		// now compare standard arguments from 0 to lastIndex
 	}
 	for (int i = 0; i < lastIndexi++)
 		if (this.[i] != arguments[i] && !arguments[i].isCompatibleWith(this.[i]))
 			return false;
 	return true;
 }
 /* Answer true if the argument types & the receiver's parameters are equal
 */
 public final boolean areParametersEqual(MethodBinding method) {
 	TypeBinding[] args = method.parameters;
 	if (this. == args)
 		return true;
 
 	int length = this..length;
 	if (length != args.length)
 		return false;
 
 	for (int i = 0; i < lengthi++)
 		if (this.[i] != args[i])
 			return false;
 	return true;
 }
 
 /* API
 * Answer the receiver's binding type from Binding.BindingID.
 */
 
 /* Answer true if the type variables have the same erasure
 */
 public final boolean areTypeVariableErasuresEqual(MethodBinding method) {
 	TypeVariableBinding[] vars = method.typeVariables;
 	if (this. == vars)
 		return true;
 
 	int length = this..length;
 	if (length != vars.length)
 		return false;
 
 	for (int i = 0; i < lengthi++)
 		if (this.[i] != vars[i] && this.[i].erasure() != vars[i].erasure())
 			return false;
 	return true;
 }
 	if (this. == .return this;
 
 	// substitute type arguments with raw types
 	int length = this..length;
 	TypeBinding[] arguments = new TypeBinding[length];
 	for (int i = 0; i < lengthi++) {
 		if (var.boundsCount() <= 1) {
 			arguments[i] = env.convertToRawType(var.upperBound(), false /*do not force conversion of enclosing types*/);
 		} else {
 			// use an intersection type to retain full bound information if more than 1 bound
 			TypeBinding[] itsSuperinterfaces = var.superInterfaces();
 			int superLength = itsSuperinterfaces.length;
 			TypeBinding rawFirstBound = null;
 			TypeBinding[] rawOtherBounds = null;
 			if (var.boundsCount() == superLength) {
 				rawFirstBound = env.convertToRawType(itsSuperinterfaces[0], false);
 				rawOtherBounds = new TypeBinding[superLength - 1];
 				for (int s = 1; s < superLengths++)
 					rawOtherBounds[s - 1] = env.convertToRawType(itsSuperinterfaces[s], false);
 			} else {
 				rawFirstBound = env.convertToRawType(var.superclass(), false);
 				rawOtherBounds = new TypeBinding[superLength];
 				for (int s = 0; s < superLengths++)
 					rawOtherBounds[s] = env.convertToRawType(itsSuperinterfaces[s], false);
 			}
 			arguments[i] = env.createWildcard(null, 0, rawFirstBoundrawOtherBounds.......);
 		}
 	}
 	return env.createParameterizedGenericMethod(thisarguments);
 }
 /* Answer true if the receiver is visible to the type provided by the scope.
 * InvocationSite implements isSuperAccess() to provide additional information
 * if the receiver is protected.
 *
 * NOTE: This method should ONLY be sent if the receiver is a constructor.
 *
 * NOTE: Cannot invoke this method with a compilation unit scope.
 */
 
 public final boolean canBeSeenBy(InvocationSite invocationSiteScope scope) {
 	if (isPublic()) return true;
 
 	SourceTypeBinding invocationType = scope.enclosingSourceType();
 	if (invocationType == this.return true;
 
 	if (isProtected()) {
 		// answer true if the receiver is in the same package as the invocationType
 		if (invocationType.fPackage == this..return true;
 		return invocationSite.isSuperAccess();
 	}
 
 	if (isPrivate()) {
 		// answer true if the invocationType and the declaringClass 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)this..erasure();
 		temp = outerDeclaringClass.enclosingType();
 		while (temp != null) {
 			outerDeclaringClass = temp;
 			temp = temp.enclosingType();
 		}
 		return outerInvocationType == outerDeclaringClass;
 	}
 
 	// isDefault()
 	return invocationType.fPackage == this..;
 }
 public final boolean canBeSeenBy(PackageBinding invocationPackage) {
 	if (isPublic()) return true;
 	if (isPrivate()) return false;
 
 	// isProtected() or isDefault()
 	return invocationPackage == this..getPackage();
 }
 
 /* Answer true if the receiver is visible to the type provided by the scope.
 * InvocationSite implements isSuperAccess() to provide additional information
 * if the receiver is protected.
 *
 * NOTE: Cannot invoke this method with a compilation unit scope.
 */
 public final boolean canBeSeenBy(TypeBinding receiverTypeInvocationSite invocationSiteScope scope) {
 	if (isPublic()) return true;
 
 	SourceTypeBinding invocationType = scope.enclosingSourceType();
 	if (invocationType == this. && invocationType == receiverTypereturn 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 receiverType is the invocationType or its subclass
 		//    OR the method is a static method accessed directly through a type
 		//    OR previous assertions are true for one of the enclosing type
 		if (invocationType == this.return true;
 		if (invocationType.fPackage == this..return true;
 
 		ReferenceBinding currentType = invocationType;
 		TypeBinding receiverErasure = receiverType.erasure();
 		ReferenceBinding declaringErasure = (ReferenceBindingthis..erasure();
 		int depth = 0;
 		do {
 			if (currentType.findSuperTypeOriginatingFrom(declaringErasure) != null) {
 				if (invocationSite.isSuperAccess())
 					return true;
 				// receiverType can be an array binding in one case... see if you can change it
 				if (receiverType instanceof ArrayBinding)
 					return false;
 				if (isStatic()) {
 					if (depth > 0) invocationSite.setDepth(depth);
 					return true// see 1FMEPDL - return invocationSite.isTypeAccess();
 				}
 				if (currentType == receiverErasure || receiverErasure.findSuperTypeOriginatingFrom(currentType) != null) {
 					if (depth > 0) invocationSite.setDepth(depth);
 					return true;
 				}
 			}
 			depth++;
 			currentType = currentType.enclosingType();
 		} while (currentType != null);
 		return false;
 	}
 
 	if (isPrivate()) {
 		// answer true if the receiverType is the declaringClass
 		// AND the invocationType and the declaringClass have a common enclosingType
 		receiverCheck: {
 			if (receiverType != this.) {
 				// special tolerance for type variable direct bounds, but only if compliance <= 1.6, see: https://bugs.eclipse.org/bugs/show_bug.cgi?id=334622
 					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)this..erasure();
 			temp = outerDeclaringClass.enclosingType();
 			while (temp != null) {
 				outerDeclaringClass = temp;
 				temp = temp.enclosingType();
 			}
 			if (outerInvocationType != outerDeclaringClassreturn false;
 		}
 		return true;
 	}
 
 	// isDefault()
 	PackageBinding declaringPackage = this..;
 	if (invocationType.fPackage != declaringPackagereturn false;
 
 	// receiverType can be an array binding in one case... see if you can change it
 	if (receiverType instanceof ArrayBinding)
 		return false;
 	TypeBinding originalDeclaringClass = this..original();
 	ReferenceBinding currentType = (ReferenceBinding) (receiverType);
 	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 != declaringPackagereturn false;
 	} while ((currentType = currentType.superclass()) != null);
 	return false;
 }
 
 public List collectMissingTypes(List missingTypes) {
 	if ((this. & .) != 0) {
 		missingTypes = this..collectMissingTypes(missingTypes);
 		for (int i = 0, max = this..lengthi < maxi++) {
 			missingTypes = this.[i].collectMissingTypes(missingTypes);
 		}
 		for (int i = 0, max = this..lengthi < maxi++) {
 			missingTypes = this.[i].collectMissingTypes(missingTypes);
 		}
 		for (int i = 0, max = this..lengthi < maxi++) {
 			TypeVariableBinding variable = this.[i];
 			missingTypes = variable.superclass().collectMissingTypes(missingTypes);
 			ReferenceBinding[] interfaces = variable.superInterfaces();
 			for (int j = 0, length = interfaces.lengthj < lengthj++) {
 				missingTypes = interfaces[j].collectMissingTypes(missingTypes);
 			}
 		}
 	}
 	return missingTypes;
 }
 
 	int length = this..length;
 	TypeVariableBinding[] vars = method.typeVariables;
 	if (length != vars.length)
 		return null;
 
 	// must substitute to detect cases like:
 	//   <T1 extends X<T1>> void dup() {}
 	//   <T2 extends X<T2>> Object dup() {return null;}
 	for (int i = 0; i < lengthi++)
 		if (!this.[i].isInterchangeableWith(vars[i], substitute))
 			return null;
 	return substitute;
 }
 
 /*
  * declaringUniqueKey dot selector genericSignature
  * p.X { <T> void bar(X<T> t) } --> Lp/X;.bar<T:Ljava/lang/Object;>(LX<TT;>;)V
  */
 public char[] computeUniqueKey(boolean isLeaf) {
 	// declaring class
 	char[] declaringKey = this..computeUniqueKey(false/*not a leaf*/);
 	int declaringLength = declaringKey.length;
 
 	// selector
 	int selectorLength = this. == . ? 0 : this..length;
 
 	// generic signature
 	char[] sig = genericSignature();
 	boolean isGeneric = sig != null;
 	if (!isGenericsig = signature();
 	int signatureLength = sig.length;
 
 	// thrown exceptions
 	int thrownExceptionsLength = this..length;
 	int thrownExceptionsSignatureLength = 0;
 	char[][] thrownExceptionsSignatures = null;
 	boolean addThrownExceptions = thrownExceptionsLength > 0 && (!isGeneric || CharOperation.lastIndexOf('^'sig) < 0);
 	if (addThrownExceptions) {
 		thrownExceptionsSignatures = new char[thrownExceptionsLength][];
 		for (int i = 0; i < thrownExceptionsLengthi++) {
 			if (this.[i] != null) {
 				thrownExceptionsSignatures[i] = this.[i].signature();
 				thrownExceptionsSignatureLength += thrownExceptionsSignatures[i].length + 1;	// add one char for separator
 			}
 		}
 	}
 
 	char[] uniqueKey = new char[declaringLength + 1 + selectorLength + signatureLength + thrownExceptionsSignatureLength];
 	int index = 0;
 	System.arraycopy(declaringKey, 0, uniqueKeyindexdeclaringLength);
 	index = declaringLength;
 	uniqueKey[index++] = '.';
 	System.arraycopy(this., 0, uniqueKeyindexselectorLength);
 	index += selectorLength;
 	System.arraycopy(sig, 0, uniqueKeyindexsignatureLength);
 	if (thrownExceptionsSignatureLength > 0) {
 		index += signatureLength;
 		for (int i = 0; i < thrownExceptionsLengthi++) {
 			char[] thrownExceptionSignature = thrownExceptionsSignatures[i];
 			if (thrownExceptionSignature != null) {
 				uniqueKey[index++] = '|';
 				int length = thrownExceptionSignature.length;
 				System.arraycopy(thrownExceptionSignature, 0, uniqueKeyindexlength);
 				index += length;
 			}
 		}
 	}
 	return uniqueKey;
 }
 
 /* Answer the receiver's constant pool name.
 *
 * <init> for constructors
 * <clinit> for clinit methods
 * or the source name of the method
 */
 public final char[] constantPoolName() {
 	return this.;
 }

After method verifier has finished, fill in missing

NonNull:
specification from the applicable default.
 
 protected void fillInDefaultNonNullness(AbstractMethodDeclaration sourceMethod) {
 	if (this. == null)
 		this. = new Boolean[this..length];
 	boolean added = false;
 	int length = this..length;
 	for (int i = 0; i < lengthi++) {
 		if (this.[i].isBaseType())
 			continue;
 		if (this.[i] == null) {
 			added = true;
 			if (sourceMethod != null) {
 				sourceMethod.arguments[i].. |= .;
 			}
 		} else if (sourceMethod != null && this.[i].booleanValue()) {
 			sourceMethod.scope.problemReporter().nullAnnotationIsRedundant(sourceMethodi);
 		}
 	}
 	if (added)
 	if (   this. != null
 		&& !this..isBaseType()
 	{
 	} else if (sourceMethod != null && (this. & .) != 0) {
 		sourceMethod.scope.problemReporter().nullAnnotationIsRedundant(sourceMethod, -1/*signifies method return*/);
 	}
 }
 
 	MethodBinding inheritedOriginal = inheritedMethod.original();
 	TypeBinding superType = this..findSuperTypeOriginatingFrom(inheritedOriginal.declaringClass);
 	if (superType == null || !(superType instanceof ReferenceBinding)) return null;
 
 	if (inheritedOriginal.declaringClass != superType) {
 		// must find inherited method with the same substituted variables
 		MethodBinding[] superMethods = ((ReferenceBindingsuperType).getMethods(inheritedOriginal.selectorinheritedOriginal.parameters.length);
 		for (int m = 0, l = superMethods.lengthm < lm++)
 			if (superMethods[m].original() == inheritedOriginal)
 				return superMethods[m];
 	}
 	return inheritedOriginal;
 }

<typeParam1 ... typeParamM>(param1 ... paramN)returnType thrownException1 ... thrownExceptionP
 T foo(T t) throws X<T>   --->   (TT;)TT;LX;
 void bar(X<T> t)   -->   (LX;)V
 <T> void bar(X<T> t)   -->  <T:Ljava.lang.Object;>(LX;)V
 
 
 public char[] genericSignature() {
 	if ((this. & .) == 0) return null;
 	StringBuffer sig = new StringBuffer(10);
 		sig.append('<');
 		for (int i = 0, length = this..lengthi < lengthi++) {
 		}
 		sig.append('>');
 	}
 	sig.append('(');
 	for (int i = 0, length = this..lengthi < lengthi++) {
 	}
 	sig.append(')');
 	if (this. != null)
 
 	// only append thrown exceptions if any is generic/parameterized
 	boolean needExceptionSignatures = false;
 	int length = this..length;
 	for (int i = 0; i < lengthi++) {
 			needExceptionSignatures = true;
 			break;
 		}
 	}
 	if (needExceptionSignatures) {
 		for (int i = 0; i < lengthi++) {
 			sig.append('^');
 		}
 	}
 	int sigLength = sig.length();
 	char[] genericSignature = new char[sigLength];
 	sig.getChars(0, sigLengthgenericSignature, 0);
 	return genericSignature;
 }
 
 public final int getAccessFlags() {
 }
 
 	MethodBinding originalMethod = original();
 	return originalMethod.declaringClass.retrieveAnnotations(originalMethod);
 }

Compute the tagbits for standard annotations. For source types, these could require lazily resolving corresponding annotation nodes, in case of forward references.

 
 public long getAnnotationTagBits() {
 	MethodBinding originalMethod = original();
 	if ((originalMethod.tagBits & .) == 0 && originalMethod.declaringClass instanceof SourceTypeBinding) {
 		ClassScope scope = ((SourceTypeBindingoriginalMethod.declaringClass).;
 		if (scope != null) {
 			TypeDeclaration typeDecl = scope.referenceContext;
 			AbstractMethodDeclaration methodDecl = typeDecl.declarationOf(originalMethod);
 			if (methodDecl != null)
 				ASTNode.resolveAnnotations(methodDecl.scopemethodDecl.annotationsoriginalMethod);
 			if (nullDefaultBits != 0 && this. instanceof SourceTypeBinding) {
 				SourceTypeBinding declaringSourceType = (SourceTypeBindingthis.;
 				if (declaringSourceType.checkRedundantNullnessDefaultOne(methodDeclmethodDecl.annotationsnullDefaultBits)) {
 					declaringSourceType.checkRedundantNullnessDefaultRecurse(methodDeclmethodDecl.annotationsnullDefaultBits);
 				}
 			}
 		}
 	}
 	return originalMethod.tagBits;
 }

Returns:
the default value for this annotation method or null if there is no default value
 
 public Object getDefaultValue() {
 	MethodBinding originalMethod = original();
 	if ((originalMethod.tagBits & .) == 0) {
 		//The method has not been resolved nor has its class been resolved.
 		//It can only be from a source type within compilation units to process.
 		if (originalMethod.declaringClass instanceof SourceTypeBinding) {
 			SourceTypeBinding sourceType = (SourceTypeBindingoriginalMethod.declaringClass;
 			if (sourceType.scope != null) {
 				AbstractMethodDeclaration methodDeclaration = originalMethod.sourceMethod();
 				if (methodDeclaration != null && methodDeclaration.isAnnotationMethod()) {
 					methodDeclaration.resolve(sourceType.scope);
 				}
 			}
 		}
 		originalMethod.tagBits |= .;
 	}
 	AnnotationHolder holder = originalMethod.declaringClass.retrieveAnnotationHolder(originalMethodtrue);
 	return holder == null ? null : holder.getDefaultValue();
 }

Returns:
the annotations for each of the method parameters or null> if there's no parameter or no annotation at all.
 
 	int length;
 	if ((length = this..length) == 0) {
 		return null;
 	}
 	MethodBinding originalMethod = original();
 	AnnotationHolder holder = originalMethod.declaringClass.retrieveAnnotationHolder(originalMethodtrue);
 	AnnotationBinding[][] allParameterAnnotations = holder == null ? null : holder.getParameterAnnotations();
 	if (allParameterAnnotations == null && (this. & .) != 0) {
 		allParameterAnnotations = new AnnotationBinding[length][];
 		// forward reference to method, where param annotations have not yet been associated to method
 		if (this. instanceof SourceTypeBinding) {
 			if (sourceType.scope != null) {
 				AbstractMethodDeclaration methodDecl = sourceType.scope.referenceType().declarationOf(this);
 				for (int i = 0; i < lengthi++) {
 					Argument argument = methodDecl.arguments[i];
 					if (argument.annotations != null) {
 						ASTNode.resolveAnnotations(methodDecl.scopeargument.annotationsargument.binding);
 						allParameterAnnotations[i] = argument.binding.getAnnotations();
 					} else {
 						allParameterAnnotations[i] = .;
 					}
 				}
 			} else {
 				for (int i = 0; i < lengthi++) {
 					allParameterAnnotations[i] = .;
 				}
 			}
 		} else {
 			for (int i = 0; i < lengthi++) {
 				allParameterAnnotations[i] = .;
 			}
 		}
 		setParameterAnnotations(allParameterAnnotations);
 	}
 	return allParameterAnnotations;
 }
 
 public TypeVariableBinding getTypeVariable(char[] variableName) {
 	for (int i = this..length; --i >= 0;)
 		if (CharOperation.equals(this.[i].variableName))
 			return this.[i];
 	return null;
 }

Returns true if method got substituted parameter types (see ParameterizedMethodBinding)
 
 public boolean hasSubstitutedParameters() {
 	return false;
 }
 
 /* Answer true if the return type got substituted.
  */
 public boolean hasSubstitutedReturnType() {
 	return false;
 }
 
 /* Answer true if the receiver is an abstract method
 */
 public final boolean isAbstract() {
 	return (this. & .) != 0;
 }
 
 /* Answer true if the receiver is a bridge method
 */
 public final boolean isBridge() {
 	return (this. & .) != 0;
 }
 
 /* Answer true if the receiver is a constructor
 */
 public final boolean isConstructor() {
 	return this. == .;
 }
 
 /* Answer true if the receiver has default visibility
 */
 public final boolean isDefault() {
 	return !isPublic() && !isProtected() && !isPrivate();
 }
 
 /* Answer true if the receiver is a system generated default abstract method
 */
 public final boolean isDefaultAbstract() {
 }
 
 /* Answer true if the receiver is a deprecated method
 */
 public final boolean isDeprecated() {
 	return (this. & .) != 0;
 }
 
 /* Answer true if the receiver is final and cannot be overridden
 */
 public final boolean isFinal() {
 	return (this. & .) != 0;
 }
 
 /* Answer true if the receiver is implementing another method
  * in other words, it is overriding and concrete, and overriden method is abstract
  * Only set for source methods
 */
 public final boolean isImplementing() {
 }
 
 /*
  * Answer true if the receiver is a "public static void main(String[])" method
  */
 public final boolean isMain() {
 	if (this..length == 4 && CharOperation.equals(this..)
 			&& . == this.
 			&& this..length == 1) {
 		TypeBinding paramType = this.[0];
 		if (paramType.dimensions() == 1 && paramType.leafComponentType(). == .) {
 			return true;
 		}
 	}
 	return false;
 }
 
 /* Answer true if the receiver is a native method
 */
 public final boolean isNative() {
 	return (this. & .) != 0;
 }
 
 /* Answer true if the receiver is overriding another method
  * Only set for source methods
 */
 public final boolean isOverriding() {
 	return (this. & .) != 0;
 }
 /* Answer true if the receiver has private visibility
 */
 public final boolean isPrivate() {
 	return (this. & .) != 0;
 }
 
 /* Answer true if the receiver has private visibility or if any of its enclosing types do.
 */
 public final boolean isOrEnclosedByPrivateType() {
 	if ((this. & .) != 0)
 		return true;
 	return this. != null && this..isOrEnclosedByPrivateType();
 }
 
 /* Answer true if the receiver has protected visibility
 */
 public final boolean isProtected() {
 	return (this. & .) != 0;
 }
 
 /* Answer true if the receiver has public visibility
 */
 public final boolean isPublic() {
 	return (this. & .) != 0;
 }
 
 /* Answer true if the receiver is a static method
 */
 public final boolean isStatic() {
 	return (this. & .) != 0;
 }
 
 /* Answer true if all float operations must adher to IEEE 754 float/double rules
 */
 public final boolean isStrictfp() {
 	return (this. & .) != 0;
 }
 
 /* Answer true if the receiver is a synchronized method
 */
 public final boolean isSynchronized() {
 	return (this. & .) != 0;
 }
 
 /* Answer true if the receiver has public visibility
 */
 public final boolean isSynthetic() {
 	return (this. & .) != 0;
 }
 
 /* Answer true if the receiver has private visibility and is used locally
 */
 public final boolean isUsed() {
 	return (this. & .) != 0;
 }
 
 /* Answer true if the receiver method has varargs
 */
 public boolean isVarargs() {
 	return (this. & .) != 0;
 }
 public boolean isPolymorphic() {
 	return false;
 }
 /* Answer true if the receiver's declaring type is deprecated (or any of its enclosing types)
 */
 public final boolean isViewedAsDeprecated() {
 }
 
 public final int kind() {
 	return .;
 }
 /* Answer true if the receiver is visible to the invocationPackage.
 */

Returns the original method (as opposed to parameterized/polymorphic instances)
 
 public MethodBinding original() {
 	return this;
 }
 
 public char[] readableName() /* foo(int, Thread) */ {
 	StringBuffer buffer = new StringBuffer(this..length + 1 * 20);
 	if (isConstructor())
 	else
 		buffer.append(this.);
 	buffer.append('(');
 	if (this. != .) {
 		for (int i = 0, length = this..lengthi < lengthi++) {
 			if (i > 0)
 				buffer.append(", "); //$NON-NLS-1$
 			buffer.append(this.[i].sourceName());
 		}
 	}
 	buffer.append(')');
 	return buffer.toString().toCharArray();
 }
 public void setAnnotations(AnnotationBinding[] annotations) {
 	this..storeAnnotations(thisannotations);
 }
 public void setAnnotations(AnnotationBinding[] annotationsAnnotationBinding[][] parameterAnnotationsObject defaultValueLookupEnvironment optionalEnv) {
 	this..storeAnnotationHolder(this,  AnnotationHolder.storeAnnotations(annotationsparameterAnnotationsdefaultValueoptionalEnv));
 }
 public void setDefaultValue(Object defaultValue) {
 	MethodBinding originalMethod = original();
 	originalMethod.tagBits |= .;
 
 	if (holder == null)
 		setAnnotations(nullnulldefaultValuenull);
 	else
 		setAnnotations(holder.getAnnotations(), holder.getParameterAnnotations(), defaultValuenull);
 }
 public void setParameterAnnotations(AnnotationBinding[][] parameterAnnotations) {
 	if (holder == null)
 		setAnnotations(nullparameterAnnotationsnullnull);
 	else
 		setAnnotations(holder.getAnnotations(), parameterAnnotationsholder.getDefaultValue(), null);
 }
 protected final void setSelector(char[] selector) {
 	this. = selector;
 	this. = null;
 }

 
 public char[] shortReadableName() {
 	StringBuffer buffer = new StringBuffer(this..length + 1 * 20);
 	if (isConstructor())
 	else
 		buffer.append(this.);
 	buffer.append('(');
 	if (this. != .) {
 		for (int i = 0, length = this..lengthi < lengthi++) {
 			if (i > 0)
 				buffer.append(", "); //$NON-NLS-1$
 			buffer.append(this.[i].shortReadableName());
 		}
 	}
 	buffer.append(')');
 	int nameLength = buffer.length();
 	char[] shortReadableName = new char[nameLength];
 	buffer.getChars(0, nameLengthshortReadableName, 0);
 	return shortReadableName;
 }
 
 /* Answer the receiver's signature.
 *
 * NOTE: This method should only be used during/after code gen.
 * The signature is cached so if the signature of the return type or any parameter
 * type changes, the cached state is invalid.
 */
 public final char[] signature() /* (ILjava/lang/Thread;)Ljava/lang/Object; */ {
 	if (this. != null)
 		return this.;
 
 	StringBuffer buffer = new StringBuffer(this..length + 1 * 20);
 	buffer.append('(');
 
 	TypeBinding[] targetParameters = this.;
 	boolean isConstructor = isConstructor();
 	if (isConstructor && this..isEnum()) { // insert String name,int ordinal
 	}
 	boolean needSynthetics = isConstructor && this..isNestedType();
 	if (needSynthetics) {
 		// take into account the synthetic argument type signatures as well
 		ReferenceBinding[] syntheticArgumentTypes = this..syntheticEnclosingInstanceTypes();
 		if (syntheticArgumentTypes != null) {
 			for (int i = 0, count = syntheticArgumentTypes.lengthi < counti++) {
 				buffer.append(syntheticArgumentTypes[i].signature());
 			}
 		}
 
 		if (this instanceof SyntheticMethodBinding) {
 			targetParameters = ((SyntheticMethodBinding)this)..;
 		}
 	}
 
 	if (targetParameters != .) {
 		for (int i = 0; i < targetParameters.lengthi++) {
 			buffer.append(targetParameters[i].signature());
 		}
 	}
 	if (needSynthetics) {
 		int count = syntheticOuterArguments == null ? 0 : syntheticOuterArguments.length;
 		for (int i = 0; i < counti++) {
 			buffer.append(syntheticOuterArguments[i]..signature());
 		}
 		// move the extra padding arguments of the synthetic constructor invocation to the end
 		for (int i = targetParameters.lengthextraLength = this..lengthi < extraLengthi++) {
 			buffer.append(this.[i].signature());
 		}
 	}
 	buffer.append(')');
 	if (this. != null)
 		buffer.append(this..signature());
 	int nameLength = buffer.length();
 	this. = new char[nameLength];
 	buffer.getChars(0, nameLengththis., 0);
 
 	return this.;
 }
 /*
  * This method is used to record references to nested types inside the method signature.
  * This is the one that must be used during code generation.
  *
  * See https://bugs.eclipse.org/bugs/show_bug.cgi?id=171184
  */
 public final char[] signature(ClassFile classFile) {
 	if (this. != null) {
 		if ((this. & .) != 0) {
 			// we need to record inner classes references
 			boolean isConstructor = isConstructor();
 			TypeBinding[] targetParameters = this.;
 			boolean needSynthetics = isConstructor && this..isNestedType();
 			if (needSynthetics) {
 				// take into account the synthetic argument type signatures as well
 				ReferenceBinding[] syntheticArgumentTypes = this..syntheticEnclosingInstanceTypes();
 				if (syntheticArgumentTypes != null) {
 					for (int i = 0, count = syntheticArgumentTypes.lengthi < counti++) {
 						ReferenceBinding syntheticArgumentType = syntheticArgumentTypes[i];
 						if ((syntheticArgumentType.tagBits & .) != 0) {
 							Util.recordNestedType(classFilesyntheticArgumentType);
 						}
 					}
 				}
 				if (this instanceof SyntheticMethodBinding) {
 					targetParameters = ((SyntheticMethodBinding)this)..;
 				}
 			}
 
 			if (targetParameters != .) {
 				for (int i = 0, max = targetParameters.lengthi < maxi++) {
 					TypeBinding targetParameter = targetParameters[i];
 					TypeBinding leafTargetParameterType = targetParameter.leafComponentType();
 					if ((leafTargetParameterType.tagBits & .) != 0) {
 						Util.recordNestedType(classFileleafTargetParameterType);
 					}
 				}
 			}
 			if (needSynthetics) {
 				// move the extra padding arguments of the synthetic constructor invocation to the end
 				for (int i = targetParameters.lengthextraLength = this..lengthi < extraLengthi++) {
 					TypeBinding parameter = this.[i];
					TypeBinding leafParameterType = parameter.leafComponentType();
					if ((leafParameterType.tagBits & .) != 0) {
						Util.recordNestedType(classFileleafParameterType);
			if (this. != null) {
				if ((ret.tagBits & .) != 0) {
					Util.recordNestedType(classFileret);
		return this.;
	StringBuffer buffer = new StringBuffer((this..length + 1) * 20);
	buffer.append('(');
	TypeBinding[] targetParameters = this.;
	boolean isConstructor = isConstructor();
	if (isConstructor && this..isEnum()) { // insert String name,int ordinal
	boolean needSynthetics = isConstructor && this..isNestedType();
	if (needSynthetics) {
		// take into account the synthetic argument type signatures as well
		ReferenceBinding[] syntheticArgumentTypes = this.