*** empty log message ***
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / lookup / BlockScope.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v0.5 
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v05.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  ******************************************************************************/
11 package net.sourceforge.phpdt.internal.compiler.lookup;
12
13 import net.sourceforge.phpdt.internal.compiler.ast.AbstractMethodDeclaration;
14 import net.sourceforge.phpdt.internal.compiler.ast.Argument;
15 import net.sourceforge.phpdt.internal.compiler.ast.AstNode;
16 import net.sourceforge.phpdt.internal.compiler.ast.ConstructorDeclaration;
17 import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration;
18 import net.sourceforge.phpdt.internal.compiler.codegen.CodeStream;
19 import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
20 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
21 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
22 import net.sourceforge.phpdt.internal.compiler.util.CharOperation;
23
24 public class BlockScope extends Scope {
25
26         // Local variable management
27         public LocalVariableBinding[] locals;
28         public int localIndex; // position for next variable
29         public int startIndex;  // start position in this scope - for ordering scopes vs. variables
30         public int offset; // for variable allocation throughout scopes
31         public int maxOffset; // for variable allocation throughout scopes
32
33         // finally scopes must be shifted behind respective try scope
34         public BlockScope[] shiftScopes; 
35
36         public final static VariableBinding[] EmulationPathToImplicitThis = {};
37
38         public Scope[] subscopes = new Scope[1]; // need access from code assist
39         public int scopeIndex = 0; // need access from code assist
40
41         protected BlockScope(int kind, Scope parent) {
42
43                 super(kind, parent);
44         }
45
46         public BlockScope(BlockScope parent) {
47
48                 this(parent, true);
49         }
50
51         public BlockScope(BlockScope parent, boolean addToParentScope) {
52
53                 this(BLOCK_SCOPE, parent);
54                 locals = new LocalVariableBinding[5];
55                 if (addToParentScope) parent.addSubscope(this);
56                 this.startIndex = parent.localIndex;
57         }
58
59         public BlockScope(BlockScope parent, int variableCount) {
60
61                 this(BLOCK_SCOPE, parent);
62                 locals = new LocalVariableBinding[variableCount];
63                 parent.addSubscope(this);
64                 this.startIndex = parent.localIndex;
65         }
66
67         /* Create the class scope & binding for the anonymous type.
68          */
69         public final void addAnonymousType(
70                 TypeDeclaration anonymousType,
71                 ReferenceBinding superBinding) {
72
73                 ClassScope anonymousClassScope = new ClassScope(this, anonymousType);
74                 anonymousClassScope.buildAnonymousTypeBinding(
75                         enclosingSourceType(),
76                         superBinding);
77         }
78
79         /* Create the class scope & binding for the local type.
80          */
81         public final void addLocalType(TypeDeclaration localType) {
82
83                 // check that the localType does not conflict with an enclosing type
84                 ReferenceBinding type = enclosingSourceType();
85                 do {
86                         if (CharOperation.equals(type.sourceName, localType.name)) {
87                                 problemReporter().hidingEnclosingType(localType);
88                                 return;
89                         }
90                         type = type.enclosingType();
91                 } while (type != null);
92
93                 // check that the localType does not conflict with another sibling local type
94                 Scope scope = this;
95                 do {
96                         if (((BlockScope) scope).findLocalType(localType.name) != null) {
97                                 problemReporter().duplicateNestedType(localType);
98                                 return;
99                         }
100                 } while ((scope = scope.parent) instanceof BlockScope);
101
102                 ClassScope localTypeScope = new ClassScope(this, localType);
103                 localTypeScope.buildLocalTypeBinding(enclosingSourceType());
104                 addSubscope(localTypeScope);
105         }
106
107         /* Insert a local variable into a given scope, updating its position
108          * and checking there are not too many locals or arguments allocated.
109          */
110         public final void addLocalVariable(LocalVariableBinding binding) {
111
112                 checkAndSetModifiersForVariable(binding);
113
114                 // insert local in scope
115                 if (localIndex == locals.length)
116                         System.arraycopy(
117                                 locals,
118                                 0,
119                                 (locals = new LocalVariableBinding[localIndex * 2]),
120                                 0,
121                                 localIndex);
122                 locals[localIndex++] = binding;
123
124                 // update local variable binding 
125                 binding.declaringScope = this;
126                 binding.id = this.outerMostMethodScope().analysisIndex++;
127                 // share the outermost method scope analysisIndex
128         }
129
130         public void addSubscope(Scope childScope) {
131                 if (scopeIndex == subscopes.length)
132                         System.arraycopy(
133                                 subscopes,
134                                 0,
135                                 (subscopes = new Scope[scopeIndex * 2]),
136                                 0,
137                                 scopeIndex);
138                 subscopes[scopeIndex++] = childScope;
139         }
140
141         /* Answer true if the receiver is suitable for assigning final blank fields.
142          *
143          * i.e. is inside an initializer, a constructor or a clinit 
144          */
145         public final boolean allowBlankFinalFieldAssignment(FieldBinding binding) {
146
147                 if (enclosingSourceType() != binding.declaringClass)
148                         return false;
149
150                 MethodScope methodScope = methodScope();
151                 if (methodScope.isStatic != binding.isStatic())
152                         return false;
153                 return methodScope.isInsideInitializer() // inside initializer
154                 || ((AbstractMethodDeclaration) methodScope.referenceContext)
155                         .isInitializationMethod();
156                 // inside constructor or clinit
157         }
158         String basicToString(int tab) {
159                 String newLine = "\n"; //$NON-NLS-1$
160                 for (int i = tab; --i >= 0;)
161                         newLine += "\t"; //$NON-NLS-1$
162
163                 String s = newLine + "--- Block Scope ---"; //$NON-NLS-1$
164                 newLine += "\t"; //$NON-NLS-1$
165                 s += newLine + "locals:"; //$NON-NLS-1$
166                 for (int i = 0; i < localIndex; i++)
167                         s += newLine + "\t" + locals[i].toString(); //$NON-NLS-1$
168                 s += newLine + "startIndex = " + startIndex; //$NON-NLS-1$
169                 return s;
170         }
171
172         private void checkAndSetModifiersForVariable(LocalVariableBinding varBinding) {
173
174                 int modifiers = varBinding.modifiers;
175                 if ((modifiers & AccAlternateModifierProblem) != 0 && varBinding.declaration != null){
176                         problemReporter().duplicateModifierForVariable(varBinding.declaration, this instanceof MethodScope);
177                 }
178                 int realModifiers = modifiers & AccJustFlag;
179                 
180                 int unexpectedModifiers = ~AccFinal;
181                 if ((realModifiers & unexpectedModifiers) != 0 && varBinding.declaration != null){ 
182                         problemReporter().illegalModifierForVariable(varBinding.declaration, this instanceof MethodScope);
183                 }
184                 varBinding.modifiers = modifiers;
185         }
186
187         /* Compute variable positions in scopes given an initial position offset
188          * ignoring unused local variables.
189          * 
190          * Special treatment to have Try secret return address variables located at non
191          * colliding positions. Return addresses are not allocated initially, but gathered
192          * and allocated behind all other variables.
193          */
194         public void computeLocalVariablePositions(
195                 int initOffset,
196                 CodeStream codeStream) {
197
198                 this.offset = initOffset;
199                 this.maxOffset = initOffset;
200
201                 // local variable init
202                 int ilocal = 0, maxLocals = 0, localsLength = locals.length;
203                 while ((maxLocals < localsLength) && (locals[maxLocals] != null))
204                         maxLocals++;
205                 boolean hasMoreVariables = maxLocals > 0;
206
207                 // scope init
208                 int iscope = 0, maxScopes = 0, subscopesLength = subscopes.length;
209                 while ((maxScopes < subscopesLength) && (subscopes[maxScopes] != null))
210                         maxScopes++;
211                 boolean hasMoreScopes = maxScopes > 0;
212
213                 // iterate scopes and variables in parallel
214                 while (hasMoreVariables || hasMoreScopes) {
215                         if (hasMoreScopes
216                                 && (!hasMoreVariables || (subscopes[iscope].startIndex() <= ilocal))) {
217                                 // consider subscope first
218                                 if (subscopes[iscope] instanceof BlockScope) {
219                                         BlockScope subscope = (BlockScope) subscopes[iscope];
220                                         int subOffset = subscope.shiftScopes == null ? this.offset : subscope.maxShiftedOffset();
221                                         subscope.computeLocalVariablePositions(subOffset, codeStream);
222                                         if (subscope.maxOffset > this.maxOffset)
223                                                 this.maxOffset = subscope.maxOffset;
224                                 }
225                                 hasMoreScopes = ++iscope < maxScopes;
226                         } else {
227                                 // consider variable first
228                                 LocalVariableBinding local = locals[ilocal];
229
230                                 // check if variable is actually used, and may force it to be preserved
231                                 boolean generatesLocal =
232                                         (local.used && (local.constant == Constant.NotAConstant)) || local.isArgument;
233                                 if (!local.used
234                                         && (local.declaration != null) // unused (and non secret) local
235                                         && ((local.declaration.bits & AstNode.IsLocalDeclarationReachableMASK) != 0)) { // declaration is reachable
236                                         if (local.isArgument) // method argument
237                                                 this.problemReporter().unusedArgument(local.declaration);
238                                         else if (!(local.declaration instanceof Argument))  // do not report unused catch arguments
239                                                 this.problemReporter().unusedLocalVariable(local.declaration);
240                                 }
241                                 if (!generatesLocal) {
242                                         if (local.declaration != null
243                                                 && environment().options.preserveAllLocalVariables) {
244                                                 generatesLocal = true; // force it to be preserved in the generated code
245                                                 local.used = true;
246                                         }
247                                 }
248                                 if (generatesLocal) {
249
250                                         if (local.declaration != null) {
251                                                 codeStream.record(local);
252                                                 // record user local variables for attribute generation
253                                         }
254                                         // allocate variable position
255                                         local.resolvedPosition = this.offset;
256
257                                         // check for too many arguments/local variables
258                                         if (local.isArgument) {
259                                                 if (this.offset > 0xFF) { // no more than 255 words of arguments
260                                                         this.problemReporter().noMoreAvailableSpaceForArgument(local, local.declaration);
261                                                 }
262                                         } else {
263                                                 if (this.offset > 0xFFFF) { // no more than 65535 words of locals
264                                                         this.problemReporter().noMoreAvailableSpaceForLocal(
265                                                                 local, local.declaration == null ? (AstNode)this.methodScope().referenceContext : local.declaration);
266                                                 }
267                                         }
268
269                                         // increment offset
270                                         if ((local.type == LongBinding) || (local.type == DoubleBinding)) {
271                                                 this.offset += 2;
272                                         } else {
273                                                 this.offset++;
274                                         }
275                                 } else {
276                                         local.resolvedPosition = -1; // not generated
277                                 }
278                                 hasMoreVariables = ++ilocal < maxLocals;
279                         }
280                 }
281                 if (this.offset > this.maxOffset)
282                         this.maxOffset = this.offset;
283         }
284
285         /* Answer true if the variable name already exists within the receiver's scope.
286          */
287         public final LocalVariableBinding duplicateName(char[] name) {
288                 for (int i = 0; i < localIndex; i++)
289                         if (CharOperation.equals(name, locals[i].name))
290                                 return locals[i];
291
292                 if (this instanceof MethodScope)
293                         return null;
294                 else
295                         return ((BlockScope) parent).duplicateName(name);
296         }
297
298         /*
299          *      Record the suitable binding denoting a synthetic field or constructor argument,
300          * mapping to the actual outer local variable in the scope context.
301          * Note that this may not need any effect, in case the outer local variable does not
302          * need to be emulated and can directly be used as is (using its back pointer to its
303          * declaring scope).
304          */
305         public void emulateOuterAccess(LocalVariableBinding outerLocalVariable) {
306
307                 MethodScope currentMethodScope;
308                 if ((currentMethodScope = this.methodScope())
309                         != outerLocalVariable.declaringScope.methodScope()) {
310                         NestedTypeBinding currentType = (NestedTypeBinding) this.enclosingSourceType();
311
312                         //do nothing for member types, pre emulation was performed already
313                         if (!currentType.isLocalType()) {
314                                 return;
315                         }
316                         // must also add a synthetic field if we're not inside a constructor
317                         if (!currentMethodScope.isInsideInitializerOrConstructor()) {
318                                 currentType.addSyntheticArgumentAndField(outerLocalVariable);
319                         } else {
320                                 currentType.addSyntheticArgument(outerLocalVariable);
321                         }
322                 }
323         }
324
325         /*
326          * Record the suitable binding denoting a synthetic field or constructor argument,
327          * mapping to a given actual enclosing instance type in the scope context.
328          * Skip it if the enclosingType is actually the current scope's enclosing type.
329          */
330
331         public void emulateOuterAccess(
332                 ReferenceBinding targetEnclosingType,
333                 boolean useDirectReference) {
334
335                 ReferenceBinding currentType = enclosingSourceType();
336                 if (currentType.isNestedType()
337                         && currentType != targetEnclosingType){
338                         /*&& !targetEnclosingType.isSuperclassOf(currentType)*/
339
340                         if (useDirectReference) {
341                                 // the target enclosing type is not in scope, we directly refer it
342                                 // must also add a synthetic field if we're not inside a constructor
343                                 NestedTypeBinding currentNestedType = (NestedTypeBinding) currentType;
344                                 if (methodScope().isInsideInitializerOrConstructor())
345                                         currentNestedType.addSyntheticArgument(targetEnclosingType);
346                                 else
347                                         currentNestedType.addSyntheticArgumentAndField(targetEnclosingType);
348                                         
349                         } else { // indirect reference sequence
350                                 int depth = 0;
351                                 
352                                 // saturate all the way up until reaching compatible enclosing type
353                                 while (currentType.isLocalType()){
354                                         NestedTypeBinding currentNestedType = (NestedTypeBinding) currentType;
355                                         currentType = currentNestedType.enclosingType;
356                                         
357                                         if (depth == 0){
358                                                 if (methodScope().isInsideInitializerOrConstructor()) {
359                                                         // must also add a synthetic field if we're not inside a constructor
360                                                         currentNestedType.addSyntheticArgument(currentType);
361                                                 } else {
362                                                         currentNestedType.addSyntheticArgumentAndField(currentType);
363                                                 }                                       
364                                         } else if (currentNestedType == targetEnclosingType 
365                                                                                 || targetEnclosingType.isSuperclassOf(currentNestedType)) {
366                                                         break;
367                                         } else {
368                                                 currentNestedType.addSyntheticArgumentAndField(currentType);
369                                         } 
370                                         depth++;
371                                 }
372                         }
373                 }
374         }
375
376         /* Note that it must never produce a direct access to the targetEnclosingType,
377          * but instead a field sequence (this$2.this$1.this$0) so as to handle such a test case:
378          *
379          * class XX {
380          *      void foo() {
381          *              class A {
382          *                      class B {
383          *                              class C {
384          *                                      boolean foo() {
385          *                                              return (Object) A.this == (Object) B.this;
386          *                                      }
387          *                              }
388          *                      }
389          *              }
390          *              new A().new B().new C();
391          *      }
392          * }
393          * where we only want to deal with ONE enclosing instance for C (could not figure out an A for C)
394          */
395         public final ReferenceBinding findLocalType(char[] name) {
396
397                 for (int i = 0, length = scopeIndex; i < length; i++) {
398                         if (subscopes[i] instanceof ClassScope) {
399                                 SourceTypeBinding sourceType =
400                                         ((ClassScope) subscopes[i]).referenceContext.binding;
401                                 if (CharOperation.equals(sourceType.sourceName(), name))
402                                         return sourceType;
403                         }
404                 }
405                 return null;
406         }
407
408         public LocalVariableBinding findVariable(char[] variable) {
409
410                 int variableLength = variable.length;
411                 for (int i = 0, length = locals.length; i < length; i++) {
412                         LocalVariableBinding local = locals[i];
413                         if (local == null)
414                                 return null;
415                         if (local.name.length == variableLength
416                                 && CharOperation.prefixEquals(local.name, variable))
417                                 return local;
418                 }
419                 return null;
420         }
421         /* API
422      * flag is a mask of the following values VARIABLE (= FIELD or LOCAL), TYPE.
423          * Only bindings corresponding to the mask will be answered.
424          *
425          *      if the VARIABLE mask is set then
426          *              If the first name provided is a field (or local) then the field (or local) is answered
427          *              Otherwise, package names and type names are consumed until a field is found.
428          *              In this case, the field is answered.
429          *
430          *      if the TYPE mask is set,
431          *              package names and type names are consumed until the end of the input.
432          *              Only if all of the input is consumed is the type answered
433          *
434          *      All other conditions are errors, and a problem binding is returned.
435          *      
436          *      NOTE: If a problem binding is returned, senders should extract the compound name
437          *      from the binding & not assume the problem applies to the entire compoundName.
438          *
439          *      The VARIABLE mask has precedence over the TYPE mask.
440          *
441          *      InvocationSite implements
442          *              isSuperAccess(); this is used to determine if the discovered field is visible.
443          *              setFieldIndex(int); this is used to record the number of names that were consumed.
444          *
445          *      For example, getBinding({"foo","y","q", VARIABLE, site) will answer
446          *      the binding for the field or local named "foo" (or an error binding if none exists).
447          *      In addition, setFieldIndex(1) will be sent to the invocation site.
448          *      If a type named "foo" exists, it will not be detected (and an error binding will be answered)
449          *
450          *      IMPORTANT NOTE: This method is written under the assumption that compoundName is longer than length 1.
451          */
452         public Binding getBinding(char[][] compoundName, int mask, InvocationSite invocationSite) {
453
454                 Binding binding = getBinding(compoundName[0], mask | TYPE | PACKAGE, invocationSite);
455                 invocationSite.setFieldIndex(1);
456                 if (binding instanceof VariableBinding) return binding;
457                 compilationUnitScope().recordSimpleReference(compoundName[0]);
458                 if (!binding.isValidBinding()) return binding;
459
460                 int length = compoundName.length;
461                 int currentIndex = 1;
462                 foundType : if (binding instanceof PackageBinding) {
463                         PackageBinding packageBinding = (PackageBinding) binding;
464                         while (currentIndex < length) {
465                                 compilationUnitScope().recordReference(packageBinding.compoundName, compoundName[currentIndex]);
466                                 binding = packageBinding.getTypeOrPackage(compoundName[currentIndex++]);
467                                 invocationSite.setFieldIndex(currentIndex);
468                                 if (binding == null) {
469                                         if (currentIndex == length)
470                                                 // must be a type if its the last name, otherwise we have no idea if its a package or type
471                                                 return new ProblemReferenceBinding(
472                                                         CharOperation.subarray(compoundName, 0, currentIndex),
473                                                         NotFound);
474                                         else
475                                                 return new ProblemBinding(
476                                                         CharOperation.subarray(compoundName, 0, currentIndex),
477                                                         NotFound);
478                                 }
479                                 if (binding instanceof ReferenceBinding) {
480                                         if (!binding.isValidBinding())
481                                                 return new ProblemReferenceBinding(
482                                                         CharOperation.subarray(compoundName, 0, currentIndex),
483                                                         binding.problemId());
484                                         if (!((ReferenceBinding) binding).canBeSeenBy(this))
485                                                 return new ProblemReferenceBinding(
486                                                         CharOperation.subarray(compoundName, 0, currentIndex),
487                                                         binding,
488                                                         NotVisible);
489                                         break foundType;
490                                 }
491                                 packageBinding = (PackageBinding) binding;
492                         }
493
494                         // It is illegal to request a PACKAGE from this method.
495                         return new ProblemReferenceBinding(
496                                 CharOperation.subarray(compoundName, 0, currentIndex),
497                                 NotFound);
498                 }
499
500                 // know binding is now a ReferenceBinding
501                 while (currentIndex < length) {
502                         ReferenceBinding typeBinding = (ReferenceBinding) binding;
503                         char[] nextName = compoundName[currentIndex++];
504                         invocationSite.setFieldIndex(currentIndex);
505                         invocationSite.setActualReceiverType(typeBinding);
506                         if ((binding = findField(typeBinding, nextName, invocationSite)) != null) {
507                                 if (!binding.isValidBinding())
508                                         return new ProblemFieldBinding(
509                                                 ((FieldBinding) binding).declaringClass,
510                                                 CharOperation.subarray(compoundName, 0, currentIndex),
511                                                 binding.problemId());
512                                 break; // binding is now a field
513                         }
514                         if ((binding = findMemberType(nextName, typeBinding)) == null)
515                                 return new ProblemBinding(
516                                         CharOperation.subarray(compoundName, 0, currentIndex),
517                                         typeBinding,
518                                         NotFound);
519                         if (!binding.isValidBinding())
520                                 return new ProblemReferenceBinding(
521                                         CharOperation.subarray(compoundName, 0, currentIndex),
522                                         binding.problemId());
523                 }
524
525                 if ((mask & FIELD) != 0 && (binding instanceof FieldBinding)) {
526                         // was looking for a field and found a field
527                         FieldBinding field = (FieldBinding) binding;
528                         if (!field.isStatic())
529                                 return new ProblemFieldBinding(
530                                         field.declaringClass,
531                                         CharOperation.subarray(compoundName, 0, currentIndex),
532                                         NonStaticReferenceInStaticContext);
533                         return binding;
534                 }
535                 if ((mask & TYPE) != 0 && (binding instanceof ReferenceBinding)) {
536                         // was looking for a type and found a type
537                         return binding;
538                 }
539
540                 // handle the case when a field or type was asked for but we resolved the compoundName to a type or field
541                 return new ProblemBinding(
542                         CharOperation.subarray(compoundName, 0, currentIndex),
543                         NotFound);
544         }
545
546         // Added for code assist... NOT Public API
547         public final Binding getBinding(
548                 char[][] compoundName,
549                 InvocationSite invocationSite) {
550                 int currentIndex = 0;
551                 int length = compoundName.length;
552                 Binding binding =
553                         getBinding(
554                                 compoundName[currentIndex++],
555                                 VARIABLE | TYPE | PACKAGE,
556                                 invocationSite);
557                 if (!binding.isValidBinding())
558                         return binding;
559
560                 foundType : if (binding instanceof PackageBinding) {
561                         while (currentIndex < length) {
562                                 PackageBinding packageBinding = (PackageBinding) binding;
563                                 binding = packageBinding.getTypeOrPackage(compoundName[currentIndex++]);
564                                 if (binding == null) {
565                                         if (currentIndex == length)
566                                                 // must be a type if its the last name, otherwise we have no idea if its a package or type
567                                                 return new ProblemReferenceBinding(
568                                                         CharOperation.subarray(compoundName, 0, currentIndex),
569                                                         NotFound);
570                                         else
571                                                 return new ProblemBinding(
572                                                         CharOperation.subarray(compoundName, 0, currentIndex),
573                                                         NotFound);
574                                 }
575                                 if (binding instanceof ReferenceBinding) {
576                                         if (!binding.isValidBinding())
577                                                 return new ProblemReferenceBinding(
578                                                         CharOperation.subarray(compoundName, 0, currentIndex),
579                                                         binding.problemId());
580                                         if (!((ReferenceBinding) binding).canBeSeenBy(this))
581                                                 return new ProblemReferenceBinding(
582                                                         CharOperation.subarray(compoundName, 0, currentIndex),
583                                                         binding, 
584                                                         NotVisible);
585                                         break foundType;
586                                 }
587                         }
588                         return binding;
589                 }
590
591                 foundField : if (binding instanceof ReferenceBinding) {
592                         while (currentIndex < length) {
593                                 ReferenceBinding typeBinding = (ReferenceBinding) binding;
594                                 char[] nextName = compoundName[currentIndex++];
595                                 if ((binding = findField(typeBinding, nextName, invocationSite)) != null) {
596                                         if (!binding.isValidBinding())
597                                                 return new ProblemFieldBinding(
598                                                         ((FieldBinding) binding).declaringClass,
599                                                         CharOperation.subarray(compoundName, 0, currentIndex),
600                                                         binding.problemId());
601                                         if (!((FieldBinding) binding).isStatic())
602                                                 return new ProblemFieldBinding(
603                                                         ((FieldBinding) binding).declaringClass,
604                                                         CharOperation.subarray(compoundName, 0, currentIndex),
605                                                         NonStaticReferenceInStaticContext);
606                                         break foundField; // binding is now a field
607                                 }
608                                 if ((binding = findMemberType(nextName, typeBinding)) == null)
609                                         return new ProblemBinding(
610                                                 CharOperation.subarray(compoundName, 0, currentIndex),
611                                                 typeBinding,
612                                                 NotFound);
613                                 if (!binding.isValidBinding())
614                                         return new ProblemReferenceBinding(
615                                                 CharOperation.subarray(compoundName, 0, currentIndex),
616                                                 binding.problemId());
617                         }
618                         return binding;
619                 }
620
621                 VariableBinding variableBinding = (VariableBinding) binding;
622                 while (currentIndex < length) {
623                         TypeBinding typeBinding = variableBinding.type;
624                         if (typeBinding == null)
625                                 return new ProblemFieldBinding(
626                                         null,
627                                         CharOperation.subarray(compoundName, 0, currentIndex + 1),
628                                         NotFound);
629                         variableBinding =
630                                 findField(typeBinding, compoundName[currentIndex++], invocationSite);
631                         if (variableBinding == null)
632                                 return new ProblemFieldBinding(
633                                         null,
634                                         CharOperation.subarray(compoundName, 0, currentIndex),
635                                         NotFound);
636                         if (!variableBinding.isValidBinding())
637                                 return variableBinding;
638                 }
639                 return variableBinding;
640         }
641
642         /* API
643      *  
644          *      Answer the binding that corresponds to the argument name.
645          *      flag is a mask of the following values VARIABLE (= FIELD or LOCAL), TYPE, PACKAGE.
646          *      Only bindings corresponding to the mask can be answered.
647          *
648          *      For example, getBinding("foo", VARIABLE, site) will answer
649          *      the binding for the field or local named "foo" (or an error binding if none exists).
650          *      If a type named "foo" exists, it will not be detected (and an error binding will be answered)
651          *
652          *      The VARIABLE mask has precedence over the TYPE mask.
653          *
654          *      If the VARIABLE mask is not set, neither fields nor locals will be looked for.
655          *
656          *      InvocationSite implements:
657          *              isSuperAccess(); this is used to determine if the discovered field is visible.
658          *
659          *      Limitations: cannot request FIELD independently of LOCAL, or vice versa
660          */
661         public Binding getBinding(char[] name, int mask, InvocationSite invocationSite) {
662                         
663                 Binding binding = null;
664                 FieldBinding problemField = null;
665                 if ((mask & VARIABLE) != 0) {
666                         if (this.kind == BLOCK_SCOPE || this.kind == METHOD_SCOPE) {
667                                 LocalVariableBinding variableBinding = findVariable(name);
668                                 // looks in this scope only
669                                 if (variableBinding != null) return variableBinding;
670                         }
671
672                         boolean insideStaticContext = false;
673                         boolean insideConstructorCall = false;
674                         if (this.kind == METHOD_SCOPE) {
675                                 MethodScope methodScope = (MethodScope) this;
676                                 insideStaticContext |= methodScope.isStatic;
677                                 insideConstructorCall |= methodScope.isConstructorCall;
678                         }
679
680                         FieldBinding foundField = null;
681                         // can be a problem field which is answered if a valid field is not found
682                         ProblemFieldBinding foundInsideProblem = null;
683                         // inside Constructor call or inside static context
684                         Scope scope = parent;
685                         int depth = 0;
686                         int foundDepth = 0;
687                         ReferenceBinding foundActualReceiverType = null;
688                         done : while (true) { // done when a COMPILATION_UNIT_SCOPE is found
689                                 switch (scope.kind) {
690                                         case METHOD_SCOPE :
691                                                 MethodScope methodScope = (MethodScope) scope;
692                                                 insideStaticContext |= methodScope.isStatic;
693                                                 insideConstructorCall |= methodScope.isConstructorCall;
694                                                 // Fall through... could duplicate the code below to save a cast - questionable optimization
695                                         case BLOCK_SCOPE :
696                                                 LocalVariableBinding variableBinding = ((BlockScope) scope).findVariable(name);
697                                                 // looks in this scope only
698                                                 if (variableBinding != null) {
699                                                         if (foundField != null && foundField.isValidBinding())
700                                                                 return new ProblemFieldBinding(
701                                                                         foundField.declaringClass,
702                                                                         name,
703                                                                         InheritedNameHidesEnclosingName);
704                                                         if (depth > 0)
705                                                                 invocationSite.setDepth(depth);
706                                                         return variableBinding;
707                                                 }
708                                                 break;
709                                         case CLASS_SCOPE :
710                                                 ClassScope classScope = (ClassScope) scope;
711                                                 SourceTypeBinding enclosingType = classScope.referenceContext.binding;
712                                                 FieldBinding fieldBinding =
713                                                         classScope.findField(enclosingType, name, invocationSite);
714                                                 // Use next line instead if willing to enable protected access accross inner types
715                                                 // FieldBinding fieldBinding = findField(enclosingType, name, invocationSite);
716                                                 if (fieldBinding != null) { // skip it if we did not find anything
717                                                         if (fieldBinding.problemId() == Ambiguous) {
718                                                                 if (foundField == null || foundField.problemId() == NotVisible)
719                                                                         // supercedes any potential InheritedNameHidesEnclosingName problem
720                                                                         return fieldBinding;
721                                                                 else
722                                                                         // make the user qualify the field, likely wants the first inherited field (javac generates an ambiguous error instead)
723                                                                         return new ProblemFieldBinding(
724                                                                                 fieldBinding.declaringClass,
725                                                                                 name,
726                                                                                 InheritedNameHidesEnclosingName);
727                                                         }
728
729                                                         ProblemFieldBinding insideProblem = null;
730                                                         if (fieldBinding.isValidBinding()) {
731                                                                 if (!fieldBinding.isStatic()) {
732                                                                         if (insideConstructorCall) {
733                                                                                 insideProblem =
734                                                                                         new ProblemFieldBinding(
735                                                                                                 fieldBinding.declaringClass,
736                                                                                                 name,
737                                                                                                 NonStaticReferenceInConstructorInvocation);
738                                                                         } else if (insideStaticContext) {
739                                                                                 insideProblem =
740                                                                                         new ProblemFieldBinding(
741                                                                                                 fieldBinding.declaringClass,
742                                                                                                 name,
743                                                                                                 NonStaticReferenceInStaticContext);
744                                                                         }
745                                                                 }
746                                                                 if (enclosingType == fieldBinding.declaringClass
747                                                                         || environment().options.complianceLevel >= CompilerOptions.JDK1_4){
748                                                                         // found a valid field in the 'immediate' scope (ie. not inherited)
749                                                                         // OR in 1.4 mode (inherited shadows enclosing)
750                                                                         if (foundField == null) {
751                                                                                 if (depth > 0){
752                                                                                         invocationSite.setDepth(depth);
753                                                                                         invocationSite.setActualReceiverType(enclosingType);
754                                                                                 }
755                                                                                 // return the fieldBinding if it is not declared in a superclass of the scope's binding (i.e. "inherited")
756                                                                                 return insideProblem == null ? fieldBinding : insideProblem;
757                                                                         }
758                                                                         if (foundField.isValidBinding())
759                                                                                 // if a valid field was found, complain when another is found in an 'immediate' enclosing type (ie. not inherited)
760                                                                                 if (foundField.declaringClass != fieldBinding.declaringClass)
761                                                                                         // ie. have we found the same field - do not trust field identity yet
762                                                                                         return new ProblemFieldBinding(
763                                                                                                 fieldBinding.declaringClass,
764                                                                                                 name,
765                                                                                                 InheritedNameHidesEnclosingName);
766                                                                 }
767                                                         }
768
769                                                         if (foundField == null
770                                                                 || (foundField.problemId() == NotVisible
771                                                                         && fieldBinding.problemId() != NotVisible)) {
772                                                                 // only remember the fieldBinding if its the first one found or the previous one was not visible & fieldBinding is...
773                                                                 foundDepth = depth;
774                                                                 foundActualReceiverType = enclosingType;
775                                                                 foundInsideProblem = insideProblem;
776                                                                 foundField = fieldBinding;
777                                                         }
778                                                 }
779                                                 depth++;
780                                                 insideStaticContext |= enclosingType.isStatic();
781                                                 // 1EX5I8Z - accessing outer fields within a constructor call is permitted
782                                                 // in order to do so, we change the flag as we exit from the type, not the method
783                                                 // itself, because the class scope is used to retrieve the fields.
784                                                 MethodScope enclosingMethodScope = scope.methodScope();
785                                                 insideConstructorCall =
786                                                         enclosingMethodScope == null ? false : enclosingMethodScope.isConstructorCall;
787                                                 break;
788                                         case COMPILATION_UNIT_SCOPE :
789                                                 break done;
790                                 }
791                                 scope = scope.parent;
792                         }
793
794                         if (foundInsideProblem != null){
795                                 return foundInsideProblem;
796                         }
797                         if (foundField != null) {
798                                 if (foundField.isValidBinding()){
799                                         if (foundDepth > 0){
800                                                 invocationSite.setDepth(foundDepth);
801                                                 invocationSite.setActualReceiverType(foundActualReceiverType);
802                                         }
803                                         return foundField;
804                                 }
805                                 problemField = foundField;
806                         }
807                 }
808
809                 // We did not find a local or instance variable.
810                 if ((mask & TYPE) != 0) {
811                         if ((binding = getBaseType(name)) != null)
812                                 return binding;
813                         binding = getTypeOrPackage(name, (mask & PACKAGE) == 0 ? TYPE : TYPE | PACKAGE);
814                         if (binding.isValidBinding() || mask == TYPE)
815                                 return binding;
816                         // answer the problem type binding if we are only looking for a type
817                 } else if ((mask & PACKAGE) != 0) {
818                         compilationUnitScope().recordSimpleReference(name);
819                         if ((binding = environment().getTopLevelPackage(name)) != null)
820                                 return binding;
821                 }
822                 if (problemField != null)
823                         return problemField;
824                 else
825                         return new ProblemBinding(name, enclosingSourceType(), NotFound);
826         }
827         
828         /*
829          * This retrieves the argument that maps to an enclosing instance of the suitable type,
830          *      if not found then answers nil -- do not create one
831          *
832          *              #implicitThis                                                           :  the implicit this will be ok
833          *              #((arg) this$n)                                                         : available as a constructor arg
834          *              #((arg) this$n access$m... access$p)            : available as as a constructor arg + a sequence of synthetic accessors to synthetic fields
835          *              #((fieldDescr) this$n access#m... access$p)     : available as a first synthetic field + a sequence of synthetic accessors to synthetic fields
836          *              nil                                                                                                                             : not found
837          *
838          */
839         public Object[] getCompatibleEmulationPath(ReferenceBinding targetEnclosingType) {
840
841                 MethodScope currentMethodScope = this.methodScope();
842                 SourceTypeBinding sourceType = currentMethodScope.enclosingSourceType();
843
844                 // identity check
845                 if (!currentMethodScope.isStatic 
846                         && !currentMethodScope.isConstructorCall
847                         && (sourceType == targetEnclosingType
848                                 || targetEnclosingType.isSuperclassOf(sourceType))) {
849                         return EmulationPathToImplicitThis; // implicit this is good enough
850                 }
851                 if (!sourceType.isNestedType()
852                         || sourceType.isStatic()) { // no emulation from within non-inner types
853                         return null;
854                 }
855                 boolean insideConstructor =
856                         currentMethodScope.isInsideInitializerOrConstructor();
857                 // use synthetic constructor arguments if possible
858                 if (insideConstructor) {
859                         SyntheticArgumentBinding syntheticArg;
860                         if ((syntheticArg = ((NestedTypeBinding) sourceType).getSyntheticArgument(targetEnclosingType, this, false)) != null) {
861                                 return new Object[] { syntheticArg };
862                         }
863                 }
864
865                 // use a direct synthetic field then
866                 if (!currentMethodScope.isStatic) {
867                         FieldBinding syntheticField;
868                         if ((syntheticField = sourceType.getSyntheticField(targetEnclosingType, this, false)) != null) {
869                                 return new Object[] { syntheticField };
870                         }
871                         // could be reached through a sequence of enclosing instance link (nested members)
872                         Object[] path = new Object[2]; // probably at least 2 of them
873                         ReferenceBinding currentType = sourceType.enclosingType();
874                         if (insideConstructor) {
875                                 path[0] = ((NestedTypeBinding) sourceType).getSyntheticArgument((SourceTypeBinding) currentType, this, false);
876                         } else {
877                                 path[0] =
878                                         sourceType.getSyntheticField((SourceTypeBinding) currentType, this, false);
879                         }
880                         if (path[0] != null) { // keep accumulating
881                                 int count = 1;
882                                 ReferenceBinding currentEnclosingType;
883                                 while ((currentEnclosingType = currentType.enclosingType()) != null) {
884                                         //done?
885                                         if (currentType == targetEnclosingType
886                                                 || targetEnclosingType.isSuperclassOf(currentType))
887                                                 break;
888                                         syntheticField = ((NestedTypeBinding) currentType).getSyntheticField((SourceTypeBinding) currentEnclosingType, this, false);
889                                         if (syntheticField == null)
890                                                 break;
891                                         // append inside the path
892                                         if (count == path.length) {
893                                                 System.arraycopy(path, 0, (path = new Object[count + 1]), 0, count);
894                                         }
895                                         // private access emulation is necessary since synthetic field is private
896                                         path[count++] = ((SourceTypeBinding) syntheticField.declaringClass).addSyntheticMethod(syntheticField, true);
897                                         currentType = currentEnclosingType;
898                                 }
899                                 if (currentType == targetEnclosingType
900                                         || targetEnclosingType.isSuperclassOf(currentType)) {
901                                         return path;
902                                 }
903                         }
904                 }
905                 return null;
906         }
907
908         /* API
909          *
910          *      Answer the constructor binding that corresponds to receiverType, argumentTypes.
911          *
912          *      InvocationSite implements 
913          *              isSuperAccess(); this is used to determine if the discovered constructor is visible.
914          *
915          *      If no visible constructor is discovered, an error binding is answered.
916          */
917         public MethodBinding getConstructor(
918                 ReferenceBinding receiverType,
919                 TypeBinding[] argumentTypes,
920                 InvocationSite invocationSite) {
921
922                 compilationUnitScope().recordTypeReference(receiverType);
923                 compilationUnitScope().recordTypeReferences(argumentTypes);
924                 MethodBinding methodBinding = receiverType.getExactConstructor(argumentTypes);
925                 if (methodBinding != null)
926                         if (methodBinding.canBeSeenBy(invocationSite, this))
927                                 return methodBinding;
928
929                 MethodBinding[] methods =
930                         receiverType.getMethods(ConstructorDeclaration.ConstantPoolName);
931                 if (methods == NoMethods)
932                         return new ProblemMethodBinding(
933                                 ConstructorDeclaration.ConstantPoolName,
934                                 argumentTypes,
935                                 NotFound);
936
937                 MethodBinding[] compatible = new MethodBinding[methods.length];
938                 int compatibleIndex = 0;
939                 for (int i = 0, length = methods.length; i < length; i++)
940                         if (areParametersAssignable(methods[i].parameters, argumentTypes))
941                                 compatible[compatibleIndex++] = methods[i];
942                 if (compatibleIndex == 0)
943                         return new ProblemMethodBinding(
944                                 ConstructorDeclaration.ConstantPoolName,
945                                 argumentTypes,
946                                 NotFound);
947                 // need a more descriptive error... cannot convert from X to Y
948
949                 MethodBinding[] visible = new MethodBinding[compatibleIndex];
950                 int visibleIndex = 0;
951                 for (int i = 0; i < compatibleIndex; i++) {
952                         MethodBinding method = compatible[i];
953                         if (method.canBeSeenBy(invocationSite, this))
954                                 visible[visibleIndex++] = method;
955                 }
956                 if (visibleIndex == 1)
957                         return visible[0];
958                 if (visibleIndex == 0)
959                         return new ProblemMethodBinding(
960                                 ConstructorDeclaration.ConstantPoolName,
961                                 argumentTypes,
962                                 NotVisible);
963                 return mostSpecificClassMethodBinding(visible, visibleIndex);
964         }
965
966         /*
967          * This retrieves the argument that maps to an enclosing instance of the suitable type,
968          *      if not found then answers nil -- do not create one
969      *  
970          *                      #implicitThis                                                                   :  the implicit this will be ok
971          *                      #((arg) this$n)                                                         : available as a constructor arg
972          *              #((arg) this$n ... this$p)                              : available as as a constructor arg + a sequence of fields
973          *              #((fieldDescr) this$n ... this$p)       : available as a sequence of fields
974          *              nil                                                                                                     : not found
975          *
976          *      Note that this algorithm should answer the shortest possible sequence when
977          *              shortcuts are available:
978          *                              this$0 . this$0 . this$0
979          *              instead of
980          *                              this$2 . this$1 . this$0 . this$1 . this$0
981          *              thus the code generation will be more compact and runtime faster
982          */
983         public VariableBinding[] getEmulationPath(LocalVariableBinding outerLocalVariable) {
984
985                 MethodScope currentMethodScope = this.methodScope();
986                 SourceTypeBinding sourceType = currentMethodScope.enclosingSourceType();
987
988                 // identity check
989                 if (currentMethodScope == outerLocalVariable.declaringScope.methodScope()) {
990                         return new VariableBinding[] { outerLocalVariable };
991                         // implicit this is good enough
992                 }
993                 // use synthetic constructor arguments if possible
994                 if (currentMethodScope.isInsideInitializerOrConstructor()
995                         && (sourceType.isNestedType())) {
996                         SyntheticArgumentBinding syntheticArg;
997                         if ((syntheticArg = ((NestedTypeBinding) sourceType).getSyntheticArgument(outerLocalVariable)) != null) {
998                                 return new VariableBinding[] { syntheticArg };
999                         }
1000                 }
1001                 // use a synthetic field then
1002                 if (!currentMethodScope.isStatic) {
1003                         FieldBinding syntheticField;
1004                         if ((syntheticField = sourceType.getSyntheticField(outerLocalVariable)) != null) {
1005                                 return new VariableBinding[] { syntheticField };
1006                         }
1007                 }
1008                 return null;
1009         }
1010
1011         /*
1012          * This retrieves the argument that maps to an enclosing instance of the suitable type,
1013          *      if not found then answers nil -- do not create one
1014          *
1015          *              #implicitThis                                                           :  the implicit this will be ok
1016          *              #((arg) this$n)                                                         : available as a constructor arg
1017          *              #((arg) this$n access$m... access$p)            : available as as a constructor arg + a sequence of synthetic accessors to synthetic fields
1018          *              #((fieldDescr) this$n access#m... access$p)     : available as a first synthetic field + a sequence of synthetic accessors to synthetic fields
1019          *              nil                                                                             : not found
1020          *
1021          *      EXACT MATCH VERSION - no type compatibility is performed
1022          */
1023         public Object[] getExactEmulationPath(ReferenceBinding targetEnclosingType) {
1024
1025                 MethodScope currentMethodScope = this.methodScope();
1026                 SourceTypeBinding sourceType = currentMethodScope.enclosingSourceType();
1027
1028                 // identity check
1029                 if (!currentMethodScope.isStatic 
1030                         && !currentMethodScope.isConstructorCall
1031                         && (sourceType == targetEnclosingType)) {
1032                         return EmulationPathToImplicitThis; // implicit this is good enough
1033                 }
1034                 if (!sourceType.isNestedType()
1035                         || sourceType.isStatic()) { // no emulation from within non-inner types
1036                         return null;
1037                 }
1038
1039                 boolean insideConstructor =
1040                         currentMethodScope.isInsideInitializerOrConstructor();
1041                 // use synthetic constructor arguments if possible
1042                 if (insideConstructor) {
1043                         SyntheticArgumentBinding syntheticArg;
1044                         if ((syntheticArg = ((NestedTypeBinding) sourceType).getSyntheticArgument(targetEnclosingType, this, true)) != null) {
1045                                 return new Object[] { syntheticArg };
1046                         }
1047                 }
1048                 // use a direct synthetic field then
1049                 if (!currentMethodScope.isStatic) {
1050                         FieldBinding syntheticField;
1051                         if ((syntheticField = sourceType.getSyntheticField(targetEnclosingType, this, true)) != null) {
1052                                 return new Object[] { syntheticField };
1053                         }
1054                         // could be reached through a sequence of enclosing instance link (nested members)
1055                         Object[] path = new Object[2]; // probably at least 2 of them
1056                         ReferenceBinding currentType = sourceType.enclosingType();
1057                         if (insideConstructor) {
1058                                 path[0] =
1059                                         ((NestedTypeBinding) sourceType).getSyntheticArgument((SourceTypeBinding) currentType,  this, true);
1060                         } else {
1061                                 path[0] =
1062                                         sourceType.getSyntheticField((SourceTypeBinding) currentType, this, true);
1063                         }
1064                         if (path[0] != null) { // keep accumulating
1065                                 int count = 1;
1066                                 ReferenceBinding currentEnclosingType;
1067                                 while ((currentEnclosingType = currentType.enclosingType()) != null) {
1068                                         //done?
1069                                         if (currentType == targetEnclosingType)
1070                                                 break;
1071                                         syntheticField =
1072                                                 ((NestedTypeBinding) currentType).getSyntheticField(
1073                                                         (SourceTypeBinding) currentEnclosingType,
1074                                                         this,
1075                                                         true);
1076                                         if (syntheticField == null)
1077                                                 break;
1078                                         // append inside the path
1079                                         if (count == path.length) {
1080                                                 System.arraycopy(path, 0, (path = new Object[count + 1]), 0, count);
1081                                         }
1082                                         // private access emulation is necessary since synthetic field is private
1083                                         path[count++] = ((SourceTypeBinding) syntheticField.declaringClass).addSyntheticMethod(syntheticField, true);
1084                                         currentType = currentEnclosingType;
1085                                 }
1086                                 if (currentType == targetEnclosingType) {
1087                                         return path;
1088                                 }
1089                         }
1090                 }
1091                 return null;
1092         }
1093
1094         /* API
1095      *  
1096          *      Answer the field binding that corresponds to fieldName.
1097          *      Start the lookup at the receiverType.
1098          *      InvocationSite implements
1099          *              isSuperAccess(); this is used to determine if the discovered field is visible.
1100          *      Only fields defined by the receiverType or its supertypes are answered;
1101          *      a field of an enclosing type will not be found using this API.
1102          *
1103          *      If no visible field is discovered, an error binding is answered.
1104          */
1105         public FieldBinding getField(
1106                 TypeBinding receiverType,
1107                 char[] fieldName,
1108                 InvocationSite invocationSite) {
1109
1110                 FieldBinding field = findField(receiverType, fieldName, invocationSite);
1111                 if (field == null)
1112                         return new ProblemFieldBinding(
1113                                 receiverType instanceof ReferenceBinding
1114                                         ? (ReferenceBinding) receiverType
1115                                         : null,
1116                                 fieldName,
1117                                 NotFound);
1118                 else
1119                         return field;
1120         }
1121
1122         /* API
1123      *  
1124          *      Answer the method binding that corresponds to selector, argumentTypes.
1125          *      Start the lookup at the enclosing type of the receiver.
1126          *      InvocationSite implements 
1127          *              isSuperAccess(); this is used to determine if the discovered method is visible.
1128          *              setDepth(int); this is used to record the depth of the discovered method
1129          *                      relative to the enclosing type of the receiver. (If the method is defined
1130          *                      in the enclosing type of the receiver, the depth is 0; in the next enclosing
1131          *                      type, the depth is 1; and so on
1132          * 
1133          *      If no visible method is discovered, an error binding is answered.
1134          */
1135         public MethodBinding getImplicitMethod(
1136                 char[] selector,
1137                 TypeBinding[] argumentTypes,
1138                 InvocationSite invocationSite) {
1139
1140                 boolean insideStaticContext = false;
1141                 boolean insideConstructorCall = false;
1142                 MethodBinding foundMethod = null;
1143                 ProblemMethodBinding foundFuzzyProblem = null;
1144                 // the weird method lookup case (matches method name in scope, then arg types, then visibility)
1145                 ProblemMethodBinding foundInsideProblem = null;
1146                 // inside Constructor call or inside static context
1147                 Scope scope = this;
1148                 int depth = 0;
1149                 done : while (true) { // done when a COMPILATION_UNIT_SCOPE is found
1150                         switch (scope.kind) {
1151                                 case METHOD_SCOPE :
1152                                         MethodScope methodScope = (MethodScope) scope;
1153                                         insideStaticContext |= methodScope.isStatic;
1154                                         insideConstructorCall |= methodScope.isConstructorCall;
1155                                         break;
1156                                 case CLASS_SCOPE :
1157                                         ClassScope classScope = (ClassScope) scope;
1158                                         SourceTypeBinding receiverType = classScope.referenceContext.binding;
1159                                         boolean isExactMatch = true;
1160                                         // retrieve an exact visible match (if possible)
1161                                         MethodBinding methodBinding =
1162                                                 (foundMethod == null)
1163                                                         ? classScope.findExactMethod(
1164                                                                 receiverType,
1165                                                                 selector,
1166                                                                 argumentTypes,
1167                                                                 invocationSite)
1168                                                         : classScope.findExactMethod(
1169                                                                 receiverType,
1170                                                                 foundMethod.selector,
1171                                                                 foundMethod.parameters,
1172                                                                 invocationSite);
1173                                         //                                              ? findExactMethod(receiverType, selector, argumentTypes, invocationSite)
1174                                         //                                              : findExactMethod(receiverType, foundMethod.selector, foundMethod.parameters, invocationSite);
1175                                         if (methodBinding == null) {
1176                                                 // answers closest approximation, may not check argumentTypes or visibility
1177                                                 isExactMatch = false;
1178                                                 methodBinding =
1179                                                         classScope.findMethod(receiverType, selector, argumentTypes, invocationSite);
1180                                                 //                                      methodBinding = findMethod(receiverType, selector, argumentTypes, invocationSite);
1181                                         }
1182                                         if (methodBinding != null) { // skip it if we did not find anything
1183                                                 if (methodBinding.problemId() == Ambiguous) {
1184                                                         if (foundMethod == null || foundMethod.problemId() == NotVisible)
1185                                                                 // supercedes any potential InheritedNameHidesEnclosingName problem
1186                                                                 return methodBinding;
1187                                                         else
1188                                                                 // make the user qualify the method, likely wants the first inherited method (javac generates an ambiguous error instead)
1189                                                                 return new ProblemMethodBinding(
1190                                                                         selector,
1191                                                                         argumentTypes,
1192                                                                         InheritedNameHidesEnclosingName);
1193                                                 }
1194
1195                                                 ProblemMethodBinding fuzzyProblem = null;
1196                                                 ProblemMethodBinding insideProblem = null;
1197                                                 if (methodBinding.isValidBinding()) {
1198                                                         if (!isExactMatch) {
1199                                                                 if (!areParametersAssignable(methodBinding.parameters, argumentTypes)) {
1200                                                                         if (foundMethod == null || foundMethod.problemId() == NotVisible){
1201                                                                                 // inherited mismatch is reported directly, not looking at enclosing matches
1202                                                                                 return new ProblemMethodBinding(methodBinding, selector, argumentTypes, NotFound);
1203                                                                         }
1204                                                                         // make the user qualify the method, likely wants the first inherited method (javac generates an ambiguous error instead)
1205                                                                         fuzzyProblem = new ProblemMethodBinding(selector, argumentTypes, InheritedNameHidesEnclosingName);
1206
1207                                                                 } else if (!methodBinding.canBeSeenBy(receiverType, invocationSite, classScope)) {
1208                                                                         // using <classScope> instead of <this> for visibility check does grant all access to innerclass
1209                                                                         fuzzyProblem =
1210                                                                                 new ProblemMethodBinding(
1211                                                                                         selector,
1212                                                                                         argumentTypes,
1213                                                                                         methodBinding.declaringClass,
1214                                                                                         NotVisible);
1215                                                                 }
1216                                                         }
1217                                                         if (fuzzyProblem == null && !methodBinding.isStatic()) {
1218                                                                 if (insideConstructorCall) {
1219                                                                         insideProblem =
1220                                                                                 new ProblemMethodBinding(
1221                                                                                         methodBinding.selector,
1222                                                                                         methodBinding.parameters,
1223                                                                                         NonStaticReferenceInConstructorInvocation);
1224                                                                 } else if (insideStaticContext) {
1225                                                                         insideProblem =
1226                                                                                 new ProblemMethodBinding(
1227                                                                                         methodBinding.selector,
1228                                                                                         methodBinding.parameters,
1229                                                                                         NonStaticReferenceInStaticContext);
1230                                                                 }
1231                                                         }
1232                                                         
1233                                                         if (receiverType == methodBinding.declaringClass
1234                                                                 || (receiverType.getMethods(selector)) != NoMethods
1235                                                                 || ((fuzzyProblem == null || fuzzyProblem.problemId() != NotVisible) && environment().options.complianceLevel >= CompilerOptions.JDK1_4)){
1236                                                                 // found a valid method in the 'immediate' scope (ie. not inherited)
1237                                                                 // OR the receiverType implemented a method with the correct name
1238                                                                 // OR in 1.4 mode (inherited visible shadows enclosing)
1239                                                                 if (foundMethod == null) {
1240                                                                         if (depth > 0){
1241                                                                                 invocationSite.setDepth(depth);
1242                                                                                 invocationSite.setActualReceiverType(receiverType);
1243                                                                         }
1244                                                                         // return the methodBinding if it is not declared in a superclass of the scope's binding (i.e. "inherited")
1245                                                                         if (fuzzyProblem != null)
1246                                                                                 return fuzzyProblem;
1247                                                                         if (insideProblem != null)
1248                                                                                 return insideProblem;
1249                                                                         return methodBinding;
1250                                                                 }
1251                                                                 // if a method was found, complain when another is found in an 'immediate' enclosing type (ie. not inherited)
1252                                                                 // NOTE: Unlike fields, a non visible method hides a visible method
1253                                                                 if (foundMethod.declaringClass != methodBinding.declaringClass)
1254                                                                         // ie. have we found the same method - do not trust field identity yet
1255                                                                         return new ProblemMethodBinding(
1256                                                                                 methodBinding.selector,
1257                                                                                 methodBinding.parameters,
1258                                                                                 InheritedNameHidesEnclosingName);
1259                                                         }
1260                                                 }
1261
1262                                                 if (foundMethod == null
1263                                                         || (foundMethod.problemId() == NotVisible
1264                                                                 && methodBinding.problemId() != NotVisible)) {
1265                                                         // only remember the methodBinding if its the first one found or the previous one was not visible & methodBinding is...
1266                                                         // remember that private methods are visible if defined directly by an enclosing class
1267                                                         if (depth > 0){
1268                                                                 invocationSite.setDepth(depth);
1269                                                                 invocationSite.setActualReceiverType(receiverType);
1270                                                         }
1271                                                         foundFuzzyProblem = fuzzyProblem;
1272                                                         foundInsideProblem = insideProblem;
1273                                                         if (fuzzyProblem == null)
1274                                                                 foundMethod = methodBinding; // only keep it if no error was found
1275                                                 }
1276                                         }
1277                                         depth++;
1278                                         insideStaticContext |= receiverType.isStatic();
1279                                         // 1EX5I8Z - accessing outer fields within a constructor call is permitted
1280                                         // in order to do so, we change the flag as we exit from the type, not the method
1281                                         // itself, because the class scope is used to retrieve the fields.
1282                                         MethodScope enclosingMethodScope = scope.methodScope();
1283                                         insideConstructorCall =
1284                                                 enclosingMethodScope == null ? false : enclosingMethodScope.isConstructorCall;
1285                                         break;
1286                                 case COMPILATION_UNIT_SCOPE :
1287                                         break done;
1288                         }
1289                         scope = scope.parent;
1290                 }
1291
1292                 if (foundFuzzyProblem != null)
1293                         return foundFuzzyProblem;
1294                 if (foundInsideProblem != null)
1295                         return foundInsideProblem;
1296                 if (foundMethod != null)
1297                         return foundMethod;
1298                 return new ProblemMethodBinding(selector, argumentTypes, NotFound);
1299         }
1300
1301         /* API
1302      *  
1303          *      Answer the method binding that corresponds to selector, argumentTypes.
1304          *      Start the lookup at the receiverType.
1305          *      InvocationSite implements 
1306          *              isSuperAccess(); this is used to determine if the discovered method is visible.
1307          *
1308          *      Only methods defined by the receiverType or its supertypes are answered;
1309          *      use getImplicitMethod() to discover methods of enclosing types.
1310          *
1311          *      If no visible method is discovered, an error binding is answered.
1312          */
1313         public MethodBinding getMethod(
1314                 TypeBinding receiverType,
1315                 char[] selector,
1316                 TypeBinding[] argumentTypes,
1317                 InvocationSite invocationSite) {
1318
1319                 if (receiverType.isArrayType())
1320                         return findMethodForArray(
1321                                 (ArrayBinding) receiverType,
1322                                 selector,
1323                                 argumentTypes,
1324                                 invocationSite);
1325                 if (receiverType.isBaseType())
1326                         return new ProblemMethodBinding(selector, argumentTypes, NotFound);
1327
1328                 ReferenceBinding currentType = (ReferenceBinding) receiverType;
1329                 if (!currentType.canBeSeenBy(this))
1330                         return new ProblemMethodBinding(selector, argumentTypes, NotVisible);
1331                 // *** Need a new problem id - TypeNotVisible?
1332
1333                 // retrieve an exact visible match (if possible)
1334                 MethodBinding methodBinding =
1335                         findExactMethod(currentType, selector, argumentTypes, invocationSite);
1336                 if (methodBinding != null)
1337                         return methodBinding;
1338
1339                 // answers closest approximation, may not check argumentTypes or visibility
1340                 methodBinding =
1341                         findMethod(currentType, selector, argumentTypes, invocationSite);
1342                 if (methodBinding == null)
1343                         return new ProblemMethodBinding(selector, argumentTypes, NotFound);
1344                 if (methodBinding.isValidBinding()) {
1345                         if (!areParametersAssignable(methodBinding.parameters, argumentTypes))
1346                                 return new ProblemMethodBinding(
1347                                         methodBinding,
1348                                         selector,
1349                                         argumentTypes,
1350                                         NotFound);
1351                         if (!methodBinding.canBeSeenBy(currentType, invocationSite, this))
1352                                 return new ProblemMethodBinding(
1353                                         selector,
1354                                         argumentTypes,
1355                                         methodBinding.declaringClass,
1356                                         NotVisible);
1357                 }
1358                 return methodBinding;
1359         }
1360
1361         public int maxShiftedOffset() {
1362                 int max = -1;
1363                 if (this.shiftScopes != null){
1364                         for (int i = 0, length = this.shiftScopes.length; i < length; i++){
1365                                 int subMaxOffset = this.shiftScopes[i].maxOffset;
1366                                 if (subMaxOffset > max) max = subMaxOffset;
1367                         }
1368                 }
1369                 return max;
1370         }
1371         
1372         /* Answer the problem reporter to use for raising new problems.
1373          *
1374          * Note that as a side-effect, this updates the current reference context
1375          * (unit, type or method) in case the problem handler decides it is necessary
1376          * to abort.
1377          */
1378         public ProblemReporter problemReporter() {
1379
1380                 return outerMostMethodScope().problemReporter();
1381         }
1382
1383         /*
1384          * Code responsible to request some more emulation work inside the invocation type, so as to supply
1385          * correct synthetic arguments to any allocation of the target type.
1386          */
1387         public void propagateInnerEmulation(
1388                 ReferenceBinding targetType,
1389                 boolean isEnclosingInstanceSupplied,
1390                 boolean useDirectReference) {
1391
1392                 // perform some emulation work in case there is some and we are inside a local type only
1393                 // propage emulation of the enclosing instances
1394                 ReferenceBinding[] syntheticArgumentTypes;
1395                 if ((syntheticArgumentTypes = targetType.syntheticEnclosingInstanceTypes())
1396                         != null) {
1397                         for (int i = 0, max = syntheticArgumentTypes.length; i < max; i++) {
1398                                 ReferenceBinding syntheticArgType = syntheticArgumentTypes[i];
1399                                 // need to filter out the one that could match a supplied enclosing instance
1400                                 if (!(isEnclosingInstanceSupplied
1401                                         && (syntheticArgType == targetType.enclosingType()))) {
1402                                         this.emulateOuterAccess(syntheticArgType, useDirectReference);
1403                                 }
1404                         }
1405                 }
1406                 SyntheticArgumentBinding[] syntheticArguments;
1407                 if ((syntheticArguments = targetType.syntheticOuterLocalVariables()) != null) {
1408                         for (int i = 0, max = syntheticArguments.length; i < max; i++) {
1409                                 SyntheticArgumentBinding syntheticArg = syntheticArguments[i];
1410                                 // need to filter out the one that could match a supplied enclosing instance
1411                                 if (!(isEnclosingInstanceSupplied
1412                                         && (syntheticArg.type == targetType.enclosingType()))) {
1413                                         this.emulateOuterAccess(syntheticArg.actualOuterLocalVariable);
1414                                 }
1415                         }
1416                 }
1417         }
1418
1419         /* Answer the reference type of this scope.
1420          *
1421          * i.e. the nearest enclosing type of this scope.
1422          */
1423         public TypeDeclaration referenceType() {
1424
1425                 return methodScope().referenceType();
1426         }
1427
1428         // start position in this scope - for ordering scopes vs. variables
1429         int startIndex() {
1430                 return startIndex;
1431         }
1432
1433         public String toString() {
1434                 return toString(0);
1435         }
1436
1437         public String toString(int tab) {
1438
1439                 String s = basicToString(tab);
1440                 for (int i = 0; i < scopeIndex; i++)
1441                         if (subscopes[i] instanceof BlockScope)
1442                                 s += ((BlockScope) subscopes[i]).toString(tab + 1) + "\n"; //$NON-NLS-1$
1443                 return s;
1444         }
1445 }