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