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