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