net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/lookup/MethodBinding.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v0.5
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v05.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  ******************************************************************************/
  11 package net.sourceforge.phpdt.internal.compiler.lookup;
  12
  13 import net.sourceforge.phpdt.internal.compiler.ast.AbstractMethodDeclaration;
  14 import net.sourceforge.phpdt.internal.compiler.ast.ConstructorDeclaration;
  15
  16 public class MethodBinding extends Binding implements BaseTypes, TypeConstants {
  17         public int modifiers;
  18         public char[] selector;
  19         public TypeBinding returnType;
  20         public TypeBinding[] parameters;
  21         public ReferenceBinding[] thrownExceptions;
  22         public ReferenceBinding declaringClass;
  23
  24         char[] signature;
  25 protected MethodBinding() {
  26 }
  27 public MethodBinding(int modifiers, char[] selector, TypeBinding returnType, TypeBinding[] args, ReferenceBinding[] exceptions, ReferenceBinding declaringClass) {
  28         this.modifiers = modifiers;
  29         this.selector = selector;
  30         this.returnType = returnType;
  31         this.parameters = (args == null || args.length == 0) ? NoParameters : args;
  32         this.thrownExceptions = (exceptions == null || exceptions.length == 0) ? NoExceptions : exceptions;
  33         this.declaringClass = declaringClass;
  34
  35         // propagate the strictfp & deprecated modifiers
  36         if (this.declaringClass != null) {
  37                 if (this.declaringClass.isStrictfp())
  38                         if (!(isNative() || isAbstract()))
  39                                 this.modifiers |= AccStrictfp;
  40                 if (this.declaringClass.isViewedAsDeprecated() && !isDeprecated())
  41                         this.modifiers |= AccDeprecatedImplicitly;
  42         }
  43 }
  44 public MethodBinding(int modifiers, TypeBinding[] args, ReferenceBinding[] exceptions, ReferenceBinding declaringClass) {
  45         this(modifiers, ConstructorDeclaration.ConstantPoolName, VoidBinding, args, exceptions, declaringClass);
  46 }
  47 // special API used to change method declaring class for runtime visibility check
  48 public MethodBinding(MethodBinding initialMethodBinding, ReferenceBinding declaringClass) {
  49         this.modifiers = initialMethodBinding.modifiers;
  50         this.selector = initialMethodBinding.selector;
  51         this.returnType = initialMethodBinding.returnType;
  52         this.parameters = initialMethodBinding.parameters;
  53         this.thrownExceptions = initialMethodBinding.thrownExceptions;
  54         this.declaringClass = declaringClass;
  55 }
  56 /* Answer true if the argument types & the receiver's parameters are equal
  57 */
  58
  59 public final boolean areParametersEqual(MethodBinding method) {
  60         TypeBinding[] args = method.parameters;
  61         if (parameters == args)
  62                 return true;
  63
  64         int length = parameters.length;
  65         if (length != args.length)
  66                 return false;
  67
  68         for (int i = 0; i < length; i++)
  69                 if (parameters[i] != args[i])
  70                         return false;
  71         return true;
  72 }
  73 /* API
  74 * Answer the receiver's binding type from Binding.BindingID.
  75 */
  76
  77 public final int bindingType() {
  78         return METHOD;
  79 }
  80 /* Answer true if the receiver is visible to the type provided by the scope.
  81 * InvocationSite implements isSuperAccess() to provide additional information
  82 * if the receiver is protected.
  83 *
  84 * NOTE: This method should ONLY be sent if the receiver is a constructor.
  85 *
  86 * NOTE: Cannot invoke this method with a compilation unit scope.
  87 */
  88
  89 public final boolean canBeSeenBy(InvocationSite invocationSite, Scope scope) {
  90         if (isPublic()) return true;
  91
  92         SourceTypeBinding invocationType = scope.enclosingSourceType();
  93         if (invocationType == declaringClass) return true;
  94
  95         if (isProtected()) {
  96                 // answer true if the receiver is in the same package as the invocationType
  97                 if (invocationType.fPackage == declaringClass.fPackage) return true;
  98                 return invocationSite.isSuperAccess();
  99         }
 100
 101         if (isPrivate()) {
 102                 // answer true if the invocationType and the declaringClass have a common enclosingType
 103                 // already know they are not the identical type
 104                 ReferenceBinding outerInvocationType = invocationType;
 105                 ReferenceBinding temp = outerInvocationType.enclosingType();
 106                 while (temp != null) {
 107                         outerInvocationType = temp;
 108                         temp = temp.enclosingType();
 109                 }
 110
 111                 ReferenceBinding outerDeclaringClass = declaringClass;
 112                 temp = outerDeclaringClass.enclosingType();
 113                 while (temp != null) {
 114                         outerDeclaringClass = temp;
 115                         temp = temp.enclosingType();
 116                 }
 117                 return outerInvocationType == outerDeclaringClass;
 118         }
 119
 120         // isDefault()
 121         return invocationType.fPackage == declaringClass.fPackage;
 122 }
 123 /* Answer true if the receiver is visible to the type provided by the scope.
 124 * InvocationSite implements isSuperAccess() to provide additional information
 125 * if the receiver is protected.
 126 *
 127 * NOTE: Cannot invoke this method with a compilation unit scope.
 128 */
 129 public final boolean canBeSeenBy(TypeBinding receiverType, InvocationSite invocationSite, Scope scope) {
 130         if (isPublic()) return true;
 131
 132         SourceTypeBinding invocationType = scope.enclosingSourceType();
 133         if (invocationType == declaringClass && invocationType == receiverType) return true;
 134
 135         if (isProtected()) {
 136                 // answer true if the invocationType is the declaringClass or they are in the same package
 137                 // OR the invocationType is a subclass of the declaringClass
 138                 //    AND the receiverType is the invocationType or its subclass
 139                 //    OR the method is a static method accessed directly through a type
 140                 //    OR previous assertions are true for one of the enclosing type
 141                 if (invocationType == declaringClass) return true;
 142                 if (invocationType.fPackage == declaringClass.fPackage) return true;
 143
 144                 ReferenceBinding currentType = invocationType;
 145                 int depth = 0;
 146                 do {
 147                         if (declaringClass.isSuperclassOf(currentType)) {
 148                                 if (invocationSite.isSuperAccess()){
 149                                         return true;
 150                                 }
 151                                 // receiverType can be an array binding in one case... see if you can change it
 152                                 if (receiverType instanceof ArrayBinding){
 153                                         return false;
 154                                 }
 155                                 if (isStatic()){
 156                                         return true; // see 1FMEPDL - return invocationSite.isTypeAccess();
 157                                 }
 158                                 if (currentType == receiverType || currentType.isSuperclassOf((ReferenceBinding) receiverType)){
 159                                         if (depth > 0) invocationSite.setDepth(depth);
 160                                         return true;
 161                                 }
 162                         }
 163                         depth++;
 164                         currentType = currentType.enclosingType();
 165                 } while (currentType != null);
 166                 return false;
 167         }
 168
 169         if (isPrivate()) {
 170                 // answer true if the receiverType is the declaringClass
 171                 // AND the invocationType and the declaringClass have a common enclosingType
 172                 if (receiverType != declaringClass) return false;
 173
 174                 if (invocationType != declaringClass) {
 175                         ReferenceBinding outerInvocationType = invocationType;
 176                         ReferenceBinding temp = outerInvocationType.enclosingType();
 177                         while (temp != null) {
 178                                 outerInvocationType = temp;
 179                                 temp = temp.enclosingType();
 180                         }
 181
 182                         ReferenceBinding outerDeclaringClass = declaringClass;
 183                         temp = outerDeclaringClass.enclosingType();
 184                         while (temp != null) {
 185                                 outerDeclaringClass = temp;
 186                                 temp = temp.enclosingType();
 187                         }
 188                         if (outerInvocationType != outerDeclaringClass) return false;
 189                 }
 190                 return true;
 191         }
 192
 193         // isDefault()
 194         if (invocationType.fPackage != declaringClass.fPackage) return false;
 195
 196         // receiverType can be an array binding in one case... see if you can change it
 197         if (receiverType instanceof ArrayBinding)
 198                 return false;
 199         ReferenceBinding type = (ReferenceBinding) receiverType;
 200         PackageBinding declaringPackage = declaringClass.fPackage;
 201         do {
 202                 if (declaringClass == type) return true;
 203                 if (declaringPackage != type.fPackage) return false;
 204         } while ((type = type.superclass()) != null);
 205         return false;
 206 }
 207 /* Answer the receiver's constant pool name.
 208 *
 209 * <init> for constructors
 210 * <clinit> for clinit methods
 211 * or the source name of the method
 212 */
 213
 214 public final char[] constantPoolName() {
 215         return selector;
 216 }
 217 public final int getAccessFlags() {
 218         return modifiers & AccJustFlag;
 219 }
 220 /* Answer true if the receiver is an abstract method
 221 */
 222
 223 public final boolean isAbstract() {
 224         return (modifiers & AccAbstract) != 0;
 225 }
 226 /* Answer true if the receiver is a constructor
 227 */
 228
 229 public final boolean isConstructor() {
 230         return selector == ConstructorDeclaration.ConstantPoolName;
 231 }
 232 protected boolean isConstructorRelated() {
 233         return isConstructor();
 234 }
 235 /* Answer true if the receiver has default visibility
 236 */
 237
 238 public final boolean isDefault() {
 239         return !isPublic() && !isProtected() && !isPrivate();
 240 }
 241 /* Answer true if the receiver is a system generated default abstract method
 242 */
 243
 244 public final boolean isDefaultAbstract() {
 245         return (modifiers & AccDefaultAbstract) != 0;
 246 }
 247 /* Answer true if the receiver is a deprecated method
 248 */
 249
 250 public final boolean isDeprecated() {
 251         return (modifiers & AccDeprecated) != 0;
 252 }
 253 /* Answer true if the receiver is final and cannot be overridden
 254 */
 255
 256 public final boolean isFinal() {
 257         return (modifiers & AccFinal) != 0;
 258 }
 259 /* Answer true if the receiver is a native method
 260 */
 261
 262 public final boolean isNative() {
 263         return (modifiers & AccNative) != 0;
 264 }
 265 /* Answer true if the receiver has private visibility
 266 */
 267
 268 public final boolean isPrivate() {
 269         return (modifiers & AccPrivate) != 0;
 270 }
 271 /* Answer true if the receiver has protected visibility
 272 */
 273
 274 public final boolean isProtected() {
 275         return (modifiers & AccProtected) != 0;
 276 }
 277 /* Answer true if the receiver has public visibility
 278 */
 279
 280 public final boolean isPublic() {
 281         return (modifiers & AccPublic) != 0;
 282 }
 283 /* Answer true if the receiver got requested to clear the private modifier
 284  * during private access emulation.
 285  */
 286
 287 public final boolean isRequiredToClearPrivateModifier() {
 288         return (modifiers & AccClearPrivateModifier) != 0;
 289 }
 290 /* Answer true if the receiver is a static method
 291 */
 292
 293 public final boolean isStatic() {
 294         return (modifiers & AccStatic) != 0;
 295 }
 296 /* Answer true if all float operations must adher to IEEE 754 float/double rules
 297 */
 298
 299 public final boolean isStrictfp() {
 300         return (modifiers & AccStrictfp) != 0;
 301 }
 302 /* Answer true if the receiver is a synchronized method
 303 */
 304
 305 public final boolean isSynchronized() {
 306         return (modifiers & AccSynchronized) != 0;
 307 }
 308 /* Answer true if the receiver has public visibility
 309 */
 310
 311 public final boolean isSynthetic() {
 312         return (modifiers & AccSynthetic) != 0;
 313 }
 314 /* Answer true if the receiver's declaring type is deprecated (or any of its enclosing types)
 315 */
 316
 317 public final boolean isViewedAsDeprecated() {
 318         return (modifiers & AccDeprecated) != 0 ||
 319                 (modifiers & AccDeprecatedImplicitly) != 0;
 320 }
 321 public char[] readableName() /* foo(int, Thread) */ {
 322         StringBuffer buffer = new StringBuffer(parameters.length + 1 * 20);
 323         if (isConstructor())
 324                 buffer.append(declaringClass.sourceName());
 325         else
 326                 buffer.append(selector);
 327         buffer.append('(');
 328         if (parameters != NoParameters) {
 329                 for (int i = 0, length = parameters.length; i < length; i++) {
 330                         if (i > 0)
 331                                 buffer.append(", "); //$NON-NLS-1$
 332                         buffer.append(parameters[i].sourceName());
 333                 }
 334         }
 335         buffer.append(')');
 336         return buffer.toString().toCharArray();
 337 }
 338 protected final void selector(char[] selector) {
 339         this.selector = selector;
 340         this.signature = null;
 341 }
 342 /* Answer the receiver's signature.
 343 *
 344 * NOTE: This method should only be used during/after code gen.
 345 * The signature is cached so if the signature of the return type or any parameter
 346 * type changes, the cached state is invalid.
 347 */
 348
 349 public final char[] signature() /* (ILjava/lang/Thread;)Ljava/lang/Object; */ {
 350         if (signature != null)
 351                 return signature;
 352
 353         StringBuffer buffer = new StringBuffer(parameters.length + 1 * 20);
 354         buffer.append('(');
 355         if (isConstructorRelated() && declaringClass.isNestedType()) {
 356                 // take into account the synthetic argument type signatures as well
 357                 ReferenceBinding[] syntheticArgumentTypes = declaringClass.syntheticEnclosingInstanceTypes();
 358                 int count = syntheticArgumentTypes == null ? 0 : syntheticArgumentTypes.length;
 359                 for (int i = 0; i < count; i++)
 360                         buffer.append(syntheticArgumentTypes[i].signature());
 361                 SyntheticArgumentBinding[] syntheticArguments = declaringClass.syntheticOuterLocalVariables();
 362                 count = syntheticArguments == null ? 0 : syntheticArguments.length;
 363                 for (int i = 0; i < count; i++)
 364                         buffer.append(syntheticArguments[i].type.signature());
 365         }
 366         if (parameters != NoParameters)
 367                 for (int i = 0, length = parameters.length; i < length; i++)
 368                         buffer.append(parameters[i].signature());
 369         buffer.append(')');
 370         buffer.append(returnType.signature());
 371         return signature = buffer.toString().toCharArray();
 372 }
 373 public final int sourceEnd() {
 374         AbstractMethodDeclaration method = sourceMethod();
 375         if (method == null)
 376                 return 0;
 377         else
 378                 return method.sourceEnd;
 379 }
 380 AbstractMethodDeclaration sourceMethod() {
 381         SourceTypeBinding sourceType;
 382         try {
 383                 sourceType = (SourceTypeBinding) declaringClass;
 384         } catch (ClassCastException e) {
 385                 return null;
 386         }
 387
 388         AbstractMethodDeclaration[] methods = sourceType.scope.referenceContext.methods;
 389         for (int i = methods.length; --i >= 0;)
 390                 if (this == methods[i].binding)
 391                         return methods[i];
 392         return null;
 393 }
 394 public final int sourceStart() {
 395         AbstractMethodDeclaration method = sourceMethod();
 396         if (method == null)
 397                 return 0;
 398         else
 399                 return method.sourceStart;
 400 }
 401 /* During private access emulation, the binding can be requested to loose its
 402  * private visibility when the class file is dumped.
 403  */
 404
 405 public final void tagForClearingPrivateModifier() {
 406         modifiers |= AccClearPrivateModifier;
 407 }
 408 public String toString() {
 409         String s = (returnType != null) ? returnType.debugName() : "NULL TYPE"; //$NON-NLS-1$
 410         s += " "; //$NON-NLS-1$
 411         s += (selector != null) ? new String(selector) : "UNNAMED METHOD"; //$NON-NLS-1$
 412
 413         s += "("; //$NON-NLS-1$
 414         if (parameters != null) {
 415                 if (parameters != NoParameters) {
 416                         for (int i = 0, length = parameters.length; i < length; i++) {
 417                                 if (i  > 0)
 418                                         s += ", "; //$NON-NLS-1$
 419                                 s += (parameters[i] != null) ? parameters[i].debugName() : "NULL TYPE"; //$NON-NLS-1$
 420                         }
 421                 }
 422         } else {
 423                 s += "NULL PARAMETERS"; //$NON-NLS-1$
 424         }
 425         s += ") "; //$NON-NLS-1$
 426
 427         if (thrownExceptions != null) {
 428                 if (thrownExceptions != NoExceptions) {
 429                         s += "throws "; //$NON-NLS-1$
 430                         for (int i = 0, length = thrownExceptions.length; i < length; i++) {
 431                                 if (i  > 0)
 432                                         s += ", "; //$NON-NLS-1$
 433                                 s += (thrownExceptions[i] != null) ? thrownExceptions[i].debugName() : "NULL TYPE"; //$NON-NLS-1$
 434                         }
 435                 }
 436         } else {
 437                 s += "NULL THROWN EXCEPTIONS"; //$NON-NLS-1$
 438         }
 439         return s;
 440 }
 441 }