/*******************************************************************************
- * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
+ * 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 v0.5
+ * 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-v05.html
+ * 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.phpdt.internal.compiler.ast.AbstractMethodDeclaration;
import net.sourceforge.phpdt.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;
+
+ protected MethodBinding() {
}
-}
-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;
+ 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;
+ }
+ }
- 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 MethodBinding(int modifiers, TypeBinding[] args,
+ ReferenceBinding[] exceptions, ReferenceBinding declaringClass) {
+ this(modifiers, ConstructorDeclaration.ConstantPoolName, VoidBinding,
+ args, exceptions, declaringClass);
+ }
-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();
- }
+ // 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;
+ }
- ReferenceBinding outerDeclaringClass = declaringClass;
- temp = outerDeclaringClass.enclosingType();
- while (temp != null) {
- outerDeclaringClass = temp;
- temp = temp.enclosingType();
- }
- return outerInvocationType == outerDeclaringClass;
+ /*
+ * 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;
}
- // 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;
+ /*
+ * API Answer the receiver's binding type from Binding.BindingID.
+ */
+
+ public final int bindingType() {
+ return METHOD;
}
- 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;
+ /*
+ * 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 (invocationType != declaringClass) {
+ 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) {
outerDeclaringClass = temp;
temp = temp.enclosingType();
}
- if (outerInvocationType != outerDeclaringClass) return false;
+ return outerInvocationType == outerDeclaringClass;
}
- return true;
+
+ // isDefault()
+ return invocationType.fPackage == declaringClass.fPackage;
}
- // isDefault()
- if (invocationType.fPackage != declaringClass.fPackage) return false;
+ /*
+ * 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;
+ }
- // receiverType can be an array binding in one case... see if you can change it
- if (receiverType instanceof ArrayBinding)
+ // 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;
- 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
-*/
+ /*
+ * 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 boolean isConstructor() {
- return selector == ConstructorDeclaration.ConstantPoolName;
-}
-protected boolean isConstructorRelated() {
- return isConstructor();
-}
-/* Answer true if the receiver has default visibility
-*/
+ public final int getAccessFlags() {
+ return modifiers & AccJustFlag;
+ }
-public final boolean isDefault() {
- return !isPublic() && !isProtected() && !isPrivate();
-}
-/* Answer true if the receiver is a system generated default abstract method
-*/
+ /*
+ * Answer true if the receiver is an abstract method
+ */
+ public final boolean isAbstract() {
+ return (modifiers & AccAbstract) != 0;
+ }
-public final boolean isDefaultAbstract() {
- return (modifiers & AccDefaultAbstract) != 0;
-}
-/* Answer true if the receiver is a deprecated method
-*/
+ /*
+ * Answer true if the receiver is a constructor
+ */
+ public final boolean isConstructor() {
+ return selector == ConstructorDeclaration.ConstantPoolName;
+ }
-public final boolean isDeprecated() {
- return (modifiers & AccDeprecated) != 0;
-}
-/* Answer true if the receiver is final and cannot be overridden
-*/
+ protected boolean isConstructorRelated() {
+ return isConstructor();
+ }
-public final boolean isFinal() {
- return (modifiers & AccFinal) != 0;
-}
-/* Answer true if the receiver is a native method
-*/
+ /*
+ * Answer true if the receiver has default visibility
+ */
+ public final boolean isDefault() {
+ return !isPublic() && !isProtected() && !isPrivate();
+ }
-public final boolean isNative() {
- return (modifiers & AccNative) != 0;
-}
-/* Answer true if the receiver has private visibility
-*/
+ /*
+ * Answer true if the receiver is a system generated default abstract method
+ */
+ public final boolean isDefaultAbstract() {
+ return (modifiers & AccDefaultAbstract) != 0;
+ }
-public final boolean isPrivate() {
- return (modifiers & AccPrivate) != 0;
-}
-/* Answer true if the receiver has protected visibility
-*/
+ /*
+ * Answer true if the receiver is a deprecated method
+ */
+ public final boolean isDeprecated() {
+ return (modifiers & AccDeprecated) != 0;
+ }
-public final boolean isProtected() {
- return (modifiers & AccProtected) != 0;
-}
-/* Answer true if the receiver has public visibility
-*/
+ /*
+ * Answer true if the receiver is final and cannot be overridden
+ */
+ public final boolean isFinal() {
+ return (modifiers & AccFinal) != 0;
+ }
-public final boolean isPublic() {
- return (modifiers & AccPublic) != 0;
-}
-/* Answer true if the receiver got requested to clear the private modifier
- * during private access emulation.
- */
+ /*
+ * 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;
+ }
-public final boolean isRequiredToClearPrivateModifier() {
- return (modifiers & AccClearPrivateModifier) != 0;
-}
-/* Answer true if the receiver is a static method
-*/
+ /*
+ * 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;
+ }
-public final boolean isStatic() {
- return (modifiers & AccStatic) != 0;
-}
-/* Answer true if all float operations must adher to IEEE 754 float/double rules
-*/
+ /*
+ * 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;
+ }
-public final boolean isStrictfp() {
- return (modifiers & AccStrictfp) != 0;
-}
-/* Answer true if the receiver is a synchronized method
-*/
+ /*
+ * Answer true if the receiver has private visibility
+ */
+ public final boolean isPrivate() {
+ return (modifiers & AccPrivate) != 0;
+ }
-public final boolean isSynchronized() {
- return (modifiers & AccSynchronized) != 0;
-}
-/* Answer true if the receiver has public visibility
-*/
+ /*
+ * Answer true if the receiver has private visibility and is used locally
+ */
+ public final boolean isPrivateUsed() {
+ return (modifiers & AccPrivateUsed) != 0;
+ }
-public final boolean isSynthetic() {
- return (modifiers & AccSynthetic) != 0;
-}
-/* Answer true if the receiver's declaring type is deprecated (or any of its enclosing types)
-*/
+ /*
+ * Answer true if the receiver has protected visibility
+ */
+ public final boolean isProtected() {
+ return (modifiers & AccProtected) != 0;
+ }
-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());
- }
+ /*
+ * Answer true if the receiver has public visibility
+ */
+ public final boolean isPublic() {
+ return (modifiers & AccPublic) != 0;
}
- 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('(');
- if (isConstructorRelated() && declaringClass.isNestedType()) {
- // 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());
- SyntheticArgumentBinding[] syntheticArguments = declaringClass.syntheticOuterLocalVariables();
- count = syntheticArguments == null ? 0 : syntheticArguments.length;
- for (int i = 0; i < count; i++)
- buffer.append(syntheticArguments[i].type.signature());
- }
- if (parameters != NoParameters)
- for (int i = 0, length = parameters.length; i < length; 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$
+ /*
+ * Answer true if the receiver got requested to clear the private modifier
+ * during private access emulation.
+ */
+ public final boolean isRequiredToClearPrivateModifier() {
+ return (modifiers & AccClearPrivateModifier) != 0;
+ }
- s += "("; //$NON-NLS-1$
- if (parameters != null) {
+ /*
+ * 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)
- s += ", "; //$NON-NLS-1$
- s += (parameters[i] != null) ? parameters[i].debugName() : "NULL TYPE"; //$NON-NLS-1$
+ if (i > 0)
+ buffer.append(", "); //$NON-NLS-1$
+ buffer.append(parameters[i].sourceName());
}
}
- } 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$
+ buffer.append(')');
+ return buffer.toString().toCharArray();
+ }
+
+ /**
+ * @see net.sourceforge.phpdt.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());
}
}
- } else {
- s += "NULL THROWN EXCEPTIONS"; //$NON-NLS-1$
+ 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;
}
- return s;
-}
}
git://secure.phpeclipse.com / phpeclipse.git / blobdiff