rogue file removed!aj_v_574_R31X

1 files changed, 0 insertions, 1054 deletions

diff --git a/org.eclipse.jdt.core/compiler/org/aspectj/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java b/org.eclipse.jdt.core/compiler/org/aspectj/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
deleted file mode 100644
index 86fcde1c..00000000
--- a/org.eclipse.jdt.core/compiler/org/aspectj/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
+++ /dev/null
@@ -1,1054 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2007 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
- *     Palo Alto Research Center, Incorporated - AspectJ adaptation
- ******************************************************************************/
-package org.aspectj.org.eclipse.jdt.internal.compiler.lookup;
-
-import org.aspectj.org.eclipse.jdt.core.compiler.CharOperation;
-import org.aspectj.org.eclipse.jdt.internal.compiler.ClassFile;
-import org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode;
-import org.aspectj.org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
-import org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
-import org.aspectj.org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
-import org.aspectj.org.eclipse.jdt.internal.compiler.codegen.ConstantPool;
-
-/**
- * AspectJ Extension- hooks for subtypes
- */
-public class MethodBinding extends Binding {
-	
-	public int modifiers;
-	public char[] selector;
-	public TypeBinding returnType;
-	public TypeBinding[] parameters;
-	public ReferenceBinding[] thrownExceptions;
-	public ReferenceBinding declaringClass;
-	public TypeVariableBinding[] typeVariables = Binding.NO_TYPE_VARIABLES;
-	char[] signature;
-	public long tagBits;
-	
-protected MethodBinding() {
-	// for creating problem or synthetic method
-}
-public MethodBinding(int modifiers, char[] selector, TypeBinding returnType, TypeBinding[] parameters, ReferenceBinding[] thrownExceptions, ReferenceBinding declaringClass) {
-	this.modifiers = modifiers;
-	this.selector = selector;
-	this.returnType = returnType;
-	this.parameters = (parameters == null || parameters.length == 0) ? Binding.NO_PARAMETERS : parameters;
-	this.thrownExceptions = (thrownExceptions == null || thrownExceptions.length == 0) ? Binding.NO_EXCEPTIONS : thrownExceptions;
-	this.declaringClass = declaringClass;
-	
-	// propagate the strictfp & deprecated modifiers
-	if (this.declaringClass != null) {
-		if (this.declaringClass.isStrictfp())
-			if (!(isNative() || isAbstract()))
-				this.modifiers |= ClassFileConstants.AccStrictfp;
-	}
-}
-public MethodBinding(int modifiers, TypeBinding[] parameters, ReferenceBinding[] thrownExceptions, ReferenceBinding declaringClass) {
-	this(modifiers, TypeConstants.INIT, TypeBinding.VOID, parameters, thrownExceptions, declaringClass);
-}
-// special API used to change method declaring class for runtime visibility check
-public MethodBinding(MethodBinding initialMethodBinding, ReferenceBinding declaringClass) {
-	this.modifiers = initialMethodBinding.modifiers;
-	this.selector = initialMethodBinding.selector;
-	this.returnType = initialMethodBinding.returnType;
-	this.parameters = initialMethodBinding.parameters;
-	this.thrownExceptions = initialMethodBinding.thrownExceptions;
-	this.declaringClass = declaringClass;
-	if (declaringClass!=null) declaringClass.storeAnnotationHolder(this, initialMethodBinding.declaringClass.retrieveAnnotationHolder(initialMethodBinding, true)); // New AspectJ Extension - check for null
-}
-/* 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 (parameters == args)
-		return true;
-
-	int length = parameters.length;
-	if (length != args.length)
-		return false;
-
-	for (int i = 0; i < length; i++)
-		if (parameters[i] != args[i] && parameters[i].erasure() != args[i].erasure())
-			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 (parameters == args)
-		return true;
-
-	int length = parameters.length;
-	if (length != args.length)
-		return false;
-	
-	for (int i = 0; i < length; i++)
-		if (parameters[i] != args[i])
-			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.parameters.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 = parameters[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 = ((ArrayBinding) parameters[lastIndex]).elementsType();
-			for (int i = lastIndex; i < argLength; i++)
-				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 < lastIndex; i++)
-		if (parameters[i] != arguments[i] && !arguments[i].isCompatibleWith(parameters[i]))
-			return false;
-	return true;
-}
-
-/* API
-* Answer the receiver's binding type from Binding.BindingID.
-*/
-
-public final int kind() {
-	return Binding.METHOD;
-}
-/* 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 == declaringClass.getPackage();
-}
-/* Answer true if the type variables have the same erasure
-*/
-public final boolean areTypeVariableErasuresEqual(MethodBinding method) {
-	TypeVariableBinding[] vars = method.typeVariables;
-	if (this.typeVariables == vars)
-		return true;
-
-	int length = this.typeVariables.length;
-	if (length != vars.length)
-		return false;
-
-	for (int i = 0; i < length; i++)
-		if (this.typeVariables[i] != vars[i] && this.typeVariables[i].erasure() != vars[i].erasure())
-			return false;
-	return true;
-}
-/* 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.
-*/
-
-//AspectJ Extension - made non-final
-public boolean canBeSeenBy(InvocationSite invocationSite, Scope scope) {
-	if (isPublic()) return true;
-
-    ReferenceBinding declaringType = original().declaringClass;  // AspectJ Extension - new local variable to hold the declaringType
-
-	SourceTypeBinding invocationType = scope.invocationType();//NewNew AspectJ Extension - enclosingSourceType();
-	if (invocationType == declaringType) return true; // AspectJ Extension - was declaringClass
-
-	if (isProtected()) {
-		// answer true if the receiver is in the same package as the invocationType
-		if (invocationType.fPackage == declaringType.fPackage) return true; // AspectJ Extension - was == declaringClass.fPackage
-		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)declaringType.erasure(); // AspectJ Extension - changed declaringClass to declaringType
-		temp = outerDeclaringClass.enclosingType();
-		while (temp != null) {
-			outerDeclaringClass = temp;
-			temp = temp.enclosingType();
-		}
-		return outerInvocationType == outerDeclaringClass;
-	}
-
-	// isDefault()
-	return invocationType.fPackage == declaringType.fPackage; // AspectJ Extension - changed declaringClass to declaringType
-}
-
-//AspectJ Extension
-public MethodBinding getVisibleBinding(TypeBinding receiverType, InvocationSite invocationSite, Scope scope) {
-	if (canBeSeenBy(receiverType, invocationSite, scope)) return this;
-	return findPrivilegedBinding(scope.invocationType(), (ASTNode)invocationSite);
-}
-
-public MethodBinding getVisibleBinding(InvocationSite invocationSite, Scope scope) {
-	if (canBeSeenBy(invocationSite, scope)) return this;
-	return findPrivilegedBinding(scope.invocationType(), (ASTNode)invocationSite);
-}
-
-
-public MethodBinding findPrivilegedBinding(SourceTypeBinding invocationType, ASTNode location) {
-	if (Scope.findPrivilegedHandler(invocationType) != null) {
-		return Scope.findPrivilegedHandler(invocationType).getPrivilegedAccessMethod(this, location); //notePrivilegedTypeAccess(this, null);
-	} else {
-		return null;
-	}
-}
-// End AspectJ Extension
-
-/* 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.
-*/
-//AspectJ Extension - made non-final
-public boolean canBeSeenBy(TypeBinding receiverType, InvocationSite invocationSite, Scope scope) {
-	if (isPublic()) return true;
-
-	SourceTypeBinding invocationType = scope.invocationType(); // AspectJ Extension - was scope.enclosingSourceType()
-	if (invocationType == declaringClass && invocationType == receiverType) return true;
-
-	if (invocationType == null) // static import call
-		return !isPrivate() && scope.getCurrentPackage() == declaringClass.fPackage;
-
-	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 == declaringClass) return true;
-		if (invocationType.fPackage == declaringClass.fPackage) return true;
-		
-		//	AspectJ Extension
-		// replaced this one line:
-        // ReferenceBinding currentType = invocationType;
-        // with:
-		// for protected we need to check based on the type of this
-		ReferenceBinding currentType = scope.enclosingSourceType(); //invocationType();// NewNew AspectJ Extension - was enclosingSourceType();
-		// MUST be in the same package as the invocationType though... (pr 71723)
-		if (invocationType != currentType) {
-		    // this MUST be an ITD
-		    if (invocationType.fPackage != currentType.fPackage) return false;
-		}
-		//	End AspectJ Extension
-		TypeBinding receiverErasure = receiverType.erasure();		
-		ReferenceBinding declaringErasure = (ReferenceBinding) declaringClass.erasure();
-		int depth = 0;
-		do {
-			if (currentType.findSuperTypeWithSameErasure(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.findSuperTypeWithSameErasure(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 != declaringClass) {
-				// special tolerance for type variable direct bounds
-				if (receiverType.isTypeVariable() && ((TypeVariableBinding) receiverType).isErasureBoundTo(declaringClass.erasure()))
-					break receiverCheck;
-				return false;
-			}
-		}
-
-		if (invocationType != declaringClass) {
-			ReferenceBinding outerInvocationType = invocationType;
-			ReferenceBinding temp = outerInvocationType.enclosingType();
-			while (temp != null) {
-				outerInvocationType = temp;
-				temp = temp.enclosingType();
-			}
-
-			ReferenceBinding outerDeclaringClass = (ReferenceBinding)declaringClass.erasure();
-			temp = outerDeclaringClass.enclosingType();
-			while (temp != null) {
-				outerDeclaringClass = temp;
-				temp = temp.enclosingType();
-			}
-			if (outerInvocationType != outerDeclaringClass) return false;
-		}
-		return true;
-	}
-
-	// isDefault()
-	PackageBinding declaringPackage = declaringClass.fPackage;
-	if (invocationType.fPackage != declaringPackage) return false;
-
-	// receiverType can be an array binding in one case... see if you can change it
-	if (receiverType instanceof ArrayBinding)
-		return false;
-	ReferenceBinding currentType = (ReferenceBinding) receiverType;
-	do {
-		if (declaringClass == currentType) return true;
-		PackageBinding currentPackage = currentType.fPackage;
-		// package could be null for wildcards/intersection types, ignore and recurse in superclass
-		if (currentPackage != null && currentPackage != declaringPackage) return false;
-	} while ((currentType = currentType.superclass()) != null);
-	return false;
-}
-MethodBinding computeSubstitutedMethod(MethodBinding method, LookupEnvironment env) {
-	int length = this.typeVariables.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;}
-	ParameterizedGenericMethodBinding substitute =
-		env.createParameterizedGenericMethod(method, this.typeVariables);
-	for (int i = 0; i < length; i++)
-		if (!this.typeVariables[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.declaringClass.computeUniqueKey(false/*not a leaf*/);
-	int declaringLength = declaringKey.length;
-	
-	// selector
-	int selectorLength = this.selector == TypeConstants.INIT ? 0 : this.selector.length;
-	
-	// generic signature
-	char[] sig = genericSignature();
-	boolean isGeneric = sig != null;
-	if (!isGeneric) sig = signature();
-	int signatureLength = sig.length;
-	
-	// thrown exceptions
-	int thrownExceptionsLength = this.thrownExceptions.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 < thrownExceptionsLength; i++) {
-			if (this.thrownExceptions[i] != null) {
-				thrownExceptionsSignatures[i] = this.thrownExceptions[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, uniqueKey, index, declaringLength);
-	index = declaringLength;
-	uniqueKey[index++] = '.';
-	System.arraycopy(this.selector, 0, uniqueKey, index, selectorLength);
-	index += selectorLength;
-	System.arraycopy(sig, 0, uniqueKey, index, signatureLength);
-	if (thrownExceptionsSignatureLength > 0) {
-		index += signatureLength;
-		for (int i = 0; i < thrownExceptionsLength; i++) {
-			char[] thrownExceptionSignature = thrownExceptionsSignatures[i];
-			if (thrownExceptionSignature != null) {
-				uniqueKey[index++] = '|';
-				int length = thrownExceptionSignature.length;
-				System.arraycopy(thrownExceptionSignature, 0, uniqueKey, index, length);
-				index += length;
-			}
-		}
-	}
-
-	return uniqueKey;
-}
-/* 
- * Answer the declaring class to use in the constant pool
- * may not be a reference binding (see subtypes)
- */
-public TypeBinding constantPoolDeclaringClass() {
-	return this.declaringClass;
-}
-/* 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 selector;
-}
-/**
- *<typeParam1 ... typeParamM>(param1 ... paramN)returnType thrownException1 ... thrownExceptionP
- * T foo(T t) throws X<T>   --->   (TT;)TT;LX<TT;>;
- * void bar(X<T> t)   -->   (LX<TT;>;)V
- * <T> void bar(X<T> t)   -->  <T:Ljava.lang.Object;>(LX<TT;>;)V
- */
-public char[] genericSignature() {
-	if ((this.modifiers & ExtraCompilerModifiers.AccGenericSignature) == 0) return null;
-	StringBuffer sig = new StringBuffer(10);
-	if (this.typeVariables != Binding.NO_TYPE_VARIABLES) {
-		sig.append('<');
-		for (int i = 0, length = this.typeVariables.length; i < length; i++) {
-			sig.append(this.typeVariables[i].genericSignature());
-		}
-		sig.append('>');
-	}
-	sig.append('(');
-	for (int i = 0, length = this.parameters.length; i < length; i++) {
-		sig.append(this.parameters[i].genericTypeSignature());
-	}
-	sig.append(')');
-	if (this.returnType != null)
-		sig.append(this.returnType.genericTypeSignature());
-	
-	// only append thrown exceptions if any is generic/parameterized
-	boolean needExceptionSignatures = false;
-	int length = this.thrownExceptions.length;
-	for (int i = 0; i < length; i++) {
-		if((this.thrownExceptions[i].modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0) {
-			needExceptionSignatures = true;
-			break;
-		}
-	}
-	if (needExceptionSignatures) {
-		for (int i = 0; i < length; i++) {
-			sig.append('^');
-			sig.append(this.thrownExceptions[i].genericTypeSignature());
-		}
-	}
-	int sigLength = sig.length();
-	char[] genericSignature = new char[sigLength];
-	sig.getChars(0, sigLength, genericSignature, 0);	
-	return genericSignature;
-}
-public AnnotationBinding[] getAnnotations() {
-	MethodBinding originalMethod = this.original();
-	return originalMethod.declaringClass.retrieveAnnotations(originalMethod);
-}
-/**
- * @param index the index of the parameter of interest
- * @return the annotations on the <code>index</code>th parameter
- * @throws ArrayIndexOutOfBoundsException when <code>index</code> is not valid 
- */
-public AnnotationBinding[] getParameterAnnotations(int index) {
-	MethodBinding originalMethod = this.original();
-	AnnotationHolder holder = originalMethod.declaringClass.retrieveAnnotationHolder(originalMethod, true);
-	return holder == null ? Binding.NO_ANNOTATIONS : holder.getParameterAnnotations(index);
-}
-public final int getAccessFlags() {
-	return modifiers & ExtraCompilerModifiers.AccJustFlag;
-}
-
-/**
- * Compute the tagbits for standard annotations. For source types, these could require
- * lazily resolving corresponding annotation nodes, in case of forward references.
- * @see org.aspectj.org.eclipse.jdt.internal.compiler.lookup.Binding#getAnnotationTagBits()
- */
-public long getAnnotationTagBits() {
-	MethodBinding originalMethod = this.original();
-	if ((originalMethod.tagBits & TagBits.AnnotationResolved) == 0 && originalMethod.declaringClass instanceof SourceTypeBinding) {
-		ClassScope scope = ((SourceTypeBinding) originalMethod.declaringClass).scope;
-		if (scope != null) {
-			TypeDeclaration typeDecl = scope.referenceContext;
-			AbstractMethodDeclaration methodDecl = typeDecl.declarationOf(originalMethod);
-			if (methodDecl != null)
-				ASTNode.resolveAnnotations(methodDecl.scope, methodDecl.annotations, originalMethod);
-		}
-	}
-	return originalMethod.tagBits;
-}
-/**
- * @return the default value for this annotation method or <code>null</code> if there is no default value
- */
-public Object getDefaultValue() {
-	MethodBinding originalMethod = this.original();
-	if ((originalMethod.tagBits & TagBits.DefaultValueResolved) == 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 = (SourceTypeBinding) originalMethod.declaringClass;
-			if (sourceType.scope != null) {
-				AbstractMethodDeclaration methodDeclaration = originalMethod.sourceMethod();
-				if (methodDeclaration != null && methodDeclaration.isAnnotationMethod()) {
-					methodDeclaration.resolve(sourceType.scope);
-				}
-			}
-		}
-		originalMethod.tagBits |= TagBits.DefaultValueResolved;
-	}
-	AnnotationHolder holder = originalMethod.declaringClass.retrieveAnnotationHolder(originalMethod, true);
-	return holder == null ? null : holder.getDefaultValue();
-}
-public TypeVariableBinding getTypeVariable(char[] variableName) {
-	for (int i = this.typeVariables.length; --i >= 0;)
-		if (CharOperation.equals(this.typeVariables[i].sourceName, variableName))
-			return this.typeVariables[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 (modifiers & ClassFileConstants.AccAbstract) != 0;
-}
-
-/* Answer true if the receiver is a bridge method
-*/
-public final boolean isBridge() {
-	return (modifiers & ClassFileConstants.AccBridge) != 0;
-}
-
-/* Answer true if the receiver is a constructor
-*/
-public final boolean isConstructor() {
-	return selector == TypeConstants.INIT;
-}
-
-/* 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() {
-	return (modifiers & ExtraCompilerModifiers.AccDefaultAbstract) != 0;
-}
-
-/* Answer true if the receiver is a deprecated method
-*/
-public final boolean isDeprecated() {
-	return (modifiers & ClassFileConstants.AccDeprecated) != 0;
-}
-
-/* Answer true if the receiver is final and cannot be overridden
-*/
-public boolean isFinal() { // AspectJ Extension, made non-final
-	return (modifiers & ClassFileConstants.AccFinal) != 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() {
-	return (modifiers & ExtraCompilerModifiers.AccImplementing) != 0;
-}
-
-/* Answer true if the receiver is a native method
-*/
-public final boolean isNative() {
-	return (modifiers & ClassFileConstants.AccNative) != 0;
-}
-
-/* Answer true if the receiver is overriding another method
- * Only set for source methods
-*/
-public final boolean isOverriding() {
-	return (modifiers & ExtraCompilerModifiers.AccOverriding) != 0;
-}
-/*
- * Answer true if the receiver is a "public static void main(String[])" method
- */
-public final boolean isMain() {
-	if (this.selector.length == 4 && CharOperation.equals(this.selector, TypeConstants.MAIN)
-			&& ((this.modifiers & (ClassFileConstants.AccPublic | ClassFileConstants.AccStatic)) != 0)
-			&& TypeBinding.VOID == this.returnType  
-			&& this.parameters.length == 1) {
-		TypeBinding paramType = this.parameters[0];
-		if (paramType.dimensions() == 1 && paramType.leafComponentType().id == TypeIds.T_JavaLangString) {
-			return true;
-		}
-	}
-	return false;
-}
-/* Answer true if the receiver has private visibility
-*/
-public final boolean isPrivate() {
-	return (modifiers & ClassFileConstants.AccPrivate) != 0;
-}
-
-/* Answer true if the receiver has private visibility and is used locally
-*/
-public final boolean isUsed() {
-	return (modifiers & ExtraCompilerModifiers.AccLocallyUsed) != 0;
-}
-
-/* Answer true if the receiver has protected visibility
-*/
-public final boolean isProtected() {
-	return (modifiers & ClassFileConstants.AccProtected) != 0;
-}
-
-/* Answer true if the receiver has public visibility
-*/
-public final boolean isPublic() {
-	return (modifiers & ClassFileConstants.AccPublic) != 0;
-}
-
-/* Answer true if the receiver is a static method
-*/
-public final boolean isStatic() {
-	return (modifiers & ClassFileConstants.AccStatic) != 0;
-}
-
-/* Answer true if all float operations must adher to IEEE 754 float/double rules
-*/
-public final boolean isStrictfp() {
-	return (modifiers & ClassFileConstants.AccStrictfp) != 0;
-}
-
-/* Answer true if the receiver is a synchronized method
-*/
-public final boolean isSynchronized() {
-	return (modifiers & ClassFileConstants.AccSynchronized) != 0;
-}
-
-/* Answer true if the receiver has public visibility
-*/
-public final boolean isSynthetic() {
-	return (modifiers & ClassFileConstants.AccSynthetic) != 0;
-}
-
-/* Answer true if the receiver method has varargs
-*/
-public final boolean isVarargs() {
-	return (modifiers & ClassFileConstants.AccVarargs) != 0;
-}
-
-/* Answer true if the receiver's declaring type is deprecated (or any of its enclosing types)
-*/
-public final boolean isViewedAsDeprecated() {
-	return (modifiers & (ClassFileConstants.AccDeprecated | ExtraCompilerModifiers.AccDeprecatedImplicitly)) != 0;
-}
-
-/**
- * Returns the original method (as opposed to parameterized instances)
- */
-public MethodBinding original() {
-	return this;
-}
-
-public char[] readableName() /* foo(int, Thread) */ {
-	StringBuffer buffer = new StringBuffer(parameters.length + 1 * 20);
-	if (isConstructor())
-		buffer.append(declaringClass.sourceName());
-	else
-		buffer.append(selector);
-	buffer.append('(');
-	if (parameters != Binding.NO_PARAMETERS) {
-		for (int i = 0, length = parameters.length; i < length; i++) {
-			if (i > 0)
-				buffer.append(", "); //$NON-NLS-1$
-			buffer.append(parameters[i].sourceName());
-		}
-	}
-	buffer.append(')');
-	return buffer.toString().toCharArray();
-}
-public void setAnnotations(AnnotationBinding[] annotations) {
-	this.declaringClass.storeAnnotations(this, annotations);
-}
-public void setAnnotations(AnnotationBinding[] annotations, AnnotationBinding[][] parameterAnnotations, Object defaultValue) {
-	this.declaringClass.storeAnnotationHolder(this,  AnnotationHolder.storeAnnotations(annotations, parameterAnnotations, defaultValue));
-}
-public void setDefaultValue(Object defaultValue) {
-	MethodBinding originalMethod = this.original();
-	originalMethod.tagBits |= TagBits.DefaultValueResolved;
-
-	AnnotationHolder holder = this.declaringClass.retrieveAnnotationHolder(this, false);
-	if (holder == null)
-		setAnnotations(null, null, defaultValue);
-	else
-		setAnnotations(holder.getAnnotations(), holder.getParameterAnnotations(), defaultValue);
-}
-public void setParameterAnnotations(AnnotationBinding[][] parameterAnnotations) {
-	AnnotationHolder holder = this.declaringClass.retrieveAnnotationHolder(this, false);
-	if (holder == null)
-		setAnnotations(null, parameterAnnotations, null);
-	else
-		setAnnotations(holder.getAnnotations(), parameterAnnotations, holder.getDefaultValue());
-}
-/**
- * @see org.aspectj.org.eclipse.jdt.internal.compiler.lookup.Binding#shortReadableName()
- */
-public char[] shortReadableName() {
-	StringBuffer buffer = new StringBuffer(parameters.length + 1 * 20);
-	if (isConstructor())
-		buffer.append(declaringClass.shortReadableName());
-	else
-		buffer.append(selector);
-	buffer.append('(');
-	if (parameters != Binding.NO_PARAMETERS) {
-		for (int i = 0, length = parameters.length; i < length; i++) {
-			if (i > 0)
-				buffer.append(", "); //$NON-NLS-1$
-			buffer.append(parameters[i].shortReadableName());
-		}
-	}
-	buffer.append(')');
-	int nameLength = buffer.length();
-	char[] shortReadableName = new char[nameLength];
-	buffer.getChars(0, nameLength, shortReadableName, 0);	    
-	return shortReadableName;
-}
-
-protected final void setSelector(char[] selector) {
-	this.selector = selector;
-	this.signature = null;
-}
-
-/* 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 (signature != null)
-		return signature;
-
-	StringBuffer buffer = new StringBuffer(parameters.length + 1 * 20);
-	buffer.append('(');
-	
-	TypeBinding[] targetParameters = this.parameters;
-	boolean isConstructor = isConstructor();
-	if (isConstructor && declaringClass.isEnum()) { // insert String name,int ordinal 
-		buffer.append(ConstantPool.JavaLangStringSignature);
-		buffer.append(TypeBinding.INT.signature());
-	}
-	boolean needSynthetics = isConstructor && declaringClass.isNestedType();
-	if (needSynthetics) {
-		// take into account the synthetic argument type signatures as well
-		ReferenceBinding[] syntheticArgumentTypes = declaringClass.syntheticEnclosingInstanceTypes();
-		if (syntheticArgumentTypes != null) {
-			for (int i = 0, count = syntheticArgumentTypes.length; i < count; i++) {
-				buffer.append(syntheticArgumentTypes[i].signature());
-			}
-		}
-		
-		if (this instanceof SyntheticMethodBinding) {
-			targetParameters = ((SyntheticMethodBinding)this).targetMethod.parameters;
-		}
-	}
-
-	if (targetParameters != Binding.NO_PARAMETERS) {
-		for (int i = 0; i < targetParameters.length; i++) {
-			buffer.append(targetParameters[i].signature());
-		}
-	}
-	if (needSynthetics) {
-		SyntheticArgumentBinding[] syntheticOuterArguments = declaringClass.syntheticOuterLocalVariables();
-		int count = syntheticOuterArguments == null ? 0 : syntheticOuterArguments.length;
-		for (int i = 0; i < count; i++) {
-			buffer.append(syntheticOuterArguments[i].type.signature());
-		}
-		// move the extra padding arguments of the synthetic constructor invocation to the end		
-		for (int i = targetParameters.length, extraLength = parameters.length; i < extraLength; i++) {
-			buffer.append(parameters[i].signature());
-		}
-	}
-	buffer.append(')');
-	if (this.returnType != null)
-		buffer.append(this.returnType.signature());
-	int nameLength = buffer.length();
-	signature = new char[nameLength];
-	buffer.getChars(0, nameLength, signature, 0);	    
-	
-	return signature;
-}
-/*
- * 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 (signature != null) {
-		if ((this.tagBits & TagBits.ContainsNestedTypesInSignature) != 0) {
-			// we need to record inner classes references
-			boolean isConstructor = isConstructor();
-			TypeBinding[] targetParameters = this.parameters;
-			boolean needSynthetics = isConstructor && declaringClass.isNestedType();
-			if (needSynthetics) {
-				// take into account the synthetic argument type signatures as well
-				ReferenceBinding[] syntheticArgumentTypes = declaringClass.syntheticEnclosingInstanceTypes();
-				if (syntheticArgumentTypes != null) {
-					for (int i = 0, count = syntheticArgumentTypes.length; i < count; i++) {
-						ReferenceBinding syntheticArgumentType = syntheticArgumentTypes[i];
-						if (syntheticArgumentType.isNestedType()) {
-							classFile.recordInnerClasses(syntheticArgumentType);
-						}
-					}
-				}
-				if (this instanceof SyntheticMethodBinding) {
-					targetParameters = ((SyntheticMethodBinding)this).targetMethod.parameters;
-				}
-			}
-
-			if (targetParameters != Binding.NO_PARAMETERS) {
-				for (int i = 0; i < targetParameters.length; i++) {
-					TypeBinding targetParameter = targetParameters[i];
-					TypeBinding leafTargetParameterType = targetParameter.leafComponentType();
-					if (leafTargetParameterType.isNestedType()) {
-						classFile.recordInnerClasses(leafTargetParameterType);
-					}
-				}
-			}
-			if (needSynthetics) {
-				// move the extra padding arguments of the synthetic constructor invocation to the end		
-				for (int i = targetParameters.length, extraLength = parameters.length; i < extraLength; i++) {
-					TypeBinding parameter = parameters[i];
-					TypeBinding leafParameterType = parameter.leafComponentType();
-					if (leafParameterType.isNestedType()) {
-						classFile.recordInnerClasses(leafParameterType);
-					}
-				}
-			}
-			if (this.returnType != null) {
-				TypeBinding ret = this.returnType.leafComponentType();
-				if (ret.isNestedType()) {
-					classFile.recordInnerClasses(ret);
-				}
-			}
-		}
-		return signature;
-	}
-
-	StringBuffer buffer = new StringBuffer(parameters.length + 1 * 20);
-	buffer.append('(');
-	
-	TypeBinding[] targetParameters = this.parameters;
-	boolean isConstructor = isConstructor();
-	if (isConstructor && declaringClass.isEnum()) { // insert String name,int ordinal 
-		buffer.append(ConstantPool.JavaLangStringSignature);
-		buffer.append(TypeBinding.INT.signature());
-	}
-	boolean needSynthetics = isConstructor && declaringClass.isNestedType();
-	if (needSynthetics) {
-		// take into account the synthetic argument type signatures as well
-		ReferenceBinding[] syntheticArgumentTypes = declaringClass.syntheticEnclosingInstanceTypes();
-		if (syntheticArgumentTypes != null) {
-			for (int i = 0, count = syntheticArgumentTypes.length; i < count; i++) {
-				ReferenceBinding syntheticArgumentType = syntheticArgumentTypes[i];
-				if (syntheticArgumentType.isNestedType()) {
-					this.tagBits |= TagBits.ContainsNestedTypesInSignature;
-					classFile.recordInnerClasses(syntheticArgumentType);
-				}
-				buffer.append(syntheticArgumentType.signature());
-			}
-		}
-		
-		if (this instanceof SyntheticMethodBinding) {
-			targetParameters = ((SyntheticMethodBinding)this).targetMethod.parameters;
-		}
-	}
-
-	if (targetParameters != Binding.NO_PARAMETERS) {
-		for (int i = 0; i < targetParameters.length; i++) {
-			TypeBinding targetParameter = targetParameters[i];
-			TypeBinding leafTargetParameterType = targetParameter.leafComponentType();
-			if (leafTargetParameterType.isNestedType()) {
-				this.tagBits |= TagBits.ContainsNestedTypesInSignature;
-				classFile.recordInnerClasses(leafTargetParameterType);
-			}
-			buffer.append(targetParameter.signature());
-		}
-	}
-	if (needSynthetics) {
-		SyntheticArgumentBinding[] syntheticOuterArguments = declaringClass.syntheticOuterLocalVariables();
-		int count = syntheticOuterArguments == null ? 0 : syntheticOuterArguments.length;
-		for (int i = 0; i < count; i++) {
-			buffer.append(syntheticOuterArguments[i].type.signature());
-		}
-		// move the extra padding arguments of the synthetic constructor invocation to the end		
-		for (int i = targetParameters.length, extraLength = parameters.length; i < extraLength; i++) {
-			TypeBinding parameter = parameters[i];
-			TypeBinding leafParameterType = parameter.leafComponentType();
-			if (leafParameterType.isNestedType()) {
-				this.tagBits |= TagBits.ContainsNestedTypesInSignature;
-				classFile.recordInnerClasses(leafParameterType);
-			}
-			buffer.append(parameter.signature());
-		}
-	}
-	buffer.append(')');
-	if (this.returnType != null) {
-		TypeBinding ret = this.returnType.leafComponentType();
-		if (ret.isNestedType()) {
-			this.tagBits |= TagBits.ContainsNestedTypesInSignature;
-			classFile.recordInnerClasses(ret);
-		}
-		buffer.append(this.returnType.signature());
-	}
-	int nameLength = buffer.length();
-	signature = new char[nameLength];
-	buffer.getChars(0, nameLength, signature, 0);	    
-	
-	return signature;
-}
-public final int sourceEnd() {
-	AbstractMethodDeclaration method = sourceMethod();
-	if (method == null) {
-		if (this.declaringClass instanceof SourceTypeBinding)
-			return ((SourceTypeBinding) this.declaringClass).sourceEnd();
-		return 0;
-	}
-	return method.sourceEnd;
-}
-public AbstractMethodDeclaration sourceMethod() {
-	SourceTypeBinding sourceType;
-	//	AspectJ Extension
-	if (declaringClass instanceof BinaryTypeBinding) return null;
-	//	End AspectJ Extension
-	try {
-		sourceType = (SourceTypeBinding) declaringClass;
-	} catch (ClassCastException e) {
-		return null;		
-	}
-
-	// AspectJ Extension
-	// guard due to pr154923 - an npe occurs that is probably disguising an underlying problem that will be reported properly
-	if (sourceType.scope==null || sourceType.scope.referenceContext==null || sourceType.scope.referenceContext.methods==null) return null;
-	// End AspectJ Extension
-	AbstractMethodDeclaration[] methods = sourceType.scope.referenceContext.methods;
-	for (int i = methods.length; --i >= 0;)
-		if (this == methods[i].binding)
-			return methods[i];
-	return null;		
-}
-public final int sourceStart() {
-	AbstractMethodDeclaration method = sourceMethod();
-	if (method == null) {
-		if (this.declaringClass instanceof SourceTypeBinding)
-			return ((SourceTypeBinding) this.declaringClass).sourceStart();
-		return 0;
-	}
-	return method.sourceStart;
-}
-    //AspectJ Extension	
-	/**
-	 * Subtypes can override this to return true if an access method should be
-	 * used when referring to this method binding.  Currently used
-	 * for AspectJ's inter-type method declarations.
-	 */
-	public boolean alwaysNeedsAccessMethod() { return false; }
-
-
-	/**
-	 * This will only be called if alwaysNeedsAccessMethod() returns true.
-	 * In that case it should return the access method to be used.
-	 */
-	public MethodBinding getAccessMethod(boolean staticReference) {
-		throw new RuntimeException("unimplemented");
-	}
-	//	End AspectJ Extension
-
-public String toString() {
-	String s = (returnType != null) ? returnType.debugName() : "NULL TYPE"; //$NON-NLS-1$
-	s += " "; //$NON-NLS-1$
-	s += (selector != null) ? new String(selector) : "UNNAMED METHOD"; //$NON-NLS-1$
-
-	s += "("; //$NON-NLS-1$
-	if (parameters != null) {
-		if (parameters != Binding.NO_PARAMETERS) {
-			for (int i = 0, length = parameters.length; i < length; i++) {
-				if (i  > 0)
-					s += ", "; //$NON-NLS-1$
-				s += (parameters[i] != null) ? parameters[i].debugName() : "NULL TYPE"; //$NON-NLS-1$
-			}
-		}
-	} else {
-		s += "NULL PARAMETERS"; //$NON-NLS-1$
-	}
-	s += ") "; //$NON-NLS-1$
-
-	if (thrownExceptions != null) {
-		if (thrownExceptions != Binding.NO_EXCEPTIONS) {
-			s += "throws "; //$NON-NLS-1$
-			for (int i = 0, length = thrownExceptions.length; i < length; i++) {
-				if (i  > 0)
-					s += ", "; //$NON-NLS-1$
-				s += (thrownExceptions[i] != null) ? thrownExceptions[i].debugName() : "NULL TYPE"; //$NON-NLS-1$
-			}
-		}
-	} else {
-		s += "NULL THROWN EXCEPTIONS"; //$NON-NLS-1$
-	}
-	return s;
-}
-/**
- * Returns the method to use during tiebreak (usually the method itself).
- * For generic method invocations, tiebreak needs to use generic method with erasure substitutes.
- */
-public MethodBinding tiebreakMethod() {
-	return this;
-}
-public TypeVariableBinding[] typeVariables() {
-	return this.typeVariables;
-}
-}