Config editor through XML file
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / lookup / Scope.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.CompilationUnitDeclaration;
14 import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
15 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
16 import net.sourceforge.phpdt.internal.compiler.util.CharOperation;
17 import net.sourceforge.phpdt.internal.compiler.util.ObjectVector;
18
19 public abstract class Scope
20         implements
21                 BaseTypes,
22                 BindingIds,
23                 CompilerModifiers,
24                 ProblemReasons,
25                 TagBits,
26                 TypeConstants,
27                 TypeIds {
28
29         public Scope parent;
30         public int kind;
31
32         public final static int BLOCK_SCOPE = 1;
33         public final static int METHOD_SCOPE = 2;
34         public final static int CLASS_SCOPE = 3;
35         public final static int COMPILATION_UNIT_SCOPE = 4;
36         protected Scope(int kind, Scope parent) {
37                 this.kind = kind;
38                 this.parent = parent;
39         }
40
41         public abstract ProblemReporter problemReporter();
42
43         // Internal use only
44         protected final boolean areParametersAssignable(TypeBinding[] parameters, TypeBinding[] arguments) {
45                 if (parameters == arguments)
46                         return true;
47
48                 int length = parameters.length;
49                 if (length != arguments.length)
50                         return false;
51
52                 for (int i = 0; i < length; i++)
53                         if (parameters[i] != arguments[i])
54                                 if (!arguments[i].isCompatibleWith(parameters[i]))
55                                         return false;
56                 return true;
57         }
58
59         /* Answer true if the left type can be assigned to right
60         */
61         public static boolean areTypesCompatible(TypeBinding left, TypeBinding right) {
62                 return left.isCompatibleWith(right);
63         }
64
65         /* Answer an int describing the relationship between the given types.
66         *
67         *               NotRelated 
68         *               EqualOrMoreSpecific : left is compatible with right
69         *               MoreGeneric : right is compatible with left
70         */
71         public static int compareTypes(TypeBinding left, TypeBinding right) {
72                 if (areTypesCompatible(left, right))
73                         return EqualOrMoreSpecific;
74                 if (areTypesCompatible(right, left))
75                         return MoreGeneric;
76                 return NotRelated;
77         }
78
79         /* Answer an int describing the relationship between the given type and unchecked exceptions.
80         *
81         *       NotRelated 
82         *       EqualOrMoreSpecific : type is known for sure to be an unchecked exception type
83         *       MoreGeneric : type is a supertype of an actual unchecked exception type
84         */
85         public int compareUncheckedException(ReferenceBinding type) {
86                 int comparison = compareTypes(type, getJavaLangRuntimeException());
87                 if (comparison != 0) return comparison;
88                 return compareTypes(type, getJavaLangError());
89         }
90
91         public final CompilationUnitScope compilationUnitScope() {
92                 Scope lastScope = null;
93                 Scope scope = this;
94                 do {
95                         lastScope = scope;
96                         scope = scope.parent;
97                 } while (scope != null);
98                 return (CompilationUnitScope) lastScope;
99         }
100
101         public ArrayBinding createArray(TypeBinding type, int dimension) {
102                 if (type.isValidBinding())
103                         return environment().createArrayType(type, dimension);
104                 else
105                         return new ArrayBinding(type, dimension);
106         }
107
108         /* Answer the receiver's enclosing source type.
109         */
110         public final SourceTypeBinding enclosingSourceType() {
111                 Scope scope = this;
112                 do {
113                         if (scope instanceof ClassScope)
114                                 return ((ClassScope) scope).referenceContext.binding;
115                         scope = scope.parent;
116                 } while (scope != null);
117                 return null;
118         }
119         public final LookupEnvironment environment() {
120                 Scope scope, unitScope = this;
121                 while ((scope = unitScope.parent) != null)
122                         unitScope = scope;
123                 return ((CompilationUnitScope) unitScope).environment;
124         }
125
126         // Internal use only
127         public ReferenceBinding findDirectMemberType(char[] typeName, ReferenceBinding enclosingType) {
128                 if ((enclosingType.tagBits & HasNoMemberTypes) != 0)
129                         return null; // know it has no member types (nor inherited member types)
130
131                 SourceTypeBinding enclosingSourceType = enclosingSourceType();
132                 compilationUnitScope().recordReference(enclosingType.compoundName, typeName);
133                 ReferenceBinding memberType = enclosingType.getMemberType(typeName);
134                 if (memberType != null) {
135                         compilationUnitScope().recordTypeReference(memberType); // to record supertypes
136                         if (enclosingSourceType == null
137                                 ? memberType.canBeSeenBy(getCurrentPackage())
138                                 : memberType.canBeSeenBy(enclosingType, enclosingSourceType))
139                                 return memberType;
140                         else
141                                 return new ProblemReferenceBinding(typeName, memberType, NotVisible);
142                 }
143                 return null;
144         }
145
146         // Internal use only
147         public MethodBinding findExactMethod(
148                 ReferenceBinding receiverType,
149                 char[] selector,
150                 TypeBinding[] argumentTypes,
151                 InvocationSite invocationSite) {
152
153                 compilationUnitScope().recordTypeReference(receiverType);
154                 compilationUnitScope().recordTypeReferences(argumentTypes);
155                 MethodBinding exactMethod = receiverType.getExactMethod(selector, argumentTypes);
156                 if (exactMethod != null) {
157                         compilationUnitScope().recordTypeReferences(exactMethod.thrownExceptions);
158                         if (receiverType.isInterface() || exactMethod.canBeSeenBy(receiverType, invocationSite, this))
159                                 return exactMethod;
160                 }
161                 return null;
162         }
163
164         // Internal use only
165         /*      Answer the field binding that corresponds to fieldName.
166                 Start the lookup at the receiverType.
167                 InvocationSite implements
168                         isSuperAccess(); this is used to determine if the discovered field is visible.
169                 Only fields defined by the receiverType or its supertypes are answered;
170                 a field of an enclosing type will not be found using this API.
171         
172                 If no visible field is discovered, null is answered.
173         */
174         public FieldBinding findField(TypeBinding receiverType, char[] fieldName, InvocationSite invocationSite) {
175                 if (receiverType.isBaseType()) return null;
176                 if (receiverType.isArrayType()) {
177                         if (CharOperation.equals(fieldName, LENGTH))
178                                 return ArrayBinding.LengthField;
179                         return null;
180                 }
181
182                 compilationUnitScope().recordTypeReference(receiverType);
183
184                 ReferenceBinding currentType = (ReferenceBinding) receiverType;
185                 if (!currentType.canBeSeenBy(this))
186                         return new ProblemFieldBinding(currentType, fieldName, NotVisible);
187                 // *** Need a new problem id - TypeNotVisible?
188
189                 FieldBinding field = currentType.getField(fieldName);
190                 if (field != null) {
191                         if (field.canBeSeenBy(currentType, invocationSite, this))
192                                 return field;
193                         else
194                                 return new ProblemFieldBinding(field.declaringClass, fieldName, NotVisible);
195                 }
196                 // collect all superinterfaces of receiverType until the field is found in a supertype
197                 ReferenceBinding[][] interfacesToVisit = null;
198                 int lastPosition = -1;
199                 FieldBinding visibleField = null;
200                 boolean keepLooking = true;
201                 boolean notVisible = false;
202                 // we could hold onto the not visible field for extra error reporting
203                 while (keepLooking) {
204                         ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
205                         if (itsInterfaces != NoSuperInterfaces) {
206                                 if (interfacesToVisit == null)
207                                         interfacesToVisit = new ReferenceBinding[5][];
208                                 if (++lastPosition == interfacesToVisit.length)
209                                         System.arraycopy(
210                                                 interfacesToVisit,
211                                                 0,
212                                                 interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
213                                                 0,
214                                                 lastPosition);
215                                 interfacesToVisit[lastPosition] = itsInterfaces;
216                         }
217                         if ((currentType = currentType.superclass()) == null)
218                                 break;
219
220                         if ((field = currentType.getField(fieldName)) != null) {
221                                 keepLooking = false;
222                                 if (field.canBeSeenBy(receiverType, invocationSite, this)) {
223                                         if (visibleField == null)
224                                                 visibleField = field;
225                                         else
226                                                 return new ProblemFieldBinding(visibleField.declaringClass, fieldName, Ambiguous);
227                                 } else {
228                                         notVisible = true;
229                                 }
230                         }
231                 }
232
233                 // walk all visible interfaces to find ambiguous references
234                 if (interfacesToVisit != null) {
235                         ProblemFieldBinding ambiguous = null;
236                         done : for (int i = 0; i <= lastPosition; i++) {
237                                 ReferenceBinding[] interfaces = interfacesToVisit[i];
238                                 for (int j = 0, length = interfaces.length; j < length; j++) {
239                                         ReferenceBinding anInterface = interfaces[j];
240                                         if ((anInterface.tagBits & InterfaceVisited) == 0) {
241                                                 // if interface as not already been visited
242                                                 anInterface.tagBits |= InterfaceVisited;
243                                                 if ((field = anInterface.getField(fieldName)) != null) {
244                                                         if (visibleField == null) {
245                                                                 visibleField = field;
246                                                         } else {
247                                                                 ambiguous = new ProblemFieldBinding(visibleField.declaringClass, fieldName, Ambiguous);
248                                                                 break done;
249                                                         }
250                                                 } else {
251                                                         ReferenceBinding[] itsInterfaces = anInterface.superInterfaces();
252                                                         if (itsInterfaces != NoSuperInterfaces) {
253                                                                 if (++lastPosition == interfacesToVisit.length)
254                                                                         System.arraycopy(
255                                                                                 interfacesToVisit,
256                                                                                 0,
257                                                                                 interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
258                                                                                 0,
259                                                                                 lastPosition);
260                                                                 interfacesToVisit[lastPosition] = itsInterfaces;
261                                                         }
262                                                 }
263                                         }
264                                 }
265                         }
266
267                         // bit reinitialization
268                         for (int i = 0; i <= lastPosition; i++) {
269                                 ReferenceBinding[] interfaces = interfacesToVisit[i];
270                                 for (int j = 0, length = interfaces.length; j < length; j++)
271                                         interfaces[j].tagBits &= ~InterfaceVisited;
272                         }
273                         if (ambiguous != null)
274                                 return ambiguous;
275                 }
276
277                 if (visibleField != null)
278                         return visibleField;
279                 if (notVisible)
280                         return new ProblemFieldBinding(currentType, fieldName, NotVisible);
281                 return null;
282         }
283
284         // Internal use only
285         public ReferenceBinding findMemberType(char[] typeName, ReferenceBinding enclosingType) {
286                 if ((enclosingType.tagBits & HasNoMemberTypes) != 0)
287                         return null; // know it has no member types (nor inherited member types)
288
289                 SourceTypeBinding enclosingSourceType = enclosingSourceType();
290                 PackageBinding currentPackage = getCurrentPackage();
291                 compilationUnitScope().recordReference(enclosingType.compoundName, typeName);
292                 ReferenceBinding memberType = enclosingType.getMemberType(typeName);
293                 if (memberType != null) {
294                         compilationUnitScope().recordTypeReference(memberType); // to record supertypes
295                         if (enclosingSourceType == null
296                                 ? memberType.canBeSeenBy(currentPackage)
297                                 : memberType.canBeSeenBy(enclosingType, enclosingSourceType))
298                                 return memberType;
299                         else
300                                 return new ProblemReferenceBinding(typeName, memberType, NotVisible);
301                 }
302
303                 // collect all superinterfaces of receiverType until the memberType is found in a supertype
304                 ReferenceBinding currentType = enclosingType;
305                 ReferenceBinding[][] interfacesToVisit = null;
306                 int lastPosition = -1;
307                 ReferenceBinding visibleMemberType = null;
308                 boolean keepLooking = true;
309                 ReferenceBinding notVisible = null;
310                 // we could hold onto the not visible field for extra error reporting
311                 while (keepLooking) {
312                         ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
313                         if (itsInterfaces != NoSuperInterfaces) {
314                                 if (interfacesToVisit == null)
315                                         interfacesToVisit = new ReferenceBinding[5][];
316                                 if (++lastPosition == interfacesToVisit.length)
317                                         System.arraycopy(
318                                                 interfacesToVisit,
319                                                 0,
320                                                 interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
321                                                 0,
322                                                 lastPosition);
323                                 interfacesToVisit[lastPosition] = itsInterfaces;
324                         }
325                         if ((currentType = currentType.superclass()) == null)
326                                 break;
327
328                         compilationUnitScope().recordReference(currentType.compoundName, typeName);
329                         if ((memberType = currentType.getMemberType(typeName)) != null) {
330                                 compilationUnitScope().recordTypeReference(memberType); // to record supertypes
331                                 keepLooking = false;
332                                 if (enclosingSourceType == null
333                                         ? memberType.canBeSeenBy(currentPackage)
334                                         : memberType.canBeSeenBy(enclosingType, enclosingSourceType)) {
335                                                 if (visibleMemberType == null)
336                                                         visibleMemberType = memberType;
337                                                 else
338                                                         return new ProblemReferenceBinding(typeName, Ambiguous);
339                                 } else {
340                                         notVisible = memberType;
341                                 }
342                         }
343                 }
344                 // walk all visible interfaces to find ambiguous references
345                 if (interfacesToVisit != null) {
346                         ProblemReferenceBinding ambiguous = null;
347                         done : for (int i = 0; i <= lastPosition; i++) {
348                                 ReferenceBinding[] interfaces = interfacesToVisit[i];
349                                 for (int j = 0, length = interfaces.length; j < length; j++) {
350                                         ReferenceBinding anInterface = interfaces[j];
351                                         if ((anInterface.tagBits & InterfaceVisited) == 0) {
352                                                 // if interface as not already been visited
353                                                 anInterface.tagBits |= InterfaceVisited;
354                                                 compilationUnitScope().recordReference(anInterface.compoundName, typeName);
355                                                 if ((memberType = anInterface.getMemberType(typeName)) != null) {
356                                                         compilationUnitScope().recordTypeReference(memberType); // to record supertypes
357                                                         if (visibleMemberType == null) {
358                                                                 visibleMemberType = memberType;
359                                                         } else {
360                                                                 ambiguous = new ProblemReferenceBinding(typeName, Ambiguous);
361                                                                 break done;
362                                                         }
363                                                 } else {
364                                                         ReferenceBinding[] itsInterfaces = anInterface.superInterfaces();
365                                                         if (itsInterfaces != NoSuperInterfaces) {
366                                                                 if (++lastPosition == interfacesToVisit.length)
367                                                                         System.arraycopy(
368                                                                                 interfacesToVisit,
369                                                                                 0,
370                                                                                 interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
371                                                                                 0,
372                                                                                 lastPosition);
373                                                                 interfacesToVisit[lastPosition] = itsInterfaces;
374                                                         }
375                                                 }
376                                         }
377                                 }
378                         }
379
380                         // bit reinitialization
381                         for (int i = 0; i <= lastPosition; i++) {
382                                 ReferenceBinding[] interfaces = interfacesToVisit[i];
383                                 for (int j = 0, length = interfaces.length; j < length; j++)
384                                         interfaces[j].tagBits &= ~InterfaceVisited;
385                         }
386                         if (ambiguous != null)
387                                 return ambiguous;
388                 }
389                 if (visibleMemberType != null)
390                         return visibleMemberType;
391                 if (notVisible != null)
392                         return new ProblemReferenceBinding(typeName, notVisible, NotVisible);
393                 return null;
394         }
395
396         // Internal use only
397         public MethodBinding findMethod(
398                 ReferenceBinding receiverType,
399                 char[] selector,
400                 TypeBinding[] argumentTypes,
401                 InvocationSite invocationSite) {
402
403                 ReferenceBinding currentType = receiverType;
404                 MethodBinding matchingMethod = null;
405                 ObjectVector found = new ObjectVector();
406
407                 compilationUnitScope().recordTypeReference(receiverType);
408                 compilationUnitScope().recordTypeReferences(argumentTypes);
409
410                 if (currentType.isInterface()) {
411                         MethodBinding[] currentMethods = currentType.getMethods(selector);
412                         int currentLength = currentMethods.length;
413                         if (currentLength == 1) {
414                                 matchingMethod = currentMethods[0];
415                         } else if (currentLength > 1) {
416                                 found.addAll(currentMethods);
417                         }
418                         matchingMethod = findMethodInSuperInterfaces(currentType, selector, found, matchingMethod);
419                         currentType = getJavaLangObject();
420                 }
421
422                 // superclass lookup
423                 ReferenceBinding classHierarchyStart = currentType;
424                 while (currentType != null) {
425                         MethodBinding[] currentMethods = currentType.getMethods(selector);
426                         int currentLength = currentMethods.length;
427                         if (currentLength == 1 && matchingMethod == null && found.size == 0) {
428                                 matchingMethod = currentMethods[0];
429                         } else if (currentLength > 0) {
430                                 if (matchingMethod != null) {
431                                         found.add(matchingMethod);
432                                         matchingMethod = null;
433                                 }
434                                 found.addAll(currentMethods);
435                         }
436                         currentType = currentType.superclass();
437                 }
438
439                 int foundSize = found.size;
440                 if (foundSize == 0) {
441                         if (matchingMethod != null && areParametersAssignable(matchingMethod.parameters, argumentTypes))
442                                 return matchingMethod;
443                         return findDefaultAbstractMethod(receiverType, selector, argumentTypes, invocationSite, classHierarchyStart, matchingMethod, found);
444                 }
445
446                 MethodBinding[] candidates = new MethodBinding[foundSize];
447                 int candidatesCount = 0;
448                 // argument type compatibility check
449                 for (int i = 0; i < foundSize; i++) {
450                         MethodBinding methodBinding = (MethodBinding) found.elementAt(i);
451                         if (areParametersAssignable(methodBinding.parameters, argumentTypes))
452                                 candidates[candidatesCount++] = methodBinding;
453                 }
454                 if (candidatesCount == 1) {
455                         compilationUnitScope().recordTypeReferences(candidates[0].thrownExceptions);
456                         return candidates[0]; // have not checked visibility
457                 }
458                 if (candidatesCount == 0) { // try to find a close match when the parameter order is wrong or missing some parameters
459                         MethodBinding interfaceMethod =
460                                 findDefaultAbstractMethod(receiverType, selector, argumentTypes, invocationSite, classHierarchyStart, matchingMethod, found);
461                         if (interfaceMethod != null) return interfaceMethod;
462
463                         int argLength = argumentTypes.length;
464                         foundSize = found.size;
465                         nextMethod : for (int i = 0; i < foundSize; i++) {
466                                 MethodBinding methodBinding = (MethodBinding) found.elementAt(i);
467                                 TypeBinding[] params = methodBinding.parameters;
468                                 int paramLength = params.length;
469                                 nextArg: for (int a = 0; a < argLength; a++) {
470                                         TypeBinding arg = argumentTypes[a];
471                                         for (int p = 0; p < paramLength; p++)
472                                                 if (params[p] == arg)
473                                                         continue nextArg;
474                                         continue nextMethod;
475                                 }
476                                 return methodBinding;
477                         }
478                         return (MethodBinding) found.elementAt(0); // no good match so just use the first one found
479                 }
480
481                 // visibility check
482                 int visiblesCount = 0;
483                 for (int i = 0; i < candidatesCount; i++) {
484                         MethodBinding methodBinding = candidates[i];
485                         if (methodBinding.canBeSeenBy(receiverType, invocationSite, this)) {
486                                 if (visiblesCount != i) {
487                                         candidates[i] = null;
488                                         candidates[visiblesCount] = methodBinding;
489                                 }
490                                 visiblesCount++;
491                         }
492                 }
493                 if (visiblesCount == 1) {
494                         compilationUnitScope().recordTypeReferences(candidates[0].thrownExceptions);
495                         return candidates[0];
496                 }
497                 if (visiblesCount == 0) {
498                         MethodBinding interfaceMethod =
499                                 findDefaultAbstractMethod(receiverType, selector, argumentTypes, invocationSite, classHierarchyStart, matchingMethod, found);
500                         if (interfaceMethod != null) return interfaceMethod;
501                         return new ProblemMethodBinding(candidates[0].selector, argumentTypes, candidates[0].declaringClass, NotVisible);
502                 }       
503                 if (candidates[0].declaringClass.isClass()) {
504                         return mostSpecificClassMethodBinding(candidates, visiblesCount);
505                 } else {
506                         return mostSpecificInterfaceMethodBinding(candidates, visiblesCount);
507                 }
508         }
509
510         // abstract method lookup lookup (since maybe missing default abstract methods)
511         public MethodBinding findDefaultAbstractMethod(
512                 ReferenceBinding receiverType, 
513                 char[] selector,
514                 TypeBinding[] argumentTypes,
515                 InvocationSite invocationSite,
516                 ReferenceBinding classHierarchyStart,
517                 MethodBinding matchingMethod,
518                 ObjectVector found) {
519
520                 int startFoundSize = found.size;
521                 ReferenceBinding currentType = classHierarchyStart;
522                 while (currentType != null) {
523                         matchingMethod = findMethodInSuperInterfaces(currentType, selector, found, matchingMethod);
524                         currentType = currentType.superclass();
525                 }
526                 int foundSize = found.size;
527                 if (foundSize == startFoundSize) return matchingMethod; // maybe null
528
529                 MethodBinding[] candidates = new MethodBinding[foundSize - startFoundSize];
530                 int candidatesCount = 0;
531                 // argument type compatibility check
532                 for (int i = startFoundSize; i < foundSize; i++) {
533                         MethodBinding methodBinding = (MethodBinding) found.elementAt(i);
534                         if (areParametersAssignable(methodBinding.parameters, argumentTypes))
535                                 candidates[candidatesCount++] = methodBinding;
536                 }
537                 if (candidatesCount == 1) {
538                         compilationUnitScope().recordTypeReferences(candidates[0].thrownExceptions);
539                         return candidates[0]; 
540                 }
541                 if (candidatesCount == 0) { // try to find a close match when the parameter order is wrong or missing some parameters
542                         int argLength = argumentTypes.length;
543                         nextMethod : for (int i = 0; i < foundSize; i++) {
544                                 MethodBinding methodBinding = (MethodBinding) found.elementAt(i);
545                                 TypeBinding[] params = methodBinding.parameters;
546                                 int paramLength = params.length;
547                                 nextArg: for (int a = 0; a < argLength; a++) {
548                                         TypeBinding arg = argumentTypes[a];
549                                         for (int p = 0; p < paramLength; p++)
550                                                 if (params[p] == arg)
551                                                         continue nextArg;
552                                         continue nextMethod;
553                                 }
554                                 return methodBinding;
555                         }
556                         return (MethodBinding) found.elementAt(0); // no good match so just use the first one found
557                 }
558                 // no need to check for visibility - interface methods are public
559                 return mostSpecificInterfaceMethodBinding(candidates, candidatesCount);
560         }
561
562         public MethodBinding findMethodInSuperInterfaces(
563                 ReferenceBinding currentType,
564                 char[] selector,
565                 ObjectVector found,
566                 MethodBinding matchingMethod) {
567
568                 ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
569                 if (itsInterfaces != NoSuperInterfaces) {
570                         ReferenceBinding[][] interfacesToVisit = new ReferenceBinding[5][];
571                         int lastPosition = -1;
572                         if (++lastPosition == interfacesToVisit.length)
573                                 System.arraycopy(
574                                         interfacesToVisit, 0,
575                                         interfacesToVisit = new ReferenceBinding[lastPosition * 2][], 0,
576                                         lastPosition);
577                         interfacesToVisit[lastPosition] = itsInterfaces;
578
579                         for (int i = 0; i <= lastPosition; i++) {
580                                 ReferenceBinding[] interfaces = interfacesToVisit[i];
581                                 for (int j = 0, length = interfaces.length; j < length; j++) {
582                                         currentType = interfaces[j];
583                                         if ((currentType.tagBits & InterfaceVisited) == 0) {
584                                                 // if interface as not already been visited
585                                                 currentType.tagBits |= InterfaceVisited;
586
587                                                 MethodBinding[] currentMethods = currentType.getMethods(selector);
588                                                 int currentLength = currentMethods.length;
589                                                 if (currentLength == 1 && matchingMethod == null && found.size == 0) {
590                                                         matchingMethod = currentMethods[0];
591                                                 } else if (currentLength > 0) {
592                                                         if (matchingMethod != null) {
593                                                                 found.add(matchingMethod);
594                                                                 matchingMethod = null;
595                                                         }
596                                                         found.addAll(currentMethods);
597                                                 }
598                                                 itsInterfaces = currentType.superInterfaces();
599                                                 if (itsInterfaces != NoSuperInterfaces) {
600                                                         if (++lastPosition == interfacesToVisit.length)
601                                                                 System.arraycopy(
602                                                                         interfacesToVisit, 0,
603                                                                         interfacesToVisit = new ReferenceBinding[lastPosition * 2][], 0,
604                                                                         lastPosition);
605                                                         interfacesToVisit[lastPosition] = itsInterfaces;
606                                                 }
607                                         }
608                                 }
609                         }
610
611                         // bit reinitialization
612                         for (int i = 0; i <= lastPosition; i++) {
613                                 ReferenceBinding[] interfaces = interfacesToVisit[i];
614                                 for (int j = 0, length = interfaces.length; j < length; j++)
615                                         interfaces[j].tagBits &= ~InterfaceVisited;
616                         }
617                 }
618                 return matchingMethod;
619         }
620         
621         // Internal use only
622         public MethodBinding findMethodForArray(
623                 ArrayBinding receiverType,
624                 char[] selector,
625                 TypeBinding[] argumentTypes,
626                 InvocationSite invocationSite) {
627
628                 ReferenceBinding object = getJavaLangObject();
629                 MethodBinding methodBinding = object.getExactMethod(selector, argumentTypes);
630                 if (methodBinding != null) {
631                         // handle the method clone() specially... cannot be protected or throw exceptions
632                         if (argumentTypes == NoParameters && CharOperation.equals(selector, CLONE))
633                                 return new MethodBinding(
634                                         (methodBinding.modifiers ^ AccProtected) | AccPublic,
635                                         CLONE,
636                                         methodBinding.returnType,
637                                         argumentTypes,
638                                         null,
639                                         object);
640                         if (methodBinding.canBeSeenBy(receiverType, invocationSite, this))
641                                 return methodBinding;
642                 }
643                 // answers closest approximation, may not check argumentTypes or visibility
644                 methodBinding = findMethod(object, selector, argumentTypes, invocationSite);
645                 if (methodBinding == null)
646                         return new ProblemMethodBinding(selector, argumentTypes, NotFound);
647                 if (methodBinding.isValidBinding()) {
648                         if (!areParametersAssignable(methodBinding.parameters, argumentTypes))
649                                 return new ProblemMethodBinding(
650                                         methodBinding,
651                                         selector,
652                                         argumentTypes,
653                                         NotFound);
654                         if (!methodBinding.canBeSeenBy(receiverType, invocationSite, this))
655                                 return new ProblemMethodBinding(
656                                         selector,
657                                         argumentTypes,
658                                         methodBinding.declaringClass,
659                                         NotVisible);
660                 }
661                 return methodBinding;
662         }
663
664         // Internal use only
665         public ReferenceBinding findType(
666                 char[] typeName,
667                 PackageBinding declarationPackage,
668                 PackageBinding invocationPackage) {
669
670                 compilationUnitScope().recordReference(declarationPackage.compoundName, typeName);
671                 ReferenceBinding typeBinding = declarationPackage.getType(typeName);
672                 if (typeBinding == null)
673                         return null;
674
675                 if (typeBinding.isValidBinding()) {
676 // Not convinced that this is necessary
677 //                      compilationUnitScope().recordTypeReference(typeBinding); // to record supertypes
678                         if (declarationPackage != invocationPackage && !typeBinding.canBeSeenBy(invocationPackage))
679                                 return new ProblemReferenceBinding(typeName, typeBinding, NotVisible);
680                 }
681                 return typeBinding;
682         }
683
684         public TypeBinding getBaseType(char[] name) {
685                 // list should be optimized (with most often used first)
686                 int length = name.length;
687                 if (length > 2 && length < 8) {
688                         switch (name[0]) {
689                                 case 'i' :
690                                         if (length == 3 && name[1] == 'n' && name[2] == 't')
691                                                 return IntBinding;
692                                         break;
693                                 case 'v' :
694                                         if (length == 4 && name[1] == 'o' && name[2] == 'i' && name[3] == 'd')
695                                                 return VoidBinding;
696                                         break;
697                                 case 'b' :
698                                         if (length == 7
699                                                 && name[1] == 'o'
700                                                 && name[2] == 'o'
701                                                 && name[3] == 'l'
702                                                 && name[4] == 'e'
703                                                 && name[5] == 'a'
704                                                 && name[6] == 'n')
705                                                 return BooleanBinding;
706                                         if (length == 4 && name[1] == 'y' && name[2] == 't' && name[3] == 'e')
707                                                 return ByteBinding;
708                                         break;
709                                 case 'c' :
710                                         if (length == 4 && name[1] == 'h' && name[2] == 'a' && name[3] == 'r')
711                                                 return CharBinding;
712                                         break;
713                                 case 'd' :
714                                         if (length == 6
715                                                 && name[1] == 'o'
716                                                 && name[2] == 'u'
717                                                 && name[3] == 'b'
718                                                 && name[4] == 'l'
719                                                 && name[5] == 'e')
720                                                 return DoubleBinding;
721                                         break;
722                                 case 'f' :
723                                         if (length == 5
724                                                 && name[1] == 'l'
725                                                 && name[2] == 'o'
726                                                 && name[3] == 'a'
727                                                 && name[4] == 't')
728                                                 return FloatBinding;
729                                         break;
730                                 case 'l' :
731                                         if (length == 4 && name[1] == 'o' && name[2] == 'n' && name[3] == 'g')
732                                                 return LongBinding;
733                                         break;
734                                 case 's' :
735                                         if (length == 5
736                                                 && name[1] == 'h'
737                                                 && name[2] == 'o'
738                                                 && name[3] == 'r'
739                                                 && name[4] == 't')
740                                                 return ShortBinding;
741                         }
742                 }
743                 return null;
744         }
745
746         public final PackageBinding getCurrentPackage() {
747                 Scope scope, unitScope = this;
748                 while ((scope = unitScope.parent) != null)
749                         unitScope = scope;
750                 return ((CompilationUnitScope) unitScope).fPackage;
751         }
752
753         public final ReferenceBinding getJavaIoSerializable() {
754                 compilationUnitScope().recordQualifiedReference(JAVA_IO_SERIALIZABLE);
755                 ReferenceBinding type = environment().getType(JAVA_IO_SERIALIZABLE);
756                 if (type != null) return type;
757         
758                 problemReporter().isClassPathCorrect(JAVA_IO_SERIALIZABLE, referenceCompilationUnit());
759                 return null; // will not get here since the above error aborts the compilation
760         }
761
762         public final ReferenceBinding getJavaLangClass() {
763                 compilationUnitScope().recordQualifiedReference(JAVA_LANG_CLASS);
764                 ReferenceBinding type = environment().getType(JAVA_LANG_CLASS);
765                 if (type != null) return type;
766         
767                 problemReporter().isClassPathCorrect(JAVA_LANG_CLASS, referenceCompilationUnit());
768                 return null; // will not get here since the above error aborts the compilation
769         }
770
771         public final ReferenceBinding getJavaLangCloneable() {
772                 compilationUnitScope().recordQualifiedReference(JAVA_LANG_CLONEABLE);
773                 ReferenceBinding type = environment().getType(JAVA_LANG_CLONEABLE);
774                 if (type != null) return type;
775         
776                 problemReporter().isClassPathCorrect(JAVA_LANG_CLONEABLE, referenceCompilationUnit());
777                 return null; // will not get here since the above error aborts the compilation
778         }
779
780         public final ReferenceBinding getJavaLangError() {
781                 compilationUnitScope().recordQualifiedReference(JAVA_LANG_ERROR);
782                 ReferenceBinding type = environment().getType(JAVA_LANG_ERROR);
783                 if (type != null) return type;
784         
785                 problemReporter().isClassPathCorrect(JAVA_LANG_ERROR, referenceCompilationUnit());
786                 return null; // will not get here since the above error aborts the compilation
787         }
788
789         public final ReferenceBinding getJavaLangAssertionError() {
790                 compilationUnitScope().recordQualifiedReference(JAVA_LANG_ASSERTIONERROR);
791                 ReferenceBinding type = environment().getType(JAVA_LANG_ASSERTIONERROR);
792                 if (type != null) return type;
793                 problemReporter().isClassPathCorrect(JAVA_LANG_ASSERTIONERROR, referenceCompilationUnit());
794                 return null; // will not get here since the above error aborts the compilation
795         }
796
797         public final ReferenceBinding getJavaLangObject() {
798                 compilationUnitScope().recordQualifiedReference(JAVA_LANG_OBJECT);
799                 ReferenceBinding type = environment().getType(JAVA_LANG_OBJECT);
800                 if (type != null) return type;
801         
802                 problemReporter().isClassPathCorrect(JAVA_LANG_OBJECT, referenceCompilationUnit());
803                 return null; // will not get here since the above error aborts the compilation
804         }
805
806         public final ReferenceBinding getJavaLangRuntimeException() {
807                 compilationUnitScope().recordQualifiedReference(JAVA_LANG_RUNTIMEEXCEPTION);
808                 ReferenceBinding type = environment().getType(JAVA_LANG_RUNTIMEEXCEPTION);
809                 if (type != null) return type;
810         
811                 problemReporter().isClassPathCorrect(JAVA_LANG_RUNTIMEEXCEPTION, referenceCompilationUnit());
812                 return null; // will not get here since the above error aborts the compilation
813         }
814
815         public final ReferenceBinding getJavaLangString() {
816                 compilationUnitScope().recordQualifiedReference(JAVA_LANG_STRING);
817                 ReferenceBinding type = environment().getType(JAVA_LANG_STRING);
818                 if (type != null) return type;
819         
820                 problemReporter().isClassPathCorrect(JAVA_LANG_STRING, referenceCompilationUnit());
821                 return null; // will not get here since the above error aborts the compilation
822         }
823
824         public final ReferenceBinding getJavaLangThrowable() {
825                 compilationUnitScope().recordQualifiedReference(JAVA_LANG_THROWABLE);
826                 ReferenceBinding type = environment().getType(JAVA_LANG_THROWABLE);
827                 if (type != null) return type;
828         
829                 problemReporter().isClassPathCorrect(JAVA_LANG_THROWABLE, referenceCompilationUnit());
830                 return null; // will not get here since the above error aborts the compilation
831         }
832
833         /* Answer the type binding corresponding to the typeName argument, relative to the enclosingType.
834         */
835         public final ReferenceBinding getMemberType(char[] typeName, ReferenceBinding enclosingType) {
836                 ReferenceBinding memberType = findMemberType(typeName, enclosingType);
837                 if (memberType != null) return memberType;
838                 return new ProblemReferenceBinding(typeName, NotFound);
839         }
840
841         /* Answer the type binding corresponding to the compoundName.
842         *
843         * NOTE: If a problem binding is returned, senders should extract the compound name
844         * from the binding & not assume the problem applies to the entire compoundName.
845         */
846         public final TypeBinding getType(char[][] compoundName) {
847                 int typeNameLength = compoundName.length;
848                 if (typeNameLength == 1) {
849                         // Would like to remove this test and require senders to specially handle base types
850                         TypeBinding binding = getBaseType(compoundName[0]);
851                         if (binding != null) return binding;
852                 }
853
854                 compilationUnitScope().recordQualifiedReference(compoundName);
855                 Binding binding =
856                         getTypeOrPackage(compoundName[0], typeNameLength == 1 ? TYPE : TYPE | PACKAGE);
857                 if (binding == null)
858                         return new ProblemReferenceBinding(compoundName[0], NotFound);
859                 if (!binding.isValidBinding())
860                         return (ReferenceBinding) binding;
861
862                 int currentIndex = 1;
863                 boolean checkVisibility = false;
864                 if (binding instanceof PackageBinding) {
865                         PackageBinding packageBinding = (PackageBinding) binding;
866                         while (currentIndex < typeNameLength) {
867                                 binding = packageBinding.getTypeOrPackage(compoundName[currentIndex++]); // does not check visibility
868                                 if (binding == null)
869                                         return new ProblemReferenceBinding(
870                                                 CharOperation.subarray(compoundName, 0, currentIndex),
871                                                 NotFound);
872                                 if (!binding.isValidBinding())
873                                         return new ProblemReferenceBinding(
874                                                 CharOperation.subarray(compoundName, 0, currentIndex),
875                                                 binding.problemId());
876                                 if (!(binding instanceof PackageBinding))
877                                         break;
878                                 packageBinding = (PackageBinding) binding;
879                         }
880                         if (binding instanceof PackageBinding)
881                                 return new ProblemReferenceBinding(
882                                         CharOperation.subarray(compoundName, 0, currentIndex),
883                                         NotFound);
884                         checkVisibility = true;
885                 }
886
887                 // binding is now a ReferenceBinding
888                 ReferenceBinding typeBinding = (ReferenceBinding) binding;
889                 compilationUnitScope().recordTypeReference(typeBinding); // to record supertypes
890                 if (checkVisibility) // handles the fall through case
891                         if (!typeBinding.canBeSeenBy(this))
892                                 return new ProblemReferenceBinding(
893                                         CharOperation.subarray(compoundName, 0, currentIndex),
894                                         typeBinding,
895                                         NotVisible);
896
897                 while (currentIndex < typeNameLength) {
898                         typeBinding = getMemberType(compoundName[currentIndex++], typeBinding);
899                         if (!typeBinding.isValidBinding())
900                                 return new ProblemReferenceBinding(
901                                         CharOperation.subarray(compoundName, 0, currentIndex),
902                                         typeBinding.problemId());
903                 }
904                 return typeBinding;
905         }
906
907         /* Answer the type binding that corresponds the given name, starting the lookup in the receiver.
908         * The name provided is a simple source name (e.g., "Object" , "Point", ...)
909         */
910         // The return type of this method could be ReferenceBinding if we did not answer base types.
911         // NOTE: We could support looking for Base Types last in the search, however any code using
912         // this feature would be extraordinarily slow.  Therefore we don't do this
913         public final TypeBinding getType(char[] name) {
914                 // Would like to remove this test and require senders to specially handle base types
915                 TypeBinding binding = getBaseType(name);
916                 if (binding != null) return binding;
917                 return (ReferenceBinding) getTypeOrPackage(name, TYPE);
918         }
919
920         // Added for code assist... NOT Public API
921         public final Binding getTypeOrPackage(char[][] compoundName) {
922                 int nameLength = compoundName.length;
923                 if (nameLength == 1) {
924                         TypeBinding binding = getBaseType(compoundName[0]);
925                         if (binding != null) return binding;
926                 }
927                 Binding binding = getTypeOrPackage(compoundName[0], TYPE | PACKAGE);
928                 if (!binding.isValidBinding()) return binding;
929
930                 int currentIndex = 1;
931                 boolean checkVisibility = false;
932                 if (binding instanceof PackageBinding) {
933                         PackageBinding packageBinding = (PackageBinding) binding;
934
935                         while (currentIndex < nameLength) {
936                                 binding = packageBinding.getTypeOrPackage(compoundName[currentIndex++]);
937                                 if (binding == null)
938                                         return new ProblemReferenceBinding(
939                                                 CharOperation.subarray(compoundName, 0, currentIndex),
940                                                 NotFound);
941                                 if (!binding.isValidBinding())
942                                         return new ProblemReferenceBinding(
943                                                 CharOperation.subarray(compoundName, 0, currentIndex),
944                                                 binding.problemId());
945                                 if (!(binding instanceof PackageBinding))
946                                         break;
947                                 packageBinding = (PackageBinding) binding;
948                         }
949                         if (binding instanceof PackageBinding) return binding;
950                         checkVisibility = true;
951                 }
952                 // binding is now a ReferenceBinding
953                 ReferenceBinding typeBinding = (ReferenceBinding) binding;
954                 if (checkVisibility) // handles the fall through case
955                         if (!typeBinding.canBeSeenBy(this))
956                                 return new ProblemReferenceBinding(
957                                         CharOperation.subarray(compoundName, 0, currentIndex),
958                                         typeBinding,
959                                         NotVisible);
960
961                 while (currentIndex < nameLength) {
962                         typeBinding = getMemberType(compoundName[currentIndex++], typeBinding);
963                         // checks visibility
964                         if (!typeBinding.isValidBinding())
965                                 return new ProblemReferenceBinding(
966                                         CharOperation.subarray(compoundName, 0, currentIndex),
967                                         typeBinding.problemId());
968                 }
969                 return typeBinding;
970         }
971
972         /* Internal use only 
973         */
974         final Binding getTypeOrPackage(char[] name, int mask) {
975                 
976                 Scope scope = this;
977                 ReferenceBinding foundType = null;
978                 if ((mask & TYPE) == 0) {
979                         Scope next = scope;
980                         while ((next = scope.parent) != null)
981                                 scope = next;
982                 } else {
983                         done : while (true) { // done when a COMPILATION_UNIT_SCOPE is found
984                                 switch (scope.kind) {
985                                         case METHOD_SCOPE :
986                                         case BLOCK_SCOPE :
987                                                 ReferenceBinding localType = ((BlockScope) scope).findLocalType(name); // looks in this scope only
988                                                 if (localType != null) {
989                                                         if (foundType != null && foundType != localType)
990                                                                 return new ProblemReferenceBinding(name, InheritedNameHidesEnclosingName);
991                                                         return localType;
992                                                 }
993                                                 break;
994                                         case CLASS_SCOPE :
995                                                 SourceTypeBinding sourceType = ((ClassScope) scope).referenceContext.binding;
996                                                 if (CharOperation.equals(sourceType.sourceName, name)) {
997                                                         if (foundType != null && foundType != sourceType)
998                                                                 return new ProblemReferenceBinding(name, InheritedNameHidesEnclosingName);
999                                                         return sourceType;
1000                                                 }
1001
1002                                                 ReferenceBinding memberType = findMemberType(name, sourceType);
1003                                                 if (memberType != null) { // skip it if we did not find anything
1004                                                         if (memberType.problemId() == Ambiguous) {
1005                                                                 if (foundType == null || foundType.problemId() == NotVisible)
1006                                                                         // supercedes any potential InheritedNameHidesEnclosingName problem
1007                                                                         return memberType;
1008                                                                 else
1009                                                                         // make the user qualify the type, likely wants the first inherited type
1010                                                                         return new ProblemReferenceBinding(name, InheritedNameHidesEnclosingName);
1011                                                         }
1012                                                         if (memberType.isValidBinding()) {
1013                                                                 if (sourceType == memberType.enclosingType()
1014                                                                         || environment().options.complianceLevel >= CompilerOptions.JDK1_4) {
1015                                                                         // found a valid type in the 'immediate' scope (ie. not inherited)
1016                                                                         // OR in 1.4 mode (inherited shadows enclosing)
1017                                                                         if (foundType == null)
1018                                                                                 return memberType;
1019                                                                         if (foundType.isValidBinding())
1020                                                                                 // if a valid type was found, complain when another is found in an 'immediate' enclosing type (ie. not inherited)
1021                                                                                 if (foundType != memberType)
1022                                                                                         return new ProblemReferenceBinding(name, InheritedNameHidesEnclosingName);
1023                                                                 }
1024                                                         }
1025                                                         if (foundType == null || (foundType.problemId() == NotVisible && memberType.problemId() != NotVisible))
1026                                                                 // only remember the memberType if its the first one found or the previous one was not visible & memberType is...
1027                                                                 foundType = memberType;
1028                                                 }
1029                                                 break;
1030                                         case COMPILATION_UNIT_SCOPE :
1031                                                 break done;
1032                                 }
1033                                 scope = scope.parent;
1034                         }
1035                         if (foundType != null && foundType.problemId() != NotVisible)
1036                                 return foundType;
1037                 }
1038
1039                 // at this point the scope is a compilation unit scope
1040                 CompilationUnitScope unitScope = (CompilationUnitScope) scope;
1041                 // ask for the imports + name
1042                 if ((mask & TYPE) != 0) {
1043                         // check single type imports.
1044                         ImportBinding[] imports = unitScope.imports;
1045                         if (imports != null){
1046                                 // copy the list, since single type imports are removed if they cannot be resolved
1047                                 for (int i = 0, length = imports.length; i < length; i++) {
1048                                         ImportBinding typeImport = imports[i];
1049                                         if (!typeImport.onDemand)
1050                                                 if (CharOperation.equals(typeImport.compoundName[typeImport.compoundName.length - 1], name))
1051                                                         if (unitScope.resolveSingleTypeImport(typeImport) != null) {
1052                                                                 if (typeImport.reference != null) typeImport.reference.used = true;
1053                                                                 return typeImport.resolvedImport; // already know its visible
1054                                                         }
1055                                 }
1056                         }
1057                         // check if the name is in the current package (answer the problem binding unless its not found in which case continue to look)
1058                         ReferenceBinding type = findType(name, unitScope.fPackage, unitScope.fPackage); // is always visible
1059                         if (type != null) return type;
1060
1061                         // check on demand imports
1062                         boolean foundInImport = false;
1063                         if (imports != null){
1064                                 for (int i = 0, length = imports.length; i < length; i++) {
1065                                         ImportBinding someImport = imports[i];
1066                                         if (someImport.onDemand) {
1067                                                 Binding resolvedImport = someImport.resolvedImport;
1068                                                 ReferenceBinding temp =
1069                                                         (resolvedImport instanceof PackageBinding)
1070                                                                 ? findType(name, (PackageBinding) resolvedImport, unitScope.fPackage)
1071                                                                 : findDirectMemberType(name, (ReferenceBinding) resolvedImport);
1072                                                 if (temp != null && temp.isValidBinding()) {
1073                                                         if (someImport.reference != null) someImport.reference.used = true;
1074                                                         if (foundInImport)
1075                                                                 // Answer error binding -- import on demand conflict; name found in two import on demand packages.
1076                                                                 return new ProblemReferenceBinding(name, Ambiguous);
1077                                                         type = temp;
1078                                                         foundInImport = true;
1079                                                 }
1080                                         }
1081                                 }
1082                         }
1083                         if (type != null)
1084                                 return type;
1085                 }
1086                 // see if the name is a package
1087                 if ((mask & PACKAGE) != 0) {
1088                         compilationUnitScope().recordSimpleReference(name);
1089                         PackageBinding packageBinding = unitScope.environment.getTopLevelPackage(name);
1090                         if (packageBinding != null)
1091                                 return packageBinding;
1092                 }
1093
1094                 compilationUnitScope().recordSimpleReference(name);
1095                 // Answer error binding -- could not find name
1096                 if (foundType != null){
1097                         return foundType;
1098                 }
1099                 return new ProblemReferenceBinding(name, NotFound);
1100         }
1101
1102         /* Answer whether the type is defined in the same compilation unit as the receiver
1103         */
1104         public final boolean isDefinedInSameUnit(ReferenceBinding type) {
1105                 // find the outer most enclosing type
1106                 ReferenceBinding enclosingType = type;
1107                 while ((type = enclosingType.enclosingType()) != null)
1108                         enclosingType = type;
1109
1110                 // find the compilation unit scope
1111                 Scope scope, unitScope = this;
1112                 while ((scope = unitScope.parent) != null)
1113                         unitScope = scope;
1114
1115                 // test that the enclosingType is not part of the compilation unit
1116                 SourceTypeBinding[] topLevelTypes =
1117                         ((CompilationUnitScope) unitScope).topLevelTypes;
1118                 for (int i = topLevelTypes.length; --i >= 0;)
1119                         if (topLevelTypes[i] == enclosingType)
1120                                 return true;
1121                 return false;
1122         }
1123
1124         public final boolean isJavaIoSerializable(TypeBinding tb) {
1125                 //a first -none optimized version-...:-)....
1126                 //please modify as needed
1127
1128                 return tb == getJavaIoSerializable();
1129         }
1130
1131         public final boolean isJavaLangCloneable(TypeBinding tb) {
1132                 //a first -none optimized version-...:-)....
1133                 //please modify as needed
1134
1135                 return tb == getJavaLangCloneable();
1136         }
1137
1138         public final boolean isJavaLangObject(TypeBinding type) {
1139                 return type.id == T_JavaLangObject;
1140         }
1141
1142         public final MethodScope methodScope() {
1143                 Scope scope = this;
1144                 do {
1145                         if (scope instanceof MethodScope)
1146                                 return (MethodScope) scope;
1147                         scope = scope.parent;
1148                 } while (scope != null);
1149                 return null;
1150         }
1151
1152         // Internal use only
1153         /* All methods in visible are acceptable matches for the method in question...
1154         * The methods defined by the receiver type appear before those defined by its
1155         * superclass and so on. We want to find the one which matches best.
1156         *
1157         * Since the receiver type is a class, we know each method's declaring class is
1158         * either the receiver type or one of its superclasses. It is an error if the best match
1159         * is defined by a superclass, when a lesser match is defined by the receiver type
1160         * or a closer superclass.
1161         */
1162         protected final MethodBinding mostSpecificClassMethodBinding(MethodBinding[] visible, int visibleSize) {
1163
1164                 MethodBinding method = null;
1165                 MethodBinding previous = null;
1166
1167                 nextVisible : for (int i = 0; i < visibleSize; i++) {
1168                         method = visible[i];
1169                                                 
1170                         if (previous != null && method.declaringClass != previous.declaringClass)
1171                                 break; // cannot answer a method farther up the hierarchy than the first method found
1172                         previous = method;
1173                         for (int j = 0; j < visibleSize; j++) {
1174                                 if (i == j) continue;
1175                                 MethodBinding next = visible[j];
1176                                 if (!areParametersAssignable(next.parameters, method.parameters))
1177                                         continue nextVisible;
1178                         }
1179                         compilationUnitScope().recordTypeReferences(method.thrownExceptions);
1180                         return method;
1181                 }
1182                 return new ProblemMethodBinding(visible[0].selector, visible[0].parameters, Ambiguous);
1183         }
1184
1185         // Internal use only
1186         /* All methods in visible are acceptable matches for the method in question...
1187         * Since the receiver type is an interface, we ignore the possibility that 2 inherited
1188         * but unrelated superinterfaces may define the same method in acceptable but
1189         * not identical ways... we just take the best match that we find since any class which
1190         * implements the receiver interface MUST implement all signatures for the method...
1191         * in which case the best match is correct.
1192         *
1193         * NOTE: This is different than javac... in the following example, the message send of
1194         * bar(X) in class Y is supposed to be ambiguous. But any class which implements the
1195         * interface I MUST implement both signatures for bar. If this class was the receiver of
1196         * the message send instead of the interface I, then no problem would be reported.
1197         *
1198         interface I1 {
1199                 void bar(J j);
1200         }
1201         interface I2 {
1202         //      void bar(J j);
1203                 void bar(Object o);
1204         }
1205         interface I extends I1, I2 {}
1206         interface J {}
1207         
1208         class X implements J {}
1209         
1210         class Y extends X {
1211                 public void foo(I i, X x) { i.bar(x); }
1212         }
1213         */
1214         protected final MethodBinding mostSpecificInterfaceMethodBinding(MethodBinding[] visible, int visibleSize) {
1215                 MethodBinding method = null;
1216                 nextVisible : for (int i = 0; i < visibleSize; i++) {
1217                         method = visible[i];
1218                         for (int j = 0; j < visibleSize; j++) {
1219                                 if (i == j) continue;
1220                                 MethodBinding next = visible[j];
1221                                 if (!areParametersAssignable(next.parameters, method.parameters))
1222                                         continue nextVisible;
1223                         }
1224                         compilationUnitScope().recordTypeReferences(method.thrownExceptions);
1225                         return method;
1226                 }
1227                 return new ProblemMethodBinding(visible[0].selector, visible[0].parameters, Ambiguous);
1228         }
1229
1230         public final ClassScope outerMostClassScope() {
1231                 ClassScope lastClassScope = null;
1232                 Scope scope = this;
1233                 do {
1234                         if (scope instanceof ClassScope)
1235                                 lastClassScope = (ClassScope) scope;
1236                         scope = scope.parent;
1237                 } while (scope != null);
1238                 return lastClassScope; // may answer null if no class around
1239         }
1240
1241         public final MethodScope outerMostMethodScope() {
1242                 MethodScope lastMethodScope = null;
1243                 Scope scope = this;
1244                 do {
1245                         if (scope instanceof MethodScope)
1246                                 lastMethodScope = (MethodScope) scope;
1247                         scope = scope.parent;
1248                 } while (scope != null);
1249                 return lastMethodScope; // may answer null if no method around
1250         }
1251
1252         public final CompilationUnitDeclaration referenceCompilationUnit() {
1253                 Scope scope, unitScope = this;
1254                 while ((scope = unitScope.parent) != null)
1255                         unitScope = scope;
1256                 return ((CompilationUnitScope) unitScope).referenceContext;
1257         }
1258         // start position in this scope - for ordering scopes vs. variables
1259         int startIndex() {
1260                 return 0;
1261         }
1262 }