X-Git-Url: http://git.phpeclipse.com

diff --git a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/lookup/MethodBinding.java b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/lookup/MethodBinding.java
new file mode 100644
index 0000000..85c5afa
--- /dev/null
+++ b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/lookup/MethodBinding.java
@@ -0,0 +1,520 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package net.sourceforge.phpdt.internal.compiler.lookup;
+
+import net.sourceforge.phpdt.core.compiler.CharOperation;
+import net.sourceforge.phpeclipse.internal.compiler.ast.AbstractMethodDeclaration;
+import net.sourceforge.phpeclipse.internal.compiler.ast.ConstructorDeclaration;
+
+public class MethodBinding extends Binding implements BaseTypes, TypeConstants {
+	public int modifiers;
+	public char[] selector;
+	public TypeBinding returnType;
+	public TypeBinding[] parameters;
+	public ReferenceBinding[] thrownExceptions;
+	public ReferenceBinding declaringClass;
+
+	char[] signature;
+
+protected MethodBinding() {
+}
+public MethodBinding(int modifiers, char[] selector, TypeBinding returnType, TypeBinding[] args, ReferenceBinding[] exceptions, ReferenceBinding declaringClass) {
+	this.modifiers = modifiers;
+	this.selector = selector;
+	this.returnType = returnType;
+	this.parameters = (args == null || args.length == 0) ? NoParameters : args;
+	this.thrownExceptions = (exceptions == null || exceptions.length == 0) ? NoExceptions : exceptions;
+	this.declaringClass = declaringClass;
+
+	// propagate the strictfp & deprecated modifiers
+	if (this.declaringClass != null) {
+//		if (this.declaringClass.isStrictfp())
+//			if (!(isNative() || isAbstract()))
+//				this.modifiers |= AccStrictfp;
+		if (this.declaringClass.isViewedAsDeprecated() && !isDeprecated())
+			this.modifiers |= AccDeprecatedImplicitly;
+	}
+}
+public MethodBinding(int modifiers, TypeBinding[] args, ReferenceBinding[] exceptions, ReferenceBinding declaringClass) {
+	this(modifiers, ConstructorDeclaration.ConstantPoolName, VoidBinding, args, exceptions, 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;
+}
+/* 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;
+}
+/* API
+* Answer the receiver's binding type from Binding.BindingID.
+*/
+
+public final int bindingType() {
+	return METHOD;
+}
+/* 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 invocationSite, Scope scope) {
+	if (isPublic()) return true;
+
+	SourceTypeBinding invocationType = scope.enclosingSourceType();
+	if (invocationType == declaringClass) return true;
+
+	if (isProtected()) {
+		// answer true if the receiver is in the same package as the invocationType
+		if (invocationType.fPackage == declaringClass.fPackage) 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 = declaringClass;
+		temp = outerDeclaringClass.enclosingType();
+		while (temp != null) {
+			outerDeclaringClass = temp;
+			temp = temp.enclosingType();
+		}
+		return outerInvocationType == outerDeclaringClass;
+	}
+
+	// isDefault()
+	return invocationType.fPackage == declaringClass.fPackage;
+}
+/* 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 receiverType, InvocationSite invocationSite, Scope scope) {
+	if (isPublic()) return true;
+
+	SourceTypeBinding invocationType = scope.enclosingSourceType();
+	if (invocationType == declaringClass && invocationType == receiverType) return 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 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;
+		
+		ReferenceBinding currentType = invocationType;
+		int depth = 0;
+		do {
+			if (declaringClass.isSuperclassOf(currentType)) {
+				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()){
+					return true; // see 1FMEPDL - return invocationSite.isTypeAccess();
+				}
+				if (currentType == receiverType || currentType.isSuperclassOf((ReferenceBinding) receiverType)){
+					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
+		if (receiverType != declaringClass) return false;
+
+		if (invocationType != declaringClass) {
+			ReferenceBinding outerInvocationType = invocationType;
+			ReferenceBinding temp = outerInvocationType.enclosingType();
+			while (temp != null) {
+				outerInvocationType = temp;
+				temp = temp.enclosingType();
+			}
+
+			ReferenceBinding outerDeclaringClass = declaringClass;
+			temp = outerDeclaringClass.enclosingType();
+			while (temp != null) {
+				outerDeclaringClass = temp;
+				temp = temp.enclosingType();
+			}
+			if (outerInvocationType != outerDeclaringClass) return false;
+		}
+		return true;
+	}
+
+	// isDefault()
+	if (invocationType.fPackage != declaringClass.fPackage) return false;
+
+	// receiverType can be an array binding in one case... see if you can change it
+	if (receiverType instanceof ArrayBinding)
+		return false;
+	ReferenceBinding type = (ReferenceBinding) receiverType;
+	PackageBinding declaringPackage = declaringClass.fPackage;
+	do {
+		if (declaringClass == type) return true;
+		if (declaringPackage != type.fPackage) return false;
+	} while ((type = type.superclass()) != null);
+	return false;
+}
+
+/* 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;
+}
+public final int getAccessFlags() {
+	return modifiers & AccJustFlag;
+}
+
+/* Answer true if the receiver is an abstract method
+*/
+public final boolean isAbstract() {
+	return (modifiers & AccAbstract) != 0;
+}
+
+/* Answer true if the receiver is a constructor
+*/
+public final boolean isConstructor() {
+	return selector == ConstructorDeclaration.ConstantPoolName;
+}
+protected boolean isConstructorRelated() {
+	return isConstructor();
+}
+
+/* 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 & AccDefaultAbstract) != 0;
+}
+
+/* Answer true if the receiver is a deprecated method
+*/
+public final boolean isDeprecated() {
+	return (modifiers & AccDeprecated) != 0;
+}
+
+/* Answer true if the receiver is final and cannot be overridden
+*/
+public final boolean isFinal() {
+	return (modifiers & 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 & AccImplementing) != 0;
+}
+
+/* Answer true if the receiver is a native method
+*/
+//public final boolean isNative() {
+//	return (modifiers & AccNative) != 0;
+//}
+
+/* Answer true if the receiver is overriding another method
+ * Only set for source methods
+*/
+public final boolean isOverriding() {
+	return (modifiers & 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, MAIN)
+			&& ((this.modifiers & (AccPublic | AccStatic)) != 0)
+			&& VoidBinding == 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 & AccPrivate) != 0;
+}
+
+/* Answer true if the receiver has private visibility and is used locally
+*/
+public final boolean isPrivateUsed() {
+	return (modifiers & AccPrivateUsed) != 0;
+}
+
+/* Answer true if the receiver has protected visibility
+*/
+public final boolean isProtected() {
+	return (modifiers & AccProtected) != 0;
+}
+
+/* Answer true if the receiver has public visibility
+*/
+public final boolean isPublic() {
+	return (modifiers & AccPublic) != 0;
+}
+
+/* Answer true if the receiver got requested to clear the private modifier
+ * during private access emulation.
+ */
+public final boolean isRequiredToClearPrivateModifier() {
+	return (modifiers & AccClearPrivateModifier) != 0;
+}
+
+/* Answer true if the receiver is a static method
+*/
+public final boolean isStatic() {
+	return (modifiers & AccStatic) != 0;
+}
+
+/* Answer true if all float operations must adher to IEEE 754 float/double rules
+*/
+//public final boolean isStrictfp() {
+//	return (modifiers & AccStrictfp) != 0;
+//}
+
+/* Answer true if the receiver is a synchronized method
+*/
+//public final boolean isSynchronized() {
+//	return (modifiers & AccSynchronized) != 0;
+//}
+
+/* Answer true if the receiver has public visibility
+*/
+//public final boolean isSynthetic() {
+//	return (modifiers & AccSynthetic) != 0;
+//}
+
+/* Answer true if the receiver's declaring type is deprecated (or any of its enclosing types)
+*/
+public final boolean isViewedAsDeprecated() {
+	return (modifiers & AccDeprecated) != 0 ||
+		(modifiers & AccDeprecatedImplicitly) != 0;
+}
+
+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 != NoParameters) {
+		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();
+}
+
+/**
+ * @see 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 != NoParameters) {
+		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(')');
+	return buffer.toString().toCharArray();
+}
+
+protected final void selector(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 considerSynthetics = isConstructorRelated() && declaringClass.isNestedType();
+	if (considerSynthetics) {
+		
+		// take into account the synthetic argument type signatures as well
+		ReferenceBinding[] syntheticArgumentTypes = declaringClass.syntheticEnclosingInstanceTypes();
+		int count = syntheticArgumentTypes == null ? 0 : syntheticArgumentTypes.length;
+		for (int i = 0; i < count; i++) {
+			buffer.append(syntheticArgumentTypes[i].signature());
+		}
+		
+		if (this instanceof SyntheticAccessMethodBinding) {
+			targetParameters = ((SyntheticAccessMethodBinding)this).targetMethod.parameters;
+		}
+	}
+
+	if (targetParameters != NoParameters) {
+		for (int i = 0; i < targetParameters.length; i++) {
+			buffer.append(targetParameters[i].signature());
+		}
+	}
+	if (considerSynthetics) {
+		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(')');
+	buffer.append(returnType.signature());
+	return signature = buffer.toString().toCharArray();
+}
+public final int sourceEnd() {
+	AbstractMethodDeclaration method = sourceMethod();
+	if (method == null)
+		return 0;
+	else
+		return method.sourceEnd;
+}
+AbstractMethodDeclaration sourceMethod() {
+	SourceTypeBinding sourceType;
+	try {
+		sourceType = (SourceTypeBinding) declaringClass;
+	} catch (ClassCastException e) {
+		return null;		
+	}
+
+	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)
+		return 0;
+	else
+		return method.sourceStart;
+}
+/* During private access emulation, the binding can be requested to loose its
+ * private visibility when the class file is dumped.
+ */
+
+public final void tagForClearingPrivateModifier() {
+	modifiers |= AccClearPrivateModifier;
+}
+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 != NoParameters) {
+			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 != NoExceptions) {
+			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;
+}
+}